SlideSorterController.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#pragma once
 
#include <model/SlsSharedPageDescriptor.hxx>
#include <pres.hxx>
 
#include <tools/link.hxx>
#include <tools/gen.hxx>
#include <rtl/ref.hxx>
#include <rtl/ustring.hxx>
 
#include <sddllapi.h>
 
#include <memory>
#include <vector>
 
namespace com::sun::star::container
{
class XIndexAccess;
}
namespace com::sun::star::uno
{
template <typename> class Reference;
}
namespace sd
{
class FuPoor;
}
namespace sd
{
class Window;
}
namespace vcl
{
class Window;
}
 
namespace sd::slidesorter
{
class SlideSorter;
}
namespace sd::slidesorter::view
{
class SlideSorterView;
}
namespace sd::slidesorter::model
{
class SlideSorterModel;
}
 
class CommandEvent;
class SdPage;
class SfxItemSet;
class SfxRequest;
class VclSimpleEvent;
class VclWindowEvent;
 
namespace sd::slidesorter::controller
{
class Animator;
class Clipboard;
class CurrentSlideManager;
class FocusManager;
class InsertionIndicatorHandler;
class Listener;
class PageSelector;
class ScrollBarManager;
class SelectionFunction;
class SelectionManager;
class SlotManager;
class VisibleAreaManager;
 
class SlideSorterController final
{
public:
    SlideSorterController(SlideSorter& rSlideSorter);
 
    void Init();
 
    ~SlideSorterController();
 
    void Dispose();
 
    void Resize(const ::tools::Rectangle& rAvailableSpace);
 
    void Rearrange(bool bForce);
 
    model::SharedPageDescriptor GetPageAt(const Point& rPixelPosition);
 
    // Exported for unit test
    SD_DLLPUBLIC PageSelector& GetPageSelector();
    FocusManager& GetFocusManager();
    // Exported for unit test
    SD_DLLPUBLIC controller::Clipboard& GetClipboard();
 
    ScrollBarManager& GetScrollBarManager();
 
    std::shared_ptr<CurrentSlideManager> const& GetCurrentSlideManager() const;
    std::shared_ptr<SlotManager> const& GetSlotManager() const;
    std::shared_ptr<SelectionManager> const& GetSelectionManager() const;
    std::shared_ptr<InsertionIndicatorHandler> const& GetInsertionIndicatorHandler() const;
 
    void Paint(const ::tools::Rectangle& rRect, vcl::Window* pWin);
 
    void FuTemporary(SfxRequest& rRequest);
    void FuPermanent(SfxRequest& rRequest);
    void FuSupport(SfxRequest& rRequest);
    bool Command(const CommandEvent& rEvent, ::sd::Window* pWindow);
 
    void GetCtrlState(SfxItemSet& rSet);
    void GetStatusBarState(SfxItemSet& rSet);
 
    void ExecCtrl(SfxRequest& rRequest);
    void GetAttrState(SfxItemSet& rSet);
 
    class ModelChangeLock
    {
    public:
        ModelChangeLock(SlideSorterController& rController);
        ~ModelChangeLock() COVERITY_NOEXCEPT_FALSE;
        void Release();
 
    private:
        SlideSorterController* mpController;
    };
    friend class ModelChangeLock;
 
    void HandleModelChange();
 
    DECL_LINK(WindowEventHandler, VclWindowEvent&, void);
    DECL_LINK(ApplicationEventHandler, VclSimpleEvent&, void);
 
    void UpdateAllPages();
 
    rtl::Reference<FuPoor> CreateSelectionFunction(SfxRequest& rRequest);
 
    ::rtl::Reference<SelectionFunction> GetCurrentSelectionFunction() const;
 
    void PrepareEditModeChange();
 
    void ChangeEditMode(EditMode eEditMode);
 
    void FinishEditModeChange();
 
    void PageNameHasChanged(int nPageIndex, const OUString& rsOldName);
 
    void SetDocumentSlides(const css::uno::Reference<css::container::XIndexAccess>& rxSlides);
 
    const std::shared_ptr<Animator>& GetAnimator() const { return mpAnimator; }
 
    VisibleAreaManager& GetVisibleAreaManager() const;
 
    void CheckForMasterPageAssignment();
    void CheckForSlideTransitionAssignment();
 
private:
    SlideSorter& mrSlideSorter;
    model::SlideSorterModel& mrModel;
    view::SlideSorterView& mrView;
    std::unique_ptr<PageSelector> mpPageSelector;
    std::unique_ptr<FocusManager> mpFocusManager;
    std::shared_ptr<SlotManager> mpSlotManager;
    std::unique_ptr<ScrollBarManager> mpScrollBarManager;
    mutable std::shared_ptr<CurrentSlideManager> mpCurrentSlideManager;
    std::shared_ptr<SelectionManager> mpSelectionManager;
    std::unique_ptr<controller::Clipboard> mpClipboard;
    std::shared_ptr<InsertionIndicatorHandler> mpInsertionIndicatorHandler;
    std::shared_ptr<Animator> mpAnimator;
    std::unique_ptr<VisibleAreaManager> mpVisibleAreaManager;
 
    // The listener listens to UNO events and thus is a UNO object.
    ::rtl::Reference<controller::Listener> mpListener;
 
    int mnModelChangeLockCount;
    bool mbIsForcedRearrangePending;
    bool mbContextMenuOpen;
 
    bool mbPostModelChangePending;
 
    ::std::vector<SdPage*> maSelectionBeforeSwitch;
    int mnCurrentPageBeforeSwitch;
 
    SdPage* mpEditModeChangeMasterPage;
 
    ::tools::Rectangle maTotalWindowArea;
 
    sal_Int32 mnPaintEntranceCount;
 
    void LockModelChange();
 
    void UnlockModelChange();
 
    void PreModelChange();
 
    void PostModelChange();
};
 
} // end of namespace ::sd::slidesorter::controller
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */