main/sd/source/ui/sidebar/MasterPageDescriptor.hxx

/**************************************************************
 * 
 * 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
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/

#ifndef SD_SIDEBAR_PANELS_MASTER_PAGE_DESCRIPTOR_HXX
#define SD_SIDEBAR_PANELS_MASTER_PAGE_DESCRIPTOR_HXX

#include "MasterPageContainer.hxx"
#include <boost/shared_ptr.hpp>

namespace sd { namespace sidebar {

class PageObjectProvider;
class PreviewProvider;

class MasterPageDescriptor;
typedef ::boost::shared_ptr<MasterPageDescriptor> SharedMasterPageDescriptor;

/** A collection of data that is stored for every master page in the
    MasterpageContainer.
*/
class MasterPageDescriptor
{
public:
    MasterPageDescriptor (
        MasterPageContainer::Origin eOrigin,
        const sal_Int32 nTemplateIndex,
        const String& rURL,
        const String& rPageName,
        const String& rStyleName,
        const bool bIsPrecious,
        const ::boost::shared_ptr<PageObjectProvider>& rpPageObjectProvider,
        const ::boost::shared_ptr<PreviewProvider>& rpPreviewProvider);
    MasterPageDescriptor (const MasterPageDescriptor& rDescriptor);
    ~MasterPageDescriptor (void);

    void SetToken (MasterPageContainer::Token aToken);

    /** Update the called MasterPageDescriptor object with values from the
        given one.  Only those values are updated that have default values
        in the called object and that have non-default values in the given
        one.
        @return
            Returns a list of event types for which event notifications have
            to be sent to listeners.  The list may be empty or NULL.
    */
    ::std::auto_ptr<std::vector<MasterPageContainerChangeEvent::EventType> >
        Update (
            const MasterPageDescriptor& rDescriptor);
    
    /** This convenience method returns either a small or a large preview,
        depending on the given size specifier.
        Note that the previews are not created when they are not present.
        @return
            The returned preview may be empty.
    */
    Image GetPreview (MasterPageContainer::PreviewSize ePreviewSize);

    /** Use the PreviewProvider to get access to a preview of the master
        page.
        
        Note that this is only done, when either bForce is <TRUE/> or
        the PreviewProvider::GetCostIndex() returns 0.
        
        The small preview is created by scaling the large one, not by
        calling PreviewProvider::operator() a second time.
        
        It is the responsibility of the caller to call UpdatePageObject()
        before calling this method  when the PreviewProvider can only work
        when the master page object is present, i.e. its NeedsPageObject()
        method returns <TRUE/>.
        
        @param nCostThreshold
            When this is zero or positive then the preview is created only
            when the preview provider has a cost equal to or smaller than
            this threshold.  A negative value forces the preview to be
            created, regardless of the cost.
        @param rSmallSize
            Size of the small preview.
        @param rLargeSize
            Size of the large preview.
        @param rRenderer
            A PreviewRenderer object that may be used to create a preview.
        @return
            When the previews are successfully provided then <TRUE/> is
            returned.
    */
    bool UpdatePreview (
        sal_Int32 nCostThreshold,
        const Size& rSmallSize,
        const Size& rLargeSize,
        ::sd::PreviewRenderer& rRenderer);

    /** Use the PageObjectProvider to get access to the master page object.
        
        Note that this is only done, when either bForce is <TRUE/> or the
        PreviewProvider::GetCostIndex() returns 0.

        @param nCostThreshold
            When this is zero or positive then the page object is created
            only when the page object provider has a cost equal to or
            smaller than this threshold.  A negative value forces the
            page object be created, regardless of the cost.
        @param pDocument
            This document of the MasterPageContainer may be used to create
            a page object with or store one in.
        @return
            When the master page object is successfully provided then
            <TRUE/> is returned.
    */
    bool UpdatePageObject (
        sal_Int32 nCostThreshold,
        SdDrawDocument* pDocument);

    enum URLClassification {
        URLCLASS_USER,
        URLCLASS_LAYOUT,
        URLCLASS_PRESENTATION,
        URLCLASS_OTHER,
        URLCLASS_UNKNOWN,
        URLCLASS_UNDETERMINED
    };

    URLClassification GetURLClassification (void);
    
    /** The Token under which the MasterPageContainer gives access to the
        object.
    */
    MasterPageContainer::Token maToken;

    /** A rough specification of the origin of the master page.
    */
    MasterPageContainer::Origin meOrigin;
    
    /** The URL is not empty for master pages loaded from a template
        document.
    */
    ::rtl::OUString msURL;
    
    /** Taken from the title of the template file.
    */
    ::rtl::OUString msPageName;
    
    /** Taken from the master page object.
    */
    ::rtl::OUString msStyleName;

    const bool mbIsPrecious;

    /** The actual master page.
    */
    SdPage* mpMasterPage;
    
    /** A slide that uses the master page.
    */
    SdPage* mpSlide;
    
    /** A small (the default size) preview of the master page.  May be
        empty.  When this smaller preview is not empty then the larger one
        is not empty, too.
    */
    Image maSmallPreview;
    
    /** A large preview of the master page.  May be empty.  When this larger
        preview is not empty then the smaller one is not empty, too.
    */
    Image maLargePreview;

    /** The prewview provider. May be empty.  May be replaced during the
        lifetime of a MasterPageDescriptor object.
    */
    ::boost::shared_ptr<PreviewProvider> mpPreviewProvider;

    /** The master page provider.  May be empty.  May be replaced during
        the lifetime of a MasterPageDescriptor object.
    */
    ::boost::shared_ptr<PageObjectProvider> mpPageObjectProvider;
    
    /** This index represents the order in which templates are provided via
        the TemplateScanner.  It defines the order in which the entries in
        the AllMasterPagesSelector are displayed.  The default value is -1.
    */
    sal_Int32 mnTemplateIndex;

    URLClassification meURLClassification;

    sal_Int32 mnUseCount;

    class URLComparator { public:
        ::rtl::OUString msURL;
        URLComparator (const ::rtl::OUString& sURL);
        bool operator() (const SharedMasterPageDescriptor& rDescriptor);
    };
    class StyleNameComparator { public:
        ::rtl::OUString msStyleName;
        StyleNameComparator (const ::rtl::OUString& sStyleName);
        bool operator() (const SharedMasterPageDescriptor& rDescriptor);
    };
    class PageObjectComparator { public:
        const SdPage* mpMasterPage;
        PageObjectComparator (const SdPage* pPageObject);
        bool operator() (const SharedMasterPageDescriptor& rDescriptor);
    };
    class AllComparator { public:
        AllComparator(const SharedMasterPageDescriptor& rDescriptor);
        bool operator() (const SharedMasterPageDescriptor& rDescriptor);
    private:
        SharedMasterPageDescriptor mpDescriptor;
    };


};


} } // end of namespace sd::sidebar

#endif