libreoffice/sd/source/ui/slidesorter/controller/SlsSelectionFunction.cxx

/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * $RCSfile: SlsSelectionFunction.cxx,v $
 * $Revision: 1.37 $
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

#include "precompiled_sd.hxx"

#include "controller/SlsSelectionFunction.hxx"

#include "SlideSorter.hxx"
#include "SlideSorterViewShell.hxx"
#include "SlsDragAndDropContext.hxx"
#include "controller/SlsTransferable.hxx"
#include "controller/SlideSorterController.hxx"
#include "controller/SlsPageSelector.hxx"
#include "controller/SlsFocusManager.hxx"
#include "controller/SlsScrollBarManager.hxx"
#include "controller/SlsClipboard.hxx"
#include "controller/SlsCurrentSlideManager.hxx"
#include "controller/SlsInsertionIndicatorHandler.hxx"
#include "controller/SlsSelectionManager.hxx"
#include "controller/SlsProperties.hxx"
#include "controller/SlsProperties.hxx"
#include "model/SlideSorterModel.hxx"
#include "model/SlsPageDescriptor.hxx"
#include "model/SlsPageEnumerationProvider.hxx"
#include "view/SlideSorterView.hxx"
#include "view/SlsLayouter.hxx"
#include "view/SlsPageObjectLayouter.hxx"
#include "framework/FrameworkHelper.hxx"
#include "showview.hxx"
#include "ViewShellBase.hxx"
#include "DrawController.hxx"
#include "Window.hxx"
#include "sdpage.hxx"
#include "drawdoc.hxx"
#include "DrawDocShell.hxx"
#include "sdxfer.hxx"
#include "ViewShell.hxx"
#include "ViewShellBase.hxx"
#include "FrameView.hxx"
#include "app.hrc"
#include "sdresid.hxx"
#include "strings.hrc"
#include <vcl/sound.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/dispatch.hxx>
#include <svx/svdpagv.hxx>
#include <vcl/msgbox.hxx>
#include <svx/svxids.hrc>
#include <boost/bind.hpp>

namespace {
static const sal_uInt32 SINGLE_CLICK             (0x00000001);
static const sal_uInt32 DOUBLE_CLICK             (0x00000002);
static const sal_uInt32 LEFT_BUTTON              (0x00000010);
static const sal_uInt32 RIGHT_BUTTON             (0x00000020);
static const sal_uInt32 MIDDLE_BUTTON            (0x00000040);
static const sal_uInt32 BUTTON_DOWN              (0x00000100);
static const sal_uInt32 BUTTON_UP                (0x00000200);
static const sal_uInt32 MOUSE_MOTION             (0x00000400);
static const sal_uInt32 MOUSE_DRAG               (0x00000800);
// The rest leaves the lower 16 bit untouched so that it can be used with
// key codes.
static const sal_uInt32 OVER_SELECTED_PAGE       (0x00010000);
static const sal_uInt32 OVER_UNSELECTED_PAGE     (0x00020000);
static const sal_uInt32 OVER_FADE_INDICATOR      (0x00040000);
static const sal_uInt32 OVER_BUTTON              (0x00080000);
static const sal_uInt32 SHIFT_MODIFIER           (0x00100000);
static const sal_uInt32 CONTROL_MODIFIER         (0x00200000);
static const sal_uInt32 DRAG_ACTIVE              (0x01000000);
static const sal_uInt32 MULTI_SELECTOR           (0x02000000);

static const sal_uInt32 KEY_EVENT                (0x10000000);

// Some absent events are defined so they can be expressed explicitly.
static const sal_uInt32 NO_MODIFIER              (0x00000000);
static const sal_uInt32 NOT_OVER_PAGE            (0x00000000);

// Masks
static const sal_uInt32 MODIFIER_MASK            (SHIFT_MODIFIER | CONTROL_MODIFIER);


} // end of anonymous namespace

#define ONLY_PREVIEW_TRIGGERS_MOUSE_OVER

namespace sd { namespace slidesorter { namespace controller {


class SelectionFunction::MouseMultiSelector
{
public:
    MouseMultiSelector (
        SlideSorter& rSlideSorter,
        const Point& rMouseModelPosition);
    virtual ~MouseMultiSelector (void);

    void RestoreInitialSelection (void);

    /** Update the rectangle selection so that the given position becomes
        the new second point of the selection rectangle.
    */
    void UpdatePosition (
        const Point& rMousePosition,
        const bool bAllowAutoScroll = true);
    enum SelectionMode { SM_Normal, SM_Add, SM_Toggle };

    void SetSelectionMode (const SelectionMode eSelectionMode);
    void SetSelectionModeFromModifier (const sal_uInt32 nEventCode);

protected:
    SlideSorter& mrSlideSorter;
    SelectionMode meSelectionMode;
    ::std::set<sal_Int32> maInitialSelection;

    virtual void UpdateModelPosition (const Point& rMouseModelPosition) = 0;
    virtual void UpdateSelection (void) = 0;

    void UpdateSelectionState (
        const model::SharedPageDescriptor& rpDescriptor,
        const bool bIsInSelection) const;
};

namespace {

    class RangeSelector
        : public SelectionFunction::MouseMultiSelector
    {
    public:
        /** Start a rectangle selection at the given position.
        */
        RangeSelector (
            SlideSorter& rSlideSorter,
            const Point& rMouseModelPosition);
        virtual ~RangeSelector (void);

    protected:
        virtual void UpdateModelPosition (const Point& rMouseModelPosition);

        /** Select all pages that lie completly in the selection rectangle.
        */
        virtual void UpdateSelection (void);

    private:
        Point maAnchor;
        Point maSecondCorner;
        Pointer maSavedPointer;
        sal_Int32 mnAnchorIndex;
        sal_Int32 mnSecondIndex;

        Rectangle GetBoundingBox (void) const;
    };

} // end of anonymous namespace


class SelectionFunction::EventDescriptor
{
public:
    Point maMousePosition;
    Point maMouseModelPosition;
    model::SharedPageDescriptor mpHitDescriptor;
    SdrPage* mpHitPage;
    sal_uInt32 mnEventCode;
    sal_Int32 mnButtonIndex;
    InsertionIndicatorHandler::Mode meDragMode;
    bool mbMakeSelectionVisible;

    EventDescriptor (
        sal_uInt32 nEventType,
        const Point& rMousePosition,
        SlideSorter& rSlideSorter);
    EventDescriptor (
        const KeyEvent& rEvent,
        SlideSorter& rSlideSorter);
    EventDescriptor (const EventDescriptor& rDescriptor);

    void SetDragMode (const InsertionIndicatorHandler::Mode eMode);
};


TYPEINIT1(SelectionFunction, FuPoor);


SelectionFunction::SelectionFunction (
    SlideSorter& rSlideSorter,
    SfxRequest& rRequest)
    : FuPoor (
        rSlideSorter.GetViewShell(),
        rSlideSorter.GetContentWindow().get(),
        &rSlideSorter.GetView(),
        rSlideSorter.GetModel().GetDocument(),
        rRequest),
      mrSlideSorter(rSlideSorter),
      mrController(mrSlideSorter.GetController()),
      mbDragSelection(false),
      maInsertionMarkerBox(),
      mbProcessingMouseButtonDown(false),
      mpDragAndDropContext(),
      mpMouseMultiSelector(),
      mnButtonDownPageIndex(-1),
      mnButtonDownButtonIndex(-1),
      mbIsDeselectionPending(false),
      mnShiftKeySelectionAnchor(-1)
{
}




SelectionFunction::~SelectionFunction (void)
{
}




FunctionReference SelectionFunction::Create(
    SlideSorter& rSlideSorter,
    SfxRequest& rRequest)
{
    FunctionReference xFunc( new SelectionFunction( rSlideSorter, rRequest ) );
    return xFunc;
}




BOOL SelectionFunction::MouseButtonDown (const MouseEvent& rEvent)
{
    // #95491# remember button state for creation of own MouseEvents
    SetMouseButtonCode (rEvent.GetButtons());
    aMDPos = rEvent.GetPosPixel();
    mbProcessingMouseButtonDown = true;

    //  mpWindow->CaptureMouse();

    ProcessMouseEvent(BUTTON_DOWN, rEvent);

    return TRUE;
}




BOOL SelectionFunction::MouseMove (const MouseEvent& rEvent)
{
    Point aMousePosition (rEvent.GetPosPixel());

    UpdatePageUnderMouse(aMousePosition, (rEvent.GetButtons() & MOUSE_LEFT)!=0);

    // Detect the mouse leaving the window.  When not button is pressed then
    // we can call IsLeaveWindow at the event.  Otherwise we have to make an
    // explicit test.
    if (rEvent.IsLeaveWindow()
        || ! Rectangle(Point(0,0),mpWindow->GetOutputSizePixel()).IsInside(aMousePosition))
    {
        if (mpDragAndDropContext)
        {
            mpDragAndDropContext->Hide();
            mpDragAndDropContext.reset();
        }
        mrSlideSorter.GetView().SetPageUnderMouse(model::SharedPageDescriptor());
    }
    else
    {
        // Call ProcessMouseEvent() only when one of the buttons is
        // pressed. This prevents calling the method on every motion.
        if (rEvent.GetButtons() != 0
            && mbProcessingMouseButtonDown)
        {
            ProcessMouseEvent(MOUSE_MOTION, rEvent);
        }
    }

    return TRUE;
}




BOOL SelectionFunction::MouseButtonUp (const MouseEvent& rEvent)
{
    mrController.GetScrollBarManager().StopAutoScroll ();

    ProcessMouseEvent(BUTTON_UP, rEvent);

    mbProcessingMouseButtonDown = false;
    mpWindow->ReleaseMouse();

    return TRUE;
}




void SelectionFunction::MouseDragged (
    const AcceptDropEvent& rEvent,
    const sal_Int8 nDragAction)
{
    const InsertionIndicatorHandler::Mode eMode (
        InsertionIndicatorHandler::GetModeFromDndAction(nDragAction));//rEvent.mnAction));
    if (rEvent.mbLeaving)
    {
        if (mpDragAndDropContext)
        {
            // Disconnect the substitution handler from this selection function.
            mpDragAndDropContext->Hide();
            mpDragAndDropContext->SetTargetSlideSorter();
            mpDragAndDropContext.reset();
        }
    }
    else if ( ! mpDragAndDropContext)
    {
        // Connect the substitution handler to this selection function.
        mpDragAndDropContext.reset(new DragAndDropContext(mrSlideSorter));
        const SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
        mrController.GetInsertionIndicatorHandler()->Start(
            pDragTransferable != NULL
            && pDragTransferable->GetView()==&mrSlideSorter.GetView());
        mpDragAndDropContext->UpdatePosition(rEvent.maPosPixel, eMode);
    }

    // 1. Compute some frequently used values relating to the event.
    ::std::auto_ptr<EventDescriptor> pEventDescriptor (
        new EventDescriptor(MOUSE_DRAG, rEvent.maPosPixel, mrSlideSorter));

    // 2. Detect whether we are dragging pages or dragging a selection rectangle.
    if (mpDragAndDropContext)
        pEventDescriptor->mnEventCode |= DRAG_ACTIVE;
    if (mpMouseMultiSelector)
        pEventDescriptor->mnEventCode |= MULTI_SELECTOR;

    // 3. Set the drag mode.
    pEventDescriptor->SetDragMode(eMode);

    // 4. Process the event.
    if ( ! ProcessEvent(*pEventDescriptor))
    {
        OSL_TRACE ("can not handle event code %x", pEventDescriptor->mnEventCode);
    }
    PostProcessEvent(*pEventDescriptor);
}




void SelectionFunction::NotifyDragFinished (void)
{
    if (mpDragAndDropContext)
    {
        mpDragAndDropContext->Dispose();
        mpDragAndDropContext.reset();
    }
    mrController.GetInsertionIndicatorHandler()->End();
}




::boost::shared_ptr<DragAndDropContext> SelectionFunction::GetDragAndDropContext (void) const
{
    return mpDragAndDropContext;
}




BOOL SelectionFunction::KeyInput (const KeyEvent& rEvent)
{
    PageSelector::UpdateLock aLock (mrSlideSorter);
    FocusManager& rFocusManager (mrController.GetFocusManager());
    BOOL bResult = FALSE;

    const KeyCode& rCode (rEvent.GetKeyCode());
    switch (rCode.GetCode())
    {
        case KEY_RETURN:
            if (rFocusManager.HasFocus())
            {
                model::SharedPageDescriptor pDescriptor (rFocusManager.GetFocusedPageDescriptor());
                if (pDescriptor.get() != NULL)
                {
                    SetCurrentPage(pDescriptor);
                    SwitchView(pDescriptor);
                }
                bResult = TRUE;
            }
            break;

        case KEY_TAB:
            if ( ! rFocusManager.IsFocusShowing())
            {
                rFocusManager.ShowFocus();
                bResult = TRUE;
            }
            break;

        case KEY_ESCAPE:
            // When there is an active multiselection or drag-and-drop
            // operation then stop that.  Otherwise transfer the focus to
            // the tool box.

            if ( ! (mpDragAndDropContext || mpMouseMultiSelector))
                rFocusManager.SetFocusToToolBox();

            if (mpDragAndDropContext)
            {
                mpDragAndDropContext->Dispose();
                mpDragAndDropContext.reset();
            }
            if (mpMouseMultiSelector)
            {
                mpMouseMultiSelector->RestoreInitialSelection();
                mpMouseMultiSelector.reset();
            }
            bResult = TRUE;
            break;

        case KEY_SPACE:
        {
            // Toggle the selection state.
            model::SharedPageDescriptor pDescriptor (rFocusManager.GetFocusedPageDescriptor());
            if (pDescriptor && rCode.IsMod1())
            {
                // Doing a multi selection by default.  Can we ask the event
                // for the state of the shift key?
                if (pDescriptor->HasState(model::PageDescriptor::ST_Selected))
                    mrController.GetPageSelector().DeselectPage(pDescriptor);
                else
                    mrController.GetPageSelector().SelectPage(pDescriptor);
            }
            bResult = TRUE;
        }
        break;


        // Move the focus indicator left.
        case KEY_LEFT:
            MoveFocus(FocusManager::FMD_LEFT, rCode.IsShift(), rCode.IsMod1());
            bResult = TRUE;
            break;

        // Move the focus indicator right.
        case KEY_RIGHT:
            MoveFocus(FocusManager::FMD_RIGHT, rCode.IsShift(), rCode.IsMod1());
            bResult = TRUE;
            break;

        // Move the focus indicator up.
        case KEY_UP:
            MoveFocus(FocusManager::FMD_UP, rCode.IsShift(), rCode.IsMod1());
            bResult = TRUE;
            break;

        // Move the focus indicator down.
        case KEY_DOWN:
            MoveFocus(FocusManager::FMD_DOWN, rCode.IsShift(), rCode.IsMod1());
            bResult = TRUE;
            break;

        // Go to previous page.  No wrap around.
        case KEY_PAGEUP:
            GotoNextPage(-1);
            bResult = TRUE;
            break;

        // Go to next page.  No wrap around..
        case KEY_PAGEDOWN:
            GotoNextPage(+1);
            bResult = TRUE;
            break;

        case KEY_DELETE:
        case KEY_BACKSPACE:
        {
            if (mrSlideSorter.GetProperties()->IsUIReadOnly())
                break;

            int nSelectedPagesCount = 0;

            // Count the selected pages and look if there any objects on any
            // of the selected pages so that we can warn the user and
            // prevent an accidental deletion.
            model::PageEnumeration aSelectedPages (
                model::PageEnumerationProvider::CreateSelectedPagesEnumeration(
                    mrSlideSorter.GetModel()));
            while (aSelectedPages.HasMoreElements())
            {
                nSelectedPagesCount++;
                aSelectedPages.GetNextElement();
            }

            if (nSelectedPagesCount > 0)
                 mrController.GetSelectionManager()->DeleteSelectedPages();

            mnShiftKeySelectionAnchor = -1;
            bResult = TRUE;
        }
        break;

        case KEY_F10:
            if (rCode.IsShift())
            {
                DeselectAllPages();
                mrController.GetPageSelector().SelectPage(
                    mrSlideSorter.GetController().GetFocusManager().GetFocusedPageDescriptor());
            }
            break;

        default:
            break;
    }

    if ( ! bResult)
        bResult = FuPoor::KeyInput(rEvent);

    return bResult;
}




void SelectionFunction::MoveFocus (
    const FocusManager::FocusMoveDirection eDirection,
    const bool bIsShiftDown,
    const bool bIsControlDown)
{
    // Remember the anchor of shift key multi selection.
    if (bIsShiftDown)
    {
        if (mnShiftKeySelectionAnchor<0)
        {
            model::SharedPageDescriptor pFocusedDescriptor (
                mrController.GetFocusManager().GetFocusedPageDescriptor());
            mnShiftKeySelectionAnchor = pFocusedDescriptor->GetPageIndex();
        }
    }
    else
        mnShiftKeySelectionAnchor = -1;

    mrController.GetFocusManager().MoveFocus(eDirection);

    PageSelector& rSelector (mrController.GetPageSelector());
    model::SharedPageDescriptor pFocusedDescriptor (
        mrController.GetFocusManager().GetFocusedPageDescriptor());
    if (bIsShiftDown)
    {
        // When shift is pressed then select all pages in the range between
        // the currently and the previously focused pages, including them.
        if (pFocusedDescriptor)
        {
            sal_Int32 nPageRangeEnd (pFocusedDescriptor->GetPageIndex());
            model::PageEnumeration aPages (
                model::PageEnumerationProvider::CreateAllPagesEnumeration(
                    mrSlideSorter.GetModel()));
            while (aPages.HasMoreElements())
            {
                model::SharedPageDescriptor pDescriptor (aPages.GetNextElement());
                if (pDescriptor)
                {
                    const sal_Int32 nPageIndex(pDescriptor->GetPageIndex());
                    if ((nPageIndex>=mnShiftKeySelectionAnchor && nPageIndex<=nPageRangeEnd)
                        || (nPageIndex<=mnShiftKeySelectionAnchor && nPageIndex>=nPageRangeEnd))
                    {
                        rSelector.SelectPage(pDescriptor);
                    }
                    else
                    {
                        rSelector.DeselectPage(pDescriptor);
                    }
                }
            }
        }
    }
    else if (bIsControlDown)
    {
        // When control is pressed then do not alter the selection or the
        // current page, just move the focus.
    }
    else
    {
        // Without shift just select the focused page.
        rSelector.DeselectAllPages();
        mrController.GetPageSelector().SelectPage(pFocusedDescriptor);
    }

    // Mark the currently focused page as last selected so that it is made
    // visible on the next paint.
    mrController.GetPageSelector().SetMostRecentlySelectedPage(pFocusedDescriptor);
}




void SelectionFunction::Activate()
{
    FuPoor::Activate();
}




void SelectionFunction::Deactivate()
{
    FuPoor::Deactivate();
}



void SelectionFunction::ScrollStart (void)
{
}




void SelectionFunction::ScrollEnd (void)
{
}




void SelectionFunction::DoCut (void)
{
    if ( ! mrSlideSorter.GetProperties()->IsUIReadOnly())
    {
        mrController.GetClipboard().DoCut();
    }
}




void SelectionFunction::DoCopy (void)
{
    mrController.GetClipboard().DoCopy();
}




void SelectionFunction::DoPaste (void)
{
    if ( ! mrSlideSorter.GetProperties()->IsUIReadOnly())
    {
        mrController.GetClipboard().DoPaste();
    }
}




void SelectionFunction::StartDrag (
    const Point& rMousePosition,
    const InsertionIndicatorHandler::Mode eMode)
{
    // Do not start a drag-and-drop operation when one is already active.
    // (when dragging pages from one document into another, pressing a
    // modifier key can trigger a MouseMotion event in the originating
    // window (focus still in there).  Together with the mouse button pressed
    // (drag-and-drop is active) this triggers the start of drag-and-drop.)
    if (SD_MOD()->pTransferDrag != NULL)
        return;

    if ( ! mrSlideSorter.GetProperties()->IsUIReadOnly())
    {
        if (mrSlideSorter.GetViewShell() != NULL)
        {
            SlideSorterViewShell* pSlideSorterViewShell
                = dynamic_cast<SlideSorterViewShell*>(mrSlideSorter.GetViewShell());
            pSlideSorterViewShell->StartDrag (rMousePosition, mpWindow);
        }

        if ( ! mpDragAndDropContext)
        {
            mpDragAndDropContext.reset(new DragAndDropContext(mrSlideSorter));
            mrController.GetInsertionIndicatorHandler()->Start(true);
        }
        mpDragAndDropContext->UpdatePosition(rMousePosition, eMode);
        mpWindow->ReleaseMouse();
    }
}




bool SelectionFunction::cancel (void)
{
    mrController.GetFocusManager().ToggleFocus();
    return true;
}




void SelectionFunction::UpdatePageUnderMouse (
    const Point& rMousePosition,
    const bool bIsMouseButtonDown)
{
    // In some modes (dragging, moving) the mouse over indicator is only
    // annoying.  Turn it off in these cases.
    if (mpDragAndDropContext || mpMouseMultiSelector)
        mrSlideSorter.GetView().SetPageUnderMouse(model::SharedPageDescriptor());
    else
        mrSlideSorter.GetView().UpdatePageUnderMouse(rMousePosition, bIsMouseButtonDown);
}




void SelectionFunction::DeselectAllPages (void)
{
    mbIsDeselectionPending = false;
    mrController.GetPageSelector().DeselectAllPages();
    mnShiftKeySelectionAnchor = -1;
}




void SelectionFunction::RangeSelect (const model::SharedPageDescriptor& rpDescriptor)
{
    PageSelector::UpdateLock aLock (mrSlideSorter);
    PageSelector& rSelector (mrController.GetPageSelector());

    model::SharedPageDescriptor pAnchor (rSelector.GetSelectionAnchor());
    DeselectAllPages();

    if (pAnchor.get() != NULL)
    {
        // Select all pages between the anchor and the given one, including
        // the two.
        USHORT nAnchorIndex ((pAnchor->GetPage()->GetPageNum()-1) / 2);
        USHORT nOtherIndex ((rpDescriptor->GetPage()->GetPageNum()-1) / 2);

        // Iterate over all pages in the range.  Start with the anchor
        // page.  This way the PageSelector will recognize it again as
        // anchor (the first selected page after a DeselectAllPages()
        // becomes the anchor.)
        USHORT nStep = (nAnchorIndex < nOtherIndex) ? +1 : -1;
        USHORT nIndex = nAnchorIndex;
        while (true)
        {
            rSelector.SelectPage(nIndex);
            if (nIndex == nOtherIndex)
                break;
            nIndex = nIndex + nStep;
        }
    }
}




void SelectionFunction::GotoNextPage (int nOffset)
{
    model::SharedPageDescriptor pDescriptor
        = mrController.GetCurrentSlideManager()->GetCurrentSlide();
    if (pDescriptor.get() != NULL)
    {
        SdPage* pPage = pDescriptor->GetPage();
        OSL_ASSERT(pPage!=NULL);
        sal_Int32 nIndex = (pPage->GetPageNum()-1) / 2;
        nIndex += nOffset;
        USHORT nPageCount = (USHORT)mrSlideSorter.GetModel().GetPageCount();

        if (nIndex >= nPageCount)
            nIndex = nPageCount - 1;
        if (nIndex < 0)
            nIndex = 0;

        mrController.GetFocusManager().SetFocusedPage(nIndex);
        model::SharedPageDescriptor pNextPageDescriptor (
            mrSlideSorter.GetModel().GetPageDescriptor (nIndex));
        if (pNextPageDescriptor.get() != NULL)
            SetCurrentPage(pNextPageDescriptor);
        else
        {
            OSL_ASSERT(pNextPageDescriptor.get() != NULL);
        }
    }
    mnShiftKeySelectionAnchor = -1;
}




void SelectionFunction::ProcessMouseEvent (sal_uInt32 nEventType, const MouseEvent& rEvent)
{
    // #95491# remember button state for creation of own MouseEvents
    SetMouseButtonCode (rEvent.GetButtons());

    // 1. Compute some frequently used values relating to the event.
    ::std::auto_ptr<EventDescriptor> pEventDescriptor (
        new EventDescriptor(nEventType, rEvent.GetPosPixel(), mrSlideSorter));

    // 2. Compute a numerical code that describes the event and that is used
    // for fast look-up of the associated reaction.
    pEventDescriptor->mnEventCode
        = EncodeMouseEvent(*pEventDescriptor, rEvent) | EncodeState(*pEventDescriptor);

    // 3. Process the event.
    if ( ! ProcessEvent(*pEventDescriptor))
    {
        OSL_TRACE ("can not handle event code %x", pEventDescriptor->mnEventCode);
    }
    PostProcessEvent(*pEventDescriptor);
}




sal_uInt32 SelectionFunction::EncodeMouseEvent (
    const EventDescriptor& rDescriptor,
    const MouseEvent& rEvent) const
{
    // Initialize with the type of mouse event.
    sal_uInt32 nEventCode (rDescriptor.mnEventCode & (BUTTON_DOWN | BUTTON_UP | MOUSE_MOTION));

    // Detect the affected button.
    switch (rEvent.GetButtons())
    {
        case MOUSE_LEFT:   nEventCode |= LEFT_BUTTON; break;
        case MOUSE_RIGHT:  nEventCode |= RIGHT_BUTTON; break;
        case MOUSE_MIDDLE: nEventCode |= MIDDLE_BUTTON; break;
    }

    // Detect the number of clicks.
    switch (rEvent.GetClicks())
    {
        case 1: nEventCode |= SINGLE_CLICK; break;
        case 2: nEventCode |= DOUBLE_CLICK; break;
    }

    // Detect pressed modifier keys.
    if (rEvent.IsShift())
        nEventCode |= SHIFT_MODIFIER;
    if (rEvent.IsMod1())
        nEventCode |= CONTROL_MODIFIER;

    // Detect whether the mouse is over one of the active elements inside a
    // page object.
    if (rDescriptor.mnButtonIndex >= 0)
        nEventCode |= OVER_BUTTON;

    return nEventCode;
}



sal_uInt32 SelectionFunction::EncodeKeyEvent (
    const EventDescriptor& rDescriptor,
    const KeyEvent& rEvent) const
{
    (void)rDescriptor;

    // Initialize as key event.
    sal_uInt32 nEventCode (KEY_EVENT);

    // Add the actual key code in the lower 16 bit.
    nEventCode |= rEvent.GetKeyCode().GetCode();

    // Detect pressed modifier keys.
    if (rEvent.GetKeyCode().IsShift())
        nEventCode |= SHIFT_MODIFIER;
    if (rEvent.GetKeyCode().IsMod1())
        nEventCode |= CONTROL_MODIFIER;

    return nEventCode;
}




sal_uInt32 SelectionFunction::EncodeState (
    const EventDescriptor& rDescriptor) const
{
    sal_uInt32 nEventCode (0);

    // Detect whether the event has happened over a page object.
    if (rDescriptor.mpHitPage != NULL && rDescriptor.mpHitDescriptor)
    {
        if (rDescriptor.mpHitDescriptor->HasState(model::PageDescriptor::ST_Selected))
            nEventCode |= OVER_SELECTED_PAGE;
        else
            nEventCode |= OVER_UNSELECTED_PAGE;

        // Detect whether the mouse is over one of the active elements
        // inside a page object.
        if (rDescriptor.mnButtonIndex >= 0)
            nEventCode |= OVER_BUTTON;
    }

    // Detect whether we are dragging pages or dragging a selection rectangle.
    if (mpDragAndDropContext)
        nEventCode |= DRAG_ACTIVE;
    if (mpMouseMultiSelector)
        nEventCode |= MULTI_SELECTOR;

    return nEventCode;
}




void SelectionFunction::ProcessKeyEvent (const KeyEvent& rEvent)
{
    // 1. Compute some frequently used values relating to the event.
    ::std::auto_ptr<EventDescriptor> pEventDescriptor (
        new EventDescriptor(rEvent, mrSlideSorter));

    // 2. Encode the event.
    pEventDescriptor->mnEventCode
        = EncodeKeyEvent(*pEventDescriptor, rEvent) | EncodeState(*pEventDescriptor);

    // 3. Process the event.
    if ( ! ProcessEvent(*pEventDescriptor))
        OSL_TRACE ("can not handle event code %x", pEventDescriptor->mnEventCode);
    PostProcessEvent(*pEventDescriptor);
}




bool Match (
    const sal_uInt32 nEventCode,
    const sal_uInt32 nPositivePattern)
{
    return (nEventCode & nPositivePattern)==nPositivePattern;
}




bool SelectionFunction::ProcessEvent (EventDescriptor& rDescriptor)
{
    // Define some macros to make the following switch statement more readable.
#define ANY_MODIFIER(code)                  \
         code|NO_MODIFIER:                  \
    case code|SHIFT_MODIFIER:               \
    case code|CONTROL_MODIFIER

    bool bResult (true);

    mrController.GetPageSelector().DisableBroadcasting();
    PageSelector::UpdateLock aLock (mrSlideSorter);

    // With the event code determine the type of operation with which to
    // react to the event.

    switch (rDescriptor.mnEventCode & (DRAG_ACTIVE | MULTI_SELECTOR))
    {
        case DRAG_ACTIVE:
            ProcessEventWhileDragActive(rDescriptor);
            break;

        case MULTI_SELECTOR:
            ProcessEventWhileMultiSelectorActive(rDescriptor);
            break;

        default:
            OSL_ASSERT(!mpMouseMultiSelector);
            OSL_ASSERT(!mpDragAndDropContext);
            switch (rDescriptor.mnEventCode & (BUTTON_DOWN | BUTTON_UP | MOUSE_MOTION))
            {
                case BUTTON_DOWN:
                    ProcessButtonDownEvent(rDescriptor);
                    break;

                case BUTTON_UP:
                    ProcessButtonUpEvent(rDescriptor);
                    break;

                case MOUSE_MOTION:
                    ProcessMouseMotionEvent(rDescriptor);
                    break;
            }
    }

    mrController.GetPageSelector().EnableBroadcasting(rDescriptor.mbMakeSelectionVisible);

    return bResult;
}




void SelectionFunction::ProcessEventWhileDragActive (EventDescriptor& rDescriptor)
{
    OSL_ASSERT(mpDragAndDropContext);
    // The substitution is visible.  Handle events accordingly.
    if (Match(rDescriptor.mnEventCode, MOUSE_MOTION | LEFT_BUTTON | SINGLE_CLICK))
    {
        //        mpDragAndDropContext->UpdatePosition(
        //            rDescriptor.maMousePosition,
        //            rDescriptor.meDragMode);
    }
    else if (Match(rDescriptor.mnEventCode, MOUSE_DRAG))
    {
        mpDragAndDropContext->UpdatePosition(
            rDescriptor.maMousePosition,
            rDescriptor.meDragMode);
    }
    else if (Match(rDescriptor.mnEventCode, BUTTON_UP | LEFT_BUTTON))
    {
        // The following Process() call may lead to the desctruction
        // of rDescriptor.mpHitDescriptor so release our reference to it.
        rDescriptor.mpHitDescriptor.reset();
        mpDragAndDropContext.reset();
    }
}




void SelectionFunction::ProcessEventWhileMultiSelectorActive (EventDescriptor& rDescriptor)
{
    OSL_ASSERT(mpMouseMultiSelector);
    // The selection rectangle is visible.  Handle events accordingly.
    if (Match(rDescriptor.mnEventCode, MOUSE_MOTION | LEFT_BUTTON | SINGLE_CLICK))
    {
        if (mpMouseMultiSelector)
        {
            mpMouseMultiSelector->SetSelectionModeFromModifier(rDescriptor.mnEventCode);
            mpMouseMultiSelector->UpdatePosition(rDescriptor.maMousePosition);
        }
        rDescriptor.mbMakeSelectionVisible = false;
    }
    else if (Match(rDescriptor.mnEventCode, BUTTON_UP | LEFT_BUTTON | SINGLE_CLICK))
    {
        mpMouseMultiSelector.reset();
    }
    // Anything else stops the rectangle selection and the event is
    // processed again.
    else
    {
        mpMouseMultiSelector.reset();
        rDescriptor.mnEventCode &= ~MULTI_SELECTOR;
        ProcessEvent(rDescriptor);
    }
}




void SelectionFunction::ProcessButtonDownEvent (EventDescriptor& rDescriptor)
{
    switch (rDescriptor.mnEventCode)
    {
        case BUTTON_DOWN | LEFT_BUTTON | SINGLE_CLICK | OVER_UNSELECTED_PAGE:
            SetCurrentPage(rDescriptor.mpHitDescriptor);
            break;

        case BUTTON_DOWN | LEFT_BUTTON | SINGLE_CLICK | OVER_SELECTED_PAGE:
            break;

        case BUTTON_DOWN | LEFT_BUTTON | DOUBLE_CLICK | OVER_SELECTED_PAGE:
        case BUTTON_DOWN | LEFT_BUTTON | DOUBLE_CLICK | OVER_UNSELECTED_PAGE:
            // A double click allways shows the selected slide in the center
            // pane in an edit view.
            SetCurrentPage(rDescriptor.mpHitDescriptor);
            SwitchView(rDescriptor.mpHitDescriptor);
            break;

        case BUTTON_DOWN | LEFT_BUTTON | SINGLE_CLICK | OVER_SELECTED_PAGE | SHIFT_MODIFIER:
        case BUTTON_DOWN | LEFT_BUTTON | SINGLE_CLICK | OVER_UNSELECTED_PAGE | SHIFT_MODIFIER:
            // Range selection with the shift modifier.
            RangeSelect(rDescriptor.mpHitDescriptor);
            break;

        case BUTTON_DOWN | LEFT_BUTTON | SINGLE_CLICK | OVER_UNSELECTED_PAGE | OVER_BUTTON:
        case BUTTON_DOWN | LEFT_BUTTON | SINGLE_CLICK | OVER_SELECTED_PAGE | OVER_BUTTON:
            // Remember page and button index.  When mouse button is
            // released over same page and button then invoke action of that
            // button.
            mnButtonDownButtonIndex = rDescriptor.mnButtonIndex;
            OSL_ASSERT(rDescriptor.mpHitDescriptor);
            mnButtonDownPageIndex = rDescriptor.mpHitDescriptor->GetPageIndex();
            rDescriptor.mpHitDescriptor->GetVisualState().SetActiveButtonState(
                mnButtonDownButtonIndex,
                model::VisualState::BS_Pressed);
            mrSlideSorter.GetView().RequestRepaint(rDescriptor.mpHitDescriptor);
            break;

            // Right button for context menu.
        case BUTTON_DOWN | RIGHT_BUTTON | SINGLE_CLICK | OVER_UNSELECTED_PAGE:
            // Single right click and shift+F10 select as preparation to
            // show the context menu.  Change the selection only when the
            // page under the mouse is not selected.  In this case the
            // selection is set to this single page.  Otherwise the
            // selection is not modified.
            DeselectAllPages();
            SetCurrentPage(rDescriptor.mpHitDescriptor);
            rDescriptor.mbMakeSelectionVisible = false;
            break;

        case BUTTON_DOWN | RIGHT_BUTTON | SINGLE_CLICK | OVER_SELECTED_PAGE:
            // Do not change the selection.  Just adjust the insertion indicator.
            rDescriptor.mbMakeSelectionVisible = false;
            break;

        case BUTTON_DOWN | RIGHT_BUTTON | SINGLE_CLICK | NOT_OVER_PAGE:
            // Fallthrough.
        case ANY_MODIFIER(BUTTON_DOWN | LEFT_BUTTON | SINGLE_CLICK | NOT_OVER_PAGE):
            DeselectAllPages();
            break;
    }
}




void SelectionFunction::ProcessButtonUpEvent (const EventDescriptor& rDescriptor)
{
    switch (rDescriptor.mnEventCode)
    {
        case BUTTON_UP | LEFT_BUTTON | SINGLE_CLICK | OVER_SELECTED_PAGE:
            SetCurrentPage(rDescriptor.mpHitDescriptor);
            break;

            // Multi selection with the control modifier.
        case BUTTON_UP | LEFT_BUTTON | SINGLE_CLICK | OVER_SELECTED_PAGE | CONTROL_MODIFIER:
            mrController.GetPageSelector().DeselectPage(rDescriptor.mpHitDescriptor);
            break;

        case BUTTON_UP | LEFT_BUTTON | SINGLE_CLICK | OVER_UNSELECTED_PAGE | CONTROL_MODIFIER:
            mrController.GetPageSelector().SelectPage(rDescriptor.mpHitDescriptor);
            // fallthrough
        case BUTTON_UP | LEFT_BUTTON | SINGLE_CLICK | OVER_UNSELECTED_PAGE | OVER_BUTTON:
        case BUTTON_UP | LEFT_BUTTON | SINGLE_CLICK | OVER_SELECTED_PAGE | OVER_BUTTON:
            if (mnButtonDownButtonIndex == rDescriptor.mnButtonIndex
                && mnButtonDownPageIndex == rDescriptor.mpHitDescriptor->GetPageIndex())
            {
                ProcessButtonClick(rDescriptor.mpHitDescriptor, mnButtonDownButtonIndex);
            }
            break;

        case BUTTON_UP | LEFT_BUTTON | SINGLE_CLICK | NOT_OVER_PAGE:
            if (mbIsDeselectionPending)
                DeselectAllPages();
            break;
    }
}




void SelectionFunction::ProcessMouseMotionEvent (const EventDescriptor& rDescriptor)
{
    switch (rDescriptor.mnEventCode)
    {
        case ANY_MODIFIER(MOUSE_MOTION | LEFT_BUTTON | SINGLE_CLICK | OVER_UNSELECTED_PAGE):
            SetCurrentPage(rDescriptor.mpHitDescriptor);
            // Fallthrough

        // A mouse motion without visible substitution starts that.
        case ANY_MODIFIER(MOUSE_MOTION | LEFT_BUTTON | SINGLE_CLICK | OVER_SELECTED_PAGE):
            StartDrag(
                rDescriptor.maMousePosition,
                (rDescriptor.mnEventCode & CONTROL_MODIFIER) != 0
                    ? InsertionIndicatorHandler::CopyMode
                    : InsertionIndicatorHandler::MoveMode);
            break;

            // A mouse motion not over a page starts a rectangle selection.
        case ANY_MODIFIER(MOUSE_MOTION | LEFT_BUTTON | SINGLE_CLICK | NOT_OVER_PAGE):
            OSL_ASSERT(!mpMouseMultiSelector);
            mpMouseMultiSelector.reset(
                new RangeSelector(mrSlideSorter, rDescriptor.maMouseModelPosition));
            mpMouseMultiSelector->SetSelectionModeFromModifier(rDescriptor.mnEventCode);
            break;
    }
}




void SelectionFunction::PostProcessEvent (const EventDescriptor& rDescriptor)
{
    if (rDescriptor.mnEventCode & BUTTON_UP)
    {
        mpWindow->ReleaseMouse();

        // Now turn them off.
        if ( ! mrController.IsContextMenuOpen())
            mrController.GetInsertionIndicatorHandler()->End();

        mnButtonDownPageIndex = -1;
        mnButtonDownButtonIndex = -1;
    }
}




void SelectionFunction::SetCurrentPage (const model::SharedPageDescriptor& rpDescriptor)
{
    PageSelector& rSelector (mrController.GetPageSelector());
    rSelector.DeselectAllPages ();
    rSelector.SelectPage(rpDescriptor);

    mrController.GetCurrentSlideManager()->SwitchCurrentSlide(rpDescriptor);
    mrController.GetFocusManager().SetFocusedPage(rpDescriptor);

    mnShiftKeySelectionAnchor = -1;
}




void SelectionFunction::SwitchView (const model::SharedPageDescriptor& rpDescriptor)
{
    // Switch to the draw view.  This is done only when the current
    // view is the main view.
    ViewShell* pViewShell = mrSlideSorter.GetViewShell();
    if (pViewShell!=NULL && pViewShell->IsMainViewShell())
    {
        if (rpDescriptor.get()!=NULL && rpDescriptor->GetPage()!=NULL)
        {
            mrSlideSorter.GetModel().GetDocument()->SetSelected(rpDescriptor->GetPage(), TRUE);
            mpViewShell->GetFrameView()->SetSelectedPage(
                (rpDescriptor->GetPage()->GetPageNum()-1)/2);
        }
        if (mrSlideSorter.GetViewShellBase() != NULL)
        framework::FrameworkHelper::Instance(*mrSlideSorter.GetViewShellBase())->RequestView(
            framework::FrameworkHelper::msImpressViewURL,
            framework::FrameworkHelper::msCenterPaneURL);
    }
}




void SelectionFunction::ProcessButtonClick (
    const model::SharedPageDescriptor& rpDescriptor,
    const sal_Int32 nButtonIndex)
{
    OSL_ASSERT(rpDescriptor);

    PageSelector::UpdateLock aLock (mrSlideSorter);
    PageSelector& rSelector (mrSlideSorter.GetController().GetPageSelector());
    switch (nButtonIndex)
    {
        case 2:
            // Start slide show at current slide.
            mrSlideSorter.GetController().GetCurrentSlideManager()->SwitchCurrentSlide(
                rpDescriptor);
            if (mrSlideSorter.GetViewShell() != NULL)
                mrSlideSorter.GetViewShell()->GetDispatcher()->Execute(
                    SID_PRESENTATION,
                    SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
            break;

        case 1:
            // Toggle exclusion state.
            rSelector.DeselectAllPages();
            rSelector.SelectPage(rpDescriptor);
            if (mrSlideSorter.GetViewShell() != NULL)
                mrSlideSorter.GetViewShell()->GetDispatcher()->Execute(
                    rpDescriptor->HasState(model::PageDescriptor::ST_Excluded)
                        ? SID_SHOW_SLIDE
                        : SID_HIDE_SLIDE,
                    SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
            break;

        case 0:
            // Insert page after current page.
            rSelector.DeselectAllPages();
            rSelector.SelectPage(rpDescriptor);
            if (mrSlideSorter.GetViewShell() != NULL)
                mrSlideSorter.GetViewShell()->GetDispatcher()->Execute(
                    SID_INSERTPAGE,
                    SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
            break;
    }
}




//===== EventDescriptor =======================================================

SelectionFunction::EventDescriptor::EventDescriptor (
    sal_uInt32 nEventType,
    const Point& rMousePosition,
    SlideSorter& rSlideSorter)
    : maMousePosition(rMousePosition),
      maMouseModelPosition(),
      mpHitDescriptor(),
      mpHitPage(),
      mnEventCode(nEventType),
      mnButtonIndex(-1)
{
    maMouseModelPosition = rSlideSorter.GetContentWindow()->PixelToLogic(maMousePosition);
    mpHitDescriptor = rSlideSorter.GetController().GetPageAt(maMousePosition);
    if (mpHitDescriptor)
    {
        mpHitPage = mpHitDescriptor->GetPage();

        mnButtonIndex
            = rSlideSorter.GetView().GetLayouter().GetPageObjectLayouter()->GetButtonIndexAt(
                mpHitDescriptor,
                maMouseModelPosition);
    }
}





SelectionFunction::EventDescriptor::EventDescriptor (
    const KeyEvent&,
    SlideSorter& rSlideSorter)
    : maMousePosition(),
      maMouseModelPosition(),
      mpHitDescriptor(),
      mpHitPage(),
      mnEventCode(0),
      mnButtonIndex(-1),
      meDragMode(InsertionIndicatorHandler::MoveMode),
      mbMakeSelectionVisible(true)
{
    model::SharedPageDescriptor pHitDescriptor (
        rSlideSorter.GetController().GetFocusManager().GetFocusedPageDescriptor());
    if (pHitDescriptor.get() != NULL)
    {
        mpHitPage = pHitDescriptor->GetPage();
        mpHitDescriptor = pHitDescriptor;
    }
}





SelectionFunction::EventDescriptor::EventDescriptor (const EventDescriptor& rDescriptor)
    : maMousePosition(rDescriptor.maMousePosition),
      maMouseModelPosition(rDescriptor.maMouseModelPosition),
      mpHitDescriptor(rDescriptor.mpHitDescriptor),
      mpHitPage(rDescriptor.mpHitPage),
      mnEventCode(rDescriptor.mnEventCode),
      mnButtonIndex(rDescriptor.mnButtonIndex),
      meDragMode(InsertionIndicatorHandler::MoveMode),
      mbMakeSelectionVisible(true)
{
}




void SelectionFunction::EventDescriptor::SetDragMode (const InsertionIndicatorHandler::Mode eMode)
{
    meDragMode = eMode;
}




//===== SelectionFunction::MouseMultiSelector ======================================

SelectionFunction::MouseMultiSelector::MouseMultiSelector (
    SlideSorter& rSlideSorter,
    const Point& rMouseModelPosition)
    : mrSlideSorter(rSlideSorter),
      meSelectionMode(SM_Normal),
      maInitialSelection()
{
    (void)rMouseModelPosition;
    // Remember the current selection.
    model::PageEnumeration aPages (
        model::PageEnumerationProvider::CreateAllPagesEnumeration(
            mrSlideSorter.GetModel()));
    while (aPages.HasMoreElements())
    {
        model::SharedPageDescriptor pDescriptor (aPages.GetNextElement());
        pDescriptor->SetState(
            model::PageDescriptor::ST_WasSelected,
            pDescriptor->HasState(model::PageDescriptor::ST_Selected));
    }
}




SelectionFunction::MouseMultiSelector::~MouseMultiSelector (void)
{
}




void SelectionFunction::MouseMultiSelector::RestoreInitialSelection (void)
{
    // Remember the current selection.
    model::PageEnumeration aPages (
        model::PageEnumerationProvider::CreateAllPagesEnumeration(
            mrSlideSorter.GetModel()));
    view::SlideSorterView& rView (mrSlideSorter.GetView());
    while (aPages.HasMoreElements())
    {
        model::SharedPageDescriptor pDescriptor (aPages.GetNextElement());
        pDescriptor->SetState(
            model::PageDescriptor::ST_Selected,
            pDescriptor->HasState(model::PageDescriptor::ST_WasSelected));
        rView.RequestRepaint(pDescriptor);
    }
}




void SelectionFunction::MouseMultiSelector::UpdatePosition (
    const Point& rMousePosition,
    const bool bAllowAutoScroll)
{
    // Convert window coordinates into model coordinates (we need the
    // window coordinates for auto-scrolling because that remains
    // constant while scrolling.)
    SharedSdWindow pWindow (mrSlideSorter.GetContentWindow());
    const Point aMouseModelPosition (pWindow->PixelToLogic(rMousePosition));

    if ( ! (bAllowAutoScroll && mrSlideSorter.GetController().GetScrollBarManager().AutoScroll(
        rMousePosition,
        ::boost::bind(
            &SelectionFunction::MouseMultiSelector::UpdatePosition,
            this,
            rMousePosition,
            false))))
    {
        UpdateModelPosition(aMouseModelPosition);
    }
}




void SelectionFunction::MouseMultiSelector::SetSelectionModeFromModifier (
    const sal_uInt32 nEventCode)
{
    switch (nEventCode & MODIFIER_MASK)
    {
        case NO_MODIFIER:
            SetSelectionMode(SM_Normal);
            break;

        case SHIFT_MODIFIER:
            SetSelectionMode(SM_Add);
            break;

        case CONTROL_MODIFIER:
            SetSelectionMode(SM_Toggle);
            break;
    }
}




void SelectionFunction::MouseMultiSelector::SetSelectionMode (const SelectionMode eSelectionMode)
{
    if (meSelectionMode != eSelectionMode)
    {
        meSelectionMode = eSelectionMode;
        UpdateSelection();
    }
}




void SelectionFunction::MouseMultiSelector::UpdateSelectionState (
    const model::SharedPageDescriptor& rpDescriptor,
    const bool bIsInSelection) const
{
    // Determine whether the page was selected before the rectangle
    // selection was started.
    const bool bWasSelected (rpDescriptor->HasState(model::PageDescriptor::ST_WasSelected));

    // Combine the two selection states depending on the selection mode.
    bool bSelect (false);
    switch(meSelectionMode)
    {
        case SM_Normal:
            bSelect = bIsInSelection;
            break;

        case SM_Add:
            bSelect = bIsInSelection || bWasSelected;
            break;

        case SM_Toggle:
            if (bIsInSelection)
                bSelect = !bWasSelected;
            else
                bSelect = bWasSelected;
            break;
    }

    // Set the new selection state.
    if (bSelect)
        mrSlideSorter.GetController().GetPageSelector().SelectPage(rpDescriptor);
    else
        mrSlideSorter.GetController().GetPageSelector().DeselectPage(rpDescriptor);
}




//===== RangeSelector =========================================================

namespace {

RangeSelector::RangeSelector (
    SlideSorter& rSlideSorter,
    const Point& rMouseModelPosition)
    : MouseMultiSelector(rSlideSorter,rMouseModelPosition),
      maAnchor(rMouseModelPosition),
      maSecondCorner(rMouseModelPosition),
      maSavedPointer(mrSlideSorter.GetContentWindow()->GetPointer()),
      mnAnchorIndex(-1)
{
    const Pointer aSelectionPointer (POINTER_TEXT);
    mrSlideSorter.GetContentWindow()->SetPointer(aSelectionPointer);
}




RangeSelector::~RangeSelector (void)
{
    mrSlideSorter.GetContentWindow()->SetPointer(maSavedPointer);
}




void RangeSelector::UpdateModelPosition (const Point& rMouseModelPosition)
{
    maSecondCorner = rMouseModelPosition;
    UpdateSelection();
}




void RangeSelector::UpdateSelection (void)
{
    view::SlideSorterView::DrawLock aLock (mrSlideSorter);

    model::SlideSorterModel& rModel (mrSlideSorter.GetModel());
    const sal_Int32 nPageCount (rModel.GetPageCount());

    const sal_Int32 nIndexUnderMouse (
        mrSlideSorter.GetView().GetLayouter().GetIndexAtPoint (
            maSecondCorner,
            false));
    if (nIndexUnderMouse>=0 && nIndexUnderMouse<nPageCount)
    {
        if (mnAnchorIndex < 0)
            mnAnchorIndex = nIndexUnderMouse;
        mnSecondIndex = nIndexUnderMouse;

        Range aRange (mnAnchorIndex, mnSecondIndex);
        aRange.Justify();

        for (sal_Int32 nIndex=0; nIndex<nPageCount; ++nIndex)
        {
            model::SharedPageDescriptor pDescriptor (rModel.GetPageDescriptor(nIndex));

            UpdateSelectionState(pDescriptor, aRange.IsInside(nIndex));
        }

        // Rely on auto scrolling to make page objects visible.
        mrSlideSorter.GetController().GetSelectionManager()->ResetMakeSelectionVisiblePending();
    }
}




Rectangle RangeSelector::GetBoundingBox (void) const
{
    return Rectangle(
        ::std::min(maAnchor.X(), maSecondCorner.X()),
        ::std::min(maAnchor.Y(), maSecondCorner.Y()),
        ::std::max(maAnchor.X(), maSecondCorner.X()),
        ::std::max(maAnchor.Y(), maSecondCorner.Y()));
}


} // end of anonymous namespace


} } } // end of namespace ::sd::slidesorter::controller