diff options
Diffstat (limited to 'sd/source/ui/view')
69 files changed, 49551 insertions, 0 deletions
diff --git a/sd/source/ui/view/DocumentRenderer.cxx b/sd/source/ui/view/DocumentRenderer.cxx new file mode 100755 index 000000000000..1660c05a124f --- /dev/null +++ b/sd/source/ui/view/DocumentRenderer.cxx @@ -0,0 +1,2388 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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 <com/sun/star/beans/XPropertySet.hpp> + +#include "DocumentRenderer.hxx" +#include "DocumentRenderer.hrc" + +#include "drawdoc.hxx" +#include "optsitem.hxx" +#include "sdresid.hxx" +#include "strings.hrc" +#include "sdattr.hxx" +#include "Window.hxx" +#include "drawview.hxx" +#include "DrawViewShell.hxx" +#include "FrameView.hxx" +#include "Outliner.hxx" +#include "OutlineViewShell.hxx" + +#include <basegfx/polygon/b2dpolygon.hxx> +#include <basegfx/polygon/b2dpolypolygon.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <sfx2/printer.hxx> +#include <editeng/editstat.hxx> +#include <editeng/outlobj.hxx> +#include <svx/svdetc.hxx> +#include <svx/svditer.hxx> +#include <svx/svdopage.hxx> +#include <svx/svdopath.hxx> +#include <svx/xlnclit.hxx> +#include <toolkit/awt/vclxdevice.hxx> +#include <tools/resary.hxx> +#include <unotools/localedatawrapper.hxx> +#include <vcl/msgbox.hxx> +#include <unotools/moduleoptions.hxx> + +#include <vector> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using ::rtl::OUString; + + +namespace sd { + +namespace { + OUString A2S (const char* pString) + { + return OUString::createFromAscii(pString); + } + + + + /** Convenience class to extract values from the sequence of properties + given to one of the XRenderable methods. + */ + class PrintOptions + { + public: + PrintOptions ( + const vcl::PrinterOptionsHelper& rHelper, + const ::std::vector<sal_Int32>& rSlidesPerPage) + : mrProperties(rHelper), + maSlidesPerPage(rSlidesPerPage) + { + } + + bool IsWarningOrientation (void) const + { + return GetBoolValue(NULL, true); + } + + bool IsPrintPageName (void) const + { + return GetBoolValue("IsPrintName"); + } + + bool IsDate (void) const + { + return GetBoolValue("IsPrintDateTime"); + } + + bool IsTime (void) const + { + return GetBoolValue("IsPrintDateTime"); + } + + bool IsHiddenPages (void) const + { + return GetBoolValue("IsPrintHidden"); + } + + bool IsHandoutHorizontal (void) const + { + return GetBoolValue("SlidesPerPageOrder", sal_Int32(0), true); + } + + sal_Int32 GetHandoutPageCount (void) const + { + sal_uInt32 nIndex = static_cast<sal_Int32>(mrProperties.getIntValue("SlidesPerPage", sal_Int32(0))); + if (nIndex<maSlidesPerPage.size()) + return maSlidesPerPage[nIndex]; + else if ( ! maSlidesPerPage.empty()) + return maSlidesPerPage[0]; + else + return 0; + } + + bool IsDraw (void) const + { + return GetBoolValue("PageContentType", sal_Int32(0)); + } + + bool IsHandout (void) const + { + return GetBoolValue("PageContentType", sal_Int32(1)); + } + + bool IsNotes (void) const + { + return GetBoolValue("PageContentType", sal_Int32(2)); + } + + bool IsOutline (void) const + { + return GetBoolValue("PageContentType", sal_Int32(3)); + } + + ULONG GetOutputQuality (void) const + { + sal_Int32 nQuality = static_cast<sal_Int32>(mrProperties.getIntValue( "Quality", sal_Int32(0) )); + return nQuality; + } + + bool IsPageSize (void) const + { + return GetBoolValue("PageOptions", sal_Int32(1)); + } + + bool IsTilePage (void) const + { + return GetBoolValue("PageOptions", sal_Int32(2)) || GetBoolValue("PageOptions", sal_Int32(3)); + } + + bool IsCutPage (void) const + { + return GetBoolValue("PageOptions", sal_Int32(0)); + } + + bool IsBooklet (void) const + { + return GetBoolValue("PrintProspect", false); + } + + bool IsPrintExcluded (void) const + { + return (IsNotes() || IsDraw() || IsHandout()) && IsHiddenPages(); + } + + bool IsPrintFrontPage (void) const + { + sal_Int32 nInclude = static_cast<sal_Int32>(mrProperties.getIntValue( "PrintProspectInclude", 0 )); + return nInclude == 0 || nInclude == 1; + } + + bool IsPrintBackPage (void) const + { + sal_Int32 nInclude = static_cast<sal_Int32>(mrProperties.getIntValue( "PrintProspectInclude", 0 )); + return nInclude == 0 || nInclude == 2; + } + + bool IsPaperBin (void) const + { + return GetBoolValue("PrintPaperFromSetup", false); + } + + OUString GetPrinterSelection (void) const + { + sal_Int32 nContent = static_cast<sal_Int32>(mrProperties.getIntValue( "PrintContent", 0 )); + OUString sValue( A2S("all") ); + if( nContent == 1 ) + sValue = mrProperties.getStringValue( "PageRange", A2S( "all" ) ); + else if( nContent == 2 ) + sValue = A2S( "selection" ); + return sValue; + } + + private: + const vcl::PrinterOptionsHelper& mrProperties; + const ::std::vector<sal_Int32> maSlidesPerPage; + + /** When the value of the property with name pName is a boolean then + return its value. When the property is unknown then + bDefaultValue is returned. Otherwise <FALSE/> is returned. + */ + bool GetBoolValue ( + const sal_Char* pName, + const bool bDefaultValue = false) const + { + sal_Bool bValue = mrProperties.getBoolValue( pName, bDefaultValue ); + return bValue; + } + + /** Return <TRUE/> when the value of the property with name pName is + a string and its value equals pValue. When the property is + unknown then bDefaultValue is returned. Otherwise <FALSE/> is + returned. + */ + bool GetBoolValue ( + const sal_Char* pName, + const sal_Char* pValue, + const bool bDefaultValue = false) const + { + OUString sValue( mrProperties.getStringValue( pName ) ); + if (sValue.getLength()) + return sValue.equalsAscii(pValue); + else + return bDefaultValue; + } + + /** Return <TRUE/> when the value of the property with name pName is + an integer and its value is nTriggerValue. Otherwise <FALSE/> is + returned. + */ + bool GetBoolValue ( + const sal_Char* pName, + const sal_Int32 nTriggerValue) const + { + sal_Int32 nValue = static_cast<sal_Int32>(mrProperties.getIntValue( pName )); + return nValue == nTriggerValue; + } + }; + + + + /** This class is like MultiSelection but understands two special values. + "all" indicates that all pages are selected. "selection" indicates that no + pages but a set of shapes is selected. + */ + class Selection + { + public: + Selection (const OUString& rsSelection, const SdPage* pCurrentPage) + : mbAreAllPagesSelected(rsSelection.equalsAscii("all")), + mbIsShapeSelection(rsSelection.equalsAscii("selection")), + mnCurrentPageIndex(pCurrentPage!=NULL ? (pCurrentPage->GetPageNum()-1)/2 : -1), + mpSelectedPages() + { + if ( ! (mbAreAllPagesSelected || mbIsShapeSelection)) + mpSelectedPages.reset(new MultiSelection(rsSelection)); + } + + bool IsMarkedOnly (void) const + { + return mbIsShapeSelection; + } + + /** Call with a 0 based page index. + */ + bool IsSelected (const sal_Int32 nIndex) const + { + if (mbAreAllPagesSelected) + return true; + else if (mpSelectedPages) + return mpSelectedPages->IsSelected(nIndex+1); + else if (mbIsShapeSelection && nIndex==mnCurrentPageIndex) + return true; + else + return false; + } + + private: + const bool mbAreAllPagesSelected; + const bool mbIsShapeSelection; + const sal_Int32 mnCurrentPageIndex; + ::boost::scoped_ptr<MultiSelection> mpSelectedPages; + }; + + /** A collection of values that helps to reduce the number of arguments + given to some functions. Note that not all values are set at the + same time. + */ + class PrintInfo + { + public: + PrintInfo ( + const Printer* pPrinter, + const OUString& rsPrinterSelection, + const ::boost::shared_ptr<ViewShell> pView) + : mpPrinter(pPrinter), + mnDrawMode(DRAWMODE_DEFAULT), + msTimeDate(), + msPageString(), + maPrintSize(0,0), + maPageSize(0,0), + meOrientation(ORIENTATION_PORTRAIT), + maMap(), + maSelection(rsPrinterSelection, pView ? pView->getCurrentPage() : NULL), + mbPrintMarkedOnly(maSelection.IsMarkedOnly()) + {} + + const Printer* mpPrinter; + ULONG mnDrawMode; + ::rtl::OUString msTimeDate; + ::rtl::OUString msPageString; + Size maPrintSize; + Size maPageSize; + Orientation meOrientation; + MapMode maMap; + const Selection maSelection; + bool mbPrintMarkedOnly; + }; + + + + /** Output one page of the document to the given printer. Note that + more than one document page may be output to one printer page. + */ + void PrintPage ( + Printer& rPrinter, + ::sd::View& rPrintView, + SdPage& rPage, + View* pView, + const bool bPrintMarkedOnly, + const SetOfByte& rVisibleLayers, + const SetOfByte& rPrintableLayers) + { + rPrintView.ShowSdrPage(&rPage); + + const MapMode aOriginalMapMode (rPrinter.GetMapMode()); + + // Set the visible layers + SdrPageView* pPageView = rPrintView.GetSdrPageView(); + OSL_ASSERT(pPageView!=NULL); + pPageView->SetVisibleLayers(rVisibleLayers); + pPageView->SetPrintableLayers(rPrintableLayers); + + if (pView!=NULL && bPrintMarkedOnly) + pView->DrawMarkedObj(rPrinter); + else + rPrintView.CompleteRedraw(&rPrinter, Rectangle(Point(0,0), rPage.GetSize())); + + rPrinter.SetMapMode(aOriginalMapMode); + + rPrintView.HideSdrPage(); + } + + + + + /** Output a string (that typically is not part of a document page) to + the given printer. + */ + void PrintMessage ( + Printer& rPrinter, + const ::rtl::OUString& rsPageString, + const Point& rPageStringOffset) + { + const Font aOriginalFont (rPrinter.OutputDevice::GetFont()); + rPrinter.SetFont(Font(FAMILY_SWISS, Size(0, 423))); + rPrinter.DrawText(rPageStringOffset, rsPageString); + rPrinter.SetFont(aOriginalFont); + } + + + + + /** Read the resource file and process it into a sequence of properties + that can be passed to the printing dialog. + */ + class DialogCreator : Resource + { + public: + DialogCreator (bool bImpress) + : Resource(SdResId(_STR_IMPRESS_PRINT_UI_OPTIONS)) + , mbImpress(bImpress) + { + ProcessResource(); + } + + Sequence< beans::PropertyValue > GetDialogControls(void) const + { + if (maProperties.empty()) + return Sequence< beans::PropertyValue >(); + else + { + return Sequence<beans::PropertyValue>( + &maProperties.front(), + maProperties.size()); + } + } + + ::std::vector<sal_Int32> GetSlidesPerPage (void) const + { + return maSlidesPerPage; + } + + private: + Any maDialog; + ::std::vector<beans::PropertyValue> maProperties; + ::std::vector<sal_Int32> maSlidesPerPage; + bool mbImpress; + + void ProcessResource (void) + { + SvtModuleOptions aOpt; + String aAppGroupname( String( SdResId( _STR_IMPRESS_PRINT_UI_GROUP_NAME ) ) ); + aAppGroupname.SearchAndReplace( String( RTL_CONSTASCII_USTRINGPARAM( "%s" ) ), + aOpt.GetModuleName( mbImpress ? SvtModuleOptions::E_SIMPRESS : SvtModuleOptions::E_SDRAW ) ); + AddDialogControl( vcl::PrinterOptionsHelper::getGroupControlOpt( + aAppGroupname, + rtl::OUString() + ) ); + + if( mbImpress ) + { + vcl::PrinterOptionsHelper::UIControlOptions aPrintOpt; + aPrintOpt.maGroupHint = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "JobPage" ) ); + AddDialogControl( vcl::PrinterOptionsHelper::getSubgroupControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_PRINT_GROUP) ), + rtl::OUString(), + aPrintOpt ) + ); + + AddDialogControl( vcl::PrinterOptionsHelper::getChoiceControlOpt( + String( SdResId( _STR_IMPRESS_PRINT_UI_CONTENT ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_CONTENT_HELP), + OUString( RTL_CONSTASCII_USTRINGPARAM( "PageContentType" ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_CONTENT_CHOICES), + 0, + OUString( RTL_CONSTASCII_USTRINGPARAM( "List" ) ) + ) + ); + + vcl::PrinterOptionsHelper::UIControlOptions + aContentOpt( OUString( RTL_CONSTASCII_USTRINGPARAM( "PageContentType" ) ), 1 ); + AddDialogControl( vcl::PrinterOptionsHelper::getChoiceControlOpt( + String( SdResId( _STR_IMPRESS_PRINT_UI_SLIDESPERPAGE ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES_HELP), + OUString( RTL_CONSTASCII_USTRINGPARAM( "SlidesPerPage" ) ), + GetSlidesPerPageSequence(), + 0, + OUString( RTL_CONSTASCII_USTRINGPARAM( "List" ) ), + aContentOpt + ) + ); + + vcl::PrinterOptionsHelper::UIControlOptions + aSlidesPerPageOpt( OUString( RTL_CONSTASCII_USTRINGPARAM( "SlidesPerPage" ) ), -1, sal_True ); + AddDialogControl( vcl::PrinterOptionsHelper::getChoiceControlOpt( + String( SdResId( _STR_IMPRESS_PRINT_UI_ORDER ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_ORDER_CHOICES_HELP), + OUString( RTL_CONSTASCII_USTRINGPARAM( "SlidesPerPageOrder" ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_ORDER_CHOICES), + 0, + OUString( RTL_CONSTASCII_USTRINGPARAM( "List" ) ), + aSlidesPerPageOpt ) + ); + } + + AddDialogControl( vcl::PrinterOptionsHelper::getSubgroupControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_INCLUDE_CONTENT) ), rtl::OUString() ) ); + + + if( mbImpress ) + { + AddDialogControl( vcl::PrinterOptionsHelper::getBoolControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_NAME) ), + String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_NAME_HELP) ), + OUString( RTL_CONSTASCII_USTRINGPARAM( "IsPrintName" ) ), + sal_False + ) + ); + } + else + { + AddDialogControl( vcl::PrinterOptionsHelper::getBoolControlOpt( + String( SdResId(_STR_DRAW_PRINT_UI_IS_PRINT_NAME) ), + String( SdResId(_STR_DRAW_PRINT_UI_IS_PRINT_NAME_HELP) ), + OUString( RTL_CONSTASCII_USTRINGPARAM( "IsPrintName" ) ), + sal_False + ) + ); + } + + AddDialogControl( vcl::PrinterOptionsHelper::getBoolControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_DATE) ), + String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_DATE_HELP) ), + OUString( RTL_CONSTASCII_USTRINGPARAM( "IsPrintDateTime" ) ), + sal_False + ) + ); + + if( mbImpress ) + { + AddDialogControl( vcl::PrinterOptionsHelper::getBoolControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_HIDDEN) ), + String( SdResId(_STR_IMPRESS_PRINT_UI_IS_PRINT_HIDDEN_HELP) ), + OUString( RTL_CONSTASCII_USTRINGPARAM( "IsPrintHidden" ) ), + sal_False + ) + ); + } + + AddDialogControl( vcl::PrinterOptionsHelper::getSubgroupControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_QUALITY) ), rtl::OUString() ) ); + + AddDialogControl( vcl::PrinterOptionsHelper::getChoiceControlOpt( + rtl::OUString(), + CreateChoice(_STR_IMPRESS_PRINT_UI_QUALITY_CHOICES_HELP), + OUString( RTL_CONSTASCII_USTRINGPARAM( "Quality" ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_QUALITY_CHOICES), + 0 + ) + ); + + AddDialogControl( vcl::PrinterOptionsHelper::getSubgroupControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_PAGE_OPTIONS) ), rtl::OUString() ) ); + + if( mbImpress ) + { + // FIXME: additional dependency on PrintProspect = false + vcl::PrinterOptionsHelper::UIControlOptions + aPageOptionsOpt( OUString( RTL_CONSTASCII_USTRINGPARAM( "PageContentType" ) ), 0 ); + AddDialogControl( vcl::PrinterOptionsHelper::getChoiceControlOpt( + rtl::OUString(), + CreateChoice(_STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_HELP), + OUString( RTL_CONSTASCII_USTRINGPARAM( "PageOptions" ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES), + 0, + OUString( RTL_CONSTASCII_USTRINGPARAM( "Radio" ) ), + aPageOptionsOpt + ) + ); + } + else + { + vcl::PrinterOptionsHelper::UIControlOptions + aPageOptionsOpt( OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintProspect" ) ), sal_False ); + AddDialogControl( vcl::PrinterOptionsHelper::getChoiceControlOpt( + rtl::OUString(), + CreateChoice(_STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_HELP), + OUString( RTL_CONSTASCII_USTRINGPARAM( "PageOptions" ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_DRAW), + 0, + OUString( RTL_CONSTASCII_USTRINGPARAM( "Radio" ) ), + aPageOptionsOpt + ) + ); + } + + vcl::PrinterOptionsHelper::UIControlOptions aBrochureOpt; + aBrochureOpt.maGroupHint = OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutPage" ) ); + AddDialogControl( vcl::PrinterOptionsHelper::getSubgroupControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_PAGE_SIDES) ), rtl::OUString(), + aBrochureOpt ) ); + + // brochure printing + AddDialogControl( vcl::PrinterOptionsHelper::getBoolControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_BROCHURE) ), + String( SdResId(_STR_IMPRESS_PRINT_UI_BROCHURE_HELP) ), + OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintProspect" ) ), + sal_False, + aBrochureOpt + ) + ); + + vcl::PrinterOptionsHelper::UIControlOptions + aIncludeOpt( OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintProspect" ) ), -1, sal_False ); + aIncludeOpt.maGroupHint = OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutPage" ) ); + AddDialogControl( vcl::PrinterOptionsHelper::getChoiceControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST_HELP), + OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintProspectInclude" ) ), + CreateChoice(_STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST), + 0, + OUString( RTL_CONSTASCII_USTRINGPARAM( "List" ) ), + aIncludeOpt + ) + ); + + // paper tray (on options page) + vcl::PrinterOptionsHelper::UIControlOptions aPaperTrayOpt; + aPaperTrayOpt.maGroupHint = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "OptionsPageOptGroup" ) ); + AddDialogControl( vcl::PrinterOptionsHelper::getBoolControlOpt( + String( SdResId(_STR_IMPRESS_PRINT_UI_PAPER_TRAY) ), + String( SdResId(_STR_IMPRESS_PRINT_UI_PAPER_TRAY_HELP) ), + OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintPaperFromSetup" ) ), + sal_False, + aPaperTrayOpt + ) + ); + // print range selection + vcl::PrinterOptionsHelper::UIControlOptions aPrintRangeOpt; + aPrintRangeOpt.mbInternalOnly = sal_True; + aPrintRangeOpt.maGroupHint = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PrintRange" ) ); + AddDialogControl( vcl::PrinterOptionsHelper::getSubgroupControlOpt( + String( SdResId( _STR_IMPRESS_PRINT_UI_PAGE_RANGE ) ), + rtl::OUString(), + aPrintRangeOpt ) + ); + + // create a choice for the content to create + rtl::OUString aPrintRangeName( RTL_CONSTASCII_USTRINGPARAM( "PrintContent" ) ); + AddDialogControl( vcl::PrinterOptionsHelper::getChoiceControlOpt( rtl::OUString(), + CreateChoice(_STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE_HELP), + aPrintRangeName, + CreateChoice(mbImpress + ? _STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE + : _STR_DRAW_PRINT_UI_PAGE_RANGE_CHOICE), + 0 ) + ); + // create a an Edit dependent on "Pages" selected + vcl::PrinterOptionsHelper::UIControlOptions aPageRangeOpt( aPrintRangeName, 1, sal_True ); + AddDialogControl( vcl::PrinterOptionsHelper::getEditControlOpt( rtl::OUString(), + rtl::OUString(), + rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "PageRange" ) ), + rtl::OUString(), + aPageRangeOpt ) + ); + + FreeResource(); + } + + void AddDialogControl( const Any& i_rCtrl ) + { + beans::PropertyValue aVal; + aVal.Value = i_rCtrl; + maProperties.push_back( aVal ); + } + + Sequence<rtl::OUString> CreateChoice (const USHORT nResourceId) const + { + SdResId aResourceId (nResourceId); + ResStringArray aChoiceStrings (aResourceId); + + const sal_uInt32 nCount (aChoiceStrings.Count()); + Sequence<rtl::OUString> aChoices (nCount); + for (sal_uInt32 nIndex=0; nIndex<nCount; ++nIndex) + aChoices[nIndex] = aChoiceStrings.GetString(nIndex); + + return aChoices; + } + + Sequence<rtl::OUString> GetSlidesPerPageSequence (void) + { + const Sequence<rtl::OUString> aChoice ( + CreateChoice(_STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES)); + maSlidesPerPage.clear(); + maSlidesPerPage.push_back(0); // first is using the default + for (sal_Int32 nIndex=1,nCount=aChoice.getLength(); nIndex<nCount; ++nIndex) + maSlidesPerPage.push_back(aChoice[nIndex].toInt32()); + return aChoice; + } + }; + + + + + /** The Prepare... methods of the DocumentRenderer::Implementation class + create a set of PrinterPage objects that contain all necessary + information to do the actual printing. There is one PrinterPage + object per printed page. Derived classes implement the actual, mode + specific printing. + + This and all derived classes support the asynchronous printing + process by not storing pointers to any data with lifetime shorter + than the PrinterPage objects, i.e. slides, shapes, (one of) the + outliner (of the document). + */ + class PrinterPage + { + public: + PrinterPage ( + const PageKind ePageKind, + const MapMode& rMapMode, + const bool bPrintMarkedOnly, + const ::rtl::OUString& rsPageString, + const Point& rPageStringOffset, + const ULONG nDrawMode, + const Orientation eOrientation, + const USHORT nPaperTray) + : mePageKind(ePageKind), + maMap(rMapMode), + mbPrintMarkedOnly(bPrintMarkedOnly), + msPageString(rsPageString), + maPageStringOffset(rPageStringOffset), + mnDrawMode(nDrawMode), + meOrientation(eOrientation), + mnPaperTray(nPaperTray) + { + } + + virtual ~PrinterPage (void) {} + + virtual void Print ( + Printer& rPrinter, + SdDrawDocument& rDocument, + ViewShell& rViewShell, + View* pView, + DrawView& rPrintView, + const SetOfByte& rVisibleLayers, + const SetOfByte& rPrintableLayers) const = 0; + + ULONG GetDrawMode (void) const { return mnDrawMode; } + Orientation GetOrientation (void) const { return meOrientation; } + USHORT GetPaperTray (void) const { return mnPaperTray; } + + protected: + const PageKind mePageKind; + const MapMode maMap; + const bool mbPrintMarkedOnly; + const ::rtl::OUString msPageString; + const Point maPageStringOffset; + const ULONG mnDrawMode; + const Orientation meOrientation; + const USHORT mnPaperTray; + }; + + + + + /** The RegularPrinterPage is used for printing one regular slide (no + notes, handout, or outline) to one printer page. + */ + class RegularPrinterPage : public PrinterPage + { + public: + RegularPrinterPage ( + const USHORT nPageIndex, + const PageKind ePageKind, + const MapMode& rMapMode, + const bool bPrintMarkedOnly, + const ::rtl::OUString& rsPageString, + const Point& rPageStringOffset, + const ULONG nDrawMode, + const Orientation eOrientation, + const USHORT nPaperTray) + : PrinterPage(ePageKind, rMapMode, bPrintMarkedOnly, rsPageString, + rPageStringOffset, nDrawMode, eOrientation, nPaperTray), + mnPageIndex(nPageIndex) + { + } + + virtual ~RegularPrinterPage (void) {} + + virtual void Print ( + Printer& rPrinter, + SdDrawDocument& rDocument, + ViewShell& rViewShell, + View* pView, + DrawView& rPrintView, + const SetOfByte& rVisibleLayers, + const SetOfByte& rPrintableLayers) const + { + (void)rViewShell; + SdPage* pPageToPrint = rDocument.GetSdPage(mnPageIndex, mePageKind); + rPrinter.SetMapMode(maMap); + PrintPage( + rPrinter, + rPrintView, + *pPageToPrint, + pView, + mbPrintMarkedOnly, + rVisibleLayers, + rPrintableLayers); + PrintMessage( + rPrinter, + msPageString, + maPageStringOffset); + } + + private: + const USHORT mnPageIndex; + }; + + + + + /** Print one slide multiple times on a printer page so that the whole + printer page is covered. + */ + class TiledPrinterPage : public PrinterPage + { + public: + TiledPrinterPage ( + const USHORT nPageIndex, + const PageKind ePageKind, + const sal_Int32 nGap, + const bool bPrintMarkedOnly, + const ::rtl::OUString& rsPageString, + const Point& rPageStringOffset, + const ULONG nDrawMode, + const Orientation eOrientation, + const USHORT nPaperTray) + : PrinterPage(ePageKind, MapMode(), bPrintMarkedOnly, rsPageString, + rPageStringOffset, nDrawMode, eOrientation, nPaperTray), + mnPageIndex(nPageIndex), + mnGap(nGap) + { + } + + virtual ~TiledPrinterPage (void) {} + + virtual void Print ( + Printer& rPrinter, + SdDrawDocument& rDocument, + ViewShell& rViewShell, + View* pView, + DrawView& rPrintView, + const SetOfByte& rVisibleLayers, + const SetOfByte& rPrintableLayers) const + { + (void)rViewShell; + SdPage* pPageToPrint = rDocument.GetSdPage(mnPageIndex, mePageKind); + if (pPageToPrint==NULL) + return; + MapMode aMap (rPrinter.GetMapMode()); + + const Size aPageSize (pPageToPrint->GetSize()); + const Size aPrintSize (rPrinter.GetOutputSize()); + + const sal_Int32 nPageWidth (aPageSize.Width() + mnGap + - pPageToPrint->GetLftBorder() - pPageToPrint->GetRgtBorder()); + const sal_Int32 nPageHeight (aPageSize.Height() + mnGap + - pPageToPrint->GetUppBorder() - pPageToPrint->GetLwrBorder()); + if (nPageWidth<=0 || nPageHeight<=0) + return; + + // Print at least two rows and columns. More if the document + // page fits completely onto the printer page. + const sal_Int32 nColumnCount (::std::max(sal_Int32(2), + sal_Int32(aPrintSize.Width() / nPageWidth))); + const sal_Int32 nRowCount (::std::max(sal_Int32(2), + sal_Int32(aPrintSize.Height() / nPageHeight))); + Point aPrintOrigin; + for (sal_Int32 nRow=0; nRow<nRowCount; ++nRow) + for (sal_Int32 nColumn=0; nColumn<nColumnCount; ++nColumn) + { + aMap.SetOrigin(Point(nColumn*nPageWidth,nRow*nPageHeight)); + rPrinter.SetMapMode(aMap); + PrintPage( + rPrinter, + rPrintView, + *pPageToPrint, + pView, + mbPrintMarkedOnly, + rVisibleLayers, + rPrintableLayers); + } + + PrintMessage( + rPrinter, + msPageString, + maPageStringOffset); + } + + private: + const USHORT mnPageIndex; + const sal_Int32 mnGap; + }; + + /** Print two slides to one printer page so that the resulting pages + form a booklet. + */ + class BookletPrinterPage : public PrinterPage + { + public: + BookletPrinterPage ( + const USHORT nFirstPageIndex, + const USHORT nSecondPageIndex, + const Point& rFirstOffset, + const Point& rSecondOffset, + const PageKind ePageKind, + const MapMode& rMapMode, + const bool bPrintMarkedOnly, + const ULONG nDrawMode, + const Orientation eOrientation, + const USHORT nPaperTray) + : PrinterPage(ePageKind, rMapMode, bPrintMarkedOnly, ::rtl::OUString(), + Point(), nDrawMode, eOrientation, nPaperTray), + mnFirstPageIndex(nFirstPageIndex), + mnSecondPageIndex(nSecondPageIndex), + maFirstOffset(rFirstOffset), + maSecondOffset(rSecondOffset) + { + } + + virtual ~BookletPrinterPage (void) {} + + virtual void Print ( + Printer& rPrinter, + SdDrawDocument& rDocument, + ViewShell& rViewShell, + View* pView, + DrawView& rPrintView, + const SetOfByte& rVisibleLayers, + const SetOfByte& rPrintableLayers) const + { + (void)rViewShell; + MapMode aMap (maMap); + SdPage* pPageToPrint = rDocument.GetSdPage(mnFirstPageIndex, mePageKind); + if (pPageToPrint) + { + aMap.SetOrigin(maFirstOffset); + rPrinter.SetMapMode(aMap); + PrintPage( + rPrinter, + rPrintView, + *pPageToPrint, + pView, + mbPrintMarkedOnly, + rVisibleLayers, + rPrintableLayers); + } + + pPageToPrint = rDocument.GetSdPage(mnSecondPageIndex, mePageKind); + if( pPageToPrint ) + { + aMap.SetOrigin(maSecondOffset); + rPrinter.SetMapMode(aMap); + PrintPage( + rPrinter, + rPrintView, + *pPageToPrint, + pView, + mbPrintMarkedOnly, + rVisibleLayers, + rPrintableLayers); + } + } + + private: + const USHORT mnFirstPageIndex; + const USHORT mnSecondPageIndex; + const Point maFirstOffset; + const Point maSecondOffset; + }; + + + + + /** One handout page displays one to nine slides. + */ + class HandoutPrinterPage : public PrinterPage + { + public: + HandoutPrinterPage ( + const USHORT nHandoutPageIndex, + const ::std::vector<USHORT>& rPageIndices, + const MapMode& rMapMode, + const ::rtl::OUString& rsPageString, + const Point& rPageStringOffset, + const ULONG nDrawMode, + const Orientation eOrientation, + const USHORT nPaperTray) + : PrinterPage(PK_HANDOUT, rMapMode, false, rsPageString, + rPageStringOffset, nDrawMode, eOrientation, nPaperTray), + mnHandoutPageIndex(nHandoutPageIndex), + maPageIndices(rPageIndices) + { + } + + virtual void Print ( + Printer& rPrinter, + SdDrawDocument& rDocument, + ViewShell& rViewShell, + View* pView, + DrawView& rPrintView, + const SetOfByte& rVisibleLayers, + const SetOfByte& rPrintableLayers) const + { + SdPage& rHandoutPage (*rDocument.GetSdPage(0, PK_HANDOUT)); + + Reference< com::sun::star::beans::XPropertySet > xHandoutPage( rHandoutPage.getUnoPage(), UNO_QUERY ); + const rtl::OUString sPageNumber( RTL_CONSTASCII_USTRINGPARAM( "Number" ) ); + + // Collect the page objects of the handout master. + std::vector<SdrPageObj*> aHandoutPageObjects; + SdrObjListIter aShapeIter (rHandoutPage); + while (aShapeIter.IsMore()) + { + SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(aShapeIter.Next()); + if (pPageObj) + aHandoutPageObjects.push_back(pPageObj); + } + if (aHandoutPageObjects.empty()) + return; + + // Connect page objects with pages. + std::vector<SdrPageObj*>::iterator aPageObjIter (aHandoutPageObjects.begin()); + for (std::vector<USHORT>::const_iterator + iPageIndex(maPageIndices.begin()), + iEnd(maPageIndices.end()); + iPageIndex!=iEnd && aPageObjIter!=aHandoutPageObjects.end(); + ++iPageIndex) + { + // Check if the page still exists. + if (*iPageIndex >= rDocument.GetSdPageCount(PK_STANDARD)) + continue; + + SdrPageObj* pPageObj = (*aPageObjIter++); + pPageObj->SetReferencedPage(rDocument.GetSdPage(*iPageIndex, PK_STANDARD)); + } + + // if there are more page objects than pages left, set the rest to invisible + int nHangoverCount = 0; + while (aPageObjIter != aHandoutPageObjects.end()) + { + (*aPageObjIter++)->SetReferencedPage(0L); + nHangoverCount++; + } + + // Hide outlines for objects that have pages attached. + if (nHangoverCount > 0) + { + int nSkip = aHandoutPageObjects.size() - nHangoverCount; + aShapeIter.Reset(); + while (aShapeIter.IsMore()) + { + SdrPathObj* pPathObj = dynamic_cast<SdrPathObj*>(aShapeIter.Next()); + if (pPathObj) + { + if (nSkip > 0) + --nSkip; + else + pPathObj->SetMergedItem(XLineStyleItem(XLINE_NONE)); + } + } + } + + if( xHandoutPage.is() ) try + { + xHandoutPage->setPropertyValue( sPageNumber, Any( static_cast<sal_Int16>(mnHandoutPageIndex) ) ); + } + catch( Exception& ) + { + } + rViewShell.SetPrintedHandoutPageNum( mnHandoutPageIndex + 1 ); + + MapMode aMap (rPrinter.GetMapMode()); + rPrinter.SetMapMode(maMap); + + PrintPage( + rPrinter, + rPrintView, + rHandoutPage, + pView, + false, + rVisibleLayers, + rPrintableLayers); + PrintMessage( + rPrinter, + msPageString, + maPageStringOffset); + + if( xHandoutPage.is() ) try + { + xHandoutPage->setPropertyValue( sPageNumber, Any( static_cast<sal_Int16>(0) ) ); + } + catch( Exception& ) + { + } + rViewShell.SetPrintedHandoutPageNum(1); + + // Restore outlines. + if (nHangoverCount > 0) + { + aShapeIter.Reset(); + while (aShapeIter.IsMore()) + { + SdrPathObj* pPathObj = dynamic_cast<SdrPathObj*>(aShapeIter.Next()); + if (pPathObj != NULL) + pPathObj->SetMergedItem(XLineStyleItem(XLINE_SOLID)); + } + } + + } + + private: + const USHORT mnHandoutPageIndex; + const ::std::vector<USHORT> maPageIndices; + }; + + + + + /** The outline information (title, subtitle, outline objects) of the + document. There is no fixed mapping of slides to printer pages. + */ + class OutlinerPrinterPage : public PrinterPage + { + public: + OutlinerPrinterPage ( + OutlinerParaObject* pParaObject, + const MapMode& rMapMode, + const ::rtl::OUString& rsPageString, + const Point& rPageStringOffset, + const ULONG nDrawMode, + const Orientation eOrientation, + const USHORT nPaperTray) + : PrinterPage(PK_HANDOUT, rMapMode, false, rsPageString, + rPageStringOffset, nDrawMode, eOrientation, nPaperTray), + mpParaObject(pParaObject) + { + } + + ~OutlinerPrinterPage (void) + { + mpParaObject.reset(); + } + + virtual void Print ( + Printer& rPrinter, + SdDrawDocument& rDocument, + ViewShell& rViewShell, + View* pView, + DrawView& rPrintView, + const SetOfByte& rVisibleLayers, + const SetOfByte& rPrintableLayers) const + { + (void)rViewShell; + (void)pView; + (void)rPrintView; + (void)rVisibleLayers; + (void)rPrintableLayers; + + // Set up the printer. + rPrinter.SetMapMode(maMap); + + // Get and set up the outliner. + const Rectangle aOutRect (rPrinter.GetPageOffset(), rPrinter.GetOutputSize()); + Outliner* pOutliner = rDocument.GetInternalOutliner(); + const USHORT nSavedOutlMode (pOutliner->GetMode()); + const BOOL bSavedUpdateMode (pOutliner->GetUpdateMode()); + const Size aSavedPaperSize (pOutliner->GetPaperSize()); + + pOutliner->Init(OUTLINERMODE_OUTLINEVIEW); + pOutliner->SetPaperSize(aOutRect.GetSize()); + pOutliner->SetUpdateMode(TRUE); + pOutliner->Clear(); + pOutliner->SetText(*mpParaObject); + + pOutliner->Draw(&rPrinter, aOutRect); + + PrintMessage( + rPrinter, + msPageString, + maPageStringOffset); + + // Restore outliner and printer. + pOutliner->Clear(); + pOutliner->SetUpdateMode(bSavedUpdateMode); + pOutliner->SetPaperSize(aSavedPaperSize); + pOutliner->Init(nSavedOutlMode); + } + + private: + ::boost::scoped_ptr<OutlinerParaObject> mpParaObject; + }; +} + + +//===== DocumentRenderer::Implementation ====================================== + +class DocumentRenderer::Implementation + : public SfxListener, + public vcl::PrinterOptionsHelper +{ +public: + Implementation (ViewShellBase& rBase) + : mrBase(rBase), + mbIsDisposed(false), + mpPrinter(NULL), + mpOptions(), + maPrinterPages(), + mpPrintView(), + mbHasOrientationWarningBeenShown(false) + { + DialogCreator aCreator( mrBase.GetDocShell()->GetDocumentType() == DOCUMENT_TYPE_IMPRESS ); + m_aUIProperties = aCreator.GetDialogControls(); + maSlidesPerPage = aCreator.GetSlidesPerPage(); + + StartListening(mrBase); + } + + + + + virtual ~Implementation (void) + { + EndListening(mrBase); + } + + + + + virtual void Notify (SfxBroadcaster& rBroadcaster, const SfxHint& rHint) + { + const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint); + if (pSimpleHint != NULL + && pSimpleHint->GetId() == SFX_HINT_DYING + && &rBroadcaster == &static_cast<SfxBroadcaster&>(mrBase)) + { + Dispose(); + } + } + + + + /** Process the sequence of properties given to one of the XRenderable + methods. + */ + void ProcessProperties (const css::uno::Sequence<css::beans::PropertyValue >& rOptions) + { + OSL_ASSERT(!mbIsDisposed); + if (mbIsDisposed) + return; + + bool bIsValueChanged = processProperties( rOptions ); + + // The RenderDevice property is handled specially: its value is + // stored in mpPrinter instead of being retrieved on demand. + Any aDev( getValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "RenderDevice" ) ) ) ); + Reference<awt::XDevice> xRenderDevice; + + if (aDev >>= xRenderDevice) + { + VCLXDevice* pDevice = VCLXDevice::GetImplementation(xRenderDevice); + OutputDevice* pOut = pDevice ? pDevice->GetOutputDevice() : NULL; + mpPrinter = dynamic_cast<Printer*>(pOut); + } + + if (bIsValueChanged) + { + if ( ! mpOptions ) + mpOptions.reset(new PrintOptions(*this, maSlidesPerPage)); + PreparePages(); + } + } + + + + /** Return the number of pages that are to be printed. + */ + sal_Int32 GetPrintPageCount (void) + { + OSL_ASSERT(!mbIsDisposed); + if (mbIsDisposed) + return 0; + else + return maPrinterPages.size(); + } + + + + /** Return a sequence of properties that can be returned by the + XRenderable::getRenderer() method. + */ + css::uno::Sequence<css::beans::PropertyValue> GetProperties ( + const css::uno::Sequence<css::beans::PropertyValue>& rOptions) + { + (void)rOptions; + + css::uno::Sequence<css::beans::PropertyValue> aProperties (3); + + aProperties[0].Name = A2S("ExtraPrintUIOptions"); + aProperties[0].Value <<= m_aUIProperties; + + aProperties[1].Name = A2S("PageSize"); + aProperties[1].Value <<= maPrintSize; + + // FIXME: is this always true ? + aProperties[2].Name = A2S("PageIncludesNonprintableArea"); + aProperties[2].Value = makeAny( sal_True ); + + return aProperties; + } + + + + + /** Print one of the prepared pages. + */ + void PrintPage (const sal_Int32 nIndex) + { + OSL_ASSERT(!mbIsDisposed); + if (mbIsDisposed) + return; + + Printer& rPrinter (*mpPrinter); + + ::boost::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell()); + if ( ! pViewShell) + return; + + SdDrawDocument* pDocument = pViewShell->GetDoc(); + OSL_ASSERT(pDocument!=NULL); + + ::boost::shared_ptr<DrawViewShell> pDrawViewShell( + ::boost::dynamic_pointer_cast<DrawViewShell>(mrBase.GetMainViewShell())); + + if ( ! mpPrintView) + mpPrintView.reset(new DrawView(mrBase.GetDocShell(), &rPrinter, pDrawViewShell.get())); + + if (nIndex<0 || sal::static_int_cast<sal_uInt32>(nIndex)>=maPrinterPages.size()) + return; + + const ::boost::shared_ptr<PrinterPage> pPage (maPrinterPages[nIndex]); + OSL_ASSERT(pPage); + if ( ! pPage) + return; + + const Orientation eSavedOrientation (rPrinter.GetOrientation()); + const ULONG nSavedDrawMode (rPrinter.GetDrawMode()); + const MapMode aSavedMapMode (rPrinter.GetMapMode()); + const USHORT nSavedPaperBin (rPrinter.GetPaperBin()); + + + // Set page orientation. + if ( ! rPrinter.SetOrientation(pPage->GetOrientation())) + { + if ( ! mbHasOrientationWarningBeenShown + && mpOptions->IsWarningOrientation()) + { + mbHasOrientationWarningBeenShown = true; + // Show warning that the orientation could not be set. + if (pViewShell) + { + WarningBox aWarnBox( + pViewShell->GetActiveWindow(), + (WinBits)(WB_OK_CANCEL | WB_DEF_CANCEL), + String(SdResId(STR_WARN_PRINTFORMAT_FAILURE))); + if (aWarnBox.Execute() != RET_OK) + return; + } + } + } + + // Set the draw mode. + rPrinter.SetDrawMode(pPage->GetDrawMode()); + + // Set paper tray. + rPrinter.SetPaperBin(pPage->GetPaperTray()); + + // Print the actual page. + pPage->Print( + rPrinter, + *pDocument, + *pViewShell, + pDrawViewShell ? pDrawViewShell->GetView() : NULL, + *mpPrintView, + pViewShell->GetFrameView()->GetVisibleLayers(), + pViewShell->GetFrameView()->GetPrintableLayers()); + + rPrinter.SetOrientation(eSavedOrientation); + rPrinter.SetDrawMode(nSavedDrawMode); + rPrinter.SetMapMode(aSavedMapMode); + rPrinter.SetPaperBin(nSavedPaperBin); + } + + + + +private: + ViewShellBase& mrBase; + bool mbIsDisposed; + Printer* mpPrinter; + ::boost::scoped_ptr<PrintOptions> mpOptions; + ::std::vector< ::boost::shared_ptr< ::sd::PrinterPage> > maPrinterPages; + ::boost::scoped_ptr<DrawView> mpPrintView; + bool mbHasOrientationWarningBeenShown; + ::std::vector<sal_Int32> maSlidesPerPage; + awt::Size maPrintSize; + + void Dispose (void) + { + mbIsDisposed = true; + } + + + + /** Determine and set the paper orientation. + */ + bool SetupPaperOrientation ( + const PageKind ePageKind, + PrintInfo& rInfo) + { + SdDrawDocument* pDocument = mrBase.GetMainViewShell()->GetDoc(); + rInfo.meOrientation = ORIENTATION_PORTRAIT; + + if( ! mpOptions->IsBooklet()) + { + rInfo.meOrientation = pDocument->GetSdPage(0, ePageKind)->GetOrientation(); + } + else if (rInfo.maPageSize.Width() < rInfo.maPageSize.Height()) + rInfo.meOrientation = ORIENTATION_LANDSCAPE; + + const Size aPaperSize (rInfo.mpPrinter->GetPaperSize()); + if( (rInfo.meOrientation == ORIENTATION_LANDSCAPE && + (aPaperSize.Width() < aPaperSize.Height())) + || + (rInfo.meOrientation == ORIENTATION_PORTRAIT && + (aPaperSize.Width() > aPaperSize.Height())) + ) + { + maPrintSize = awt::Size(aPaperSize.Height(), aPaperSize.Width()); + // rInfo.maPrintSize = Size(rInfo.maPrintSize.Height(), rInfo.maPrintSize.Width()); + } + else + { + maPrintSize = awt::Size(aPaperSize.Width(), aPaperSize.Height()); + } + + return true; + } + + + + /** Top most method for preparing printer pages. In this and the other + Prepare... methods the various special cases are detected and + handled. + For every page that is to be printed (that may contain several + slides) one PrinterPage object is created and inserted into + maPrinterPages. + */ + void PreparePages (void) + { + mpPrintView.reset(); + maPrinterPages.clear(); + mbHasOrientationWarningBeenShown = false; + + ViewShell* pShell = mrBase.GetMainViewShell().get(); + + PrintInfo aInfo (mpPrinter, mpOptions->GetPrinterSelection(), mrBase.GetMainViewShell()); + + if (aInfo.mpPrinter!=NULL && pShell!=NULL) + { + + MapMode aMap (aInfo.mpPrinter->GetMapMode()); + aMap.SetMapUnit(MAP_100TH_MM); + aInfo.maMap = aMap; + mpPrinter->SetMapMode(aMap); + + ::Outliner& rOutliner = mrBase.GetDocument()->GetDrawOutliner(); + const ULONG nSavedControlWord (rOutliner.GetControlWord()); + ULONG nCntrl = nSavedControlWord; + nCntrl &= ~EE_CNTRL_MARKFIELDS; + nCntrl &= ~EE_CNTRL_ONLINESPELLING; + rOutliner.SetControlWord( nCntrl ); + + // When in outline view then apply all pending changes to the model. + if (pShell->ISA(OutlineViewShell)) + static_cast<OutlineViewShell*>(pShell)->PrepareClose (FALSE, FALSE); + + // Collect some frequently used data. + if (mpOptions->IsDate()) + { + aInfo.msTimeDate += GetSdrGlobalData().GetLocaleData()->getDate( Date() ); + aInfo.msTimeDate += ::rtl::OUString((sal_Unicode)' '); + } + + if (mpOptions->IsTime()) + aInfo.msTimeDate += GetSdrGlobalData().GetLocaleData()->getTime( Time(), FALSE, FALSE ); + aInfo.maPrintSize = aInfo.mpPrinter->GetOutputSize(); + maPrintSize = awt::Size( + aInfo.mpPrinter->GetPaperSize().Width(), + aInfo.mpPrinter->GetPaperSize().Height()); + + switch (mpOptions->GetOutputQuality()) + { + case 1: + aInfo.mnDrawMode = DRAWMODE_GRAYLINE | DRAWMODE_GRAYFILL + | DRAWMODE_BLACKTEXT | DRAWMODE_GRAYBITMAP + | DRAWMODE_GRAYGRADIENT; + break; + + case 2: + aInfo.mnDrawMode = DRAWMODE_BLACKLINE | DRAWMODE_BLACKTEXT + | DRAWMODE_WHITEFILL | DRAWMODE_GRAYBITMAP + | DRAWMODE_WHITEGRADIENT; + break; + + default: + aInfo.mnDrawMode = DRAWMODE_DEFAULT; + } + + // check if selected range of pages contains transparent objects + /* + const bool bPrintPages (bPrintNotes || bPrintDraw || bPrintHandout); + const bool bContainsTransparency (bPrintPages && ContainsTransparency()); + if (pPrinter->InitJob (mrBase.GetWindow(), !bIsAPI && bContainsTransparency)) + */ + + if (mpOptions->IsDraw()) + PrepareStdOrNotes(PK_STANDARD, aInfo); + if (mpOptions->IsNotes()) + PrepareStdOrNotes(PK_NOTES, aInfo); + if (mpOptions->IsHandout()) + { + InitHandoutTemplate(); + PrepareHandout(aInfo); + } + if (mpOptions->IsOutline()) + PrepareOutline(aInfo); + + rOutliner.SetControlWord(nSavedControlWord); + } + } + + + + + /** Create the page objects of the handout template. When the actual + printing takes place then the page objects are assigned different + sets of slides for each printed page (see HandoutPrinterPage::Print). + */ + void InitHandoutTemplate (void) + { + const sal_Int32 nSlidesPerHandout (mpOptions->GetHandoutPageCount()); + const bool bHandoutHorizontal (mpOptions->IsHandoutHorizontal()); + + AutoLayout eLayout = AUTOLAYOUT_HANDOUT6; + switch (nSlidesPerHandout) + { + case 0: eLayout = AUTOLAYOUT_NONE; break; // AUTOLAYOUT_HANDOUT1; break; + case 1: eLayout = AUTOLAYOUT_HANDOUT1; break; + case 2: eLayout = AUTOLAYOUT_HANDOUT2; break; + case 3: eLayout = AUTOLAYOUT_HANDOUT3; break; + case 4: eLayout = AUTOLAYOUT_HANDOUT4; break; + default: + case 6: eLayout = AUTOLAYOUT_HANDOUT6; break; + case 9: eLayout = AUTOLAYOUT_HANDOUT9; break; + } + + if( !mrBase.GetDocument() ) + return; + + SdDrawDocument& rModel = *mrBase.GetDocument(); + + // first, prepare handout page (not handout master) + + SdPage* pHandout = rModel.GetSdPage(0, PK_HANDOUT); + if( !pHandout ) + return; + + // delete all previous shapes from handout page + while( pHandout->GetObjCount() ) + { + SdrObject* pObj = pHandout->NbcRemoveObject(0); + if( pObj ) + SdrObject::Free( pObj ); + } + + const bool bDrawLines (eLayout == AUTOLAYOUT_HANDOUT3); + + std::vector< Rectangle > aAreas; + SdPage::CalculateHandoutAreas( rModel, eLayout, bHandoutHorizontal, aAreas ); + + std::vector< Rectangle >::iterator iter( aAreas.begin() ); + while( iter != aAreas.end() ) + { + pHandout->NbcInsertObject( new SdrPageObj((*iter++)) ); + + if( bDrawLines && (iter != aAreas.end()) ) + { + Rectangle aRect( (*iter++) ); + + basegfx::B2DPolygon aPoly; + aPoly.insert(0, basegfx::B2DPoint( aRect.Left(), aRect.Top() ) ); + aPoly.insert(1, basegfx::B2DPoint( aRect.Right(), aRect.Top() ) ); + + basegfx::B2DHomMatrix aMatrix; + aMatrix.translate( 0.0, static_cast< double >( aRect.GetHeight() / 7 ) ); + + basegfx::B2DPolyPolygon aPathPoly; + for( sal_uInt16 nLine = 0; nLine < 7; nLine++ ) + { + aPoly.transform( aMatrix ); + aPathPoly.append( aPoly ); + } + + SdrPathObj* pPathObj = new SdrPathObj(OBJ_PATHLINE, aPathPoly ); + pPathObj->SetMergedItem(XLineStyleItem(XLINE_SOLID)); + pPathObj->SetMergedItem(XLineColorItem(String(), Color(COL_BLACK))); + + pHandout->NbcInsertObject( pPathObj ); + } + } + } + + + + + /** Detect whether any of the slides that are to be printed contains + partially transparent or translucent shapes. + */ + bool ContainsTransparency (const PrintInfo& rInfo) const + { + // const bool bPrintExcluded (mpOptions->IsPrintExcluded()); + bool bContainsTransparency = false; + + for (USHORT + nIndex=0, + nCount=mrBase.GetDocument()->GetSdPageCount(PK_STANDARD); + nIndex < nCount && !bContainsTransparency; + ++nIndex) + { + SdPage* pPage = GetFilteredPage(nIndex, PK_STANDARD, rInfo); + if (pPage == NULL) + continue; + + bContainsTransparency = pPage->HasTransparentObjects(); + if ( ! bContainsTransparency && pPage->TRG_HasMasterPage()) + bContainsTransparency = pPage->TRG_GetMasterPage().HasTransparentObjects(); + } + + return bContainsTransparency; + } + + + + + /** Detect whether the specified slide is to be printed. + @return + When the slide is not to be printed then <NULL/> is returned. + Otherwise a pointer to the slide is returned. + */ + SdPage* GetFilteredPage ( + const sal_Int32 nPageIndex, + const PageKind ePageKind, + const PrintInfo& rInfo) const + { + OSL_ASSERT(mrBase.GetDocument() != NULL); + OSL_ASSERT(nPageIndex>=0); + if ( ! rInfo.maSelection.IsSelected(nPageIndex)) + return NULL; + SdPage* pPage = mrBase.GetDocument()->GetSdPage( + sal::static_int_cast<USHORT>(nPageIndex), + ePageKind); + if (pPage == NULL) + return NULL; + if ( ! pPage->IsExcluded() || mpOptions->IsPrintExcluded()) + return pPage; + else + return NULL; + } + + + + + /** Prepare the outline of the document for printing. There is no fixed + number of slides whose outline data is put onto one printer page. + If the current printer page has enough room for the outline of the + current slide then that is added. Otherwise a new printer page is + started. + */ + void PrepareOutline (PrintInfo& rInfo) + { + MapMode aMap (rInfo.maMap); + Point aPageOfs (rInfo.mpPrinter->GetPageOffset() ); + // aMap.SetOrigin(Point() - aPageOfs); + aMap.SetScaleX(Fraction(1,2)); + aMap.SetScaleY(Fraction(1,2)); + mpPrinter->SetMapMode(aMap); + + Rectangle aOutRect(aPageOfs, rInfo.mpPrinter->GetOutputSize()); + if( aOutRect.GetWidth() > aOutRect.GetHeight() ) + { + Size aPaperSize( rInfo.mpPrinter->PixelToLogic( rInfo.mpPrinter->GetPaperSizePixel(), MapMode( MAP_100TH_MM ) ) ); + maPrintSize.Width = aPaperSize.Height(); + maPrintSize.Height = aPaperSize.Width(); + aOutRect = Rectangle( Point( aPageOfs.Y(), aPageOfs.X() ), + Size( aOutRect.GetHeight(), aOutRect.GetWidth() ) ); + } + + Link aOldLink; + Outliner* pOutliner = mrBase.GetDocument()->GetInternalOutliner(); + pOutliner->Init(OUTLINERMODE_OUTLINEVIEW); + const USHORT nSavedOutlMode (pOutliner->GetMode()); + const BOOL bSavedUpdateMode (pOutliner->GetUpdateMode()); + const Size aSavedPaperSize (pOutliner->GetPaperSize()); + const MapMode aSavedMapMode (pOutliner->GetRefMapMode()); + pOutliner->SetPaperSize(aOutRect.GetSize()); + pOutliner->SetUpdateMode(TRUE); + + long nPageH = aOutRect.GetHeight(); + + for (USHORT + nIndex=0, + nCount=mrBase.GetDocument()->GetSdPageCount(PK_STANDARD); + nIndex < nCount; + ) + { + pOutliner->Clear(); + pOutliner->SetFirstPageNumber(nIndex+1); + + Paragraph* pPara = NULL; + sal_Int32 nH (0); + while (nH < nPageH && nIndex<nCount) + { + SdPage* pPage = GetFilteredPage(nIndex, PK_STANDARD, rInfo); + ++nIndex; + if (pPage == NULL) + continue; + + SdrTextObj* pTextObj = NULL; + sal_uInt32 nObj (0); + + while (pTextObj==NULL && nObj < pPage->GetObjCount()) + { + SdrObject* pObj = pPage->GetObj(nObj++); + if (pObj->GetObjInventor() == SdrInventor + && pObj->GetObjIdentifier() == OBJ_TITLETEXT) + { + pTextObj = dynamic_cast<SdrTextObj*>(pObj); + } + } + + pPara = pOutliner->GetParagraph(pOutliner->GetParagraphCount() - 1); + + if (pTextObj!=NULL + && !pTextObj->IsEmptyPresObj() + && pTextObj->GetOutlinerParaObject()) + { + pOutliner->AddText(*(pTextObj->GetOutlinerParaObject())); + } + else + pOutliner->Insert(String()); + + pTextObj = NULL; + nObj = 0; + + while (pTextObj==NULL && nObj<pPage->GetObjCount()) + { + SdrObject* pObj = pPage->GetObj(nObj++); + if (pObj->GetObjInventor() == SdrInventor + && pObj->GetObjIdentifier() == OBJ_OUTLINETEXT) + { + pTextObj = dynamic_cast<SdrTextObj*>(pObj); + } + } + + bool bSubTitle (false); + if (!pTextObj) + { + bSubTitle = true; + pTextObj = dynamic_cast<SdrTextObj*>(pPage->GetPresObj(PRESOBJ_TEXT)); // Untertitel vorhanden? + } + + ULONG nParaCount1 = pOutliner->GetParagraphCount(); + + if (pTextObj!=NULL + && !pTextObj->IsEmptyPresObj() + && pTextObj->GetOutlinerParaObject()) + { + pOutliner->AddText(*(pTextObj->GetOutlinerParaObject())); + } + + if (bSubTitle ) + { + const sal_Int32 nParaCount2 (pOutliner->GetParagraphCount()); + for (sal_Int32 nPara=nParaCount1; nPara<nParaCount2; ++nPara) + { + Paragraph* pP = pOutliner->GetParagraph(nPara); + if (pP!=NULL && pOutliner->GetDepth((USHORT)nPara) > 0) + pOutliner->SetDepth(pP, 0); + } + } + + nH = pOutliner->GetTextHeight(); + } + + // Remove the last paragraph when that does not fit completely on + // the current page. + if (nH > nPageH && pPara!=NULL) + { + ULONG nCnt = pOutliner->GetAbsPos( + pOutliner->GetParagraph( pOutliner->GetParagraphCount() - 1 ) ); + ULONG nParaPos = pOutliner->GetAbsPos( pPara ); + nCnt -= nParaPos; + pPara = pOutliner->GetParagraph( ++nParaPos ); + if ( nCnt && pPara ) + { + pOutliner->Remove(pPara, nCnt); + --nIndex; + } + } + + maPrinterPages.push_back( + ::boost::shared_ptr<PrinterPage>( + new OutlinerPrinterPage( + pOutliner->CreateParaObject(), + aMap, + rInfo.msTimeDate, + aPageOfs, + rInfo.mnDrawMode, + rInfo.meOrientation, + rInfo.mpPrinter->GetPaperBin()))); + } + + pOutliner->SetRefMapMode(aSavedMapMode); + pOutliner->SetUpdateMode(bSavedUpdateMode); + pOutliner->SetPaperSize(aSavedPaperSize); + pOutliner->Init(nSavedOutlMode); + } + + + + + /** Prepare handout pages for slides that are to be printed. + */ + void PrepareHandout (PrintInfo& rInfo) + { + SdDrawDocument* pDocument = mrBase.GetDocument(); + OSL_ASSERT(pDocument != NULL); + SdPage& rHandoutPage (*pDocument->GetSdPage(0, PK_HANDOUT)); + + const bool bScalePage (mpOptions->IsPageSize()); + + USHORT nPaperBin; + if ( ! mpOptions->IsPaperBin()) + nPaperBin = rHandoutPage.GetPaperBin(); + else + nPaperBin = rInfo.mpPrinter->GetPaperBin(); + + // Change orientation? + SdPage& rMaster (dynamic_cast<SdPage&>(rHandoutPage.TRG_GetMasterPage())); + rInfo.meOrientation = rMaster.GetOrientation(); + + const Size aPaperSize (rInfo.mpPrinter->GetPaperSize()); + if( (rInfo.meOrientation == ORIENTATION_LANDSCAPE && + (aPaperSize.Width() < aPaperSize.Height())) + || + (rInfo.meOrientation == ORIENTATION_PORTRAIT && + (aPaperSize.Width() > aPaperSize.Height())) + ) + { + maPrintSize = awt::Size(aPaperSize.Height(), aPaperSize.Width()); + } + else + { + maPrintSize = awt::Size(aPaperSize.Width(), aPaperSize.Height()); + } + + MapMode aMap (rInfo.maMap); + const Point aPageOfs (rInfo.mpPrinter->GetPageOffset()); + //DrawView* pPrintView; + + // aMap.SetOrigin(Point() - aPageOfs); + + if ( bScalePage ) + { + const Size aPageSize (rHandoutPage.GetSize()); + const Size aPrintSize (rInfo.mpPrinter->GetOutputSize()); + + const double fHorz = (double) aPrintSize.Width() / aPageSize.Width(); + const double fVert = (double) aPrintSize.Height() / aPageSize.Height(); + + Fraction aFract; + if ( fHorz < fVert ) + aFract = Fraction(aPrintSize.Width(), aPageSize.Width()); + else + aFract = Fraction(aPrintSize.Height(), aPageSize.Height()); + + aMap.SetScaleX(aFract); + aMap.SetScaleY(aFract); + aMap.SetOrigin(Point()); + } + + ::boost::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell()); + pViewShell->WriteFrameViewData(); + + // Count page shapes. + sal_uInt32 nShapeCount (0); + SdrObjListIter aShapeIter (rHandoutPage); + while (aShapeIter.IsMore()) + { + SdrPageObj* pPageObj = dynamic_cast<SdrPageObj*>(aShapeIter.Next()); + if (pPageObj) + ++nShapeCount; + } + + const USHORT nPageCount = mrBase.GetDocument()->GetSdPageCount(PK_STANDARD); + const USHORT nHandoutPageCount = nShapeCount ? (nPageCount + nShapeCount - 1) / nShapeCount : 0; + pViewShell->SetPrintedHandoutPageCount( nHandoutPageCount ); + mrBase.GetDocument()->setHandoutPageCount( nHandoutPageCount ); + + // Distribute pages to handout pages. + ::std::vector<USHORT> aPageIndices; + std::vector<SdPage*> aPagesVector; + for (USHORT + nIndex=0, + nCount= nPageCount, + nHandoutPageIndex=0; + nIndex <= nCount; + ++nIndex) + { + if (nIndex < nCount) + { + if (GetFilteredPage(nIndex, PK_STANDARD, rInfo) == NULL) + continue; + aPageIndices.push_back(nIndex); + } + + // Create a printer page when we have found one page for each + // placeholder or when this is the last (and special) loop. + if (aPageIndices.size() == nShapeCount + || nIndex==nCount) + { + maPrinterPages.push_back( + ::boost::shared_ptr<PrinterPage>( + new HandoutPrinterPage( + nHandoutPageIndex++, + aPageIndices, + aMap, + rInfo.msTimeDate, + aPageOfs, + rInfo.mnDrawMode, + rInfo.meOrientation, + nPaperBin))); + aPageIndices.clear(); + } + } + } + + + + + /** Prepare the notes pages or regular slides. + */ + void PrepareStdOrNotes ( + const PageKind ePageKind, + PrintInfo& rInfo) + { + OSL_ASSERT(rInfo.mpPrinter != NULL); + + // Fill in page kind specific data. + SdDrawDocument* pDocument = mrBase.GetMainViewShell()->GetDoc(); + if (pDocument->GetSdPageCount(ePageKind) == 0) + return; + SdPage* pRefPage = pDocument->GetSdPage(0, ePageKind); + rInfo.maPageSize = pRefPage->GetSize(); + + if ( ! SetupPaperOrientation(ePageKind, rInfo)) + return; + + MapMode aMap (rInfo.maMap); + // aMap.SetOrigin(Point() - rInfo.mpPrinter->GetPageOffset()); + rInfo.maMap = aMap; + + if (mpOptions->IsBooklet()) + PrepareBooklet(ePageKind, rInfo); + else + PrepareRegularPages(ePageKind, rInfo); + } + + + + + /** Prepare slides in a non-booklet way: one slide per one to many + printer pages. + */ + void PrepareRegularPages ( + const PageKind ePageKind, + PrintInfo& rInfo) + { + ::boost::shared_ptr<ViewShell> pViewShell (mrBase.GetMainViewShell()); + pViewShell->WriteFrameViewData(); + Point aPtZero; + + for (USHORT + nIndex=0, + nCount=mrBase.GetDocument()->GetSdPageCount(PK_STANDARD); + nIndex < nCount; + ++nIndex) + { + SdPage* pPage = GetFilteredPage(nIndex, ePageKind, rInfo); + if (pPage == NULL) + continue; + + MapMode aMap (rInfo.maMap); + // Kann sich die Seitengroesse geaendert haben? + const Size aPageSize = pPage->GetSize(); + + if (mpOptions->IsPageSize()) + { + const double fHorz ((double) rInfo.maPrintSize.Width() / aPageSize.Width()); + const double fVert ((double) rInfo.maPrintSize.Height() / aPageSize.Height()); + + Fraction aFract; + if (fHorz < fVert) + aFract = Fraction(rInfo.maPrintSize.Width(), aPageSize.Width()); + else + aFract = Fraction(rInfo.maPrintSize.Height(), aPageSize.Height()); + + aMap.SetScaleX(aFract); + aMap.SetScaleY(aFract); + aMap.SetOrigin(Point()); + } + + if (mpOptions->IsPrintPageName()) + { + rInfo.msPageString = pPage->GetName(); + rInfo.msPageString += ::rtl::OUString(sal_Unicode(' ')); + } + else + rInfo.msPageString = ::rtl::OUString(); + rInfo.msPageString += rInfo.msTimeDate; + + long aPageWidth = aPageSize.Width() - pPage->GetLftBorder() - pPage->GetRgtBorder(); + long aPageHeight = aPageSize.Height() - pPage->GetUppBorder() - pPage->GetLwrBorder(); + // Bugfix zu 44530: + // Falls implizit umgestellt wurde (Landscape/Portrait) + // wird dies beim Kacheln, bzw. aufteilen (Poster) beruecksichtigt + BOOL bSwitchPageSize = FALSE; + if( ( rInfo.maPrintSize.Width() > rInfo.maPrintSize.Height() + && aPageWidth < aPageHeight ) + || ( rInfo.maPrintSize.Width() < rInfo.maPrintSize.Height() + && aPageWidth > aPageHeight ) ) + { + bSwitchPageSize = TRUE; + const sal_Int32 nTmp (rInfo.maPrintSize.Width()); + rInfo.maPrintSize.Width() = rInfo.maPrintSize.Height(); + rInfo.maPrintSize.Height() = nTmp; + } + + if (mpOptions->IsTilePage() + && aPageWidth < rInfo.maPrintSize.Width() + && aPageHeight < rInfo.maPrintSize.Height()) + { + // Put multiple slides on one printer page. + PrepareTiledPage(nIndex, *pPage, ePageKind, rInfo); + } + else + { + rInfo.maMap = aMap; + PrepareScaledPage(nIndex, *pPage, ePageKind, rInfo); + } + } + } + + + + + /** Put two slides on one printer page. + */ + void PrepareBooklet ( + const PageKind ePageKind, + const PrintInfo& rInfo) + { + MapMode aStdMap (rInfo.maMap); + Point aOffset; + Size aPrintSize_2 (rInfo.maPrintSize); + Size aPageSize_2 (rInfo.maPageSize); + + if (rInfo.meOrientation == ORIENTATION_LANDSCAPE) + aPrintSize_2.Width() >>= 1; + else + aPrintSize_2.Height() >>= 1; + + const double fPageWH = (double) aPageSize_2.Width() / aPageSize_2.Height(); + const double fPrintWH = (double) aPrintSize_2.Width() / aPrintSize_2.Height(); + + if( fPageWH < fPrintWH ) + { + aPageSize_2.Width() = (long) ( aPrintSize_2.Height() * fPageWH ); + aPageSize_2.Height()= aPrintSize_2.Height(); + } + else + { + aPageSize_2.Width() = aPrintSize_2.Width(); + aPageSize_2.Height() = (long) ( aPrintSize_2.Width() / fPageWH ); + } + + MapMode aMap (rInfo.maMap); + aMap.SetScaleX( Fraction( aPageSize_2.Width(), rInfo.maPageSize.Width() ) ); + aMap.SetScaleY( Fraction( aPageSize_2.Height(), rInfo.maPageSize.Height() ) ); + + // calculate adjusted print size + const Size aAdjustedPrintSize (OutputDevice::LogicToLogic( + rInfo.maPrintSize, + aStdMap, + aMap)); + + if (rInfo.meOrientation == ORIENTATION_LANDSCAPE) + { + aOffset.X() = ( ( aAdjustedPrintSize.Width() >> 1 ) - rInfo.maPageSize.Width() ) >> 1; + aOffset.Y() = ( aAdjustedPrintSize.Height() - rInfo.maPageSize.Height() ) >> 1; + } + else + { + aOffset.X() = ( aAdjustedPrintSize.Width() - rInfo.maPageSize.Width() ) >> 1; + aOffset.Y() = ( ( aAdjustedPrintSize.Height() >> 1 ) - rInfo.maPageSize.Height() ) >> 1; + } + + // create vector of pages to print + ::std::vector< USHORT > aPageVector; + for (USHORT + nIndex=0, + nCount=mrBase.GetDocument()->GetSdPageCount(ePageKind); + nIndex < nCount; + ++nIndex) + { + SdPage* pPage = GetFilteredPage(nIndex, ePageKind, rInfo); + if (pPage != NULL) + aPageVector.push_back(nIndex); + } + + // create pairs of pages to print on each page + typedef ::std::vector< ::std::pair< USHORT, USHORT > > PairVector; + PairVector aPairVector; + if ( ! aPageVector.empty()) + { + sal_uInt32 nFirstIndex = 0, nLastIndex = aPageVector.size() - 1; + + if( aPageVector.size() & 1 ) + aPairVector.push_back( ::std::make_pair( (USHORT) 65535, aPageVector[ nFirstIndex++ ] ) ); + else + aPairVector.push_back( ::std::make_pair( aPageVector[ nLastIndex-- ], aPageVector[ nFirstIndex++ ] ) ); + + while( nFirstIndex < nLastIndex ) + { + if( nFirstIndex & 1 ) + aPairVector.push_back( ::std::make_pair( aPageVector[ nFirstIndex++ ], aPageVector[ nLastIndex-- ] ) ); + else + aPairVector.push_back( ::std::make_pair( aPageVector[ nLastIndex-- ], aPageVector[ nFirstIndex++ ] ) ); + } + } + + for (sal_uInt32 + nIndex=0, + nCount=aPairVector.size(); + nIndex < nCount; + ++nIndex) + { + const bool bIsIndexOdd (nIndex & 1); + if ((!bIsIndexOdd && mpOptions->IsPrintFrontPage()) + || (bIsIndexOdd && mpOptions->IsPrintBackPage())) + { + const ::std::pair<USHORT, USHORT> aPair (aPairVector[nIndex]); + Point aSecondOffset (aOffset); + if (rInfo.meOrientation == ORIENTATION_LANDSCAPE) + aSecondOffset.X() += aAdjustedPrintSize.Width() / 2; + else + aSecondOffset.Y() += aAdjustedPrintSize.Height() / 2; + maPrinterPages.push_back( + ::boost::shared_ptr<PrinterPage>( + new BookletPrinterPage( + aPair.first, + aPair.second, + aOffset, + aSecondOffset, + ePageKind, + aMap, + rInfo.mbPrintMarkedOnly, + rInfo.mnDrawMode, + rInfo.meOrientation, + rInfo.mpPrinter->GetPaperBin()))); + + } + } + } + + + + + /** Print one slide multiple times on one printer page so that the whole + printer page is covered. + */ + void PrepareTiledPage ( + const sal_Int32 nPageIndex, + const SdPage& rPage, + const PageKind ePageKind, + const PrintInfo& rInfo) + { + USHORT nPaperBin; + if ( ! mpOptions->IsPaperBin()) + nPaperBin = rPage.GetPaperBin(); + else + nPaperBin = rInfo.mpPrinter->GetPaperBin(); + + maPrinterPages.push_back( + ::boost::shared_ptr<PrinterPage>( + new TiledPrinterPage( + sal::static_int_cast<USHORT>(nPageIndex), + ePageKind, + 500, + rInfo.mbPrintMarkedOnly, + rInfo.msPageString, + rInfo.mpPrinter->GetPageOffset(), + rInfo.mnDrawMode, + rInfo.meOrientation, + nPaperBin))); + } + + + + /** Print one standard slide or notes page on one to many printer + pages. More than on printer page is used when the slide is larger + than the printable area. + */ + void PrepareScaledPage ( + const sal_Int32 nPageIndex, + const SdPage& rPage, + const PageKind ePageKind, + const PrintInfo& rInfo) + { + const Point aPageOffset (rInfo.mpPrinter->GetPageOffset()); + + USHORT nPaperBin; + if ( ! mpOptions->IsPaperBin()) + nPaperBin = rPage.GetPaperBin(); + else + nPaperBin = rInfo.mpPrinter->GetPaperBin(); + + // For pages larger then the printable area there + // are three options: + // 1. Scale down to the page to the printable area. + // 2. Print only the upper left part of the page + // (without the unprintable borders). + // 3. Split the page into parts of the size of the + // printable area. + const bool bScalePage (mpOptions->IsPageSize()); + const bool bCutPage (mpOptions->IsCutPage()); + MapMode aMap (rInfo.maMap); + if (bScalePage || bCutPage) + { + // Handle 1 and 2. + + // if CutPage is set then do not move it, otherwise move the + // scaled page to printable area + #if 0 + if (bCutPage) + aMap.SetOrigin(Point(-aPageOffset.X(), -aPageOffset.Y())); + else + aMap.SetOrigin(Point(0,0)); + #endif + maPrinterPages.push_back( + ::boost::shared_ptr<PrinterPage>( + new RegularPrinterPage( + sal::static_int_cast<USHORT>(nPageIndex), + ePageKind, + aMap, + rInfo.mbPrintMarkedOnly, + rInfo.msPageString, + aPageOffset, + rInfo.mnDrawMode, + rInfo.meOrientation, + nPaperBin))); + } + else + { + // Handle 3. Print parts of the page in the size of the + // printable area until the whole page is covered. + + // keep the page content at its position if it fits, otherwise + // move it to the printable area + const long nPageWidth ( + rInfo.maPageSize.Width() - rPage.GetLftBorder() - rPage.GetRgtBorder()); + const long nPageHeight ( + rInfo.maPageSize.Height() - rPage.GetUppBorder() - rPage.GetLwrBorder()); + #if 0 + Point aOrigin ( + nPageWidth < rInfo.maPrintSize.Width() ? -aPageOffset.X() : 0, + nPageHeight < rInfo.maPrintSize.Height() ? -aPageOffset.Y() : 0); + #else + Point aOrigin ( 0, 0 ); + #endif + for (Point aPageOrigin = aOrigin; + -aPageOrigin.Y()<nPageHeight; + aPageOrigin.Y() -= rInfo.maPrintSize.Height()) + { + for (aPageOrigin.X()=aOrigin.X(); + -aPageOrigin.X()<nPageWidth; + aPageOrigin.X() -= rInfo.maPrintSize.Width()) + { + aMap.SetOrigin(aPageOrigin); + maPrinterPages.push_back( + ::boost::shared_ptr<PrinterPage>( + new RegularPrinterPage( + sal::static_int_cast<USHORT>(nPageIndex), + ePageKind, + aMap, + rInfo.mbPrintMarkedOnly, + rInfo.msPageString, + aPageOffset, + rInfo.mnDrawMode, + rInfo.meOrientation, + nPaperBin))); + } + } + } + } +}; + + + + +//===== DocumentRenderer ====================================================== + +DocumentRenderer::DocumentRenderer (ViewShellBase& rBase) + : DocumentRendererInterfaceBase(m_aMutex), + mpImpl(new Implementation(rBase)) +{ +} + + + + +DocumentRenderer::~DocumentRenderer (void) +{ +} + + + + +//----- XRenderable ----------------------------------------------------------- + +sal_Int32 SAL_CALL DocumentRenderer::getRendererCount ( + const css::uno::Any& aSelection, + const css::uno::Sequence<css::beans::PropertyValue >& rOptions) + throw (css::lang::IllegalArgumentException, css::uno::RuntimeException) +{ + (void)aSelection; + mpImpl->ProcessProperties(rOptions); + return mpImpl->GetPrintPageCount(); +} + + + + +Sequence<beans::PropertyValue> SAL_CALL DocumentRenderer::getRenderer ( + sal_Int32 nRenderer, + const css::uno::Any& rSelection, + const css::uno::Sequence<css::beans::PropertyValue>& rOptions) + throw (css::lang::IllegalArgumentException, css::uno::RuntimeException) +{ + (void)nRenderer; + (void)rSelection; + mpImpl->ProcessProperties(rOptions); + return mpImpl->GetProperties(rOptions); +} + + + + +void SAL_CALL DocumentRenderer::render ( + sal_Int32 nRenderer, + const css::uno::Any& rSelection, + const css::uno::Sequence<css::beans::PropertyValue>& rOptions) + throw (css::lang::IllegalArgumentException, css::uno::RuntimeException) +{ + (void)rSelection; + mpImpl->ProcessProperties(rOptions); + mpImpl->PrintPage(nRenderer); +} + + + +} // end of namespace sd diff --git a/sd/source/ui/view/DocumentRenderer.hrc b/sd/source/ui/view/DocumentRenderer.hrc new file mode 100644 index 000000000000..3dd57429dd13 --- /dev/null +++ b/sd/source/ui/view/DocumentRenderer.hrc @@ -0,0 +1,77 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +#define _STR_IMPRESS_PRINT_UI_OPTIONS 32001 +#define _STR_IMPRESS_PRINT_UI_GROUP_NAME 1 +#define _STR_IMPRESS_PRINT_UI_PRINT_CONTENT 2 +#define _STR_IMPRESS_PRINT_UI_PRINT_GROUP 3 +#define _STR_IMPRESS_PRINT_UI_CONTENT 4 +#define _STR_IMPRESS_PRINT_UI_CONTENT_HELP 5 +#define _STR_IMPRESS_PRINT_UI_CONTENT_CHOICES 6 +#define _STR_IMPRESS_PRINT_UI_SLIDESPERPAGE 7 +#define _STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES 8 +#define _STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES_HELP 9 +#define _STR_IMPRESS_PRINT_UI_ORDER 10 +#define _STR_IMPRESS_PRINT_UI_ORDER_CHOICES 11 +#define _STR_IMPRESS_PRINT_UI_ORDER_CHOICES_HELP 12 +#define _STR_IMPRESS_PRINT_UI_INCLUDE_CONTENT 13 +#define _STR_IMPRESS_PRINT_UI_IS_PRINT_NAME 14 +#define _STR_IMPRESS_PRINT_UI_IS_PRINT_NAME_HELP 15 +#define _STR_IMPRESS_PRINT_UI_IS_PRINT_DATE 16 +#define _STR_IMPRESS_PRINT_UI_IS_PRINT_DATE_HELP 17 +#define _STR_IMPRESS_PRINT_UI_IS_PRINT_TIME 18 +#define _STR_IMPRESS_PRINT_UI_IS_PRINT_TIME_HELP 19 +#define _STR_IMPRESS_PRINT_UI_IS_PRINT_HIDDEN 20 +#define _STR_IMPRESS_PRINT_UI_IS_PRINT_HIDDEN_HELP 21 + +#define _STR_IMPRESS_PRINT_UI_OUTPUT_OPTIONS_GROUP 22 +#define _STR_IMPRESS_PRINT_UI_QUALITY 23 +#define _STR_IMPRESS_PRINT_UI_QUALITY_CHOICES 24 +#define _STR_IMPRESS_PRINT_UI_QUALITY_CHOICES_HELP 25 +#define _STR_IMPRESS_PRINT_UI_PAGE_OPTIONS 26 +#define _STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES 27 +#define _STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_DRAW 28 +#define _STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_HELP 29 +#define _STR_IMPRESS_PRINT_UI_BROCHURE 30 +#define _STR_IMPRESS_PRINT_UI_BROCHURE_HELP 31 +#define _STR_IMPRESS_PRINT_UI_PAGE_SIDES 32 +#define _STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE 33 +#define _STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_HELP 34 +#define _STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST 35 +#define _STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST_HELP 36 +#define _STR_IMPRESS_PRINT_UI_PAPER_TRAY_GROUP 37 +#define _STR_IMPRESS_PRINT_UI_PAPER_TRAY 38 +#define _STR_IMPRESS_PRINT_UI_PAPER_TRAY_HELP 39 + +#define _STR_IMPRESS_PRINT_UI_PAGE_RANGE 40 +#define _STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE 41 +#define _STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE_HELP 42 +#define _STR_DRAW_PRINT_UI_PAGE_RANGE_CHOICE 43 + +#define _STR_DRAW_PRINT_UI_IS_PRINT_NAME 44 +#define _STR_DRAW_PRINT_UI_IS_PRINT_NAME_HELP 45 + diff --git a/sd/source/ui/view/DocumentRenderer.src b/sd/source/ui/view/DocumentRenderer.src new file mode 100755 index 000000000000..abd82ea0d397 --- /dev/null +++ b/sd/source/ui/view/DocumentRenderer.src @@ -0,0 +1,296 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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 "app.hrc" +#include "DocumentRenderer.hrc" + +Resource _STR_IMPRESS_PRINT_UI_OPTIONS +{ + String _STR_IMPRESS_PRINT_UI_GROUP_NAME + { + Text [en-US] = "%PRODUCTNAME %s"; + }; + String _STR_IMPRESS_PRINT_UI_PRINT_CONTENT + { + Text [ en-US ] = "Print content"; + }; + String _STR_IMPRESS_PRINT_UI_PRINT_GROUP + { + Text [ en-US ] = "Print"; + }; + String _STR_IMPRESS_PRINT_UI_CONTENT + { + Text [ en-US ] = "Document"; + }; + StringArray _STR_IMPRESS_PRINT_UI_CONTENT_HELP + { + ItemList [ en-US ] = + { + < "Select which parts of the document should be printed"; >; + < "Select which parts of the document should be printed"; >; + }; + }; + StringArray _STR_IMPRESS_PRINT_UI_CONTENT_CHOICES + { + ItemList [ en-US ] = + { + < "Slides" ; > ; + < "Handouts" ; > ; + < "Notes" ; > ; + < "Outline" ; > ; + }; + }; + String _STR_IMPRESS_PRINT_UI_SLIDESPERPAGE + { + Text [ en-US ] = "Slides per page" ; + }; + StringArray _STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES + { + ItemList [ en-US ] = + { + < "Default" ; > ; + < "1" ; > ; + < "2" ; > ; + < "3" ; > ; + < "4" ; > ; + < "6" ; > ; + < "9" ; > ; + }; + }; + StringArray _STR_IMPRESS_PRINT_UI_SLIDESPERPAGE_CHOICES_HELP + { + ItemList [ en-US ] = + { + < "Select how many slides to print per page." ; >; + < "Select how many slides to print per page." ; >; + }; + }; + String _STR_IMPRESS_PRINT_UI_ORDER + { + Text [ en-US ] = "Order" ; + }; + StringArray _STR_IMPRESS_PRINT_UI_ORDER_CHOICES + { + ItemList [ en-US ] = + { + < "Left to right, then down" ; > ; + < "Top to bottom, then right" ; > ; + }; + }; + StringArray _STR_IMPRESS_PRINT_UI_ORDER_CHOICES_HELP + { + ItemList [ en-US ] = + { + < "Specify how to arrange slides on the printed page." ; > ; + < "Arrange slides horizontally" ; > ; + < "Arrange slides vertically" ; > ; + }; + }; + String _STR_IMPRESS_PRINT_UI_INCLUDE_CONTENT + { + Text [ en-US ] = "~Contents"; + }; + String _STR_IMPRESS_PRINT_UI_IS_PRINT_NAME + { + Text [ en-US ] = "~Slide name"; + }; + String _STR_IMPRESS_PRINT_UI_IS_PRINT_NAME_HELP + { + Text [ en-US ] = "Specifies whether to print the page name of a document."; + }; + String _STR_DRAW_PRINT_UI_IS_PRINT_NAME + { + Text [ en-US ] = "P~age name"; + }; + String _STR_DRAW_PRINT_UI_IS_PRINT_NAME_HELP + { + Text [ en-US ] = "Specifies whether to print the page name of a document."; + }; + String _STR_IMPRESS_PRINT_UI_IS_PRINT_DATE + { + Text [ en-US ] = "~Date and time"; + }; + String _STR_IMPRESS_PRINT_UI_IS_PRINT_DATE_HELP + { + Text [ en-US ] = "Specifies whether to print the current date and time."; + }; + String _STR_IMPRESS_PRINT_UI_IS_PRINT_HIDDEN + { + Text [ en-US ] = "Hidden pages"; + }; + String _STR_IMPRESS_PRINT_UI_IS_PRINT_HIDDEN_HELP + { + Text [ en-US ] = "Specifies whether to print the pages that are currently hidden from the application."; + }; + + String _STR_IMPRESS_PRINT_UI_OUTPUT_OPTIONS_GROUP + { + Text [ en-US ] = "Output options"; + }; + String _STR_IMPRESS_PRINT_UI_QUALITY + { + Text [ en-US ] = "Color"; + }; + StringArray _STR_IMPRESS_PRINT_UI_QUALITY_CHOICES + { + ItemList [ en-US ] = + { + < "Original colors" ; > ; + < "Grayscale" ; > ; + < "Black & white" ; > ; + }; + }; + StringArray _STR_IMPRESS_PRINT_UI_QUALITY_CHOICES_HELP + { + ItemList [ en-US ] = + { + < "Specify how to treat colors in the printout."; >; + < "Specifies that you want to print in original colors." ; > ; + < "Specifies that you want to print colors as grayscale." ; > ; + < "Specifies that you want to print in black and white." ; > ; + }; + }; + + String _STR_IMPRESS_PRINT_UI_PAGE_OPTIONS + { + Text [ en-US ] = "~Size"; + }; + StringArray _STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES + { + ItemList [ en-US ] = + { + < "Original size" ; > ; + < "Fit to printable page" ; > ; + < "Distribute on multiple sheets of paper" ; > ; + < "Tile sheet of paper with repeated slides" ; > ; + }; + }; + StringArray _STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_DRAW + { + ItemList [ en-US ] = + { + < "Original size" ; > ; + < "Fit to printable page" ; > ; + < "Distribute on multiple sheets of paper" ; > ; + < "Tile sheet of paper with repeated pages" ; > ; + }; + }; + StringArray _STR_IMPRESS_PRINT_UI_PAGE_OPTIONS_CHOICES_HELP + { + ItemList [ en-US ] = + { + < "Specify how to scale slides in the printout."; >; + < "Specifies that you do not want to further scale pages when printing." ; > ; + < "Specifies whether to scale down objects that are beyond the margins of the current printer so they fit on the paper in the printer." ; > ; + < "Specifies that pages are to be printed in tiled format. If the pages or slides are smaller than the paper, several pages or slides will be printed on one page of paper." ; > ; + }; + }; + String _STR_IMPRESS_PRINT_UI_BROCHURE + { + Text [en-US] = "Brochure"; + }; + String _STR_IMPRESS_PRINT_UI_BROCHURE_HELP + { + Text [en-US] = "Select the \"Brochure\" option to print the document in brochure format."; + }; + String _STR_IMPRESS_PRINT_UI_PAGE_SIDES + { + Text [ en-US ] = "Page sides"; + }; + String _STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE + { + Text [ en-US ] = "Include"; + }; + String _STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_HELP + { + Text [ en-US ] = "Select which pages of a brochure to print."; + }; + StringArray _STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST + { + ItemList [ en-US ] = + { + < "All pages" ; > ; + < "Front sides / right pages" ; > ; + < "Back sides / left pages" ; > ; + }; + }; + StringArray _STR_IMPRESS_PRINT_UI_BROCHURE_INCLUDE_LIST_HELP + { + ItemList [ en-US ] = + { + < "Print all pages of a brochure." ; > ; + < "Print only front pages of a brochure." ; > ; + < "Print only back pages of a brochure." ; > ; + }; + }; + + String _STR_IMPRESS_PRINT_UI_PAPER_TRAY_GROUP + { + Text [ en-US ] = "Paper tray"; + }; + String _STR_IMPRESS_PRINT_UI_PAPER_TRAY + { + Text [ en-US ] = "~Use only paper tray from printer preferences"; + }; + String _STR_IMPRESS_PRINT_UI_PAPER_TRAY_HELP + { + Text [ en-US ] = "Determines that the paper tray to be used is the one defined in the printer setup."; + }; + String _STR_IMPRESS_PRINT_UI_PAGE_RANGE + { + Text [en-US] = "Print range"; + }; + StringArray _STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE + { + ItemList [ en-US ] = + { + < "~All slides"; >; + < "~Slides"; >; + < "Se~lection"; >; + }; + }; + + StringArray _STR_IMPRESS_PRINT_UI_PAGE_RANGE_CHOICE_HELP + { + ItemList [ en-US ] = + { + < "Print the whole document."; >; + < "Print a specified range of the document."; >; + < "Print only the currently selected content."; >; + }; + }; + + StringArray _STR_DRAW_PRINT_UI_PAGE_RANGE_CHOICE + { + ItemList [ en-US ] = + { + < "~All pages"; >; + < "Pa~ges"; >; + < "Se~lection"; >; + }; + }; +}; diff --git a/sd/source/ui/view/FormShellManager.cxx b/sd/source/ui/view/FormShellManager.cxx new file mode 100644 index 000000000000..448df20b50cd --- /dev/null +++ b/sd/source/ui/view/FormShellManager.cxx @@ -0,0 +1,393 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "FormShellManager.hxx" + +#include "EventMultiplexer.hxx" +#include "ViewShell.hxx" +#include "ViewShellBase.hxx" +#include "ViewShellManager.hxx" +#include "Window.hxx" +#include <svx/fmshell.hxx> + +namespace sd { + +namespace { + +/** This factory is responsible for creating and deleting the FmFormShell. +*/ +class FormShellManagerFactory + : public ::sd::ShellFactory<SfxShell> +{ +public: + FormShellManagerFactory (ViewShell& rViewShell, FormShellManager& rManager); + virtual FmFormShell* CreateShell (ShellId nId, ::Window* pParentWindow, FrameView* pFrameView); + virtual void ReleaseShell (SfxShell* pShell); + +private: + ::sd::ViewShell& mrViewShell; + FormShellManager& mrFormShellManager; +}; + +} // end of anonymous namespace + + +FormShellManager::FormShellManager (ViewShellBase& rBase) + : mrBase(rBase), + mpFormShell(NULL), + mbFormShellAboveViewShell(false), + mpSubShellFactory(), + mbIsMainViewChangePending(false), + mpMainViewShellWindow(NULL) +{ + // Register at the EventMultiplexer to be informed about changes in the + // center pane. + Link aLink (LINK(this, FormShellManager, ConfigurationUpdateHandler)); + mrBase.GetEventMultiplexer()->AddEventListener( + aLink, + sd::tools::EventMultiplexerEvent::EID_MAIN_VIEW_REMOVED + | sd::tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED + | sd::tools::EventMultiplexerEvent::EID_CONFIGURATION_UPDATED); + + RegisterAtCenterPane(); +} + + + + +FormShellManager::~FormShellManager (void) +{ + SetFormShell(NULL); + UnregisterAtCenterPane(); + + // Unregister from the EventMultiplexer. + Link aLink (LINK(this, FormShellManager, ConfigurationUpdateHandler)); + mrBase.GetEventMultiplexer()->RemoveEventListener(aLink); + + if (mpSubShellFactory.get() != NULL) + { + ViewShell* pShell = mrBase.GetMainViewShell().get(); + if (pShell != NULL) + mrBase.GetViewShellManager()->RemoveSubShellFactory(pShell,mpSubShellFactory); + } +} + + + + +void FormShellManager::SetFormShell (FmFormShell* pFormShell) +{ + if (mpFormShell != pFormShell) + { + // Disconnect from the old form shell. + if (mpFormShell != NULL) + { + mpFormShell->SetControlActivationHandler(Link()); + EndListening(*mpFormShell); + mpFormShell->SetView(NULL); + } + + mpFormShell = pFormShell; + + // Connect to the new form shell. + if (mpFormShell != NULL) + { + mpFormShell->SetControlActivationHandler( + LINK( + this, + FormShellManager, + FormControlActivated)); + StartListening(*mpFormShell); + + ViewShell* pMainViewShell = mrBase.GetMainViewShell().get(); + if (pMainViewShell != NULL) + { + // Prevent setting the view twice at the FmFormShell. + FmFormView* pFormView = static_cast<FmFormView*>(pMainViewShell->GetView()); + if (mpFormShell->GetFormView() != pFormView) + mpFormShell->SetView(pFormView); + } + } + + // Tell the ViewShellManager where on the stack to place the form shell. + mrBase.GetViewShellManager()->SetFormShell( + mrBase.GetMainViewShell().get(), + mpFormShell, + mbFormShellAboveViewShell); + } +} + + + + +FmFormShell* FormShellManager::GetFormShell (void) +{ + return mpFormShell; +} + + + + +void FormShellManager::RegisterAtCenterPane (void) +{ + do + { + ViewShell* pShell = mrBase.GetMainViewShell().get(); + if (pShell == NULL) + break; + + // No form shell for the slide sorter. Besides that it is not + // necessary, using both together results in crashes. + if (pShell->GetShellType() == ViewShell::ST_SLIDE_SORTER) + break; + + mpMainViewShellWindow = pShell->GetActiveWindow(); + if (mpMainViewShellWindow == NULL) + break; + + // Register at the window to get informed when to move the form + // shell to the bottom of the shell stack. + mpMainViewShellWindow->AddEventListener( + LINK( + this, + FormShellManager, + WindowEventHandler)); + + // Create a shell factory and with it activate the form shell. + OSL_ASSERT(mpSubShellFactory.get()==NULL); + mpSubShellFactory.reset(new FormShellManagerFactory(*pShell, *this)); + mrBase.GetViewShellManager()->AddSubShellFactory(pShell,mpSubShellFactory); + mrBase.GetViewShellManager()->ActivateSubShell(*pShell, RID_FORMLAYER_TOOLBOX); + } + while (false); +} + + + + +void FormShellManager::UnregisterAtCenterPane (void) +{ + do + { + if (mpMainViewShellWindow != NULL) + { + // Unregister from the window. + mpMainViewShellWindow->RemoveEventListener( + LINK( + this, + FormShellManager, + WindowEventHandler)); + mpMainViewShellWindow = NULL; + } + + // Unregister form at the form shell. + SetFormShell(NULL); + + // Deactivate the form shell and destroy the shell factory. + ViewShell* pShell = mrBase.GetMainViewShell().get(); + if (pShell != NULL) + { + mrBase.GetViewShellManager()->DeactivateSubShell(*pShell, RID_FORMLAYER_TOOLBOX); + mrBase.GetViewShellManager()->RemoveSubShellFactory(pShell, mpSubShellFactory); + } + + mpSubShellFactory.reset(); + } + while (false); +} + + + + +IMPL_LINK(FormShellManager, FormControlActivated, FmFormShell*, EMPTYARG) +{ + // The form shell has been actived. To give it priority in reacting to + // slot calls the form shell is moved to the top of the object bar shell + // stack. + ViewShell* pShell = mrBase.GetMainViewShell().get(); + if (pShell!=NULL && !mbFormShellAboveViewShell) + { + mbFormShellAboveViewShell = true; + + ViewShellManager::UpdateLock aLock (mrBase.GetViewShellManager()); + mrBase.GetViewShellManager()->SetFormShell(pShell,mpFormShell,mbFormShellAboveViewShell); + } + + return 0; +} + + + + +IMPL_LINK(FormShellManager, ConfigurationUpdateHandler, sd::tools::EventMultiplexerEvent*, pEvent) +{ + switch (pEvent->meEventId) + { + case sd::tools::EventMultiplexerEvent::EID_MAIN_VIEW_REMOVED: + UnregisterAtCenterPane(); + break; + + case sd::tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED: + mbIsMainViewChangePending = true; + break; + + case sd::tools::EventMultiplexerEvent::EID_CONFIGURATION_UPDATED: + if (mbIsMainViewChangePending) + { + mbIsMainViewChangePending = false; + RegisterAtCenterPane(); + } + break; + + default: + break; + } + + return 0; +} + + + + +IMPL_LINK(FormShellManager, WindowEventHandler, VclWindowEvent*, pEvent) +{ + if (pEvent != NULL) + { + switch (pEvent->GetId()) + { + case VCLEVENT_WINDOW_GETFOCUS: + { + // The window of the center pane got the focus. Therefore + // the form shell is moved to the bottom of the object bar + // stack. + ViewShell* pShell = mrBase.GetMainViewShell().get(); + if (pShell!=NULL && mbFormShellAboveViewShell) + { + mbFormShellAboveViewShell = false; + ViewShellManager::UpdateLock aLock (mrBase.GetViewShellManager()); + mrBase.GetViewShellManager()->SetFormShell( + pShell, + mpFormShell, + mbFormShellAboveViewShell); + } + } + break; + + case VCLEVENT_WINDOW_LOSEFOCUS: + // We follow the sloppy focus policy. Losing the focus is + // ignored. We wait for the focus to be placed either in + // the window or the form shell. The later, however, is + // notified over the FormControlActivated handler, not this + // one. + break; + + case VCLEVENT_OBJECT_DYING: + mpMainViewShellWindow = NULL; + break; + } + } + + return 0; +} + + + + +void FormShellManager::Notify(SfxBroadcaster&, const SfxHint& rHint) +{ + const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint); + if (pSimpleHint!=NULL && pSimpleHint->GetId()==SFX_HINT_DYING) + { + // If all goes well this listener is called after the + // FormShellManager was notified about the dying form shell by the + // FormShellManagerFactory. + OSL_ASSERT(mpFormShell==NULL); + if (mpFormShell != NULL) + { + mpFormShell = NULL; + mrBase.GetViewShellManager()->SetFormShell( + mrBase.GetMainViewShell().get(), + NULL, + false); + } + } +} + + + + + +//===== FormShellManagerFactory =============================================== + +namespace { + +FormShellManagerFactory::FormShellManagerFactory ( + ::sd::ViewShell& rViewShell, + FormShellManager& rManager) + : mrViewShell(rViewShell), + mrFormShellManager(rManager) +{ +} + + + + +FmFormShell* FormShellManagerFactory::CreateShell ( + ::sd::ShellId nId, + ::Window*, + ::sd::FrameView*) +{ + FmFormShell* pShell = NULL; + + ::sd::View* pView = mrViewShell.GetView(); + if (nId == RID_FORMLAYER_TOOLBOX) + { + pShell = new FmFormShell(&mrViewShell.GetViewShellBase(), pView); + mrFormShellManager.SetFormShell(pShell); + } + + return pShell; +} + + + + +void FormShellManagerFactory::ReleaseShell (SfxShell* pShell) +{ + if (pShell != NULL) + { + mrFormShellManager.SetFormShell(NULL); + delete pShell; + } +} + +} // end of anonymous namespace + +} // end of namespace sd diff --git a/sd/source/ui/view/GraphicObjectBar.cxx b/sd/source/ui/view/GraphicObjectBar.cxx new file mode 100644 index 000000000000..cea33fda98bf --- /dev/null +++ b/sd/source/ui/view/GraphicObjectBar.cxx @@ -0,0 +1,185 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "GraphicObjectBar.hxx" + +#include <limits.h> +#include <vcl/msgbox.hxx> +#include <svl/whiter.hxx> +#include <svl/itempool.hxx> +#include <sfx2/app.hxx> +#include <sfx2/shell.hxx> +#include <svx/svxids.hrc> +#include <sfx2/request.hxx> +#include <sfx2/basedlgs.hxx> +#include <svx/svdograf.hxx> +#include <svx/grfflt.hxx> +#include <svl/aeitem.hxx> +#include <svx/grafctrl.hxx> + + +#include <sfx2/objface.hxx> + +#include "app.hrc" +#include "res_bmp.hrc" +#include "glob.hrc" +#include "strings.hrc" +#include "DrawDocShell.hxx" +#include "ViewShell.hxx" +#include "Window.hxx" +#include "drawview.hxx" +#include "sdresid.hxx" +#include "drawdoc.hxx" + +using namespace sd; +#define GraphicObjectBar +#include "sdslots.hxx" + +namespace sd { + + + +// ----------------------- +// - GraphicObjectBar - +// ----------------------- + +SFX_IMPL_INTERFACE( GraphicObjectBar, SfxShell, SdResId( STR_GRAFOBJECTBARSHELL ) ) +{ +} + +// ----------------------------------------------------------------------------- + +TYPEINIT1( GraphicObjectBar, SfxShell ); + +// ----------------------------------------------------------------------------- + +GraphicObjectBar::GraphicObjectBar ( + ViewShell* pSdViewShell, + ::sd::View* pSdView ) + : SfxShell (pSdViewShell->GetViewShell()), + mpView ( pSdView ), + mpViewSh ( pSdViewShell ), + nMappedSlotFilter ( SID_GRFFILTER_INVERT ) +{ + DrawDocShell* pDocShell = mpViewSh->GetDocSh(); + + SetPool( &pDocShell->GetPool() ); + SetUndoManager( pDocShell->GetUndoManager() ); + SetRepeatTarget( mpView ); + SetHelpId( SD_IF_SDDRAWGRAFOBJECTBAR ); + SetName( String( RTL_CONSTASCII_USTRINGPARAM( "Graphic objectbar" ))); +} + +// ----------------------------------------------------------------------------- + +GraphicObjectBar::~GraphicObjectBar() +{ + SetRepeatTarget( NULL ); +} + +// ----------------------------------------------------------------------------- + +void GraphicObjectBar::GetAttrState( SfxItemSet& rSet ) +{ + if( mpView ) + SvxGrafAttrHelper::GetGrafAttrState( rSet, *mpView ); +} + +// ----------------------------------------------------------------------------- + +void GraphicObjectBar::Execute( SfxRequest& rReq ) +{ + if( mpView ) + { + SvxGrafAttrHelper::ExecuteGrafAttr( rReq, *mpView ); + Invalidate(); + } +} + +// ----------------------------------------------------------------------------- + +void GraphicObjectBar::GetFilterState( SfxItemSet& rSet ) +{ + const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); + BOOL bEnable = FALSE; + + if( rMarkList.GetMarkCount() == 1 ) + { + SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + + if( pObj && pObj->ISA( SdrGrafObj ) && ( ( (SdrGrafObj*) pObj )->GetGraphicType() == GRAPHIC_BITMAP ) ) + bEnable = TRUE; + } + + if( !bEnable ) + SvxGraphicFilter::DisableGraphicFilterSlots( rSet ); +} + +// ----------------------------------------------------------------------------- + +void GraphicObjectBar::ExecuteFilter( SfxRequest& rReq ) +{ + const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); + + if( rMarkList.GetMarkCount() == 1 ) + { + SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + + if( pObj && pObj->ISA( SdrGrafObj ) && ( (SdrGrafObj*) pObj )->GetGraphicType() == GRAPHIC_BITMAP ) + { + GraphicObject aFilterObj( ( (SdrGrafObj*) pObj )->GetGraphicObject() ); + + if( SVX_GRAPHICFILTER_ERRCODE_NONE == + SvxGraphicFilter::ExecuteGrfFilterSlot( rReq, aFilterObj ) ) + { + SdrPageView* pPageView = mpView->GetSdrPageView(); + + if( pPageView ) + { + SdrGrafObj* pFilteredObj = (SdrGrafObj*) pObj->Clone(); + String aStr( mpView->GetDescriptionOfMarkedObjects() ); + + aStr.Append( sal_Unicode(' ') ); + aStr.Append( String( SdResId( STR_UNDO_GRAFFILTER ) ) ); + mpView->BegUndo( aStr ); + pFilteredObj->SetGraphicObject( aFilterObj ); + ::sd::View* const pView = mpView; + pView->ReplaceObjectAtView( pObj, *pPageView, pFilteredObj ); + pView->EndUndo(); + return; + } + } + } + } + + Invalidate(); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/GraphicViewShellBase.cxx b/sd/source/ui/view/GraphicViewShellBase.cxx new file mode 100755 index 000000000000..759103760bfe --- /dev/null +++ b/sd/source/ui/view/GraphicViewShellBase.cxx @@ -0,0 +1,138 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "GraphicViewShellBase.hxx" + +#include "GraphicDocShell.hxx" +#include "sdresid.hxx" +#include "strings.hrc" +#include "app.hrc" +#include "framework/DrawModule.hxx" +#include "framework/FrameworkHelper.hxx" +#include <sfx2/request.hxx> + +namespace sd { + +TYPEINIT1(GraphicViewShellBase, ViewShellBase); + +// We have to expand the SFX_IMPL_VIEWFACTORY macro to call LateInit() after a +// new GraphicViewShellBase object has been constructed. + +/* +SFX_IMPL_VIEWFACTORY(GraphicViewShellBase, SdResId(STR_DEFAULTVIEW)) +{ + SFX_VIEW_REGISTRATION(GraphicDocShell); +} +*/ +SfxViewFactory* GraphicViewShellBase::pFactory; +SfxViewShell* __EXPORT GraphicViewShellBase::CreateInstance ( + SfxViewFrame *pFrame, SfxViewShell *pOldView) +{ + GraphicViewShellBase* pBase = new GraphicViewShellBase(pFrame, pOldView); + pBase->LateInit(framework::FrameworkHelper::msDrawViewURL); + return pBase; +} +void GraphicViewShellBase::RegisterFactory( USHORT nPrio ) +{ + pFactory = new SfxViewFactory( + &CreateInstance,&InitFactory,nPrio,SdResId(STR_DEFAULTVIEW)); + InitFactory(); +} +void GraphicViewShellBase::InitFactory() +{ + SFX_VIEW_REGISTRATION(GraphicDocShell); +} + + + + + + + + +GraphicViewShellBase::GraphicViewShellBase ( + SfxViewFrame* _pFrame, + SfxViewShell* pOldShell) + : ViewShellBase (_pFrame, pOldShell) +{ +} + + + + +GraphicViewShellBase::~GraphicViewShellBase (void) +{ +} + + + + +void GraphicViewShellBase::Execute (SfxRequest& rRequest) +{ + USHORT nSlotId = rRequest.GetSlot(); + + switch (nSlotId) + { + case SID_NOTES_WINDOW: + case SID_SLIDE_SORTER_MULTI_PANE_GUI: + case SID_DIAMODE: + case SID_OUTLINEMODE: + case SID_NOTESMODE: + case SID_HANDOUTMODE: + case SID_SHOW_TOOL_PANEL: + // Prevent some Impress-only slots from being executed. + rRequest.Cancel(); + break; + + case SID_TASKPANE: + case SID_SWITCH_SHELL: + case SID_LEFT_PANE_DRAW: + case SID_LEFT_PANE_IMPRESS: + default: + // The remaining requests are forwarded to our base class. + ViewShellBase::Execute (rRequest); + break; + } + +} + + + + +void GraphicViewShellBase::InitializeFramework (void) +{ + com::sun::star::uno::Reference<com::sun::star::frame::XController> + xController (GetController()); + sd::framework::DrawModule::Initialize(xController); +} + + +} // end of namespace sd + diff --git a/sd/source/ui/view/ImpressViewShellBase.cxx b/sd/source/ui/view/ImpressViewShellBase.cxx new file mode 100644 index 000000000000..0cd5971eb51e --- /dev/null +++ b/sd/source/ui/view/ImpressViewShellBase.cxx @@ -0,0 +1,128 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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 "ImpressViewShellBase.hxx" + +#include "DrawDocShell.hxx" +#include "sdresid.hxx" +#include "strings.hrc" +#include "app.hrc" +#include "framework/FrameworkHelper.hxx" +#include "framework/ImpressModule.hxx" +#include "MasterPageObserver.hxx" +#include <sfx2/request.hxx> + +namespace sd { + +TYPEINIT1(ImpressViewShellBase, ViewShellBase); + +// We have to expand the SFX_IMPL_VIEWFACTORY macro to call LateInit() after a +// new ImpressViewShellBase object has been constructed. + +/* +SFX_IMPL_VIEWFACTORY(ImpressViewShellBase, SdResId(STR_DEFAULTVIEW)) +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} +*/ +SfxViewFactory* ImpressViewShellBase::pFactory; +SfxViewShell* __EXPORT ImpressViewShellBase::CreateInstance ( + SfxViewFrame *pFrame, SfxViewShell *pOldView) +{ + ImpressViewShellBase* pBase = new ImpressViewShellBase(pFrame, pOldView); + pBase->LateInit(::rtl::OUString()); + return pBase; +} +void ImpressViewShellBase::RegisterFactory( USHORT nPrio ) +{ + pFactory = new SfxViewFactory( + &CreateInstance,&InitFactory,nPrio,SdResId(STR_DEFAULTVIEW)); + InitFactory(); +} +void ImpressViewShellBase::InitFactory() +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} + + + + + + + + +ImpressViewShellBase::ImpressViewShellBase ( + SfxViewFrame* _pFrame, + SfxViewShell* pOldShell) + : ViewShellBase (_pFrame, pOldShell) +{ + MasterPageObserver::Instance().RegisterDocument (*GetDocShell()->GetDoc()); +} + + + + +ImpressViewShellBase::~ImpressViewShellBase (void) +{ + MasterPageObserver::Instance().UnregisterDocument (*GetDocShell()->GetDoc()); +} + + + + +void ImpressViewShellBase::Execute (SfxRequest& rRequest) +{ + USHORT nSlotId = rRequest.GetSlot(); + + switch (nSlotId) + { + case SID_LEFT_PANE_DRAW: + // Prevent a Draw-only slots from being executed. + rRequest.Cancel(); + break; + + default: + // The remaining requests are forwarded to our base class. + ViewShellBase::Execute(rRequest); + break; + } +} + + + + +void ImpressViewShellBase::InitializeFramework (void) +{ + ::com::sun::star::uno::Reference<com::sun::star::frame::XController> + xController (GetController()); + sd::framework::ImpressModule::Initialize(xController); +} + +} // end of namespace sd + diff --git a/sd/source/ui/view/MediaObjectBar.cxx b/sd/source/ui/view/MediaObjectBar.cxx new file mode 100644 index 000000000000..ad5135939bc3 --- /dev/null +++ b/sd/source/ui/view/MediaObjectBar.cxx @@ -0,0 +1,166 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "MediaObjectBar.hxx" +#include <avmedia/mediaitem.hxx> +#include <sfx2/msg.hxx> +#include <sfx2/app.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/request.hxx> +#include <sfx2/objface.hxx> +#include <svl/whiter.hxx> +#include <svl/itempool.hxx> +#include <svx/svdomedia.hxx> +#include <svx/sdr/contact/viewcontactofsdrmediaobj.hxx> + +#include "app.hrc" +#include "res_bmp.hrc" +#include "glob.hrc" +#include "strings.hrc" +#include "DrawDocShell.hxx" +#include "ViewShell.hxx" +#include "Window.hxx" +#include "drawview.hxx" +#include "sdresid.hxx" +#include "drawdoc.hxx" + +using namespace sd; + +#define MediaObjectBar +#include "sdslots.hxx" + +namespace sd { + +// ------------------ +// - MediaObjectBar - +// ------------------ + +TYPEINIT1( MediaObjectBar, SfxShell ); + +// ----------------------------------------------------------------------------- + +SFX_IMPL_INTERFACE( MediaObjectBar, SfxShell, SdResId( STR_MEDIAOBJECTBARSHELL ) ) +{ +} + +// ----------------------------------------------------------------------------- + +MediaObjectBar::MediaObjectBar( ViewShell* pSdViewShell, ::sd::View* pSdView ) : + SfxShell( pSdViewShell->GetViewShell() ), + mpView( pSdView ), + mpViewSh( pSdViewShell ) +{ + DrawDocShell* pDocShell = mpViewSh->GetDocSh(); + + SetPool( &pDocShell->GetPool() ); + SetUndoManager( pDocShell->GetUndoManager() ); + SetRepeatTarget( mpView ); + SetHelpId( SD_IF_SDDRAWMEDIAOBJECTBAR ); + SetName( String( SdResId( RID_DRAW_MEDIA_TOOLBOX ) ) ); +} + +// ----------------------------------------------------------------------------- + +MediaObjectBar::~MediaObjectBar() +{ + SetRepeatTarget( NULL ); +} + +// ----------------------------------------------------------------------------- + +void MediaObjectBar::GetState( SfxItemSet& rSet ) +{ + SfxWhichIter aIter( rSet ); + USHORT nWhich = aIter.FirstWhich(); + + while( nWhich ) + { + if( SID_AVMEDIA_TOOLBOX == nWhich ) + { + SdrMarkList* pMarkList = new SdrMarkList( mpView->GetMarkedObjectList() ); + bool bDisable = true; + + if( 1 == pMarkList->GetMarkCount() ) + { + SdrObject* pObj =pMarkList->GetMark( 0 )->GetMarkedSdrObj(); + + if( pObj && pObj->ISA( SdrMediaObj ) ) + { + ::avmedia::MediaItem aItem( SID_AVMEDIA_TOOLBOX ); + + static_cast< sdr::contact::ViewContactOfSdrMediaObj& >( pObj->GetViewContact() ).updateMediaItem( aItem ); + rSet.Put( aItem ); + bDisable = false; + } + } + + if( bDisable ) + rSet.DisableItem( SID_AVMEDIA_TOOLBOX ); + + delete pMarkList; + } + + nWhich = aIter.NextWhich(); + } +} + +// ----------------------------------------------------------------------------- + +void MediaObjectBar::Execute( SfxRequest& rReq ) +{ + if( SID_AVMEDIA_TOOLBOX == rReq.GetSlot() ) + { + const SfxItemSet* pArgs = rReq.GetArgs(); + const SfxPoolItem* pItem; + + if( !pArgs || ( SFX_ITEM_SET != pArgs->GetItemState( SID_AVMEDIA_TOOLBOX, FALSE, &pItem ) ) ) + pItem = NULL; + + if( pItem ) + { + SdrMarkList* pMarkList = new SdrMarkList( mpView->GetMarkedObjectList() ); + + if( 1 == pMarkList->GetMarkCount() ) + { + SdrObject* pObj = pMarkList->GetMark( 0 )->GetMarkedSdrObj(); + + if( pObj && pObj->ISA( SdrMediaObj ) ) + { + static_cast< sdr::contact::ViewContactOfSdrMediaObj& >( pObj->GetViewContact() ).executeMediaItem( + static_cast< const ::avmedia::MediaItem& >( *pItem ) ); + } + } + + delete pMarkList; + } + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/OutlineViewShellBase.cxx b/sd/source/ui/view/OutlineViewShellBase.cxx new file mode 100644 index 000000000000..762219c88016 --- /dev/null +++ b/sd/source/ui/view/OutlineViewShellBase.cxx @@ -0,0 +1,92 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "OutlineViewShellBase.hxx" +#include "sdresid.hxx" +#include "DrawDocShell.hxx" +#include "strings.hrc" +#include "framework/FrameworkHelper.hxx" + +namespace sd { + +class DrawDocShell; + +TYPEINIT1(OutlineViewShellBase, ViewShellBase); + +// We have to expand the SFX_IMPL_VIEWFACTORY macro to call LateInit() after a +// new OutlineViewShellBase object has been constructed. + +/* +SFX_IMPL_VIEWFACTORY(OutlineViewShellBase, SdResId(STR_DEFAULTVIEW)) +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} +*/ +SfxViewFactory* OutlineViewShellBase::pFactory; +SfxViewShell* __EXPORT OutlineViewShellBase::CreateInstance ( + SfxViewFrame *pFrame, SfxViewShell *pOldView) +{ + OutlineViewShellBase* pBase = new OutlineViewShellBase(pFrame, pOldView); + pBase->LateInit(framework::FrameworkHelper::msOutlineViewURL); + return pBase; +} +void OutlineViewShellBase::RegisterFactory( USHORT nPrio ) +{ + pFactory = new SfxViewFactory( + &CreateInstance,&InitFactory,nPrio,SdResId(STR_DEFAULTVIEW)); + InitFactory(); +} +void OutlineViewShellBase::InitFactory() +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} + + + + +OutlineViewShellBase::OutlineViewShellBase ( + SfxViewFrame* _pFrame, + SfxViewShell* pOldShell) + : ImpressViewShellBase (_pFrame, pOldShell) +{ +} + + + + +OutlineViewShellBase::~OutlineViewShellBase (void) +{ +} + + + + +} // end of namespace sd + diff --git a/sd/source/ui/view/Outliner.cxx b/sd/source/ui/view/Outliner.cxx new file mode 100755 index 000000000000..356c03b82387 --- /dev/null +++ b/sd/source/ui/view/Outliner.cxx @@ -0,0 +1,1826 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "Outliner.hxx" +#include <vcl/wrkwin.hxx> +#include <svl/srchitem.hxx> +#include <editeng/colritem.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/editstat.hxx> +#include <vcl/outdev.hxx> +#include <svx/dlgutil.hxx> +#include <svx/xtable.hxx> +#include <vcl/msgbox.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/printer.hxx> +#include <svx/svxerr.hxx> +#include <svx/svdotext.hxx> +#include <editeng/unolingu.hxx> +#include <svx/svditer.hxx> +#include <comphelper/extract.hxx> +#include <com/sun/star/linguistic2/XSpellChecker1.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <comphelper/processfactory.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/forbiddencharacterstable.hxx> +#include <svx/srchdlg.hxx> +#include <unotools/linguprops.hxx> +#include <unotools/lingucfg.hxx> +#include <editeng/editeng.hxx> +#include <vcl/metric.hxx> +#include <sfx2/viewfrm.hxx> +#include <svtools/langtab.hxx> +#include <tools/diagnose_ex.h> + +#include "strings.hrc" +#include "sdstring.hrc" +#include "eetext.hxx" +#include "sdpage.hxx" +#include "app.hxx" +#include "Window.hxx" +#include "sdresid.hxx" +#include "DrawViewShell.hxx" +#include "OutlineViewShell.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "FrameView.hxx" +#include "optsitem.hxx" +#include "drawview.hxx" +#include "ViewShellBase.hxx" +#include "SpellDialogChildWindow.hxx" +#include "ToolBarManager.hxx" +#include "framework/FrameworkHelper.hxx" +#include <svx/svxids.hrc> +#include <editeng/editerr.hxx> + +using ::rtl::OUString; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::linguistic2; + +class SfxStyleSheetPool; + +namespace sd { + +class Outliner::Implementation +{ +public: + /** The original edit mode directly after switching to a different view + mode. Used for restoring the edit mode when leaving that view mode + again. + */ + EditMode meOriginalEditMode; + + Implementation (void); + ~Implementation (void); + + /** Return the OutlinerView that was provided by the last call to + ProvideOutlinerView() (or NULL when there was no such call.) + */ + OutlinerView* GetOutlinerView (void); + + /** Provide in the member mpOutlineView an instance of OutlinerView that + is either taken from the ViewShell, when it is an OutlineViewShell, + or is created. When an OutlinerView already exists it is initialied. + */ + void ProvideOutlinerView ( + Outliner& rOutliner, + const ::boost::shared_ptr<ViewShell>& rpViewShell, + ::Window* pWindow); + + /** This method is called when the OutlinerView is no longer used. + */ + void ReleaseOutlinerView (void); + +private: + /** Flag that specifies whether we own the outline view pointed to by + <member>mpOutlineView</member> and thus have to + delete it in <member>EndSpelling()</member>. + */ + bool mbOwnOutlineView; + + /** The outline view used for searching and spelling. If searching or + spell checking an outline view this data member points to that view. + For all other views an instance is created. The + <member>mbOwnOutlineView</member> distinguishes between both cases. + */ + OutlinerView* mpOutlineView; +}; + + + + +/************************************************************************* +|* +|* Ctor +|* +\************************************************************************/ + +Outliner::Outliner( SdDrawDocument* pDoc, USHORT nMode ) + : SdrOutliner( &pDoc->GetItemPool(), nMode ), + mpImpl(new Implementation()), + meMode(SEARCH), + mpView(NULL), + mpViewShell(), + mpWindow(NULL), + mpDrawDocument(pDoc), + mnConversionLanguage(LANGUAGE_NONE), + mnIgnoreCurrentPageChangesLevel(0), + mbStringFound(FALSE), + mbMatchMayExist(false), + mnPageCount(0), + mnObjectCount(0), + mbEndOfSearch(FALSE), + mbFoundObject(FALSE), + mbError(FALSE), + mbDirectionIsForward(true), + mbRestrictSearchToSelection(false), + maMarkListCopy(), + mbProcessCurrentViewOnly(false), + mpObj(NULL), + mpFirstObj(NULL), + mpTextObj(NULL), + mnText(0), + mpParaObj(NULL), + meStartViewMode(PK_STANDARD), + meStartEditMode(EM_PAGE), + mnStartPageIndex((USHORT)-1), + mpStartEditedObject(NULL), + maStartSelection(), + mpSearchItem(NULL), + maObjectIterator(), + maCurrentPosition(), + maSearchStartPosition(), + maLastValidPosition(), + mbSelectionHasChanged(false), + mbExpectingSelectionChangeEvent(false), + mbWholeDocumentProcessed(false), + mbPrepareSpellingPending(true), + mbViewShellValid(true) +{ + SetStyleSheetPool((SfxStyleSheetPool*) mpDrawDocument->GetStyleSheetPool()); + SetEditTextObjectPool( &pDoc->GetItemPool() ); + SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl)); + SetForbiddenCharsTable( pDoc->GetForbiddenCharsTable() ); + + ULONG nCntrl = GetControlWord(); + nCntrl |= EE_CNTRL_ALLOWBIGOBJS; + nCntrl |= EE_CNTRL_URLSFXEXECUTE; + nCntrl |= EE_CNTRL_MARKFIELDS; + nCntrl |= EE_CNTRL_AUTOCORRECT; + + BOOL bOnlineSpell = false; + + DrawDocShell* pDocSh = mpDrawDocument->GetDocSh(); + + if (pDocSh) + { + bOnlineSpell = mpDrawDocument->GetOnlineSpell(); + } + else + { + bOnlineSpell = false; + + try + { + const SvtLinguConfig aLinguConfig; + Any aAny; + + aAny = aLinguConfig.GetProperty( + rtl::OUString::createFromAscii( UPN_IS_SPELL_AUTO ) ); + aAny >>= bOnlineSpell; + } + catch( ... ) + { + DBG_ERROR( "Ill. type in linguistic property" ); + } + } + + if (bOnlineSpell) + nCntrl |= EE_CNTRL_ONLINESPELLING; + else + nCntrl &= ~EE_CNTRL_ONLINESPELLING; + + SetControlWord(nCntrl); + + Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() ); + if ( xSpellChecker.is() ) + SetSpeller( xSpellChecker ); + + Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() ); + if( xHyphenator.is() ) + SetHyphenator( xHyphenator ); + + SetDefaultLanguage( Application::GetSettings().GetLanguage() ); +} + + + + +/// Nothing spectecular in the destructor. +Outliner::~Outliner (void) +{ + mpImpl.reset(); +} + + + + +/** Prepare find&replace or spellchecking. This distinguishes between three + cases: + <ol> + <li>The current shell is a <type>DrawViewShell</type>: Create a + <type>OutlinerView</type> object and search all objects of (i) the + current mark list, (ii) of the current view, or (iii) of all the view + combinations: + <ol> + <li>Draw view, slide view</li> + <li>Draw view, background view</li> + <li>Notes view, slide view</li> + <li>Notes view, background view</li> + <li>Handout view, slide view</li> + <li>Handout view, background view</li> + </ol> + + <li>When the current shell is a <type>SdOutlineViewShell</type> then + directly operate on it. No switching into other views takes place.</li> + + <li>For a <type>SlideViewShell</type> no action is performed.</li> + </ol> +*/ +void Outliner::PrepareSpelling (void) +{ + if (mbViewShellValid) + { + mbPrepareSpellingPending = false; + + ViewShellBase* pBase = PTR_CAST(ViewShellBase,SfxViewShell::Current()); + if (pBase != NULL) + SetViewShell (pBase->GetMainViewShell()); + SetRefDevice( SD_MOD()->GetRefDevice( *mpDrawDocument->GetDocSh() ) ); + + if (mpViewShell.get() != NULL) + { + mbStringFound = FALSE; + + mbWholeDocumentProcessed = false; + // Supposed that we are not located at the very beginning/end of + // the document then there may be a match in the document + // prior/after the current position. + mbMatchMayExist = TRUE; + + maObjectIterator = ::sd::outliner::Iterator(); + maSearchStartPosition = ::sd::outliner::Iterator(); + RememberStartPosition(); + + mpImpl->ProvideOutlinerView(*this, mpViewShell, mpWindow); + + HandleChangedSelection (); + } + ClearModifyFlag(); + } +} + + + + + +void Outliner::StartSpelling (void) +{ + meMode = SPELL; + mbDirectionIsForward = true; + mpSearchItem = NULL; +} + +/** Proxy for method from base class to avoid compiler warning */ +void Outliner::StartSpelling(EditView& rView, unsigned char c) +{ + SdrOutliner::StartSpelling( rView, c ); +} + +/** Free all resources acquired during the search/spell check. After a + spell check the start position is restored here. +*/ +void Outliner::EndSpelling (void) +{ + if (mbViewShellValid) + { + // Keep old view shell alive until we release the outliner view. + ::boost::shared_ptr<ViewShell> pOldViewShell (mpViewShell); + + ViewShellBase* pBase = PTR_CAST(ViewShellBase,SfxViewShell::Current()); + if (pBase != NULL) + mpViewShell = pBase->GetMainViewShell(); + else + mpViewShell.reset(); + + // When in <member>PrepareSpelling()</member> a new outline view has + // been created then delete it here. + sal_Bool bViewIsDrawViewShell(mpViewShell.get()!=NULL + && mpViewShell->ISA(DrawViewShell)); + if (bViewIsDrawViewShell) + { + SetStatusEventHdl(Link()); + mpView = mpViewShell->GetView(); + mpView->UnmarkAllObj (mpView->GetSdrPageView()); + mpView->SdrEndTextEdit(); + // Make FuSelection the current function. + mpViewShell->GetDispatcher()->Execute( + SID_OBJECT_SELECT, + SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD); + + // Remove and, if previously created by us, delete the outline + // view. + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + { + RemoveView(pOutlinerView); + mpImpl->ReleaseOutlinerView(); + } + + SetUpdateMode(TRUE); + } + + // #95811# Before clearing the modify flag use it as a hint that + // changes were done at SpellCheck + if(IsModified()) + { + if(mpView && mpView->ISA(OutlineView)) + static_cast<OutlineView*>(mpView)->PrepareClose(FALSE); + if(mpDrawDocument && !mpDrawDocument->IsChanged()) + mpDrawDocument->SetChanged(TRUE); + } + + // #95811# now clear the modify flag to have a specified state of + // Outliner + ClearModifyFlag(); + + // When spell checking then restore the start position. + if (meMode==SPELL || meMode==TEXT_CONVERSION) + RestoreStartPosition (); + } + + mpViewShell.reset(); + mpView = NULL; + mpWindow = NULL; +} + + + + +BOOL Outliner::SpellNextDocument (void) +{ + if (mpViewShell->ISA(OutlineViewShell)) + { + // When doing a spell check in the outline view then there is + // only one document. + mbEndOfSearch = true; + EndOfSearch (); + } + else + { + if (mpView->ISA(OutlineView)) + ((OutlineView*)mpView)->PrepareClose(FALSE); + mpDrawDocument->GetDocSh()->SetWaitCursor( TRUE ); + + Initialize (true); + + mpWindow = mpViewShell->GetActiveWindow(); + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + pOutlinerView->SetWindow(mpWindow); + ProvideNextTextObject (); + + mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE ); + ClearModifyFlag(); + } + + return mbEndOfSearch ? FALSE : TRUE; + +} + + +/************************************************************************* +|* +|* Spelling: naechstes TextObjekt pruefen +|* +\************************************************************************/ + +::svx::SpellPortions Outliner::GetNextSpellSentence (void) +{ + ::svx::SpellPortions aResult; + + DetectChange(); + // Iterate over sentences and text shapes until a sentence with a + // spelling error has been found. If no such sentence can be + // found the loop is left through a break. + // It is the responsibility of the sd outliner object to correctly + // iterate over all text shapes, i.e. switch between views, wrap + // arround at the end of the document, stop when all text shapes + // have been examined exactly once. + bool bFoundNextSentence = false; + while ( ! bFoundNextSentence) + { + OutlinerView* pOutlinerView = GetView(0); + if (pOutlinerView != NULL) + { + ESelection aCurrentSelection (pOutlinerView->GetSelection()); + if ( ! mbMatchMayExist + && maStartSelection.IsLess(aCurrentSelection)) + EndOfSearch(); + + // Advance to the next sentence. + bFoundNextSentence = SpellSentence ( + pOutlinerView->GetEditView(), + aResult, false); + } + + // When no sentence with spelling errors has been found in the + // currently selected text shape or there is no selected text + // shape then advance to the next text shape. + if ( ! bFoundNextSentence) + if ( ! SpellNextDocument()) + // All text objects have been processed so exit the + // loop and return an empty portions list. + break; + } + + return aResult; +} + + + + +/** Go to next match. +*/ +bool Outliner::StartSearchAndReplace (const SvxSearchItem* pSearchItem) +{ + BOOL bEndOfSearch = TRUE; + + if (mbViewShellValid) + { + mpDrawDocument->GetDocSh()->SetWaitCursor( TRUE ); + if (mbPrepareSpellingPending) + PrepareSpelling(); + ViewShellBase* pBase = PTR_CAST(ViewShellBase,SfxViewShell::Current()); + // Determine whether we have to abort the search. This is necessary + // when the main view shell does not support searching. + bool bAbort = false; + if (pBase != NULL) + { + ::boost::shared_ptr<ViewShell> pShell (pBase->GetMainViewShell()); + SetViewShell(pShell); + if (pShell.get() == NULL) + bAbort = true; + else + switch (pShell->GetShellType()) + { + case ViewShell::ST_DRAW: + case ViewShell::ST_IMPRESS: + case ViewShell::ST_NOTES: + case ViewShell::ST_HANDOUT: + case ViewShell::ST_OUTLINE: + bAbort = false; + break; + default: + bAbort = true; + break; + } + } + + if ( ! bAbort) + { + meMode = SEARCH; + mpSearchItem = pSearchItem; + + mbFoundObject = FALSE; + + Initialize ( ! mpSearchItem->GetBackward()); + + USHORT nCommand = mpSearchItem->GetCommand(); + if (nCommand == SVX_SEARCHCMD_REPLACE_ALL) + bEndOfSearch = SearchAndReplaceAll (); + else + { + RememberStartPosition (); + bEndOfSearch = SearchAndReplaceOnce (); + //#107233# restore start position if nothing was found + if(!mbStringFound) + RestoreStartPosition (); + else + mnStartPageIndex = (USHORT)-1; + } + } + else + mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE ); + } + + return bEndOfSearch; +} + + + + +void Outliner::Initialize (bool bDirectionIsForward) +{ + const bool bIsAtEnd (maObjectIterator == ::sd::outliner::OutlinerContainer(this).end()); + const bool bOldDirectionIsForward = mbDirectionIsForward; + mbDirectionIsForward = bDirectionIsForward; + + if (maObjectIterator == ::sd::outliner::Iterator()) + { + // Initialize a new search. + maObjectIterator = ::sd::outliner::OutlinerContainer(this).current(); + maCurrentPosition = *maObjectIterator; + + // In case we are searching in an outline view then first remove the + // current selection and place cursor at its start or end. + if (mpViewShell->ISA(OutlineViewShell)) + { + ESelection aSelection = mpImpl->GetOutlinerView()->GetSelection (); + if (mbDirectionIsForward) + { + aSelection.nEndPara = aSelection.nStartPara; + aSelection.nEndPos = aSelection.nStartPos; + } + else + { + aSelection.nStartPara = aSelection.nEndPara; + aSelection.nStartPos = aSelection.nEndPos; + } + mpImpl->GetOutlinerView()->SetSelection (aSelection); + } + + // When not beginning the search at the beginning of the search area + // then there may be matches before the current position. + mbMatchMayExist = (maObjectIterator!=::sd::outliner::OutlinerContainer(this).begin()); + } + else if (bOldDirectionIsForward != mbDirectionIsForward) + { + // Requested iteration direction has changed. Turn arround the iterator. + maObjectIterator.Reverse(); + if (bIsAtEnd) + { + // The iterator has pointed to end(), which after the search + // direction is reversed, becomes begin(). + maObjectIterator = ::sd::outliner::OutlinerContainer(this).begin(); + } + else + { + // The iterator has pointed to the object one ahead/before the current + // one. Now move it to the one before/ahead the current one. + ++maObjectIterator; + ++maObjectIterator; + } + + mbMatchMayExist = true; + } + + // Initialize the last valid position with where the search starts so + // that it always points to a valid position. + maLastValidPosition = *::sd::outliner::OutlinerContainer(this).current(); +} + + + + +bool Outliner::SearchAndReplaceAll (void) +{ + // Save the current position to be restored after having replaced all + // matches. + RememberStartPosition (); + + if (mpViewShell->ISA(OutlineViewShell)) + { + // Put the cursor to the beginning/end of the outliner. + mpImpl->GetOutlinerView()->SetSelection (GetSearchStartPosition ()); + + // The outliner does all the work for us when we are in this mode. + SearchAndReplaceOnce(); + } + else if (mpViewShell->ISA(DrawViewShell)) + { + // Go to beginning/end of document. + maObjectIterator = ::sd::outliner::OutlinerContainer(this).begin(); + // Switch to the current object only if it is a valid text object. + ::sd::outliner::IteratorPosition aNewPosition (*maObjectIterator); + if (IsValidTextObject (aNewPosition)) + { + maCurrentPosition = aNewPosition; + SetObject (maCurrentPosition); + } + + // Search/replace until the end of the document is reached. + bool bFoundMatch; + do + { + bFoundMatch = ! SearchAndReplaceOnce(); + } + while (bFoundMatch); + } + + RestoreStartPosition (); + + return true; +} + + + + +bool Outliner::SearchAndReplaceOnce (void) +{ + DetectChange (); + + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + DBG_ASSERT(pOutlinerView!=NULL && GetEditEngine().HasView( &pOutlinerView->GetEditView() ), + "SearchAndReplace without valid view!" ); + + if( NULL == pOutlinerView || !GetEditEngine().HasView( &pOutlinerView->GetEditView() ) ) + return true; + + if (mpViewShell != NULL) + { + mpView = mpViewShell->GetView(); + mpWindow = mpViewShell->GetActiveWindow(); + pOutlinerView->SetWindow(mpWindow); + + if (mpViewShell->ISA(DrawViewShell) ) + { + // When replacing we first check if there is a selection + // indicating a match. If there is then replace it. The + // following call to StartSearchAndReplace will then search for + // the next match. + if (meMode == SEARCH + && mpSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE) + if (pOutlinerView->GetSelection().HasRange()) + pOutlinerView->StartSearchAndReplace(*mpSearchItem); + + // Search for the next match. + ULONG nMatchCount = 0; + if (mpSearchItem->GetCommand() != SVX_SEARCHCMD_REPLACE_ALL) + nMatchCount = pOutlinerView->StartSearchAndReplace(*mpSearchItem); + + // Go to the next text object when there have been no matches in + // the current object or the whole object has already been + // processed. + if (nMatchCount==0 || mpSearchItem->GetCommand()==SVX_SEARCHCMD_REPLACE_ALL) + { + ProvideNextTextObject (); + + if ( ! mbEndOfSearch) + { + // Remember the current position as the last one with a + // text object. + maLastValidPosition = maCurrentPosition; + + // Now that the mbEndOfSearch flag guards this block the + // following assertion and return should not be + // necessary anymore. + DBG_ASSERT(GetEditEngine().HasView(&pOutlinerView->GetEditView() ), + "SearchAndReplace without valid view!" ); + if ( ! GetEditEngine().HasView( &pOutlinerView->GetEditView() ) ) + { + mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE ); + return true; + } + + if (meMode == SEARCH) + nMatchCount = pOutlinerView->StartSearchAndReplace(*mpSearchItem); + } + } + } + else if (mpViewShell->ISA(OutlineViewShell)) + { + mpDrawDocument->GetDocSh()->SetWaitCursor (FALSE); + // The following loop is executed more then once only when a + // wrap arround search is done. + while (true) + { + int nResult = pOutlinerView->StartSearchAndReplace(*mpSearchItem); + if (nResult == 0) + { + if (HandleFailedSearch ()) + { + pOutlinerView->SetSelection (GetSearchStartPosition ()); + continue; + } + } + else + mbStringFound = true; + break; + } + } + } + + mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE ); + + return mbEndOfSearch; +} + + + + +/** Try to detect whether the document or the view (shell) has changed since + the last time <member>StartSearchAndReplace()</member> has been called. +*/ +void Outliner::DetectChange (void) +{ + ::sd::outliner::IteratorPosition aPosition (maCurrentPosition); + + ::boost::shared_ptr<DrawViewShell> pDrawViewShell ( + ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell)); + + // Detect whether the view has been switched from the outside. + if (pDrawViewShell.get() != NULL + && (aPosition.meEditMode != pDrawViewShell->GetEditMode() + || aPosition.mePageKind != pDrawViewShell->GetPageKind())) + { + // Either the edit mode or the page kind has changed. + SetStatusEventHdl(Link()); + + SdrPageView* pPageView = mpView->GetSdrPageView(); + if (pPageView != NULL) + mpView->UnmarkAllObj (pPageView); + mpView->SdrEndTextEdit(); + SetUpdateMode(FALSE); + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + pOutlinerView->SetOutputArea( Rectangle( Point(), Size(1, 1) ) ); + if (meMode == SPELL) + SetPaperSize( Size(1, 1) ); + SetText( String(), GetParagraph( 0 ) ); + + RememberStartPosition (); + + mnPageCount = mpDrawDocument->GetSdPageCount(pDrawViewShell->GetPageKind()); + maObjectIterator = ::sd::outliner::OutlinerContainer(this).current(); + } + + // Detect change of the set of selected objects. If their number has + // changed start again with the first selected object. + else if (DetectSelectionChange()) + { + HandleChangedSelection (); + maObjectIterator = ::sd::outliner::OutlinerContainer(this).current(); + } + + // Detect change of page count. Restart search at first/last page in + // that case. + else if (aPosition.meEditMode == EM_PAGE + && mpDrawDocument->GetSdPageCount(aPosition.mePageKind) != mnPageCount) + { + // The number of pages has changed. + mnPageCount = mpDrawDocument->GetSdPageCount(aPosition.mePageKind); + maObjectIterator = ::sd::outliner::OutlinerContainer(this).current(); + } + else if (aPosition.meEditMode == EM_MASTERPAGE + && mpDrawDocument->GetSdPageCount(aPosition.mePageKind) != mnPageCount) + { + // The number of master pages has changed. + mnPageCount = mpDrawDocument->GetSdPageCount(aPosition.mePageKind); + maObjectIterator = ::sd::outliner::OutlinerContainer(this).current(); + } +} + + + + +bool Outliner::DetectSelectionChange (void) +{ + bool bSelectionHasChanged = false; + ULONG nMarkCount = mpView->GetMarkedObjectList().GetMarkCount(); + + // If mpObj is NULL then we have not yet found our first match. + // Detecting a change makes no sense. + if (mpObj != NULL) + switch (nMarkCount) + { + case 0: + // The selection has changed when previously there have been + // selected objects. + bSelectionHasChanged = mbRestrictSearchToSelection; + break; + case 1: + // Check if the only selected object is not the one that we + // had selected. + if (mpView != NULL) + { + SdrMark* pMark = mpView->GetMarkedObjectList().GetMark(0); + if (pMark != NULL) + bSelectionHasChanged = (mpObj != pMark->GetMarkedSdrObj ()); + } + break; + default: + // We had selected exactly one object. + bSelectionHasChanged = true; + break; + } + + return bSelectionHasChanged; +} + + + + +void Outliner::RememberStartPosition (void) +{ + if (mpViewShell->ISA(DrawViewShell)) + { + ::boost::shared_ptr<DrawViewShell> pDrawViewShell ( + ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell)); + if (pDrawViewShell.get() != NULL) + { + meStartViewMode = pDrawViewShell->GetPageKind(); + meStartEditMode = pDrawViewShell->GetEditMode(); + mnStartPageIndex = pDrawViewShell->GetCurPageId() - 1; + } + + if (mpView != NULL) + { + mpStartEditedObject = mpView->GetTextEditObject(); + if (mpStartEditedObject != NULL) + { + // Try to retrieve current caret position only when there is an + // edited object. + ::Outliner* pOutliner = + static_cast<DrawView*>(mpView)->GetTextEditOutliner(); + if (pOutliner!=NULL && pOutliner->GetViewCount()>0) + { + OutlinerView* pOutlinerView = pOutliner->GetView(0); + maStartSelection = pOutlinerView->GetSelection(); + } + } + } + } + else if (mpViewShell->ISA(OutlineViewShell)) + { + // Remember the current cursor position. + OutlinerView* pView = GetView(0); + if (pView != NULL) + pView->GetSelection(); + } + else + { + mnStartPageIndex = (USHORT)-1; + } +} + + + + +void Outliner::RestoreStartPosition (void) +{ + bool bRestore = true; + // Take a negative start page index as inidicator that restoring the + // start position is not requested. + if (mnStartPageIndex == (USHORT)-1 ) + bRestore = false; + // Dont't resore when the view shell is not valid. + if (mpViewShell == NULL) + bRestore = false; + if ( ! mbViewShellValid) + bRestore = false; + + if (bRestore) + { + if (mpViewShell->ISA(DrawViewShell)) + { + ::boost::shared_ptr<DrawViewShell> pDrawViewShell ( + ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell)); + SetViewMode (meStartViewMode); + if (pDrawViewShell.get() != NULL) + SetPage (meStartEditMode, mnStartPageIndex); + + + if (mpStartEditedObject != NULL) + { + // Turn on the text toolbar as it is done in FuText so that + // undo manager setting/restoring in + // sd::View::{Beg,End}TextEdit() works on the same view shell. + mpViewShell->GetViewShellBase().GetToolBarManager()->SetToolBarShell( + ToolBarManager::TBG_FUNCTION, + RID_DRAW_TEXT_TOOLBOX); + + mpView->SdrBeginTextEdit(mpStartEditedObject); + ::Outliner* pOutliner = + static_cast<DrawView*>(mpView)->GetTextEditOutliner(); + if (pOutliner!=NULL && pOutliner->GetViewCount()>0) + { + OutlinerView* pOutlinerView = pOutliner->GetView(0); + pOutlinerView->SetSelection(maStartSelection); + } + } + } + else if (mpViewShell->ISA(OutlineViewShell)) + { + // Set cursor to its old position. + GetView(0)->SetSelection (maStartSelection); + } + } +} + + + + +/** The main purpose of this method is to iterate over all shape objects of + the search area (current selection, current view, or whole document) + until a text object has been found that contains at least one match or + until no such object can be found anymore. These two conditions are + expressed by setting one of the flags <member>mbFoundObject</member> or + <member>mbEndOfSearch</member> to <TRUE/>. +*/ +void Outliner::ProvideNextTextObject (void) +{ + mbEndOfSearch = false; + mbFoundObject = false; + + mpView->UnmarkAllObj (mpView->GetSdrPageView()); + try + { + mpView->SdrEndTextEdit(); + } + catch (::com::sun::star::uno::Exception e) + { + DBG_UNHANDLED_EXCEPTION(); + } + SetUpdateMode(FALSE); + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + pOutlinerView->SetOutputArea( Rectangle( Point(), Size(1, 1) ) ); + if (meMode == SPELL) + SetPaperSize( Size(1, 1) ); + SetText( String(), GetParagraph( 0 ) ); + + mpTextObj = NULL; + + // Iterate until a valid text object has been found or the search ends. + do + { + mpObj = NULL; + mpParaObj = NULL; + + if (maObjectIterator != ::sd::outliner::OutlinerContainer(this).end()) + { + maCurrentPosition = *maObjectIterator; + // Switch to the current object only if it is a valid text object. + if (IsValidTextObject (maCurrentPosition)) + { + mpObj = SetObject (maCurrentPosition); + } + ++maObjectIterator; + + if (mpObj != NULL) + { + PutTextIntoOutliner (); + + if (mpViewShell != NULL) + switch (meMode) + { + case SEARCH: + PrepareSearchAndReplace (); + break; + case SPELL: + PrepareSpellCheck (); + break; + case TEXT_CONVERSION: + PrepareConversion(); + break; + } + } + } + else + { + mbEndOfSearch = true; + EndOfSearch (); + } + } + while ( ! (mbFoundObject || mbEndOfSearch)); +} + + + + +void Outliner::EndOfSearch (void) +{ + // Before we display a dialog we first jump to where the last valid text + // object was found. All page and view mode switching since then was + // temporary and should not be visible to the user. + if ( ! mpViewShell->ISA(OutlineViewShell)) + SetObject (maLastValidPosition); + + if (mbRestrictSearchToSelection) + ShowEndOfSearchDialog (); + else + { + // When no match has been found so far then terminate the search. + if ( ! mbMatchMayExist) + { + ShowEndOfSearchDialog (); + mbEndOfSearch = TRUE; + } + // Ask the user whether to wrap arround and continue the search or + // to terminate. + else if (meMode==TEXT_CONVERSION || ShowWrapArroundDialog ()) + { + mbMatchMayExist = false; + // Everything back to beginning (or end?) of the document. + maObjectIterator = ::sd::outliner::OutlinerContainer(this).begin(); + if (mpViewShell->ISA(OutlineViewShell)) + { + // Set cursor to first character of the document. + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + pOutlinerView->SetSelection (GetSearchStartPosition ()); + } + + mbEndOfSearch = false; + } + else + { + // No wrap arround. + mbEndOfSearch = true; + } + } +} + +void Outliner::ShowEndOfSearchDialog (void) +{ + String aString; + if (meMode == SEARCH) + { + if (mbStringFound) + aString = String( SdResId(STR_END_SEARCHING) ); + else + aString = String( SdResId(STR_STRING_NOTFOUND) ); + } + else + { + if (mpView->AreObjectsMarked()) + aString = String(SdResId(STR_END_SPELLING_OBJ)); + else + aString = String(SdResId(STR_END_SPELLING)); + } + + // Show the message in an info box that is modal with respect to the + // whole application. + InfoBox aInfoBox (NULL, aString); + ShowModalMessageBox (aInfoBox); + + mbWholeDocumentProcessed = true; +} + + + + +bool Outliner::ShowWrapArroundDialog (void) +{ + bool bDoWrapArround = false; + + // Determine whether to show the dialog. + bool bShowDialog = false; + if (mpSearchItem != NULL) + { + // When searching display the dialog only for single find&replace. + USHORT nCommand = mpSearchItem->GetCommand(); + bShowDialog = (nCommand==SVX_SEARCHCMD_REPLACE) + || (nCommand==SVX_SEARCHCMD_FIND); + } + else + // Spell checking needs the dialog, too. + bShowDialog = (meMode == SPELL); + + if (bShowDialog) + { + // The question text depends on the search direction. + BOOL bImpress = mpDrawDocument!=NULL + && mpDrawDocument->GetDocumentType() == DOCUMENT_TYPE_IMPRESS; + USHORT nStringId; + if (mbDirectionIsForward) + nStringId = bImpress + ? STR_SAR_WRAP_FORWARD + : STR_SAR_WRAP_FORWARD_DRAW; + else + nStringId = bImpress + ? STR_SAR_WRAP_BACKWARD + : STR_SAR_WRAP_BACKWARD_DRAW; + + // Pop up question box that asks the user whether to wrap arround. + // The dialog is made modal with respect to the whole application. + QueryBox aQuestionBox ( + NULL, + WB_YES_NO | WB_DEF_YES, + String(SdResId(nStringId))); + aQuestionBox.SetImage (QueryBox::GetStandardImage()); + USHORT nBoxResult = ShowModalMessageBox(aQuestionBox); + bDoWrapArround = (nBoxResult == BUTTONID_YES); + } + + return bDoWrapArround; +} + + + + +bool Outliner::IsValidTextObject (const ::sd::outliner::IteratorPosition& rPosition) +{ + SdrTextObj* pObject = dynamic_cast< SdrTextObj* >( rPosition.mxObject.get() ); + return (pObject != NULL) && pObject->HasText() && ! pObject->IsEmptyPresObj(); +} + + + + +void Outliner::PutTextIntoOutliner() +{ + mpTextObj = dynamic_cast<SdrTextObj*>( mpObj ); + if ( mpTextObj && mpTextObj->HasText() && !mpTextObj->IsEmptyPresObj() ) + { + SdrText* pText = mpTextObj->getText( mnText ); + mpParaObj = pText ? pText->GetOutlinerParaObject() : NULL; + + if (mpParaObj != NULL) + { + SetText(*mpParaObj); + + ClearModifyFlag(); + } + } + else + { + mpTextObj = NULL; + } +} + + + + +void Outliner::PrepareSpellCheck (void) +{ + EESpellState eState = HasSpellErrors(); + DBG_ASSERT(eState != EE_SPELL_NOSPELLER, "No SpellChecker"); + + if (eState == EE_SPELL_NOLANGUAGE) + { + mbError = TRUE; + mbEndOfSearch = TRUE; + ErrorBox aErrorBox (NULL, + WB_OK, + String(SdResId(STR_NOLANGUAGE))); + ShowModalMessageBox (aErrorBox); + } + else if (eState != EE_SPELL_OK) + { + // When spell checking we have to test whether we have processed the + // whole document and have reached the start page again. + if (meMode == SPELL) + { + if (maSearchStartPosition == ::sd::outliner::Iterator()) + // Remember the position of the first text object so that we + // know when we have processed the whole document. + maSearchStartPosition = maObjectIterator; + else if (maSearchStartPosition == maObjectIterator) + { + mbEndOfSearch = true; + } + } + + EnterEditMode( FALSE ); + } +} + + + + +void Outliner::PrepareSearchAndReplace (void) +{ + if (HasText( *mpSearchItem )) + { + mbStringFound = true; + mbMatchMayExist = true; + + EnterEditMode (); + + mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE ); + // Start seach at the right end of the current object's text + // depending on the search direction. + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + pOutlinerView->SetSelection (GetSearchStartPosition ()); + } +} + + + + +void Outliner::SetViewMode (PageKind ePageKind) +{ + ::boost::shared_ptr<DrawViewShell> pDrawViewShell( + ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell)); + if (pDrawViewShell.get()!=NULL && ePageKind != pDrawViewShell->GetPageKind()) + { + // Restore old edit mode. + pDrawViewShell->ChangeEditMode(mpImpl->meOriginalEditMode, FALSE); + + SetStatusEventHdl(Link()); + ::rtl::OUString sViewURL; + switch (ePageKind) + { + case PK_STANDARD: + default: + sViewURL = framework::FrameworkHelper::msImpressViewURL; + break; + case PK_NOTES: + sViewURL = framework::FrameworkHelper::msNotesViewURL; + break; + case PK_HANDOUT: + sViewURL = framework::FrameworkHelper::msHandoutViewURL; + break; + } + // The text object iterator is destroyed when the shells are + // switched but we need it so save it and restore it afterwards. + ::sd::outliner::Iterator aIterator (maObjectIterator); + bool bMatchMayExist = mbMatchMayExist; + + ViewShellBase& rBase = mpViewShell->GetViewShellBase(); + SetViewShell(::boost::shared_ptr<ViewShell>()); + framework::FrameworkHelper::Instance(rBase)->RequestView( + sViewURL, + framework::FrameworkHelper::msCenterPaneURL); + + // Force (well, request) a synchronous update of the configuration. + // In a better world we would handle the asynchronous view update + // instead. But that would involve major restucturing of the + // Outliner code. + framework::FrameworkHelper::Instance(rBase)->RequestSynchronousUpdate(); + SetViewShell(rBase.GetMainViewShell()); + + // Switching to another view shell has intermediatly called + // EndSpelling(). A PrepareSpelling() is pending, so call that now. + PrepareSpelling(); + + // Update the number of pages so that + // <member>DetectChange()</member> has the correct value to compare + // to. + mnPageCount = mpDrawDocument->GetSdPageCount(ePageKind); + + maObjectIterator = aIterator; + mbMatchMayExist = bMatchMayExist; + + // Save edit mode so that it can be restored when switching the view + // shell again. + pDrawViewShell = ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell); + OSL_ASSERT(pDrawViewShell.get()!=NULL); + if (pDrawViewShell.get() != NULL) + mpImpl->meOriginalEditMode = pDrawViewShell->GetEditMode(); + } +} + + + + +void Outliner::SetPage (EditMode eEditMode, USHORT nPageIndex) +{ + if ( ! mbRestrictSearchToSelection) + { + ::boost::shared_ptr<DrawViewShell> pDrawViewShell( + ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell)); + OSL_ASSERT(pDrawViewShell.get()!=NULL); + if (pDrawViewShell.get() != NULL) + { + pDrawViewShell->ChangeEditMode(eEditMode, FALSE); + pDrawViewShell->SwitchPage(nPageIndex); + } + } +} + + + + +void Outliner::EnterEditMode (BOOL bGrabFocus) +{ + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (mbViewShellValid && pOutlinerView != NULL) + { + pOutlinerView->SetOutputArea( Rectangle( Point(), Size(1, 1))); + SetPaperSize( mpTextObj->GetLogicRect().GetSize() ); + SdrPageView* pPV = mpView->GetSdrPageView(); + + // Make FuText the current function. + SfxUInt16Item aItem (SID_TEXTEDIT, 1); + mpViewShell->GetDispatcher()-> + Execute(SID_TEXTEDIT, SFX_CALLMODE_SYNCHRON | + SFX_CALLMODE_RECORD, &aItem, 0L); + + // To be consistent with the usual behaviour in the Office the text + // object that is put into edit mode would have also to be selected. + // Starting the text edit mode is not enough so we do it here by + // hand. + mbExpectingSelectionChangeEvent = true; + mpView->UnmarkAllObj (pPV); + mpView->MarkObj (mpTextObj, pPV); + + if( mpTextObj ) + mpTextObj->setActiveText( mnText ); + + // Turn on the edit mode for the text object. + mpView->SdrBeginTextEdit(mpTextObj, pPV, mpWindow, sal_True, this, pOutlinerView, sal_True, sal_True, bGrabFocus); + + SetUpdateMode(TRUE); + mbFoundObject = TRUE; + } +} + + + + +/************************************************************************* +|* +|* SpellChecker: Error-LinkHdl +|* +\************************************************************************/ + +IMPL_LINK_INLINE_START( Outliner, SpellError, void *, nLang ) +{ + mbError = true; + String aError( SvtLanguageTable::GetLanguageString( (LanguageType)(ULONG)nLang ) ); + ErrorHandler::HandleError(* new StringErrorInfo( + ERRCODE_SVX_LINGU_LANGUAGENOTEXISTS, aError) ); + return 0; +} +IMPL_LINK_INLINE_END( Outliner, SpellError, void *, nLang ) + + + + +ESelection Outliner::GetSearchStartPosition (void) +{ + ESelection aPosition; + if (mbDirectionIsForward) + { + // The default constructor uses the beginning of the text as default. + aPosition = ESelection (); + } + else + { + // Retrieve the position after the last character in the last + // paragraph. + USHORT nParagraphCount = static_cast<USHORT>(GetParagraphCount()); + if (nParagraphCount == 0) + aPosition = ESelection(); + else + { + xub_StrLen nLastParagraphLength = GetEditEngine().GetTextLen ( + nParagraphCount-1); + aPosition = ESelection (nParagraphCount-1, nLastParagraphLength); + } + } + + return aPosition; +} + + + + +bool Outliner::HasNoPreviousMatch (void) +{ + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + + DBG_ASSERT (pOutlinerView!=NULL, "outline view in Outliner::HasNoPreviousMatch is NULL"); + + // Detect whether the cursor stands at the beginning + // resp. at the end of the text. + return pOutlinerView->GetSelection().IsEqual(GetSearchStartPosition ()) == TRUE; +} + + + + +bool Outliner::HandleFailedSearch (void) +{ + bool bContinueSearch = false; + + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL && mpSearchItem != NULL) + { + // Detect whether there is/may be a prior match. If there is then + // ask the user whether to wrap arround. Otherwise tell the user + // that there is no match. + if (HasNoPreviousMatch ()) + { + // No match found in the whole presentation. Tell the user. + InfoBox aInfoBox (NULL, + String(SdResId(STR_SAR_NOT_FOUND))); + ShowModalMessageBox (aInfoBox); + } + + else + { + // No further matches found. Ask the user whether to wrap + // arround and start again. + bContinueSearch = ShowWrapArroundDialog (); + } + } + + return bContinueSearch; +} + + +SdrObject* Outliner::SetObject ( + const ::sd::outliner::IteratorPosition& rPosition) +{ + SetViewMode (rPosition.mePageKind); + SetPage (rPosition.meEditMode, (USHORT)rPosition.mnPageIndex); + mnText = rPosition.mnText; + return rPosition.mxObject.get(); +} + + + + +void Outliner::SetViewShell (const ::boost::shared_ptr<ViewShell>& rpViewShell) +{ + if (mpViewShell != rpViewShell) + { + // Set the new view shell. + mpViewShell = rpViewShell; + // When the outline view is not owned by us then we have to clear + // that pointer so that the current one for the new view shell will + // be used (in ProvideOutlinerView). + // if ( ! mbOwnOutlineView) + // mpOutlineView = NULL; + if (mpViewShell.get() != NULL) + { + mpView = mpViewShell->GetView(); + + mpWindow = mpViewShell->GetActiveWindow(); + + mpImpl->ProvideOutlinerView(*this, mpViewShell, mpWindow); + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + pOutlinerView->SetWindow(mpWindow); + } + else + { + mpView = NULL; + mpWindow = NULL; + } + } +} + + + + +void Outliner::HandleChangedSelection (void) +{ + maMarkListCopy.clear(); + mbRestrictSearchToSelection = (mpView->AreObjectsMarked()==TRUE); + if (mbRestrictSearchToSelection) + { + // Make a copy of the current mark list. + const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); + ULONG nCount = rMarkList.GetMarkCount(); + if (nCount > 0) + { + maMarkListCopy.clear(); + maMarkListCopy.reserve (nCount); + for (ULONG i=0; i<nCount; i++) + maMarkListCopy.push_back (rMarkList.GetMark(i)->GetMarkedSdrObj ()); + } + else + // No marked object. Is this case possible? + mbRestrictSearchToSelection = false; + } +} + + + + + +void Outliner::StartConversion( INT16 nSourceLanguage, INT16 nTargetLanguage, + const Font *pTargetFont, INT32 nOptions, BOOL bIsInteractive ) +{ + BOOL bMultiDoc = mpViewShell->ISA(DrawViewShell); + + meMode = TEXT_CONVERSION; + mbDirectionIsForward = true; + mpSearchItem = NULL; + mnConversionLanguage = nSourceLanguage; + + BeginConversion(); + + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + { + pOutlinerView->StartTextConversion( + nSourceLanguage, + nTargetLanguage, + pTargetFont, + nOptions, + bIsInteractive, + bMultiDoc); + } + + EndConversion(); +} + + + + +/** Prepare to do a text conversion on the current text object. This + includes putting it into edit mode. +*/ +void Outliner::PrepareConversion (void) +{ + SetUpdateMode(sal_True); + if( HasConvertibleTextPortion( mnConversionLanguage ) ) + { + SetUpdateMode(sal_False); + mbStringFound = TRUE; + mbMatchMayExist = TRUE; + + EnterEditMode (); + + mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE ); + // Start seach at the right end of the current object's text + // depending on the search direction. +// mpOutlineView->SetSelection (GetSearchStartPosition ()); + } + else + { + SetUpdateMode(sal_False); + } +} + + + + +void Outliner::BeginConversion (void) +{ + SetRefDevice( SD_MOD()->GetRefDevice( *mpDrawDocument->GetDocSh() ) ); + + ViewShellBase* pBase = PTR_CAST(ViewShellBase, SfxViewShell::Current()); + if (pBase != NULL) + SetViewShell (pBase->GetMainViewShell()); + + if (mpViewShell != NULL) + { + mbStringFound = FALSE; + + // Supposed that we are not located at the very beginning/end of the + // document then there may be a match in the document prior/after + // the current position. + mbMatchMayExist = TRUE; + + maObjectIterator = ::sd::outliner::Iterator(); + maSearchStartPosition = ::sd::outliner::Iterator(); + RememberStartPosition(); + + mpImpl->ProvideOutlinerView(*this, mpViewShell, mpWindow); + + HandleChangedSelection (); + } + ClearModifyFlag(); +} + + + + +void Outliner::EndConversion() +{ + EndSpelling(); +} + + + + +sal_Bool Outliner::ConvertNextDocument() +{ + if( mpViewShell && mpViewShell->ISA(OutlineViewShell) ) + return false; + + mpDrawDocument->GetDocSh()->SetWaitCursor( TRUE ); + + Initialize ( true ); + + OutlinerView* pOutlinerView = mpImpl->GetOutlinerView(); + if (pOutlinerView != NULL) + { + mpWindow = mpViewShell->GetActiveWindow(); + pOutlinerView->SetWindow(mpWindow); + } + ProvideNextTextObject (); + + mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE ); + ClearModifyFlag(); + + // for text conversion we automaticly wrap around one + // time and stop at the start shape + if( mpFirstObj ) + { + if( (mnText == 0) && (mpFirstObj == mpObj) ) + return false; + } + else + { + mpFirstObj = mpObj; + } + + return !mbEndOfSearch; +} + + + + +USHORT Outliner::ShowModalMessageBox (Dialog& rMessageBox) +{ + // We assume that the parent of the given messge box is NULL, i.e. it is + // modal with respect to the top application window. However, this + // does not affect the search dialog. Therefore we have to lock it here + // while the message box is being shown. We also have to take into + // account that we are called during a spell check and the search dialog + // is not available. + ::Window* pSearchDialog = NULL; + SfxChildWindow* pChildWindow = NULL; + switch (meMode) + { + case SEARCH: + pChildWindow = SfxViewFrame::Current()->GetChildWindow( + SvxSearchDialogWrapper::GetChildWindowId()); + break; + + case SPELL: + pChildWindow = SfxViewFrame::Current()->GetChildWindow( + SpellDialogChildWindow::GetChildWindowId()); + break; + + case TEXT_CONVERSION: + // There should no messages boxes be displayed while doing the + // hangul hanja conversion. + break; + } + + if (pChildWindow != NULL) + pSearchDialog = pChildWindow->GetWindow(); + if (pSearchDialog != NULL) + pSearchDialog->EnableInput(FALSE,TRUE); + + USHORT nResult = rMessageBox.Execute(); + + // Unlock the search dialog. + if (pSearchDialog != NULL) + pSearchDialog->EnableInput(TRUE,TRUE); + + return nResult; +} + + + + +//===== Outliner::Implementation ============================================== + +Outliner::Implementation::Implementation (void) + : meOriginalEditMode(EM_PAGE), + mbOwnOutlineView(false), + mpOutlineView(NULL) +{ +} + + + + +Outliner::Implementation::~Implementation (void) +{ + if (mbOwnOutlineView && mpOutlineView!=NULL) + { + mpOutlineView->SetWindow(NULL); + delete mpOutlineView; + mpOutlineView = NULL; + } +} + + + + +OutlinerView* Outliner::Implementation::GetOutlinerView () +{ + return mpOutlineView; +} + + + + +/** We try to create a new OutlinerView only when there is none available, + either from an OutlinerViewShell or a previous call to + ProvideOutlinerView(). This is necessary to support the spell checker + which can not cope with exchanging the OutlinerView. +*/ +void Outliner::Implementation::ProvideOutlinerView ( + Outliner& rOutliner, + const ::boost::shared_ptr<ViewShell>& rpViewShell, + ::Window* pWindow) +{ + if (rpViewShell.get() != NULL) + { + switch (rpViewShell->GetShellType()) + { + case ViewShell::ST_DRAW: + case ViewShell::ST_IMPRESS: + case ViewShell::ST_NOTES: + case ViewShell::ST_HANDOUT: + { + // Create a new outline view to do the search on. + bool bInsert = false; + if (mpOutlineView!=NULL && !mbOwnOutlineView) + mpOutlineView = NULL; + if (mpOutlineView == NULL) + { + mpOutlineView = new OutlinerView(&rOutliner, pWindow); + mbOwnOutlineView = true; + bInsert = true; + } + else + mpOutlineView->SetWindow(pWindow); + ULONG nStat = mpOutlineView->GetControlWord(); + nStat &= ~EV_CNTRL_AUTOSCROLL; + mpOutlineView->SetControlWord(nStat); + if (bInsert) + rOutliner.InsertView( mpOutlineView ); + rOutliner.SetUpdateMode(FALSE); + mpOutlineView->SetOutputArea (Rectangle (Point(), Size(1, 1))); + rOutliner.SetPaperSize( Size(1, 1) ); + rOutliner.SetText( String(), rOutliner.GetParagraph( 0 ) ); + + meOriginalEditMode = + ::boost::static_pointer_cast<DrawViewShell>(rpViewShell)->GetEditMode(); + } + break; + + case ViewShell::ST_OUTLINE: + { + if (mpOutlineView!=NULL && mbOwnOutlineView) + delete mpOutlineView; + mpOutlineView = rOutliner.GetView(0); + mbOwnOutlineView = false; + } + break; + + default: + case ViewShell::ST_NONE: + case ViewShell::ST_PRESENTATION: + // Ignored + break; + } + } +} + + + + +void Outliner::Implementation::ReleaseOutlinerView (void) +{ + if (mbOwnOutlineView) + { + OutlinerView* pView = mpOutlineView; + mpOutlineView = NULL; + mbOwnOutlineView = false; + if (pView != NULL) + { + pView->SetWindow(NULL); + delete pView; + } + } + else + { + mpOutlineView = NULL; + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/OutlinerIterator.cxx b/sd/source/ui/view/OutlinerIterator.cxx new file mode 100755 index 000000000000..226d767c6c91 --- /dev/null +++ b/sd/source/ui/view/OutlinerIterator.cxx @@ -0,0 +1,898 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "OutlinerIterator.hxx" +#include "OutlinerIteratorImpl.hxx" +#include <svx/svditer.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/viewfrm.hxx> +#include "Outliner.hxx" + +#include "drawdoc.hxx" +#include "DrawViewShell.hxx" +#include "drawview.hxx" +#include "sdpage.hxx" +#ifndef SD_FRAME_VIEW +#include "FrameView.hxx" +#endif +#include "DrawDocShell.hxx" +#include "Window.hxx" + +namespace sd { namespace outliner { + + +//===== IteratorPosition ====================================================== + +IteratorPosition::IteratorPosition (void) +: mnText(0) +, mnPageIndex(-1) +, mePageKind(PK_STANDARD) +, meEditMode(EM_PAGE) +{ +} + +IteratorPosition::IteratorPosition (const IteratorPosition& aPosition) +: mxObject(aPosition.mxObject) +, mnText(aPosition.mnText) +, mnPageIndex(aPosition.mnPageIndex) +, mePageKind(aPosition.mePageKind) +, meEditMode(aPosition.meEditMode) +{ +} + +IteratorPosition::~IteratorPosition (void) +{ +} + +IteratorPosition& IteratorPosition::operator= (const IteratorPosition& aPosition) +{ + mxObject = aPosition.mxObject; + mnText = aPosition.mnText; + mnPageIndex = aPosition.mnPageIndex; + mePageKind = aPosition.mePageKind; + meEditMode = aPosition.meEditMode; + return *this; +} + +bool IteratorPosition::operator== (const IteratorPosition& aPosition) const +{ + return mxObject.get() == aPosition.mxObject.get() + && mnText == aPosition.mnText + && mnPageIndex == aPosition.mnPageIndex + && mePageKind == aPosition.mePageKind + && meEditMode == aPosition.meEditMode; +} + + + + +//===== Iterator ============================================================== + +Iterator::Iterator (void) +{ + mpIterator = NULL; +} + +Iterator::Iterator (const Iterator& rIterator) +{ + mpIterator = rIterator.mpIterator->Clone(); +} + +Iterator::Iterator (IteratorImplBase* pObject) +{ + mpIterator = pObject; +} + +Iterator::~Iterator (void) +{ + delete mpIterator; +} + +Iterator& Iterator::operator= (const Iterator& rIterator) +{ + if (this != &rIterator) + { + delete mpIterator; + if (rIterator.mpIterator != NULL) + mpIterator = rIterator.mpIterator->Clone(); + else + mpIterator = NULL; + } + return *this; +} + +const IteratorPosition& Iterator::operator* () const +{ + DBG_ASSERT (mpIterator!=NULL, "::sd::outliner::Iterator::operator* : missing implementation object"); + return mpIterator->GetPosition(); +} + +Iterator& Iterator::operator++ () +{ + if (mpIterator!=NULL) + mpIterator->GotoNextText(); + return *this; +} + +Iterator Iterator::operator++ (int) +{ + Iterator aTmp (*this); + if (mpIterator!=NULL) + mpIterator->GotoNextText(); + return aTmp; +} + +bool Iterator::operator== (const Iterator& rIterator) +{ + if (mpIterator == NULL || rIterator.mpIterator==NULL) + return mpIterator == rIterator.mpIterator; + else + return *mpIterator == *rIterator.mpIterator; +} + +bool Iterator::operator!= (const Iterator& rIterator) +{ + return ! operator==(rIterator); +} + +void Iterator::Reverse (void) +{ + if (mpIterator != NULL) + mpIterator->Reverse(); +} + +//===== IteratorFactory ======================================================= + +OutlinerContainer::OutlinerContainer (Outliner* pOutliner) +: mpOutliner(pOutliner) +{ +} + +Iterator OutlinerContainer::begin (void) +{ + return CreateIterator (BEGIN); +} + +Iterator OutlinerContainer::end (void) +{ + return CreateIterator (END); +} + +Iterator OutlinerContainer::current (void) +{ + return CreateIterator (CURRENT); +} + + +Iterator OutlinerContainer::CreateIterator (IteratorLocation aLocation) +{ + // Decide on certain features of the outliner which kind of iterator to + // use. + if (mpOutliner->mbRestrictSearchToSelection) + // There is a selection. Search only in this. + return CreateSelectionIterator ( + mpOutliner->maMarkListCopy, + mpOutliner->mpDrawDocument, + mpOutliner->mpViewShell, + mpOutliner->mbDirectionIsForward, + aLocation); + else + // Search in the whole document. + return CreateDocumentIterator ( + mpOutliner->mpDrawDocument, + mpOutliner->mpViewShell, + mpOutliner->mbDirectionIsForward, + aLocation); +} + +Iterator OutlinerContainer::CreateSelectionIterator ( + const ::std::vector<SdrObjectWeakRef>& rObjectList, + SdDrawDocument* pDocument, + const ::boost::shared_ptr<ViewShell>& rpViewShell, + bool bDirectionIsForward, + IteratorLocation aLocation) +{ + OSL_ASSERT(rpViewShell.get()); + + sal_Int32 nObjectIndex; + + if (bDirectionIsForward) + switch (aLocation) + { + case CURRENT: + case BEGIN: + default: + nObjectIndex = 0; + break; + case END: + nObjectIndex = rObjectList.size(); + break; + } + else + switch (aLocation) + { + case CURRENT: + case BEGIN: + default: + nObjectIndex = rObjectList.size()-1; + break; + case END: + nObjectIndex = -1; + break; + } + + return Iterator (new SelectionIteratorImpl ( + rObjectList, nObjectIndex, pDocument, rpViewShell, bDirectionIsForward)); +} + +Iterator OutlinerContainer::CreateDocumentIterator ( + SdDrawDocument* pDocument, + const ::boost::shared_ptr<ViewShell>& rpViewShell, + bool bDirectionIsForward, + IteratorLocation aLocation) +{ + OSL_ASSERT(rpViewShell.get()); + + PageKind ePageKind; + EditMode eEditMode; + + switch (aLocation) + { + case BEGIN: + default: + if (bDirectionIsForward) + { + ePageKind = PK_STANDARD; + eEditMode = EM_PAGE; + } + else + { + ePageKind = PK_HANDOUT; + eEditMode = EM_MASTERPAGE; + } + break; + + case END: + if (bDirectionIsForward) + { + ePageKind = PK_HANDOUT; + eEditMode = EM_MASTERPAGE; + } + else + { + ePageKind = PK_STANDARD; + eEditMode = EM_PAGE; + } + break; + + case CURRENT: + const ::boost::shared_ptr<DrawViewShell> pDrawViewShell( + ::boost::dynamic_pointer_cast<DrawViewShell>(rpViewShell)); + if (pDrawViewShell.get()) + { + ePageKind = pDrawViewShell->GetPageKind(); + eEditMode = pDrawViewShell->GetEditMode(); + } + else + { + ePageKind = PK_STANDARD; + eEditMode = EM_PAGE; + } + break; + } + + sal_Int32 nPageIndex = GetPageIndex (pDocument, rpViewShell, + ePageKind, eEditMode, bDirectionIsForward, aLocation); + + return Iterator ( + new DocumentIteratorImpl (nPageIndex, ePageKind, eEditMode, + pDocument, rpViewShell, bDirectionIsForward)); +} + +sal_Int32 OutlinerContainer::GetPageIndex ( + SdDrawDocument* pDocument, + const ::boost::shared_ptr<ViewShell>& rpViewShell, + PageKind ePageKind, + EditMode eEditMode, + bool bDirectionIsForward, + IteratorLocation aLocation) +{ + OSL_ASSERT(rpViewShell); + + sal_Int32 nPageIndex; + sal_Int32 nPageCount; + + const ::boost::shared_ptr<DrawViewShell> pDrawViewShell( + ::boost::dynamic_pointer_cast<DrawViewShell>(rpViewShell)); + + switch (eEditMode) + { + case EM_PAGE: + nPageCount = pDocument->GetSdPageCount (ePageKind); + break; + case EM_MASTERPAGE: + nPageCount = pDocument->GetMasterSdPageCount(ePageKind); + break; + default: + nPageCount = 0; + } + + switch (aLocation) + { + case CURRENT: + if (pDrawViewShell.get()) + nPageIndex = pDrawViewShell->GetCurPageId() - 1; + else + { + const SdPage* pPage = rpViewShell->GetActualPage(); + if (pPage != NULL) + nPageIndex = (pPage->GetPageNum()-1)/2; + else + nPageIndex = 0; + } + break; + + case BEGIN: + default: + if (bDirectionIsForward) + nPageIndex = 0; + else + nPageIndex = nPageCount-1; + break; + + case END: + if (bDirectionIsForward) + nPageIndex = nPageCount; + else + nPageIndex = -1; + break; + } + + return nPageIndex; +} + + + + +//===== IteratorImplBase ==================================================== + +IteratorImplBase::IteratorImplBase(SdDrawDocument* pDocument, + const ::boost::weak_ptr<ViewShell>& rpViewShellWeak, + bool bDirectionIsForward) +: maPosition() +, mpDocument (pDocument) +, mpViewShellWeak (rpViewShellWeak) +, mbDirectionIsForward (bDirectionIsForward) +{ + ::boost::shared_ptr<DrawViewShell> pDrawViewShell; + if ( ! mpViewShellWeak.expired()) + pDrawViewShell = ::boost::dynamic_pointer_cast<DrawViewShell>(rpViewShellWeak.lock()); + + if (pDrawViewShell.get()) + { + maPosition.mePageKind = pDrawViewShell->GetPageKind(); + maPosition.meEditMode = pDrawViewShell->GetEditMode(); + } + else + { + maPosition.mePageKind = PK_STANDARD; + maPosition.meEditMode = EM_PAGE; + } +} + +IteratorImplBase::IteratorImplBase( SdDrawDocument* pDocument, + const ::boost::weak_ptr<ViewShell>& rpViewShellWeak, + bool bDirectionIsForward, PageKind ePageKind, EditMode eEditMode) +: maPosition() +, mpDocument (pDocument) +, mpViewShellWeak (rpViewShellWeak) +, mbDirectionIsForward (bDirectionIsForward) +{ + maPosition.mePageKind = ePageKind; + maPosition.meEditMode = eEditMode; +} + +IteratorImplBase::~IteratorImplBase (void) +{} + +bool IteratorImplBase::operator== (const IteratorImplBase& rIterator) const +{ + return maPosition == rIterator.maPosition; +} + +bool IteratorImplBase::IsEqual (const IteratorImplBase& rIterator, IteratorType ) const +{ + // When this method is executed instead of the ones from derived classes + // then the argument is of another type then the object itself. In this + // just compare the position objects. + return maPosition == rIterator.maPosition; +} + +const IteratorPosition& IteratorImplBase::GetPosition (void) +{ + return maPosition; +} + + + + +IteratorImplBase* IteratorImplBase::Clone (IteratorImplBase* pObject) const +{ + if (pObject != NULL) + { + pObject->maPosition = maPosition; + pObject->mpDocument = mpDocument; + pObject->mpViewShellWeak = mpViewShellWeak; + pObject->mbDirectionIsForward = mbDirectionIsForward; + } + return pObject; +} + + + +void IteratorImplBase::Reverse (void) +{ + mbDirectionIsForward = ! mbDirectionIsForward; +} + + + +//===== SelectionIteratorImpl =========================================== + +SelectionIteratorImpl::SelectionIteratorImpl ( + const ::std::vector<SdrObjectWeakRef>& rObjectList, + sal_Int32 nObjectIndex, + SdDrawDocument* pDocument, + const ::boost::weak_ptr<ViewShell>& rpViewShellWeak, + bool bDirectionIsForward) + : IteratorImplBase (pDocument, rpViewShellWeak, bDirectionIsForward), + mrObjectList(rObjectList), + mnObjectIndex(nObjectIndex) +{ +} + +SelectionIteratorImpl::~SelectionIteratorImpl (void) +{} + +IteratorImplBase* SelectionIteratorImpl::Clone (IteratorImplBase* pObject) const +{ + SelectionIteratorImpl* pIterator = static_cast<SelectionIteratorImpl*>(pObject); + if (pIterator == NULL) + pIterator = new SelectionIteratorImpl ( + mrObjectList, mnObjectIndex, mpDocument, mpViewShellWeak, mbDirectionIsForward); + return pIterator; +} + + +void SelectionIteratorImpl::GotoNextText (void) +{ + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( mrObjectList.at(mnObjectIndex).get() ); + if (mbDirectionIsForward) + { + if( pTextObj ) + { + ++maPosition.mnText; + if( maPosition.mnText >= pTextObj->getTextCount() ) + { + maPosition.mnText = 0; + ++mnObjectIndex; + } + } + else + { + ++mnObjectIndex; + } + } + else + { + if( pTextObj ) + { + --maPosition.mnText; + if( maPosition.mnText < 0 ) + { + maPosition.mnText = -1; + --mnObjectIndex; + } + } + else + { + --mnObjectIndex; + maPosition.mnText = -1; + } + + if( (maPosition.mnText == -1) && (mnObjectIndex >= 0) ) + { + pTextObj = dynamic_cast< SdrTextObj* >( mrObjectList.at(mnObjectIndex).get() ); + if( pTextObj ) + maPosition.mnText = pTextObj->getTextCount() - 1; + } + + if( maPosition.mnText == -1 ) + maPosition.mnText = 0; + } +} + + +const IteratorPosition& SelectionIteratorImpl::GetPosition (void) +{ + maPosition.mxObject = mrObjectList.at(mnObjectIndex); + + return maPosition; +} + + +bool SelectionIteratorImpl::operator== (const IteratorImplBase& rIterator) const +{ + return rIterator.IsEqual (*this, SELECTION); +} + + +bool SelectionIteratorImpl::IsEqual ( + const IteratorImplBase& rIterator, + IteratorType aType) const +{ + if (aType == SELECTION) + { + const SelectionIteratorImpl* pSelectionIterator = + static_cast<const SelectionIteratorImpl*>(&rIterator); + return mpDocument == pSelectionIterator->mpDocument + && mnObjectIndex == pSelectionIterator->mnObjectIndex; + } + else + return false; +} + + + + +//===== ViewIteratorImpl ================================================ + +ViewIteratorImpl::ViewIteratorImpl ( + sal_Int32 nPageIndex, + SdDrawDocument* pDocument, + const ::boost::weak_ptr<ViewShell>& rpViewShellWeak, + bool bDirectionIsForward) + : IteratorImplBase (pDocument, rpViewShellWeak, bDirectionIsForward), + mbPageChangeOccured(false), + mpPage(NULL), + mpObjectIterator(NULL) +{ + SetPage (nPageIndex); +} + + + + +ViewIteratorImpl::ViewIteratorImpl ( + sal_Int32 nPageIndex, + SdDrawDocument* pDocument, + const ::boost::weak_ptr<ViewShell>& rpViewShellWeak, + bool bDirectionIsForward, + PageKind ePageKind, + EditMode eEditMode) + : IteratorImplBase (pDocument, rpViewShellWeak, bDirectionIsForward, ePageKind, eEditMode), + mbPageChangeOccured(false), + mpPage(NULL), + mpObjectIterator(NULL) +{ + SetPage (nPageIndex); +} + + + + +ViewIteratorImpl::~ViewIteratorImpl (void) +{ +} + + + + +IteratorImplBase* ViewIteratorImpl::Clone (IteratorImplBase* pObject) const +{ + + ViewIteratorImpl* pIterator = static_cast<ViewIteratorImpl*>(pObject); + if (pIterator == NULL) + pIterator = new ViewIteratorImpl ( + maPosition.mnPageIndex, mpDocument, mpViewShellWeak, mbDirectionIsForward); + + IteratorImplBase::Clone (pObject); + + if (mpObjectIterator != NULL) + { + pIterator->mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, !mbDirectionIsForward); + + // No direct way to set the object iterator to the current object. + pIterator->maPosition.mxObject.reset(NULL); + while (pIterator->mpObjectIterator->IsMore() && pIterator->maPosition.mxObject!=maPosition.mxObject) + pIterator->maPosition.mxObject.reset(pIterator->mpObjectIterator->Next()); + } + else + pIterator->mpObjectIterator = NULL; + + return pIterator; +} + + + +void ViewIteratorImpl::GotoNextText(void) +{ + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( maPosition.mxObject.get() ); + if( pTextObj ) + { + if (mbDirectionIsForward) + { + ++maPosition.mnText; + if( maPosition.mnText < pTextObj->getTextCount() ) + return; + } + else + { + --maPosition.mnText; + if( maPosition.mnText >= 0 ) + return; + } + } + + if (mpObjectIterator != NULL && mpObjectIterator->IsMore()) + maPosition.mxObject.reset(mpObjectIterator->Next()); + else + maPosition.mxObject.reset(NULL); + + if (!maPosition.mxObject.is() ) + { + if (mbDirectionIsForward) + SetPage (maPosition.mnPageIndex+1); + else + SetPage (maPosition.mnPageIndex-1); + + if (mpPage != NULL) + mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, !mbDirectionIsForward); + if (mpObjectIterator!=NULL && mpObjectIterator->IsMore()) + maPosition.mxObject.reset(mpObjectIterator->Next()); + else + maPosition.mxObject.reset(NULL); + } + + maPosition.mnText = 0; + if( !mbDirectionIsForward && maPosition.mxObject.is() ) + { + pTextObj = dynamic_cast< SdrTextObj* >( maPosition.mxObject.get() ); + if( pTextObj ) + maPosition.mnText = pTextObj->getTextCount() - 1; + } +} + + + + +void ViewIteratorImpl::SetPage (sal_Int32 nPageIndex) +{ + mbPageChangeOccured = (maPosition.mnPageIndex!=nPageIndex); + if (mbPageChangeOccured) + { + maPosition.mnPageIndex = nPageIndex; + + sal_Int32 nPageCount; + if (maPosition.meEditMode == EM_PAGE) + nPageCount = mpDocument->GetSdPageCount(maPosition.mePageKind); + else + nPageCount = mpDocument->GetMasterSdPageCount( + maPosition.mePageKind); + + // Get page pointer. Here we have three cases: regular pages, + // master pages and invalid page indices. The later ones are not + // errors but the effect of the iterator advancing to the next page + // and going past the last one. This dropping of the rim at the far + // side is detected here and has to be reacted to by the caller. + if (nPageIndex>=0 && nPageIndex < nPageCount) + { + if (maPosition.meEditMode == EM_PAGE) + mpPage = mpDocument->GetSdPage ( + (USHORT)nPageIndex, + maPosition.mePageKind); + else + mpPage = mpDocument->GetMasterSdPage ( + (USHORT)nPageIndex, + maPosition.mePageKind); + } + else + mpPage = NULL; + } + + // Set up object list iterator. + if (mpPage != NULL) + mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, ! mbDirectionIsForward); + else + mpObjectIterator = NULL; + + // Get object pointer. + if (mpObjectIterator!=NULL && mpObjectIterator->IsMore()) + maPosition.mxObject.reset( mpObjectIterator->Next() ); + else + maPosition.mxObject.reset( NULL ); + + maPosition.mnText = 0; + if( !mbDirectionIsForward && maPosition.mxObject.is() ) + { + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( maPosition.mxObject.get() ); + if( pTextObj ) + maPosition.mnText = pTextObj->getTextCount() - 1; + } + +} + + + + +void ViewIteratorImpl::Reverse (void) +{ + IteratorImplBase::Reverse (); + + // Create reversed object list iterator. + if (mpObjectIterator != NULL) + delete mpObjectIterator; + if (mpPage != NULL) + mpObjectIterator = new SdrObjListIter(*mpPage, IM_DEEPNOGROUPS, ! mbDirectionIsForward); + else + mpObjectIterator = NULL; + + // Move iterator to the current object. + SdrObjectWeakRef xObject = maPosition.mxObject; + maPosition.mxObject.reset(NULL); + while (mpObjectIterator->IsMore() && maPosition.mxObject != xObject) + maPosition.mxObject.reset(mpObjectIterator->Next()); +} + + + + +//===== DocumentIteratorImpl ============================================ + +DocumentIteratorImpl::DocumentIteratorImpl ( + sal_Int32 nPageIndex, + PageKind ePageKind, EditMode eEditMode, + SdDrawDocument* pDocument, + const ::boost::weak_ptr<ViewShell>& rpViewShellWeak, + bool bDirectionIsForward) + : ViewIteratorImpl (nPageIndex, pDocument, rpViewShellWeak, bDirectionIsForward, + ePageKind, eEditMode) +{ + if (eEditMode == EM_PAGE) + mnPageCount = pDocument->GetSdPageCount (ePageKind); + else + mnPageCount = pDocument->GetMasterSdPageCount(ePageKind); +} + + + + +DocumentIteratorImpl::~DocumentIteratorImpl (void) +{} + + + + +IteratorImplBase* DocumentIteratorImpl::Clone (IteratorImplBase* pObject) const +{ + DocumentIteratorImpl* pIterator = static_cast<DocumentIteratorImpl*>(pObject); + if (pIterator == NULL) + pIterator = new DocumentIteratorImpl ( + maPosition.mnPageIndex, maPosition.mePageKind, maPosition.meEditMode, + mpDocument, mpViewShellWeak, mbDirectionIsForward); + // Finish the cloning. + return ViewIteratorImpl::Clone (pIterator); +} + + + + +void DocumentIteratorImpl::GotoNextText (void) +{ + bool bSetToOnePastLastPage = false; + bool bViewChanged = false; + + ViewIteratorImpl::GotoNextText(); + + if (mbDirectionIsForward) + { + if (maPosition.mnPageIndex >= mnPageCount) + { + // Switch to master page. + if (maPosition.meEditMode == EM_PAGE) + { + maPosition.meEditMode = EM_MASTERPAGE; + SetPage (0); + } + + // Switch to next view mode. + else + { + if (maPosition.mePageKind == PK_HANDOUT) + // Not really necessary but makes things more clear. + bSetToOnePastLastPage = true; + else + { + maPosition.meEditMode = EM_PAGE; + if (maPosition.mePageKind == PK_STANDARD) + maPosition.mePageKind = PK_NOTES; + else if (maPosition.mePageKind == PK_NOTES) + maPosition.mePageKind = PK_HANDOUT; + SetPage (0); + } + } + bViewChanged = true; + } + } + else + if (maPosition.mnPageIndex < 0) + { + // Switch from master pages to draw pages. + if (maPosition.meEditMode == EM_MASTERPAGE) + { + maPosition.meEditMode = EM_PAGE; + bSetToOnePastLastPage = true; + } + + // Switch to previous view mode. + else + { + if (maPosition.mePageKind == PK_STANDARD) + SetPage (-1); + else + { + maPosition.meEditMode = EM_MASTERPAGE; + if (maPosition.mePageKind == PK_HANDOUT) + maPosition.mePageKind = PK_NOTES; + else if (maPosition.mePageKind == PK_NOTES) + maPosition.mePageKind = PK_STANDARD; + bSetToOnePastLastPage = true; + } + } + bViewChanged = true; + } + + if (bViewChanged) + { + // Get new page count; + sal_Int32 nPageCount; + if (maPosition.meEditMode == EM_PAGE) + nPageCount = mpDocument->GetSdPageCount (maPosition.mePageKind); + else + nPageCount = mpDocument->GetMasterSdPageCount(maPosition.mePageKind); + + // Now that we know the number of pages we can set the current page index. + if (bSetToOnePastLastPage) + SetPage (nPageCount); + } +} + + +} } // end of namespace ::sd::outliner diff --git a/sd/source/ui/view/PresentationViewShellBase.cxx b/sd/source/ui/view/PresentationViewShellBase.cxx new file mode 100644 index 000000000000..a16b12d3cb63 --- /dev/null +++ b/sd/source/ui/view/PresentationViewShellBase.cxx @@ -0,0 +1,130 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "PresentationViewShellBase.hxx" +#include "sdresid.hxx" +#include "DrawDocShell.hxx" +#include "strings.hrc" +#include "UpdateLockManager.hxx" +#include "framework/FrameworkHelper.hxx" +#include "framework/PresentationModule.hxx" + +#include <sfx2/viewfrm.hxx> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/frame/XLayoutManager.hpp> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +namespace sd { + +class DrawDocShell; + +TYPEINIT1(PresentationViewShellBase, ViewShellBase); + +// We have to expand the SFX_IMPL_VIEWFACTORY macro to call LateInit() after a +// new PresentationViewShellBase object has been constructed. + +/* +SFX_IMPL_VIEWFACTORY(PresentationViewShellBase, SdResId(STR_DEFAULTVIEW)) +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} +*/ +SfxViewFactory* PresentationViewShellBase::pFactory; +SfxViewShell* __EXPORT PresentationViewShellBase::CreateInstance ( + SfxViewFrame *_pFrame, SfxViewShell *pOldView) +{ + PresentationViewShellBase* pBase = + new PresentationViewShellBase(_pFrame, pOldView); + pBase->LateInit(framework::FrameworkHelper::msPresentationViewURL); + return pBase; +} +void PresentationViewShellBase::RegisterFactory( USHORT nPrio ) +{ + pFactory = new SfxViewFactory( + &CreateInstance,&InitFactory,nPrio,SdResId(STR_DEFAULTVIEW)); + InitFactory(); +} +void PresentationViewShellBase::InitFactory() +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} + + + + +PresentationViewShellBase::PresentationViewShellBase ( + SfxViewFrame* _pFrame, + SfxViewShell* pOldShell) + : ViewShellBase (_pFrame, pOldShell) +{ + GetUpdateLockManager()->Disable(); + + // Hide the automatic (non-context sensitive) tool bars. + if (_pFrame!=NULL) + { + Reference<beans::XPropertySet> xFrameSet ( + _pFrame->GetFrame().GetFrameInterface(), + UNO_QUERY); + if (xFrameSet.is()) + { + Reference<beans::XPropertySet> xLayouterSet ( + xFrameSet->getPropertyValue(::rtl::OUString::createFromAscii("LayoutManager")), + UNO_QUERY); + if (xLayouterSet.is()) + { + xLayouterSet->setPropertyValue( + ::rtl::OUString::createFromAscii("AutomaticToolbars"), + makeAny(sal_False)); + } + } + } +} + + + + +PresentationViewShellBase::~PresentationViewShellBase (void) +{ +} + + + + +void PresentationViewShellBase::InitializeFramework (void) +{ + com::sun::star::uno::Reference<com::sun::star::frame::XController> + xController (GetController()); + sd::framework::PresentationModule::Initialize(xController); +} + +} // end of namespace sd + diff --git a/sd/source/ui/view/SlideSorterViewShellBase.cxx b/sd/source/ui/view/SlideSorterViewShellBase.cxx new file mode 100644 index 000000000000..466f699b1bb0 --- /dev/null +++ b/sd/source/ui/view/SlideSorterViewShellBase.cxx @@ -0,0 +1,103 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "SlideSorterViewShellBase.hxx" +#include "sdresid.hxx" +#include "DrawDocShell.hxx" +#include "strings.hrc" +#include "framework/FrameworkHelper.hxx" + +namespace sd { + +class DrawDocShell; + +TYPEINIT1(SlideSorterViewShellBase, ViewShellBase); + +// We have to expand the SFX_IMPL_VIEWFACTORY macro to call LateInit() after a +// new SlideSorterViewShellBase object has been constructed. + +/* +SFX_IMPL_VIEWFACTORY(SlideSorterViewShellBase, SdResId(STR_DEFAULTVIEW)) +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} +*/ +SfxViewFactory* SlideSorterViewShellBase::pFactory; +SfxViewShell* __EXPORT SlideSorterViewShellBase::CreateInstance ( + SfxViewFrame *pFrame, SfxViewShell *pOldView) +{ + SlideSorterViewShellBase* pBase = new SlideSorterViewShellBase(pFrame, pOldView); + pBase->LateInit(framework::FrameworkHelper::msSlideSorterURL); + return pBase; +} + + + + +void SlideSorterViewShellBase::RegisterFactory( USHORT nPrio ) +{ + pFactory = new SfxViewFactory( + &CreateInstance,&InitFactory,nPrio,SdResId(STR_DEFAULTVIEW)); + InitFactory(); +} + + + + +void SlideSorterViewShellBase::InitFactory() +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} + + + + + + + +SlideSorterViewShellBase::SlideSorterViewShellBase ( + SfxViewFrame* _pFrame, + SfxViewShell* pOldShell) + : ImpressViewShellBase (_pFrame, pOldShell) +{ +} + + + + +SlideSorterViewShellBase::~SlideSorterViewShellBase (void) +{ +} + + + + +} // end of namespace sd + diff --git a/sd/source/ui/view/ToolBarManager.cxx b/sd/source/ui/view/ToolBarManager.cxx new file mode 100755 index 000000000000..ce3064392d40 --- /dev/null +++ b/sd/source/ui/view/ToolBarManager.cxx @@ -0,0 +1,1697 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "ToolBarManager.hxx" + +#include "DrawViewShell.hxx" +#include "EventMultiplexer.hxx" +#include "ViewShellBase.hxx" +#include "ViewShellManager.hxx" +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/frame/XLayoutManager.hpp> +#include <com/sun/star/ui/UIElementType.hpp> + +#include <cppuhelper/implbase1.hxx> +#include <osl/mutex.hxx> +#include <rtl/ref.hxx> +#include <sfx2/app.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/request.hxx> +#include <sfx2/viewfrm.hxx> +#include <svl/eitem.hxx> +#include <svx/dialogs.hrc> +#include <svx/extrusionbar.hxx> +#include <svx/fontworkbar.hxx> +#ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_ +#include <toolkit/unohlp.hxx> +#endif +#include <tools/link.hxx> + +#include <map> +#include <vector> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +#undef VERBOSE + +#undef OUSTRING // Remove definition made in the SFX +#define OUSTRING(s) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(s))) + +namespace { + +using namespace sd; + +class ToolBarRules; + +/** Lock of the frame::XLayoutManager. +*/ +class LayouterLock +{ +public: + LayouterLock (const Reference<frame::XLayoutManager>& rxLayouter); + ~LayouterLock (void); +private: + Reference<frame::XLayoutManager> mxLayouter; +}; + + +typedef ::std::vector<rtl::OUString> NameList; + +/** Store a list of tool bars for each of the tool bar groups. From + this the list of requested tool bars is built. +*/ +class ToolBarList +{ +public: + ToolBarList (void); + + void ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup); + void AddToolBar (sd::ToolBarManager::ToolBarGroup eGroup, const ::rtl::OUString& rsName); + bool RemoveToolBar (sd::ToolBarManager::ToolBarGroup eGroup, const ::rtl::OUString& rsName); + + void GetToolBarsToActivate (NameList& rToolBars) const; + void GetToolBarsToDeactivate (NameList& rToolBars) const; + + void MarkToolBarAsActive (const ::rtl::OUString& rsName); + void MarkToolBarAsNotActive (const ::rtl::OUString& rsName); + void MarkAllToolBarsAsNotActive (void); + +private: + typedef ::std::map<sd::ToolBarManager::ToolBarGroup,NameList> Groups; + Groups maGroups; + NameList maActiveToolBars; + + void MakeRequestedToolBarList (NameList& rToolBars) const; +}; + + + + +/** Manage tool bars that are implemented as sub shells of a view shell. + The typical procedure of updating the sub shells of a view shell is to + rebuild a list of sub shells that the caller would like to have active. + The methods ClearGroup() and AddShellId() allow the caller to do that. A + final call to UpdateShells() activates the requested shells that are not + active and deactivates the active shells that are not requested . + + This is done by maintaining two lists. One (the current list) + reflects the current state. The other (the requested list) contains the + currently requested shells. UpdateShells() makes the requested + list the current list and clears the current list. + + Each shell belongs to one group. Different groups can be modified + seperately. +*/ +class ToolBarShellList +{ +public: + /** Create a new object with an empty current list and an empty + requested list. + */ + ToolBarShellList (void); + + /** Remove all shells from a group. Calling this method should normally + not be necessary because after the construction or after a call to + UpdateShells() the requested list is empty. + @param eGroup + The group to clear. Shells in other groups are not modified. + */ + void ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup); + + /** Add a shell. When the specified shell has alreadt been requested + for another group then it is moved to this group. + @param eGroup + The group to which to add the shell. + @param nId + The id of the shell to add. + */ + void AddShellId (sd::ToolBarManager::ToolBarGroup eGroup, sd::ShellId nId); + + /** Releasing all shells means that the given ToolBarRules object is + informed that every shell mananged by the called ToolBarShellList is + about to be removed and that the associated framework tool bars can + be removed as well. The caller still has to call UpdateShells(). + */ + void ReleaseAllShells (ToolBarRules& rRules); + + /** The requested list is made the current list by activating all + shells in the requested list and by deactivating the shells in the + current list that are not in the requested list. + @param pMainViewShell + The shells that are activated or deactivated are sub shells of + this view shell. + @param rManager + This ViewShellManager is used to activate or deactivate shells. + */ + void UpdateShells ( + const ::boost::shared_ptr<ViewShell>& rpMainViewShell, + const ::boost::shared_ptr<ViewShellManager>& rpManager); + +private: + class ShellDescriptor + {public: + ShellDescriptor (ShellId nId,sd::ToolBarManager::ToolBarGroup eGroup); + ShellId mnId; + sd::ToolBarManager::ToolBarGroup meGroup; + friend bool operator<(const ShellDescriptor& r1, const ShellDescriptor& r2) + { return r1.mnId < r2.mnId; } + }; + + /** The requested list of tool bar shells that will be active after the + next call to UpdateShells(). + */ + typedef ::std::set<ShellDescriptor> GroupedShellList; + GroupedShellList maNewList; + + /** The list of tool bar shells that are currently on the shell stack. + Using a GroupedShellList is not strictly necessary but it makes + things easier and does not waste too much memory. + */ + GroupedShellList maCurrentList; +}; + + + + +/** This class concentrates the knowledge about when to show what tool bars + in one place. +*/ +class ToolBarRules +{ +public: + ToolBarRules ( + const ::boost::shared_ptr<ToolBarManager>& rpToolBarManager, + const ::boost::shared_ptr<ViewShellManager>& rpViewShellManager); + + /** This method calls MainViewShellChanged() and SelectionHasChanged() + for the current main view shell and its view. + */ + void Update (ViewShellBase& rBase); + + /** Reset all tool bars in all groups and add tool bars and tool bar + shells to the TBG_PERMANENT group for the specified ViewShell type. + */ + void MainViewShellChanged (ViewShell::ShellType nShellType); + + /** Reset all tool bars in all groups and add tool bars and tool bar + shells to the TBG_PERMANENT group for the specified ViewShell. + */ + void MainViewShellChanged (const ViewShell& rMainViewShell); + + /** Reset all tool bars in the TBG_FUNCTION group and add tool bars and tool bar + shells to this group for the current selection. + */ + void SelectionHasChanged ( + const ::sd::ViewShell& rViewShell, + const SdrView& rView); + + /** Add a tool bar for the specified tool bar shell. + */ + void SubShellAdded ( + ::sd::ToolBarManager::ToolBarGroup eGroup, + sd::ShellId nShellId); + + /** Remove a tool bar for the specified tool bar shell. + */ + void SubShellRemoved ( + ::sd::ToolBarManager::ToolBarGroup eGroup, + sd::ShellId nShellId); + +private: + ::boost::shared_ptr<ToolBarManager> mpToolBarManager; + ::boost::shared_ptr<ViewShellManager> mpViewShellManager; +}; + +} // end of anonymous namespace + + + + +namespace sd { + +//===== ToolBarManager::Implementation ======================================== + +class ToolBarManager::Implementation +{ +public: + /** This constructor takes three arguments even though the + ToolBarManager could be taken from the ViewShellBase. This is so to + state explicitly which information has to be present when this + constructor is called. The ViewShellBase may not have been fully + initialized at this point and must not be asked for this values. + */ + Implementation ( + ViewShellBase& rBase, + const ::boost::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer, + const ::boost::shared_ptr<ViewShellManager>& rpViewShellManager, + const ::boost::shared_ptr<ToolBarManager>& rpToolBarManager); + ~Implementation (void); + + void SetValid (bool bValid); + + void ResetToolBars (ToolBarGroup eGroup); + void ResetAllToolBars (void); + void AddToolBar (ToolBarGroup eGroup, const ::rtl::OUString& rsToolBarName); + void AddToolBarShell (ToolBarGroup eGroup, ShellId nToolBarId); + void RemoveToolBar (ToolBarGroup eGroup, const ::rtl::OUString& rsToolBarName); + + /** Release all tool bar shells and the associated framework tool bars. + Typically called when the main view shell is being replaced by + another, all tool bar shells are released. In that process the + shells are destroyed anyway and whithout calling this method they + would still be referenced. + */ + void ReleaseAllToolBarShells (void); + + void ToolBarsDestroyed(void); + + void RequestUpdate (void); + + void PreUpdate (void); + void PostUpdate (void); + /** Tell the XLayoutManager about the tool bars that we would like to be + shown. + @param rpLayouterLock + This typically is the mpSynchronousLayouterLock that is used in + this method and that is either released at its end or assigned + to mpAsynchronousLock in order to be unlocked later. + */ + void Update (::std::auto_ptr<LayouterLock> pLayouterLock); + + class UpdateLockImplementation + { + public: + UpdateLockImplementation (Implementation& rImplementation) + : mrImplementation(rImplementation) { mrImplementation.LockUpdate(); } + ~UpdateLockImplementation (void) { mrImplementation.UnlockUpdate(); } + private: + Implementation& mrImplementation; + }; + + void LockViewShellManager (void); + void LockUpdate (void); + void UnlockUpdate (void); + + ToolBarRules& GetToolBarRules (void); + +private: + const static ::rtl::OUString msToolBarResourcePrefix; + + mutable ::osl::Mutex maMutex; + ViewShellBase& mrBase; + ::boost::shared_ptr<sd::tools::EventMultiplexer> mpEventMultiplexer; + bool mbIsValid; + ToolBarList maToolBarList; + ToolBarShellList maToolBarShellList; + Reference<frame::XLayoutManager> mxLayouter; + sal_Int32 mnLockCount; + bool mbPreUpdatePending; + bool mbPostUpdatePending; + /** The layouter locks manage the locking of the XLayoutManager. The + lock() and unlock() functions are not called directly because the + (final) unlocking is usually done asynchronously *after* the + list of requested toolbars is updated. + */ + ::std::auto_ptr<LayouterLock> mpSynchronousLayouterLock; + ::std::auto_ptr<LayouterLock> mpAsynchronousLayouterLock; + ::std::auto_ptr<ViewShellManager::UpdateLock> mpViewShellManagerLock; + ULONG mnPendingUpdateCall; + ULONG mnPendingSetValidCall; + ToolBarRules maToolBarRules; + + ::rtl::OUString GetToolBarResourceName (const ::rtl::OUString& rsBaseName) const; + bool CheckPlugInMode (const ::rtl::OUString& rsName) const; + + DECL_LINK(UpdateCallback,bool*); + DECL_LINK(EventMultiplexerCallback, sd::tools::EventMultiplexerEvent*); + DECL_LINK(SetValidCallback,void*); +}; + + + +//===== ToolBarManager ======================================================== + +const ::rtl::OUString ToolBarManager::msToolBar(OUSTRING("toolbar")); +const ::rtl::OUString ToolBarManager::msOptionsToolBar(OUSTRING("optionsbar")); +const ::rtl::OUString ToolBarManager::msCommonTaskToolBar(OUSTRING("commontaskbar")); +const ::rtl::OUString ToolBarManager::msViewerToolBar(OUSTRING("viewerbar")); +const ::rtl::OUString ToolBarManager::msSlideSorterToolBar(OUSTRING("slideviewtoolbar")); +const ::rtl::OUString ToolBarManager::msSlideSorterObjectBar(OUSTRING("slideviewobjectbar")); +const ::rtl::OUString ToolBarManager::msOutlineToolBar(OUSTRING("outlinetoolbar")); +const ::rtl::OUString ToolBarManager::msMasterViewToolBar(OUSTRING("masterviewtoolbar")); +const ::rtl::OUString ToolBarManager::msDrawingObjectToolBar(OUSTRING("drawingobjectbar")); +const ::rtl::OUString ToolBarManager::msGluePointsToolBar(OUSTRING("gluepointsobjectbar")); +const ::rtl::OUString ToolBarManager::msTextObjectBar(OUSTRING("textobjectbar")); +const ::rtl::OUString ToolBarManager::msBezierObjectBar(OUSTRING("bezierobjectbar")); +const ::rtl::OUString ToolBarManager::msGraphicObjectBar(OUSTRING("graphicobjectbar")); +const ::rtl::OUString ToolBarManager::msMediaObjectBar(OUSTRING("mediaobjectbar")); +const ::rtl::OUString ToolBarManager::msTableObjectBar(OUSTRING("tableobjectbar")); + + +::boost::shared_ptr<ToolBarManager> ToolBarManager::Create ( + ViewShellBase& rBase, + const ::boost::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer, + const ::boost::shared_ptr<ViewShellManager>& rpViewShellManager) +{ + ::boost::shared_ptr<ToolBarManager> pManager (new ToolBarManager()); + pManager->mpImpl.reset( + new Implementation(rBase,rpMultiplexer,rpViewShellManager,pManager)); + return pManager; +} + + + + +ToolBarManager::ToolBarManager (void) + : mpImpl() +{ +} + + + + +ToolBarManager::~ToolBarManager (void) +{ +} + + + + +void ToolBarManager::Shutdown (void) +{ + if (mpImpl.get() != NULL) + mpImpl.reset(); +} + + + + +void ToolBarManager::ResetToolBars (ToolBarGroup eGroup) +{ + if (mpImpl.get() != NULL) + { + UpdateLock aLock (shared_from_this()); + mpImpl->ResetToolBars(eGroup); + } +} + + + + +void ToolBarManager::ResetAllToolBars (void) +{ + if (mpImpl.get() != NULL) + { + UpdateLock aLock (shared_from_this()); + mpImpl->ResetAllToolBars(); + } +} + + + + +void ToolBarManager::AddToolBar ( + ToolBarGroup eGroup, + const ::rtl::OUString& rsToolBarName) +{ + if (mpImpl.get() != NULL) + { + UpdateLock aLock (shared_from_this()); + mpImpl->AddToolBar(eGroup,rsToolBarName); + } +} + + + + +void ToolBarManager::AddToolBarShell ( + ToolBarGroup eGroup, + ShellId nToolBarId) +{ + if (mpImpl.get() != NULL) + { + UpdateLock aLock (shared_from_this()); + mpImpl->AddToolBarShell(eGroup,nToolBarId); + } +} + + + + +void ToolBarManager::RemoveToolBar ( + ToolBarGroup eGroup, + const ::rtl::OUString& rsToolBarName) +{ + if (mpImpl.get() != NULL) + { + UpdateLock aLock (shared_from_this()); + mpImpl->RemoveToolBar(eGroup,rsToolBarName); + } +} + + + + +void ToolBarManager::SetToolBar ( + ToolBarGroup eGroup, + const ::rtl::OUString& rsToolBarName) +{ + if (mpImpl.get() != NULL) + { + UpdateLock aLock (shared_from_this()); + mpImpl->ResetToolBars(eGroup); + mpImpl->AddToolBar(eGroup,rsToolBarName); + } +} + + + + +void ToolBarManager::SetToolBarShell ( + ToolBarGroup eGroup, + ShellId nToolBarId) +{ + if (mpImpl.get() != NULL) + { + UpdateLock aLock (shared_from_this()); + mpImpl->ResetToolBars(eGroup); + mpImpl->AddToolBarShell(eGroup,nToolBarId); + } +} + + + + +void ToolBarManager::PreUpdate (void) +{ + if (mpImpl.get()!=NULL) + mpImpl->PreUpdate(); +} + + + + +void ToolBarManager::RequestUpdate (void) +{ + if (mpImpl.get()!=NULL) + mpImpl->RequestUpdate(); +} + + + + +void ToolBarManager::LockViewShellManager (void) +{ + if (mpImpl.get() != NULL) + mpImpl->LockViewShellManager(); +} + + + + +void ToolBarManager::LockUpdate (void) +{ + if (mpImpl.get()!=NULL) + mpImpl->LockUpdate(); +} + + + + +void ToolBarManager::UnlockUpdate (void) +{ + if (mpImpl.get()!=NULL) + mpImpl->UnlockUpdate(); +} + + + + +void ToolBarManager::MainViewShellChanged (ViewShell::ShellType nShellType) +{ + if (mpImpl.get() != NULL) + { + mpImpl->ReleaseAllToolBarShells(); + mpImpl->GetToolBarRules().MainViewShellChanged(nShellType); + } +} + + + + +void ToolBarManager::MainViewShellChanged (const ViewShell& rMainViewShell) +{ + if (mpImpl.get() != NULL) + { + mpImpl->ReleaseAllToolBarShells(); + mpImpl->GetToolBarRules().MainViewShellChanged(rMainViewShell); + } +} + + + + +void ToolBarManager::SelectionHasChanged ( + const ViewShell& rViewShell, + const SdrView& rView) +{ + if (mpImpl.get() != NULL) + mpImpl->GetToolBarRules().SelectionHasChanged(rViewShell,rView); +} + + +void ToolBarManager::ToolBarsDestroyed(void) +{ + if (mpImpl.get() != NULL) + mpImpl->ToolBarsDestroyed(); +} + + +//===== ToolBarManager::Implementation ======================================= + +const ::rtl::OUString ToolBarManager::Implementation::msToolBarResourcePrefix( + OUSTRING("private:resource/toolbar/")); + +ToolBarManager::Implementation::Implementation ( + ViewShellBase& rBase, + const ::boost::shared_ptr<sd::tools::EventMultiplexer>& rpMultiplexer, + const ::boost::shared_ptr<ViewShellManager>& rpViewShellManager, + const ::boost::shared_ptr<ToolBarManager>& rpToolBarManager) + : maMutex(), + mrBase(rBase), + mpEventMultiplexer(rpMultiplexer), + mbIsValid(false), + maToolBarList(), + maToolBarShellList(), + mxLayouter(NULL), + mnLockCount(0), + mbPreUpdatePending(false), + mbPostUpdatePending(false), + mpSynchronousLayouterLock(), + mpAsynchronousLayouterLock(), + mpViewShellManagerLock(), + mnPendingUpdateCall(0), + mnPendingSetValidCall(0), + maToolBarRules(rpToolBarManager,rpViewShellManager) +{ + Link aLink (LINK(this,ToolBarManager::Implementation,EventMultiplexerCallback)); + mpEventMultiplexer->AddEventListener( + aLink, + tools::EventMultiplexerEvent::EID_CONTROLLER_ATTACHED + | tools::EventMultiplexerEvent::EID_CONTROLLER_DETACHED + | tools::EventMultiplexerEvent::EID_PANE_MANAGER_DYING); +} + + + +/** The order of statements is important. + First unregister listeners, which may post user events. + Then remove pending user events. +*/ +ToolBarManager::Implementation::~Implementation (void) +{ + // Unregister at broadcasters. + Link aLink (LINK(this,ToolBarManager::Implementation,EventMultiplexerCallback)); + mpEventMultiplexer->RemoveEventListener(aLink); + + // Abort pending user calls. + if (mnPendingUpdateCall != 0) + Application::RemoveUserEvent(mnPendingUpdateCall); + if (mnPendingSetValidCall != 0) + Application::RemoveUserEvent(mnPendingSetValidCall); +} + + +void ToolBarManager::Implementation::ToolBarsDestroyed(void) +{ + maToolBarList.MarkAllToolBarsAsNotActive(); +} + + +void ToolBarManager::Implementation::SetValid (bool bValid) +{ + ::osl::MutexGuard aGuard(maMutex); + + if (mbIsValid != bValid) + { + UpdateLockImplementation aUpdateLock (*this); + + mbIsValid = bValid; + if (mbIsValid) + { + Reference<frame::XFrame> xFrame; + if (mrBase.GetViewFrame() != NULL) + xFrame = mrBase.GetViewFrame()->GetFrame().GetFrameInterface(); + try + { + Reference<beans::XPropertySet> xFrameProperties (xFrame, UNO_QUERY_THROW); + Any aValue (xFrameProperties->getPropertyValue(OUSTRING("LayoutManager"))); + aValue >>= mxLayouter; + } + catch (RuntimeException aException) + { + } + + GetToolBarRules().Update(mrBase); + } + else + { + ResetAllToolBars(); + mxLayouter = NULL; + } + } +} + + + + +void ToolBarManager::Implementation::ResetToolBars (ToolBarGroup eGroup) +{ + ::osl::MutexGuard aGuard(maMutex); + + maToolBarList.ClearGroup(eGroup); + maToolBarShellList.ClearGroup(eGroup); + + mbPreUpdatePending = true; +} + + + + +void ToolBarManager::Implementation::ResetAllToolBars (void) +{ +#ifdef VERBOSE + OSL_TRACE("resetting all tool bars\n"); +#endif + for (int i=TBG__FIRST; i<=TBG__LAST; ++i) + ResetToolBars((ToolBarGroup)i); +} + + + + +void ToolBarManager::Implementation::AddToolBar ( + ToolBarGroup eGroup, + const ::rtl::OUString& rsToolBarName) +{ + ::osl::MutexGuard aGuard(maMutex); + + if (CheckPlugInMode(rsToolBarName)) + { + maToolBarList.AddToolBar(eGroup,rsToolBarName); + + mbPostUpdatePending = true; + if (mnLockCount == 0) + PostUpdate(); + } +} + + + + +void ToolBarManager::Implementation::RemoveToolBar ( + ToolBarGroup eGroup, + const ::rtl::OUString& rsToolBarName) +{ + ::osl::MutexGuard aGuard(maMutex); + + if (maToolBarList.RemoveToolBar(eGroup,rsToolBarName)) + { + mbPreUpdatePending = true; + if (mnLockCount == 0) + PreUpdate(); + } +} + + + + +void ToolBarManager::Implementation::AddToolBarShell ( + ToolBarGroup eGroup, + ShellId nToolBarId) +{ + ViewShell* pMainViewShell = mrBase.GetMainViewShell().get(); + if (pMainViewShell != NULL) + { + maToolBarShellList.AddShellId(eGroup,nToolBarId); + GetToolBarRules().SubShellAdded(eGroup, nToolBarId); + } +} + + + + +void ToolBarManager::Implementation::ReleaseAllToolBarShells (void) +{ + maToolBarShellList.ReleaseAllShells(GetToolBarRules()); + maToolBarShellList.UpdateShells(mrBase.GetMainViewShell(), mrBase.GetViewShellManager()); +} + + + + +void ToolBarManager::Implementation::RequestUpdate (void) +{ + if (mnPendingUpdateCall == 0) + { + mnPendingUpdateCall = Application::PostUserEvent( + LINK(this,ToolBarManager::Implementation,UpdateCallback)); + } +} + + + + +void ToolBarManager::Implementation::PreUpdate (void) +{ + ::osl::MutexGuard aGuard(maMutex); + + if (mbIsValid + && mbPreUpdatePending + && mxLayouter.is()) + { + mbPreUpdatePending = false; + +#ifdef VERBOSE + OSL_TRACE("ToolBarManager::PreUpdate ["); +#endif + + // Get the list of tool bars that are not used anymore and are to be + // deactivated. + NameList aToolBars; + maToolBarList.GetToolBarsToDeactivate(aToolBars); + + // Turn off the tool bars. + NameList::const_iterator iToolBar; + for (iToolBar=aToolBars.begin(); iToolBar!=aToolBars.end(); ++iToolBar) + { + ::rtl::OUString sFullName (GetToolBarResourceName(*iToolBar)); +#ifdef VERBOSE + OSL_TRACE(" turning off tool bar %s", + ::rtl::OUStringToOString(sFullName, RTL_TEXTENCODING_UTF8).getStr()); +#endif + mxLayouter->destroyElement(sFullName); + maToolBarList.MarkToolBarAsNotActive(*iToolBar); + } + +#ifdef VERBOSE + OSL_TRACE("ToolBarManager::PreUpdate ]\n"); +#endif + } +} + + + + +void ToolBarManager::Implementation::PostUpdate (void) +{ + ::osl::MutexGuard aGuard(maMutex); + + if (mbIsValid + && mbPostUpdatePending + && mxLayouter.is()) + { + mbPostUpdatePending = false; + + // Create the list of requested tool bars. + NameList aToolBars; + maToolBarList.GetToolBarsToActivate(aToolBars); + +#ifdef VERBOSE + OSL_TRACE("ToolBarManager::PostUpdate ["); +#endif + + // Turn on the tool bars that are visible in the new context. + NameList::const_iterator iToolBar; + for (iToolBar=aToolBars.begin(); iToolBar!=aToolBars.end(); ++iToolBar) + { + ::rtl::OUString sFullName (GetToolBarResourceName(*iToolBar)); +#ifdef VERBOSE + OSL_TRACE(" turning on tool bar %s", + ::rtl::OUStringToOString(sFullName, RTL_TEXTENCODING_UTF8).getStr()); +#endif + mxLayouter->requestElement(sFullName); + maToolBarList.MarkToolBarAsActive(*iToolBar); + } + +#ifdef VERBOSE + OSL_TRACE("ToolBarManager::PostUpdate ]\n"); +#endif + } +} + + + + +void ToolBarManager::Implementation::LockViewShellManager (void) +{ + if (mpViewShellManagerLock.get() == NULL) + mpViewShellManagerLock.reset( + new ViewShellManager::UpdateLock(mrBase.GetViewShellManager())); +} + + + + +void ToolBarManager::Implementation::LockUpdate (void) +{ +#ifdef VERBOSE + OSL_TRACE("LockUpdate %d\n", mnLockCount); +#endif + ::osl::MutexGuard aGuard(maMutex); + + DBG_ASSERT(mnLockCount<100, "ToolBarManager lock count unusually high"); + if (mnLockCount == 0) + { + OSL_ASSERT(mpSynchronousLayouterLock.get()==NULL); + + mpSynchronousLayouterLock.reset(new LayouterLock(mxLayouter)); + } + ++mnLockCount; +} + + + + +void ToolBarManager::Implementation::UnlockUpdate (void) +{ +#ifdef VERBOSE + OSL_TRACE("UnlockUpdate %d\n", mnLockCount); +#endif + ::osl::MutexGuard aGuard(maMutex); + + OSL_ASSERT(mnLockCount>0); + --mnLockCount; + if (mnLockCount == 0) + { + Update(mpSynchronousLayouterLock); + } +} + + + + +void ToolBarManager::Implementation::Update ( + ::std::auto_ptr<LayouterLock> pLocalLayouterLock) +{ + // When the lock is released and there are pending changes to the set of + // tool bars then update this set now. + if (mnLockCount == 0) + { + // During ceation of ViewShellBase we may have the situation that + // the controller has already been created and attached to the frame + // but that the ToolBarManager has not yet completed its + // initialization (by initializing the mxLayouter member.) We do + // this here so that we do not have to wait for the next Update() + // call to show the tool bars. + if (mnPendingSetValidCall != 0) + { + Application::RemoveUserEvent(mnPendingSetValidCall); + mnPendingSetValidCall = 0; + SetValid(true); + } + + if (mbIsValid && mxLayouter.is() && (mbPreUpdatePending || mbPostUpdatePending)) + { + // 1) Release UNO tool bars that are not longer used. Do this + // now so that they are not updated when the SFX shell stack is + // modified. + if (mbPreUpdatePending) + PreUpdate(); + + // 2) Update the requested shells that represent tool bar + // functionality. Those that are not used anymore are + // deactivated now. Those that are missing are activated in the + // next step together with the view shells. + if (mpViewShellManagerLock.get() == NULL) + mpViewShellManagerLock.reset( + new ViewShellManager::UpdateLock(mrBase.GetViewShellManager())); + maToolBarShellList.UpdateShells( + mrBase.GetMainViewShell(), + mrBase.GetViewShellManager()); + + // 3) Unlock the ViewShellManager::UpdateLock. This updates the + // shell stack. We have to be carfull here. The deletion of + // the lock may end in a synchronous call to LockUpdate(). When + // at this time the lock has been deleted but the auto_ptr has + // not yet been reset then the lock is deleted a second time. + ViewShellManager::UpdateLock* pLock = mpViewShellManagerLock.release(); + delete pLock; + + // 4) Make the UNO tool bars visible. The outstanding call to + // PostUpdate() is done via PostUserEvent() so that it is + // guaranteed to be executed when the SFX shell stack has been + // updated (under the assumption that our lock to the + // ViewShellManager was the only one open. If that is not the + // case then all should still be well but not as fast.) + // + // Note that the lock count may have been increased since + // entering this method. In that case one of the next + // UnlockUpdate() calls will post the UpdateCallback. + if (mnPendingUpdateCall==0 && mnLockCount==0) + { + mpAsynchronousLayouterLock = pLocalLayouterLock; + mnPendingUpdateCall = Application::PostUserEvent( + LINK(this,ToolBarManager::Implementation,UpdateCallback)); + } + } + else + { + mpViewShellManagerLock.reset(); + pLocalLayouterLock.reset(); + } + } +} + + + + +ToolBarRules& ToolBarManager::Implementation::GetToolBarRules (void) +{ + return maToolBarRules; +} + + + + +IMPL_LINK(ToolBarManager::Implementation,UpdateCallback,bool*,EMPTYARG) +{ + mnPendingUpdateCall = 0; + if (mnLockCount == 0) + { + if (mbPreUpdatePending) + PreUpdate(); + if (mbPostUpdatePending) + PostUpdate(); + if (mbIsValid && mxLayouter.is()) + mpAsynchronousLayouterLock.reset(); + } + return 0; +} + + + + +IMPL_LINK(ToolBarManager::Implementation,EventMultiplexerCallback, + sd::tools::EventMultiplexerEvent*,pEvent) +{ + if (pEvent != NULL) + { + switch (pEvent->meEventId) + { + case tools::EventMultiplexerEvent::EID_CONTROLLER_ATTACHED: + if (mnPendingSetValidCall == 0) + mnPendingSetValidCall + = Application::PostUserEvent(LINK(this,Implementation,SetValidCallback)); + break; + + case tools::EventMultiplexerEvent::EID_CONTROLLER_DETACHED: + SetValid(false); + break; + + case tools::EventMultiplexerEvent::EID_PANE_MANAGER_DYING: + SetValid(false); + break; + } + } + return 0; +} + + + + +IMPL_LINK(ToolBarManager::Implementation, SetValidCallback,void*,EMPTYARG) +{ + mnPendingSetValidCall = 0; + SetValid(true); + return 0; +} + + + + + +::rtl::OUString ToolBarManager::Implementation::GetToolBarResourceName ( + const ::rtl::OUString& rsBaseName) const +{ + ::rtl::OUString sToolBarName (msToolBarResourcePrefix); + sToolBarName += rsBaseName; + return sToolBarName; +} + + + + +bool ToolBarManager::Implementation::CheckPlugInMode (const ::rtl::OUString& rsName) const +{ + bool bValid (false); + + // Determine the plug in mode. + bool bIsPlugInMode (false); + do + { + SfxObjectShell* pObjectShell = mrBase.GetObjectShell(); + if (pObjectShell == NULL) + break; + + SfxMedium* pMedium = pObjectShell->GetMedium(); + if (pMedium == NULL) + break; + + SFX_ITEMSET_ARG(pMedium->GetItemSet(),pViewOnlyItem,SfxBoolItem,SID_VIEWONLY,sal_False); + if (pViewOnlyItem == NULL) + break; + + bIsPlugInMode = pViewOnlyItem->GetValue(); + } + while (false); + + if (rsName.equals(msViewerToolBar)) + bValid = bIsPlugInMode; + else + bValid = ! bIsPlugInMode; + + return bValid; +} + + + + +} // end of namespace sd + + + + +namespace { + +using namespace ::sd; + +//===== LayouterLock ========================================================== + +LayouterLock::LayouterLock (const Reference<frame::XLayoutManager>& rxLayouter) + : mxLayouter(rxLayouter) +{ +#ifdef VERBOSE + OSL_TRACE("LayouterLock %d", mxLayouter.is() ? 1 :0); +#endif + if (mxLayouter.is()) + mxLayouter->lock(); +} + + + + +LayouterLock::~LayouterLock (void) +{ +#ifdef VERBOSE + OSL_TRACE("~LayouterLock %d", mxLayouter.is() ? 1 :0); +#endif + if (mxLayouter.is()) + mxLayouter->unlock(); +} + + + + +//===== ToolBarRules ========================================================== + +ToolBarRules::ToolBarRules ( + const ::boost::shared_ptr<sd::ToolBarManager>& rpToolBarManager, + const ::boost::shared_ptr<sd::ViewShellManager>& rpViewShellManager) + : mpToolBarManager(rpToolBarManager), + mpViewShellManager(rpViewShellManager) +{ +} + + + + +void ToolBarRules::Update (ViewShellBase& rBase) +{ + ViewShell* pMainViewShell = rBase.GetMainViewShell().get(); + if (pMainViewShell != NULL) + { + MainViewShellChanged(pMainViewShell->GetShellType()); + if (pMainViewShell->GetView()) + SelectionHasChanged (*pMainViewShell, *pMainViewShell->GetView()); + } + else + MainViewShellChanged(ViewShell::ST_NONE); +} + + + + +void ToolBarRules::MainViewShellChanged (ViewShell::ShellType nShellType) +{ + ::sd::ToolBarManager::UpdateLock aToolBarManagerLock (mpToolBarManager); + ::sd::ViewShellManager::UpdateLock aViewShellManagerLock (mpViewShellManager); + + mpToolBarManager->ResetAllToolBars(); + + switch(nShellType) + { + case ::sd::ViewShell::ST_IMPRESS: + case ::sd::ViewShell::ST_NOTES: + case ::sd::ViewShell::ST_HANDOUT: + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msToolBar); + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msOptionsToolBar); + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msCommonTaskToolBar); + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msViewerToolBar); + break; + + case ::sd::ViewShell::ST_DRAW: + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msToolBar); + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msOptionsToolBar); + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msViewerToolBar); + break; + + case ViewShell::ST_OUTLINE: + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msOutlineToolBar); + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msViewerToolBar); + mpToolBarManager->AddToolBarShell( + ToolBarManager::TBG_PERMANENT, RID_DRAW_TEXT_TOOLBOX); + break; + + case ViewShell::ST_SLIDE_SORTER: + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msViewerToolBar); + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msSlideSorterToolBar); + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_PERMANENT, + ToolBarManager::msSlideSorterObjectBar); + break; + + case ViewShell::ST_NONE: + case ViewShell::ST_PRESENTATION: + case ViewShell::ST_TASK_PANE: + default: + break; + } +} + + + + +void ToolBarRules::MainViewShellChanged (const ViewShell& rMainViewShell) +{ + ::sd::ToolBarManager::UpdateLock aToolBarManagerLock (mpToolBarManager); + ::sd::ViewShellManager::UpdateLock aViewShellManagerLock (mpViewShellManager); + + MainViewShellChanged(rMainViewShell.GetShellType()); + switch(rMainViewShell.GetShellType()) + { + case ::sd::ViewShell::ST_IMPRESS: + case ::sd::ViewShell::ST_DRAW: + case ::sd::ViewShell::ST_NOTES: + { + const DrawViewShell* pDrawViewShell + = dynamic_cast<const DrawViewShell*>(&rMainViewShell); + if (pDrawViewShell != NULL) + if (pDrawViewShell->GetEditMode() == EM_MASTERPAGE) + mpToolBarManager->AddToolBar( + ToolBarManager::TBG_MASTER_MODE, + ToolBarManager::msMasterViewToolBar); + break; + } + + default: + break; + } +} + + + + +void ToolBarRules::SelectionHasChanged ( + const ::sd::ViewShell& rViewShell, + const SdrView& rView) +{ + ::sd::ToolBarManager::UpdateLock aLock (mpToolBarManager); + mpToolBarManager->LockViewShellManager(); + bool bTextEdit = rView.IsTextEdit(); + + mpToolBarManager->ResetToolBars(ToolBarManager::TBG_FUNCTION); + + switch (rView.GetContext()) + { + case SDRCONTEXT_GRAPHIC: + if( !bTextEdit ) + mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_GRAF_TOOLBOX); + break; + + case SDRCONTEXT_MEDIA: + if( !bTextEdit ) + mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_MEDIA_TOOLBOX); + break; + + case SDRCONTEXT_TABLE: + mpToolBarManager->SetToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_TABLE_TOOLBOX); + bTextEdit = true; + break; + + case SDRCONTEXT_STANDARD: + default: + if( !bTextEdit ) + { + switch(rViewShell.GetShellType()) + { + case ::sd::ViewShell::ST_IMPRESS: + case ::sd::ViewShell::ST_DRAW: + case ::sd::ViewShell::ST_NOTES: + case ::sd::ViewShell::ST_HANDOUT: + mpToolBarManager->SetToolBar( + ToolBarManager::TBG_FUNCTION, + ToolBarManager::msDrawingObjectToolBar); + break; + default: + break; + } + break; + } + } + + if( bTextEdit ) + mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_DRAW_TEXT_TOOLBOX); + + SdrView* pView = &const_cast<SdrView&>(rView); + // Check if the extrusion tool bar and the fontwork tool bar have to + // be activated. + if (svx::checkForSelectedCustomShapes(pView, true /* bOnlyExtruded */ )) + mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_SVX_EXTRUSION_BAR); + sal_uInt32 nCheckStatus = 0; + if (svx::checkForSelectedFontWork(pView, nCheckStatus)) + mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_SVX_FONTWORK_BAR); + + // Switch on additional context-sensitive tool bars. + if (rView.GetContext() == SDRCONTEXT_POINTEDIT) + mpToolBarManager->AddToolBarShell(ToolBarManager::TBG_FUNCTION, RID_BEZIER_TOOLBOX); +} + + + + +void ToolBarRules::SubShellAdded ( + ::sd::ToolBarManager::ToolBarGroup eGroup, + sd::ShellId nShellId) +{ + // For some tool bar shells (those defined in sd) we have to add the + // actual tool bar here. + switch (nShellId) + { + case RID_DRAW_GRAF_TOOLBOX: + mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msGraphicObjectBar); + break; + + case RID_DRAW_MEDIA_TOOLBOX: + mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msMediaObjectBar); + break; + + case RID_DRAW_TEXT_TOOLBOX: + mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msTextObjectBar); + break; + + case RID_BEZIER_TOOLBOX: + mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msBezierObjectBar); + break; + + case RID_DRAW_TABLE_TOOLBOX: + mpToolBarManager->AddToolBar(eGroup, ToolBarManager::msTableObjectBar); + break; + } +} + + + + +void ToolBarRules::SubShellRemoved ( + ::sd::ToolBarManager::ToolBarGroup eGroup, + sd::ShellId nShellId) +{ + // For some tool bar shells (those defined in sd) we have to add the + // actual tool bar here. + switch (nShellId) + { + case RID_DRAW_GRAF_TOOLBOX: + mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msGraphicObjectBar); + break; + + case RID_DRAW_MEDIA_TOOLBOX: + mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msMediaObjectBar); + break; + + case RID_DRAW_TEXT_TOOLBOX: + mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msTextObjectBar); + break; + + case RID_BEZIER_TOOLBOX: + mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msBezierObjectBar); + break; + + case RID_DRAW_TABLE_TOOLBOX: + mpToolBarManager->RemoveToolBar(eGroup, ToolBarManager::msTableObjectBar); + break; + } +} + + + + +//===== ToolBarList =========================================================== + +ToolBarList::ToolBarList (void) + : maGroups(), + maActiveToolBars() +{ +} + + + + +void ToolBarList::ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup) +{ + Groups::iterator iGroup (maGroups.find(eGroup)); + if (iGroup != maGroups.end()) + { + if ( ! iGroup->second.empty()) + { + iGroup->second.clear(); + } + } +} + + + + +void ToolBarList::AddToolBar ( + sd::ToolBarManager::ToolBarGroup eGroup, + const ::rtl::OUString& rsName) +{ + Groups::iterator iGroup (maGroups.find(eGroup)); + if (iGroup == maGroups.end()) + iGroup = maGroups.insert(Groups::value_type(eGroup,NameList())).first; + + if (iGroup != maGroups.end()) + { + NameList::const_iterator iBar ( + ::std::find(iGroup->second.begin(),iGroup->second.end(),rsName)); + if (iBar == iGroup->second.end()) + { + iGroup->second.push_back(rsName); + } + } +} + + + + +bool ToolBarList::RemoveToolBar ( + sd::ToolBarManager::ToolBarGroup eGroup, + const ::rtl::OUString& rsName) +{ + Groups::iterator iGroup (maGroups.find(eGroup)); + if (iGroup != maGroups.end()) + { + NameList::iterator iBar ( + ::std::find(iGroup->second.begin(),iGroup->second.end(),rsName)); + if (iBar != iGroup->second.end()) + { + iGroup->second.erase(iBar); + return true; + } + } + return false; +} + + + + +void ToolBarList::MakeRequestedToolBarList (NameList& rRequestedToolBars) const +{ + for (int i=sd::ToolBarManager::TBG__FIRST; i<=sd::ToolBarManager::TBG__LAST; ++i) + { + ::sd::ToolBarManager::ToolBarGroup eGroup = (::sd::ToolBarManager::ToolBarGroup)i; + Groups::const_iterator iGroup (maGroups.find(eGroup)); + if (iGroup != maGroups.end()) + ::std::copy( + iGroup->second.begin(), + iGroup->second.end(), + ::std::inserter(rRequestedToolBars,rRequestedToolBars.end())); + } +} + + + + +void ToolBarList::GetToolBarsToActivate (NameList& rToolBars) const +{ + NameList aRequestedToolBars; + MakeRequestedToolBarList(aRequestedToolBars); + + NameList::const_iterator iToolBar; + for (iToolBar=aRequestedToolBars.begin(); iToolBar!=aRequestedToolBars.end(); ++iToolBar) + { + if (::std::find(maActiveToolBars.begin(),maActiveToolBars.end(),*iToolBar) + == maActiveToolBars.end()) + { + rToolBars.push_back(*iToolBar); + } + } +} + + + + +void ToolBarList::GetToolBarsToDeactivate (NameList& rToolBars) const +{ + NameList aRequestedToolBars; + MakeRequestedToolBarList(aRequestedToolBars); + + NameList::const_iterator iToolBar; + for (iToolBar=maActiveToolBars.begin(); iToolBar!=maActiveToolBars.end(); ++iToolBar) + { + if (::std::find(aRequestedToolBars.begin(),aRequestedToolBars.end(),*iToolBar) + == aRequestedToolBars.end()) + { + rToolBars.push_back(*iToolBar); + } + } +} + + + + +void ToolBarList::MarkToolBarAsActive (const ::rtl::OUString& rsName) +{ + maActiveToolBars.push_back(rsName); +} + + + + +void ToolBarList::MarkToolBarAsNotActive (const ::rtl::OUString& rsName) +{ + maActiveToolBars.erase( + ::std::find(maActiveToolBars.begin(),maActiveToolBars.end(), rsName)); +} + + + + +void ToolBarList::MarkAllToolBarsAsNotActive (void) +{ + maActiveToolBars.clear(); +} + + + + +//===== ToolBarShellList ====================================================== + +ToolBarShellList::ShellDescriptor::ShellDescriptor ( + ShellId nId, + sd::ToolBarManager::ToolBarGroup eGroup) + : mnId(nId), + meGroup(eGroup) +{ +} + + + + +ToolBarShellList::ToolBarShellList (void) +: maNewList() +, maCurrentList() +{ +} + + + + +void ToolBarShellList::ClearGroup (sd::ToolBarManager::ToolBarGroup eGroup) +{ + // In every loop we erase the first member of the specified group. + // Because that invalidates the iterator another loop is started after + // that. The loop is left only when no member of the group is found and + // no element is erased + bool bLoop; + do + { + bLoop = false; + + GroupedShellList::iterator iDescriptor; + for (iDescriptor=maNewList.begin(); iDescriptor!=maNewList.end(); ++iDescriptor) + if (iDescriptor->meGroup == eGroup) + { + maNewList.erase(iDescriptor); + // Erasing the descriptor invalidated the iterator so we + // have to exit the for loop and start anew to search for + // further elements of the group. + bLoop = true; + break; + } + } + while (bLoop); +} + + + + +void ToolBarShellList::AddShellId (sd::ToolBarManager::ToolBarGroup eGroup, sd::ShellId nId) +{ + // Make sure that the shell is not added twice (and possibly in + // different groups.) + ShellDescriptor aDescriptor (nId,eGroup); + GroupedShellList::iterator iDescriptor (maNewList.find(aDescriptor)); + if (iDescriptor != maNewList.end()) + { + // The shell is already requested. + if (iDescriptor->meGroup != eGroup) + { + // It is now being requested for another group. + // (Is this an error?) + // Move it to that group. + maNewList.erase(iDescriptor); + maNewList.insert(aDescriptor); + } + // else nothing to do. + } + else + maNewList.insert(aDescriptor); +} + + + + +void ToolBarShellList::ReleaseAllShells (ToolBarRules& rRules) +{ + // Release the currently active tool bars. + GroupedShellList aList (maCurrentList); + GroupedShellList::iterator iDescriptor; + for (iDescriptor=aList.begin(); iDescriptor!=aList.end(); ++iDescriptor) + { + rRules.SubShellRemoved(iDescriptor->meGroup, iDescriptor->mnId); + } + + // Clear the list of requested tool bars. + maNewList.clear(); +} + + + + +void ToolBarShellList::UpdateShells ( + const ::boost::shared_ptr<ViewShell>& rpMainViewShell, + const ::boost::shared_ptr<ViewShellManager>& rpManager) +{ + if (rpMainViewShell.get() != NULL) + { + GroupedShellList aList; + + // Deactivate shells that are in maCurrentList, but not in + // maNewList. + ::std::set_difference(maCurrentList.begin(), maCurrentList.end(), + maNewList.begin(), maNewList.end(), + std::insert_iterator<GroupedShellList>(aList,aList.begin())); + for (GroupedShellList::iterator iShell=aList.begin(); iShell!=aList.end(); ++iShell) + { +#ifdef VERBOSE + OSL_TRACE("deactivating tool bar shell %d\n", iShell->mnId); +#endif + rpManager->DeactivateSubShell(*rpMainViewShell, iShell->mnId); + } + + // Activate shells that are in maNewList, but not in + // maCurrentList. + aList.clear(); + ::std::set_difference(maNewList.begin(), maNewList.end(), + maCurrentList.begin(), maCurrentList.end(), + std::insert_iterator<GroupedShellList>(aList,aList.begin())); + for (GroupedShellList::iterator iShell=aList.begin(); iShell!=aList.end(); ++iShell) + { +#ifdef VERBOSE + OSL_TRACE("activating tool bar shell %d\n", iShell->mnId); +#endif + rpManager->ActivateSubShell(*rpMainViewShell, iShell->mnId); + } + + // The maNewList now refelects the current state and thus is made + // maCurrentList. + maCurrentList = maNewList; + } +} + + + + +} // end of anonymous namespace diff --git a/sd/source/ui/view/UpdateLockManager.cxx b/sd/source/ui/view/UpdateLockManager.cxx new file mode 100644 index 000000000000..f373042f627b --- /dev/null +++ b/sd/source/ui/view/UpdateLockManager.cxx @@ -0,0 +1,429 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "UpdateLockManager.hxx" + +#include "MutexOwner.hxx" +#include "ViewShellBase.hxx" +#include <com/sun/star/frame/XLayoutManager.hpp> +#include <com/sun/star/frame/XLayoutManagerEventBroadcaster.hpp> +#include <com/sun/star/frame/LayoutManagerEvents.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <cppuhelper/compbase1.hxx> + +#include <vcl/timer.hxx> +#include <sfx2/viewfrm.hxx> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star; + +namespace { +typedef cppu::WeakComponentImplHelper1<frame::XLayoutManagerListener> InterfaceBase; +} + +namespace sd { + + +/** This implementation class not only implements the Lock() and Unlock() + methods but as well listens for the right combination of events to call + Unlock() when all is ready after the PaneManager has switched (some of) + its view shells. +*/ + +class UpdateLockManager::Implementation + : protected MutexOwner, + public InterfaceBase +{ +public: + Implementation (ViewShellBase& rBase); + virtual ~Implementation (void); + + void Lock (void); + void Unlock (void); + bool IsLocked (void) const; + + /** Unlock regardless of the current lock level. + */ + void ForceUnlock (void); + +private: + ViewShellBase& mrBase; + /// A lock level greater than 0 indicates that the ViewShellBase is locked. + sal_Int32 mnLockDepth; + /// The emergency timer to unlock the ViewShellBase when all else fails. + Timer maTimer; + /// Remember when to unlock after a layout event from frame::XLayoutManager + bool mbUnlockOnNextLayout; + /// Remember whether we are listening to the frame::XLayoutManager + bool mbListenerIsRegistered; + /// Remember whether the frame::XLayoutManager is locked. + bool mbLayouterIsLocked; + /** We hold a weak reference to the layout manager in order to have + access to it even when the ViewShellBase object is not valid anymore + and can not be used to obtain the layout manager. + */ + WeakReference<frame::XLayoutManager> mxLayoutManager; + + //===== frame::XLayoutEventListener ===================================== + + /** The event of the layouter are observed to find the best moment for + unlocking. This is the first layout after the lock level of the + layouter drops to one (we hold a lock to it ourselves which we + release when unlocking). + */ + virtual void SAL_CALL layoutEvent ( + const lang::EventObject& xSource, + sal_Int16 eLayoutEvent, + const Any& rInfo) + throw (uno::RuntimeException); + + //===== lang::XEventListener ============================================ + virtual void SAL_CALL + disposing (const lang::EventObject& rEventObject) + throw (::com::sun::star::uno::RuntimeException); + + virtual void SAL_CALL disposing (void); + + /** This is only a fallback to make the office usable when for some + reason the intended way of unlocking it failed. + */ + DECL_LINK(Timeout, void*); + + /** Convenience method that finds the layout manager associated with the + frame that shows the ViewShellBase. + */ + Reference<frame::XLayoutManager> GetLayoutManager (void); + + Implementation (const Implementation&); // Not implemented. + Implementation& operator= (const Implementation&); // Not implemented. +}; + + + + +//===== UpdateLockManager ===================================================== + +UpdateLockManager::UpdateLockManager (ViewShellBase& rBase) + : mpImpl(new Implementation(rBase)) +{ + mpImpl->acquire(); +} + + + +UpdateLockManager::~UpdateLockManager (void) +{ + if (mpImpl != NULL) + { + mpImpl->ForceUnlock(); + mpImpl->release(); + } +} + + + + +void UpdateLockManager::Disable (void) +{ + if (mpImpl != NULL) + { + mpImpl->ForceUnlock(); + mpImpl->release(); + mpImpl = NULL; + } +} + + + + +void UpdateLockManager::Lock (void) +{ + if (mpImpl != NULL) + mpImpl->Lock(); +} + + + + +void UpdateLockManager::Unlock (void) +{ + if (mpImpl != NULL) + mpImpl->Unlock(); +} + + + + +bool UpdateLockManager::IsLocked (void) const +{ + if (mpImpl != NULL) + return mpImpl->IsLocked(); + else + return false; +} + + + +//===== UpdateLock::Implementation ============================================ + +UpdateLockManager::Implementation::Implementation (ViewShellBase& rBase) + : InterfaceBase(maMutex), + mrBase(rBase), + mnLockDepth(0), + maTimer(), + mbUnlockOnNextLayout(false), + mbListenerIsRegistered(false), + mbLayouterIsLocked(false) +{ +} + + + + +UpdateLockManager::Implementation::~Implementation (void) +{ + OSL_ASSERT(mnLockDepth==0); + ForceUnlock(); +} + + + + +void UpdateLockManager::Implementation::Lock (void) +{ + ++mnLockDepth; + if (mnLockDepth == 1) + { + Reference<frame::XLayoutManager> xLayouter (GetLayoutManager()); + if (xLayouter.is()) + { + // Register as event listener. + Reference<frame::XLayoutManagerEventBroadcaster> xBroadcaster ( + xLayouter, UNO_QUERY); + if (xBroadcaster.is()) + { + mbListenerIsRegistered = true; + xBroadcaster->addLayoutManagerEventListener( + Reference<frame::XLayoutManagerListener> ( + static_cast<XWeak*>(this), UNO_QUERY) ); + } + + // Lock the layout manager. + mbLayouterIsLocked = true; + xLayouter->lock(); + } + + // As a fallback, when the notification mechanism does not work (or is + // incorrectly used) we use a timer that will unlock us eventually. + maTimer.SetTimeout(5000 /*ms*/); + maTimer.SetTimeoutHdl(LINK(this,UpdateLockManager::Implementation,Timeout)); + maTimer.Start(); + } +} + + + + +void UpdateLockManager::Implementation::Unlock (void) +{ + --mnLockDepth; + + if (mnLockDepth == 0) + { + // Stop the timer. We don't need it anymore. + maTimer.Stop(); + + try + { + Reference<frame::XLayoutManager> xLayouter (GetLayoutManager()); + if (xLayouter.is()) + { + // Detach from the layouter. + if (mbListenerIsRegistered) + { + Reference<frame::XLayoutManagerEventBroadcaster> xBroadcaster ( + xLayouter, UNO_QUERY); + if (xBroadcaster.is()) + { + mbListenerIsRegistered = false; + xBroadcaster->removeLayoutManagerEventListener( + Reference<frame::XLayoutManagerListener> ( + static_cast<XWeak*>(this), UNO_QUERY) ); + } + } + + // Unlock the layouter. + if (mbLayouterIsLocked) + { + mbLayouterIsLocked = false; + xLayouter->unlock(); + } + } + } + catch (RuntimeException) + { } + + // Force a rearrangement of the UI elements of the views. + mrBase.Rearrange(); + } +} + + + + +bool UpdateLockManager::Implementation::IsLocked (void) const +{ + return (mnLockDepth > 0); +} + + + + +void UpdateLockManager::Implementation::ForceUnlock (void) +{ + while (IsLocked()) + Unlock(); +} + + + + +void SAL_CALL UpdateLockManager::Implementation::layoutEvent ( + const lang::EventObject&, + sal_Int16 eLayoutEvent, + const Any& rInfo) + throw (uno::RuntimeException) +{ + switch (eLayoutEvent) + { + case frame::LayoutManagerEvents::LOCK: + { + sal_Int32 nLockCount; + rInfo >>= nLockCount; + } + break; + + case frame::LayoutManagerEvents::UNLOCK: + { + sal_Int32 nLockCount = 0; + rInfo >>= nLockCount; + if (nLockCount == 1) + { + // The lock count dropped to one. This means that we are + // the only one that still holds a lock to the layout + // manager. We unlock the layout manager now and the + // ViewShellBase on the next layout of the layout manager. + mbUnlockOnNextLayout = true; + Reference<frame::XLayoutManager> xLayouter (GetLayoutManager()); + if (xLayouter.is() && mbLayouterIsLocked) + { + mbLayouterIsLocked = false; + xLayouter->unlock(); + } + } + } + break; + + case frame::LayoutManagerEvents::LAYOUT: + // Unlock when the layout manager is not still locked. + if (mbUnlockOnNextLayout) + Unlock(); + break; + } +} + + + + +void SAL_CALL UpdateLockManager::Implementation::disposing (const lang::EventObject& ) + throw (::com::sun::star::uno::RuntimeException) +{ +} + + + + +void SAL_CALL UpdateLockManager::Implementation::disposing (void) +{ +} + + + + +IMPL_LINK(UpdateLockManager::Implementation, Timeout, void*, EMPTYARG) +{ + // This method is only called when all else failed. We unlock + // regardless of how deep the lock depth. + while (mnLockDepth > 0) + Unlock(); + return 1; +} + + + + +Reference< ::com::sun::star::frame::XLayoutManager> + UpdateLockManager::Implementation::GetLayoutManager (void) +{ + Reference<frame::XLayoutManager> xLayoutManager; + + if (mxLayoutManager.get() == NULL) + { + if (mrBase.GetViewFrame()!=NULL) + { + Reference<beans::XPropertySet> xFrameProperties ( + mrBase.GetViewFrame()->GetFrame().GetFrameInterface(), + UNO_QUERY); + if (xFrameProperties.is()) + { + try + { + Any aValue (xFrameProperties->getPropertyValue( + ::rtl::OUString::createFromAscii("LayoutManager"))); + aValue >>= xLayoutManager; + } + catch (const beans::UnknownPropertyException& rException) + { + (void)rException; + } + } + mxLayoutManager = xLayoutManager; + } + } + else + xLayoutManager = mxLayoutManager; + + return xLayoutManager; +} + + + + +} // end of anonymous namespace diff --git a/sd/source/ui/view/ViewClipboard.cxx b/sd/source/ui/view/ViewClipboard.cxx new file mode 100755 index 000000000000..ab108fd1991a --- /dev/null +++ b/sd/source/ui/view/ViewClipboard.cxx @@ -0,0 +1,278 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "ViewClipboard.hxx" + +#include "DrawDocShell.hxx" +#include "View.hxx" +#include "ViewShell.hxx" +#include "Window.hxx" + +#include "drawdoc.hxx" +#include "sdpage.hxx" +#include "sdxfer.hxx" +#include "sdresid.hxx" +#include "glob.hrc" + +#include <svx/svdpagv.hxx> +#include <vos/mutex.hxx> +#include <vcl/svapp.hxx> + +namespace sd { + +ViewClipboard::ViewClipboard (::sd::View& rView) + : mrView(rView) +{ +} + + + + +ViewClipboard::~ViewClipboard (void) +{ +} + + + + +void ViewClipboard::HandlePageDrop (const SdTransferable& rTransferable) +{ + // Determine whether to insert the given set of slides or to assign a + // given master page. + SdPage* pMasterPage = GetFirstMasterPage (rTransferable); + if (pMasterPage != NULL) + AssignMasterPage (rTransferable, pMasterPage); + else + InsertSlides (rTransferable, DetermineInsertPosition (rTransferable)); +} + + + + +SdPage* ViewClipboard::GetFirstMasterPage (const SdTransferable& rTransferable) +{ + SdPage* pFirstMasterPage = NULL; + + if (rTransferable.HasPageBookmarks()) + { + do + { + const List* pBookmarks = &rTransferable.GetPageBookmarks(); + if (pBookmarks == NULL) + break; + + DrawDocShell* pDocShell = rTransferable.GetPageDocShell(); + if (pDocShell == NULL) + break; + + SdDrawDocument* pDocument = pDocShell->GetDoc(); + if (pDocument == NULL) + break; + + if (pBookmarks->Count() <= 0) + break; + + int nBookmarkCount = pBookmarks->Count(); + for (int nIndex=0; nIndex<nBookmarkCount; nIndex++) + { + String sName (*(String*) pBookmarks->GetObject(nIndex)); + BOOL bIsMasterPage; + + // SdPage* GetMasterSdPage(USHORT nPgNum, PageKind ePgKind); + // USHORT GetMasterSdPageCount(PageKind ePgKind) const; + + USHORT nBMPage = pDocument->GetPageByName ( + sName, bIsMasterPage); + if ( ! bIsMasterPage) + { + // At least one regular slide: return NULL to indicate + // that not all bookmarks point to master pages. + pFirstMasterPage = NULL; + break; + } + else if (pFirstMasterPage == NULL) + { + // Remember the first master page for later. + if (nBMPage != SDRPAGE_NOTFOUND) + pFirstMasterPage = static_cast<SdPage*>( + pDocument->GetMasterPage(nBMPage)); + } + } + } + while (false); + } + + return pFirstMasterPage; +} + + + + +void ViewClipboard::AssignMasterPage ( + const SdTransferable& rTransferable, + SdPage* pMasterPage) +{ + do + { + if (pMasterPage == NULL) + return; + + // Get the target page to which the master page is assigned. + SdrPageView* pPageView = mrView.GetSdrPageView(); + if (pPageView == NULL) + break; + + SdPage* pPage = static_cast<SdPage*>(pPageView->GetPage()); + if (pPage == NULL) + break; + + SdDrawDocument* pDocument = mrView.GetDoc(); + if (pDocument == NULL) + break; + + if ( ! rTransferable.HasPageBookmarks()) + break; + + DrawDocShell* pDataDocShell = rTransferable.GetPageDocShell(); + if (pDataDocShell == NULL) + break; + + SdDrawDocument* pSourceDocument = pDataDocShell->GetDoc(); + if (pSourceDocument == NULL) + break; + + // We have to remove the layout suffix from the layout name which is + // appended again by SetMasterPage() to the given name. Don't ask. + String sLayoutSuffix (RTL_CONSTASCII_STRINGPARAM(SD_LT_SEPARATOR)); + sLayoutSuffix.Append (SdResId(STR_LAYOUT_OUTLINE)); + USHORT nLength = sLayoutSuffix.Len(); + String sLayoutName (pMasterPage->GetLayoutName()); + if (String(sLayoutName, sLayoutName.Len()-nLength, nLength).Equals ( + sLayoutSuffix)) + sLayoutName = String(sLayoutName, 0, sLayoutName.Len()-nLength); + + pDocument->SetMasterPage ( + pPage->GetPageNum() / 2, + sLayoutName, + pSourceDocument, + FALSE, // Exchange the master page of only the target page. + FALSE // Keep unused master pages. + ); + } + while (false); +} + + + + +USHORT ViewClipboard::DetermineInsertPosition ( + const SdTransferable& ) +{ + SdDrawDocument* pDoc = mrView.GetDoc(); + USHORT nPgCnt = pDoc->GetSdPageCount( PK_STANDARD ); + + // Insert position is the behind the last selected page or behind the + // last page when the selection is empty. + USHORT nInsertPos = pDoc->GetSdPageCount( PK_STANDARD ) * 2 + 1; + for( USHORT nPage = 0; nPage < nPgCnt; nPage++ ) + { + SdPage* pPage = pDoc->GetSdPage( nPage, PK_STANDARD ); + + if( pPage->IsSelected() ) + nInsertPos = nPage * 2 + 3; + } + + return nInsertPos; +} + + + + +USHORT ViewClipboard::InsertSlides ( + const SdTransferable& rTransferable, + USHORT nInsertPosition) +{ + SdDrawDocument* pDoc = mrView.GetDoc(); + + USHORT nInsertPgCnt = 0; + BOOL bMergeMasterPages = !rTransferable.HasSourceDoc( pDoc ); + + // Prepare the insertion. + const List* pBookmarkList; + DrawDocShell* pDataDocSh; + if (rTransferable.HasPageBookmarks()) + { + // When the transferable contains page bookmarks then the referenced + // pages are inserted. + pBookmarkList = &rTransferable.GetPageBookmarks(); + pDataDocSh = rTransferable.GetPageDocShell(); + nInsertPgCnt = (USHORT)pBookmarkList->Count(); + } + else + { + // Otherwise all pages of the document of the transferable are + // inserted. + SfxObjectShell* pShell = rTransferable.GetDocShell(); + pDataDocSh = (DrawDocShell*) pShell; + SdDrawDocument* pDataDoc = pDataDocSh->GetDoc(); + pBookmarkList = NULL; + if (pDataDoc!=NULL && pDataDoc->GetSdPageCount(PK_STANDARD)) + nInsertPgCnt = pDataDoc->GetSdPageCount(PK_STANDARD); + } + if (nInsertPgCnt > 0) + { + const ::vos::OGuard aGuard( Application::GetSolarMutex() ); + ::sd::Window* pWin = mrView.GetViewShell()->GetActiveWindow(); + const BOOL bWait = pWin && pWin->IsWait(); + + if( bWait ) + pWin->LeaveWait(); + + pDoc->InsertBookmarkAsPage( + const_cast<List*>(pBookmarkList), + NULL, + FALSE, + FALSE, + nInsertPosition, + (&rTransferable == SD_MOD()->pTransferDrag), + pDataDocSh, + TRUE, + bMergeMasterPages, + FALSE); + + if( bWait ) + pWin->EnterWait(); + } + + return nInsertPgCnt; +} + + +} // end of namespace ::sd diff --git a/sd/source/ui/view/ViewShellBase.cxx b/sd/source/ui/view/ViewShellBase.cxx new file mode 100644 index 000000000000..1e18ad5c5ee9 --- /dev/null +++ b/sd/source/ui/view/ViewShellBase.cxx @@ -0,0 +1,1787 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include <comphelper/processfactory.hxx> + +#include <com/sun/star/frame/UnknownModuleException.hpp> +#include <com/sun/star/frame/XModuleManager.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> + +#include "ViewShellBase.hxx" +#include <algorithm> +#include "EventMultiplexer.hxx" +#include "cache/SlsPageCacheManager.hxx" +#include "sdresid.hxx" +#include "app.hrc" +#include "strings.hrc" +#include "glob.hrc" +#include "unokywds.hxx" +#include <svx/svxids.hrc> +#include "DrawDocShell.hxx" +#include <sfx2/app.hxx> +#include "PaneChildWindows.hxx" +#include "NotesChildWindow.hxx" +#include "ViewShellManager.hxx" +#include "DrawController.hxx" +#include "UpdateLockManager.hxx" +#include "FrameView.hxx" +#include "ViewTabBar.hxx" +#include <sfx2/event.hxx> +#include "drawdoc.hxx" +#include <sfx2/dispatch.hxx> +#include <sfx2/request.hxx> +#include <sfx2/printer.hxx> +#include "DrawViewShell.hxx" +#include "GraphicViewShell.hxx" +#include "OutlineViewShell.hxx" +#include "SlideSorterViewShell.hxx" +#include "PresentationViewShell.hxx" +#include "FormShellManager.hxx" +#include "ToolBarManager.hxx" +#include "taskpane/PanelId.hxx" +#include "Window.hxx" +#include "framework/ConfigurationController.hxx" +#include "DocumentRenderer.hxx" + +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/frame/XController.hpp> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/document/XViewDataSupplier.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/drawing/XDrawPagesSupplier.hpp> +#include <com/sun/star/drawing/XMasterPagesSupplier.hpp> +#include <com/sun/star/drawing/framework/XControllerManager.hpp> +#include <com/sun/star/drawing/framework/XConfigurationController.hpp> +#include <com/sun/star/drawing/framework/ResourceId.hpp> +#include "framework/FrameworkHelper.hxx" + +#include <rtl/ref.hxx> +#include <sfx2/msg.hxx> +#include <sfx2/objface.hxx> +#include <sfx2/viewfrm.hxx> +#include <svl/whiter.hxx> +#include <comphelper/processfactory.hxx> +#include <vcl/msgbox.hxx> +#include <tools/diagnose_ex.h> + +#include "fubullet.hxx" + +using namespace sd; +#define ViewShellBase +#include "sdslots.hxx" + +using ::sd::framework::FrameworkHelper; +using ::rtl::OUString; +using namespace com::sun::star::uno; +using namespace com::sun::star::frame; +using namespace com::sun::star::container; +using namespace com::sun::star::lang; +using namespace com::sun::star::beans; + +namespace { + +class CurrentPageSetter +{ +public: + CurrentPageSetter (ViewShellBase& rBase); + void operator () (bool); +private: + ViewShellBase& mrBase; +}; + +} // end of anonymous namespace + + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::drawing::framework; +using ::sd::framework::FrameworkHelper; + +namespace sd { + +class ViewShellBase::Implementation +{ +public: + /** Main controller of the view shell. During the switching from one + stacked shell to another this pointer may be NULL. + */ + ::rtl::Reference<DrawController> mpController; + + /** The view tab bar is the control for switching between different + views in one pane. + */ + ::rtl::Reference<ViewTabBar> mpViewTabBar; + + // contains the complete area of the current view relative to the frame window + Rectangle maClientArea; + + // This is set to true when PrepareClose() is called. + bool mbIsClosing; + + /** The view window is the parent of all UI elements that belong to the + view or ViewShell. This comprises the rulers, the scroll bars, and + the content window. + It does not include the ViewTabBar. + */ + ::boost::scoped_ptr< ::Window> mpViewWindow; + + ::boost::shared_ptr<ToolBarManager> mpToolBarManager; + + ::boost::shared_ptr<ViewShellManager> mpViewShellManager; + + ::boost::shared_ptr<tools::EventMultiplexer> mpEventMultiplexer; + + ::boost::shared_ptr<UpdateLockManager> mpUpdateLockManager; + + ::boost::shared_ptr<FormShellManager> mpFormShellManager; + + Implementation (ViewShellBase& rBase); + ~Implementation (void); + + void LateInit (void); + + /** Show or hide the ViewTabBar. + @param bShow + When <TRUE/> then the ViewTabBar is shown, otherwise it is hidden. + */ + void ShowViewTabBar (bool bShow); + + /** Common code of ViewShellBase::OuterResizePixel() and + ViewShellBase::InnerResizePixel(). + */ + void ResizePixel ( + const Point& rOrigin, + const Size& rSize, + bool bOuterResize); + + /** Show or hide the specified pane. The visibility state is taken + fromthe given request. + @param rRequest + The request determines the new visibility state. The state can + either be toggled or be set to a given value. + @param rsPaneURL + This URL specifies the pane whose visibility state to set. + @param rsViewURL + When the pane becomes visible then this view URL specifies which + type of view to show in it. + */ + void SetPaneVisibility ( + const SfxRequest& rRequest, + const ::rtl::OUString& rsPaneURL, + const ::rtl::OUString& rsViewURL); + + void GetSlotState (SfxItemSet& rSet); + + void ProcessRestoreEditingViewSlot (void); + void ProcessTaskPaneSlot (SfxRequest& rRequest); + +private: + ViewShellBase& mrBase; + + /** Hold a reference to the page cache manager of the slide sorter in + order to ensure that it stays alive while the ViewShellBase is + alive. + */ + ::boost::shared_ptr<slidesorter::cache::PageCacheManager> mpPageCacheManager; +}; + + +namespace { +/** The only task of this window is to forward key presses to the content + window of the main view shell. With the key press it forwards the focus + so that it is not called very often. +*/ +class FocusForwardingWindow : public ::Window +{ +public: + FocusForwardingWindow (::Window& rParentWindow, ViewShellBase& rBase); + virtual ~FocusForwardingWindow (void); + virtual void KeyInput (const KeyEvent& rEvent); + virtual void Command (const CommandEvent& rEvent); + +private: + ViewShellBase& mrBase; +}; +} // end of anonymous namespace + + +//===== ViewShellBase ========================================================= + +TYPEINIT1(ViewShellBase, SfxViewShell); + +// We have to expand the SFX_IMPL_VIEWFACTORY macro to call LateInit() after a +// new ViewShellBase object has been constructed. + +/* +SFX_IMPL_VIEWFACTORY(ViewShellBase, SdResId(STR_DEFAULTVIEW)) +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} +*/ +SfxViewFactory* ViewShellBase::pFactory; +SfxViewShell* __EXPORT ViewShellBase::CreateInstance ( + SfxViewFrame *pFrame, SfxViewShell *pOldView) +{ + ViewShellBase* pBase = new ViewShellBase(pFrame, pOldView); + pBase->LateInit(OUString()); + return pBase; +} +void ViewShellBase::RegisterFactory( USHORT nPrio ) +{ + pFactory = new SfxViewFactory( + &CreateInstance,&InitFactory,nPrio,SdResId(STR_DEFAULTVIEW)); + InitFactory(); +} +void ViewShellBase::InitFactory() +{ + SFX_VIEW_REGISTRATION(DrawDocShell); +} + + + +SFX_IMPL_INTERFACE(ViewShellBase, SfxViewShell, SdResId(STR_VIEWSHELLBASE)) +{ +} + + + + +ViewShellBase::ViewShellBase ( + SfxViewFrame* _pFrame, + SfxViewShell*) + : SfxViewShell (_pFrame, + SFX_VIEW_CAN_PRINT + | SFX_VIEW_HAS_PRINTOPTIONS), + maMutex(), + mpImpl(), + mpDocShell (NULL), + mpDocument (NULL) +{ + mpImpl.reset(new Implementation(*this)); + mpImpl->mpViewWindow.reset(new FocusForwardingWindow(_pFrame->GetWindow(),*this)); + mpImpl->mpViewWindow->SetBackground(Wallpaper()); + mpImpl->mpUpdateLockManager.reset(new UpdateLockManager(*this)); + + _pFrame->GetWindow().SetBackground(Wallpaper()); + + // Set up the members in the correct order. + if (GetViewFrame()->GetObjectShell()->ISA(DrawDocShell)) + mpDocShell = static_cast<DrawDocShell*>( + GetViewFrame()->GetObjectShell()); + if (mpDocShell != NULL) + mpDocument = mpDocShell->GetDoc(); + mpImpl->mpViewShellManager.reset(new ViewShellManager(*this)); + + SetWindow(mpImpl->mpViewWindow.get()); + + // Hide the window to avoid complaints from Sfx...SwitchViewShell... + _pFrame->GetWindow().Hide(); +} + + + + +/** In this destructor the order in which some of the members are destroyed + (and/or being prepared to being destroyed) is important. Change it only + when you know what you are doing. +*/ +ViewShellBase::~ViewShellBase (void) +{ + // Tell the controller that the ViewShellBase is not available anymore. + if (mpImpl->mpController.get() != NULL) + mpImpl->mpController->ReleaseViewShellBase(); + + // We have to hide the main window to prevent SFX complaining after a + // reload about it being already visible. + ViewShell* pShell = GetMainViewShell().get(); + if (pShell!=NULL + && pShell->GetActiveWindow()!=NULL + && pShell->GetActiveWindow()->GetParent()!=NULL) + { + pShell->GetActiveWindow()->GetParent()->Hide(); + } + + mpImpl->mpUpdateLockManager->Disable(); + mpImpl->mpToolBarManager->Shutdown(); + mpImpl->mpViewShellManager->Shutdown(); + + EndListening(*GetViewFrame()); + EndListening(*GetDocShell()); + + SetWindow(NULL); +} + + + + +void ViewShellBase::LateInit (const ::rtl::OUString& rsDefaultView) +{ + StartListening(*GetViewFrame(),TRUE); + StartListening(*GetDocShell(),TRUE); + mpImpl->LateInit(); + InitializeFramework(); + + mpImpl->mpEventMultiplexer.reset(new tools::EventMultiplexer (*this)); + + mpImpl->mpFormShellManager.reset(new FormShellManager(*this)); + + mpImpl->mpToolBarManager = ToolBarManager::Create( + *this, + mpImpl->mpEventMultiplexer, + mpImpl->mpViewShellManager); + + try + { + Reference<XControllerManager> xControllerManager (GetDrawController(), UNO_QUERY_THROW); + Reference<XConfigurationController> xConfigurationController ( + xControllerManager->getConfigurationController()); + if (xConfigurationController.is()) + { + OUString sView (rsDefaultView); + if (sView.getLength() == 0) + sView = GetInitialViewShellType(); + + ::boost::shared_ptr<FrameworkHelper> pHelper (FrameworkHelper::Instance(*this)); + + // Create the resource ids for the center pane and view. + const Reference<drawing::framework::XResourceId> xCenterPaneId ( + pHelper->CreateResourceId(FrameworkHelper::msCenterPaneURL)); + const Reference<drawing::framework::XResourceId> xCenterViewId ( + pHelper->CreateResourceId(sView, xCenterPaneId)); + + // Request center pane and view. + xConfigurationController->requestResourceActivation(xCenterPaneId, ResourceActivationMode_ADD); + xConfigurationController->requestResourceActivation(xCenterViewId, ResourceActivationMode_REPLACE); + + // Process configuration events synchronously until the center view + // has been created. + sd::framework::ConfigurationController* pConfigurationController + = dynamic_cast<sd::framework::ConfigurationController*>(xConfigurationController.get()); + if (pConfigurationController != NULL) + { + while ( + ! pConfigurationController->getResource(xCenterViewId).is() + && pConfigurationController->hasPendingRequests()) + { + pConfigurationController->ProcessEvent(); + } + } + } + } + catch (RuntimeException&) + {} + + // AutoLayouts have to be ready. + GetDocument()->StopWorkStartupDelay(); + + UpdateBorder(); + + // Remember the type of the current main view shell in the frame view. + ViewShell* pViewShell = GetMainViewShell().get(); + if (pViewShell != NULL) + { + FrameView* pFrameView = pViewShell->GetFrameView(); + if (pFrameView != NULL) + pFrameView->SetViewShellTypeOnLoad(pViewShell->GetShellType()); + } +} + + + + +::boost::shared_ptr<ViewShellManager> ViewShellBase::GetViewShellManager (void) const +{ + return mpImpl->mpViewShellManager; +} + + + + +::boost::shared_ptr<ViewShell> ViewShellBase::GetMainViewShell (void) const +{ + ::boost::shared_ptr<ViewShell> pMainViewShell ( + framework::FrameworkHelper::Instance(*const_cast<ViewShellBase*>(this)) + ->GetViewShell(framework::FrameworkHelper::msCenterPaneURL)); + if (pMainViewShell.get() == NULL) + pMainViewShell = framework::FrameworkHelper::Instance(*const_cast<ViewShellBase*>(this)) + ->GetViewShell(framework::FrameworkHelper::msFullScreenPaneURL); + return pMainViewShell; +} + + + + +ViewShellBase* ViewShellBase::GetViewShellBase (SfxViewFrame* pViewFrame) +{ + ViewShellBase* pBase = NULL; + + if (pViewFrame != NULL) + { + // Get the view shell for the frame and cast it to + // sd::ViewShellBase. + SfxViewShell* pSfxViewShell = pViewFrame->GetViewShell(); + if (pSfxViewShell!=NULL && pSfxViewShell->ISA(::sd::ViewShellBase)) + pBase = static_cast<ViewShellBase*>(pSfxViewShell); + } + + return pBase; +} + + + + +DrawDocShell* ViewShellBase::GetDocShell (void) const +{ + return mpDocShell; +} + + + +SdDrawDocument* ViewShellBase::GetDocument (void) const +{ + return mpDocument; +} + + + + +void ViewShellBase::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + SfxViewShell::Notify(rBC, rHint); + + if (rHint.IsA(TYPE(SfxEventHint))) + { + switch (static_cast<const SfxEventHint&>(rHint).GetEventId()) + { + case SFX_EVENT_OPENDOC: + if( GetDocument() && GetDocument()->IsStartWithPresentation() ) + { + if( GetViewFrame() ) + { + GetDocument()->SetStartWithPresentation( false ); + GetViewFrame()->GetDispatcher()->Execute( + SID_PRESENTATION, SFX_CALLMODE_ASYNCHRON ); + } + } + else + { + // mpPaneManager->InitPanes(); + } + break; + + default: + break; + } + } +} + + + + +void ViewShellBase::InitializeFramework (void) +{ +} + + + + +void ViewShellBase::InnerResizePixel (const Point& rOrigin, const Size &rSize) +{ + Size aObjSize = GetObjectShell()->GetVisArea().GetSize(); + if ( aObjSize.Width() > 0 && aObjSize.Height() > 0 ) + { + SvBorder aBorder( GetBorderPixel() ); + Size aSize( rSize ); + aSize.Width() -= (aBorder.Left() + aBorder.Right()); + aSize.Height() -= (aBorder.Top() + aBorder.Bottom()); + Size aObjSizePixel = mpImpl->mpViewWindow->LogicToPixel( aObjSize, MAP_100TH_MM ); + SfxViewShell::SetZoomFactor( + Fraction( aSize.Width(), std::max( aObjSizePixel.Width(), (long int)1 ) ), + Fraction( aSize.Height(), std::max( aObjSizePixel.Height(), (long int)1) ) ); + } + + mpImpl->ResizePixel(rOrigin, rSize, false); +} + + + + +void ViewShellBase::OuterResizePixel (const Point& rOrigin, const Size &rSize) +{ + mpImpl->ResizePixel (rOrigin, rSize, true); +} + + + + +void ViewShellBase::Rearrange (void) +{ + OSL_ASSERT(GetViewFrame()!=NULL); + + // There is a bug in the communication between embedded objects and the + // framework::LayoutManager that leads to missing resize updates. The + // following workaround enforces such an update by cycling the border to + // zero and back to the current value. + if (GetWindow() != NULL) + { + SetBorderPixel(SvBorder()); + UpdateBorder(true); + } + else + { + OSL_TRACE("Rearrange: window missing"); + } + + GetViewFrame()->Resize(TRUE); +} + + + + +ErrCode ViewShellBase::DoVerb (long nVerb) +{ + ErrCode aResult = ERRCODE_NONE; + + ::sd::ViewShell* pShell = GetMainViewShell().get(); + if (pShell != NULL) + aResult = pShell->DoVerb (nVerb); + + return aResult; +} + + + + +Reference<view::XRenderable> ViewShellBase::GetRenderable (void) +{ + // Create a new DocumentRenderer on every call. It observes the life + // time of this ViewShellBase object. + return Reference<view::XRenderable>(new DocumentRenderer(*this)); +} + + + + +SfxPrinter* ViewShellBase::GetPrinter (BOOL bCreate) +{ + OSL_ASSERT(mpImpl.get()!=NULL); + + return GetDocShell()->GetPrinter (bCreate); +} + + + + +USHORT ViewShellBase::SetPrinter ( + SfxPrinter* pNewPrinter, + USHORT nDiffFlags, + bool bIsAPI) +{ + OSL_ASSERT(mpImpl.get()!=NULL); + + GetDocShell()->SetPrinter(pNewPrinter); + + if ( (nDiffFlags & SFX_PRINTER_CHG_ORIENTATION || + nDiffFlags & SFX_PRINTER_CHG_SIZE) && pNewPrinter ) + { + MapMode aMap = pNewPrinter->GetMapMode(); + aMap.SetMapUnit(MAP_100TH_MM); + MapMode aOldMap = pNewPrinter->GetMapMode(); + pNewPrinter->SetMapMode(aMap); + Size aNewSize = pNewPrinter->GetOutputSize(); + + BOOL bScaleAll = FALSE; + if ( bIsAPI ) + { + WarningBox aWarnBox ( + GetWindow(), + (WinBits)(WB_YES_NO | WB_DEF_YES), + String(SdResId(STR_SCALE_OBJS_TO_PAGE))); + bScaleAll = (aWarnBox.Execute() == RET_YES); + } + + ::boost::shared_ptr<DrawViewShell> pDrawViewShell ( + ::boost::dynamic_pointer_cast<DrawViewShell>(GetMainViewShell())); + if (pDrawViewShell) + { + SdPage* pPage = GetDocument()->GetSdPage( + 0, PK_STANDARD ); + pDrawViewShell->SetPageSizeAndBorder ( + pDrawViewShell->GetPageKind(), + aNewSize, + -1,-1,-1,-1, + bScaleAll, + pNewPrinter->GetOrientation(), + pPage->GetPaperBin(), + pPage->IsBackgroundFullSize()); + } + + pNewPrinter->SetMapMode(aOldMap); + } + + return 0; +} + + + + +PrintDialog* ViewShellBase::CreatePrintDialog (::Window *pParent) +{ + (void)pParent; + return NULL; + // return mpImpl->mpPrintManager->CreatePrintDialog (pParent); +} + + + + +SfxTabPage* ViewShellBase::CreatePrintOptionsPage( + ::Window *pParent, + const SfxItemSet &rOptions) +{ + (void)pParent; + (void)rOptions; + return NULL; + // return mpImpl->mpPrintManager->CreatePrintOptionsPage (pParent, rOptions); +} + + + + +USHORT ViewShellBase::Print(SfxProgress&, BOOL bIsAPI, PrintDialog* pDlg) +{ + (void)bIsAPI; + (void)pDlg; + return 0; + // return mpImpl->mpPrintManager->Print (rProgress, bIsAPI, pDlg); +} + + + + +ErrCode ViewShellBase::DoPrint ( + SfxPrinter* pPrinter, + PrintDialog* pPrintDialog, + BOOL bSilent, BOOL bIsAPI ) +{ + (void)pPrinter; + (void)pPrintDialog; + (void)bSilent; + (void)bIsAPI; + return 0; + //return mpImpl->mpPrintManager->DoPrint (pPrinter, pPrintDialog, bSilent, bIsAPI ); +} + + + + +void ViewShellBase::PreparePrint (PrintDialog* pPrintDialog) +{ + SfxViewShell::PreparePrint (pPrintDialog); + //mpImpl->mpPrintManager->PreparePrint (pPrintDialog); +} + + + + +void ViewShellBase::UIActivating( SfxInPlaceClient* pClient ) +{ + mpImpl->ShowViewTabBar(false); + + ViewShell* pViewShell = GetMainViewShell().get(); + if ( pViewShell ) + pViewShell->UIActivating( pClient ); + + SfxViewShell::UIActivating( pClient ); +} + + + + +void ViewShellBase::UIDeactivated( SfxInPlaceClient* pClient ) +{ + SfxViewShell::UIDeactivated( pClient ); + + mpImpl->ShowViewTabBar(true); + + ViewShell* pViewShell = GetMainViewShell().get(); + if ( pViewShell ) + pViewShell->UIDeactivated( pClient ); +} + + + + +SvBorder ViewShellBase::GetBorder (bool ) +{ + int nTop = 0; + if (mpImpl->mpViewTabBar.is() && mpImpl->mpViewTabBar->GetTabControl()->IsVisible()) + nTop = mpImpl->mpViewTabBar->GetHeight(); + return SvBorder(0,nTop,0,0); +} + + + + +void ViewShellBase::Execute (SfxRequest& rRequest) +{ + USHORT nSlotId = rRequest.GetSlot(); + + switch (nSlotId) + { + case SID_SWITCH_SHELL: + { + Reference<XControllerManager> xControllerManager (GetController(), UNO_QUERY); + if (xControllerManager.is()) + { + Reference<XConfigurationController> xConfigurationController ( + xControllerManager->getConfigurationController()); + if (xConfigurationController.is()) + xConfigurationController->update(); + } + } + break; + + case SID_LEFT_PANE_DRAW: + mpImpl->SetPaneVisibility( + rRequest, + framework::FrameworkHelper::msLeftDrawPaneURL, + framework::FrameworkHelper::msSlideSorterURL); + break; + + case SID_LEFT_PANE_IMPRESS: + mpImpl->SetPaneVisibility( + rRequest, + framework::FrameworkHelper::msLeftImpressPaneURL, + framework::FrameworkHelper::msSlideSorterURL); + break; + + case SID_TASKPANE: + mpImpl->SetPaneVisibility( + rRequest, + framework::FrameworkHelper::msRightPaneURL, + framework::FrameworkHelper::msTaskPaneURL); + break; + + case SID_NORMAL_MULTI_PANE_GUI: + case SID_SLIDE_SORTER_MULTI_PANE_GUI: + case SID_DRAWINGMODE: + case SID_DIAMODE: + case SID_OUTLINEMODE: + case SID_NOTESMODE: + case SID_HANDOUTMODE: + framework::FrameworkHelper::Instance(*this)->HandleModeChangeSlot(nSlotId, rRequest); + break; + + case SID_WIN_FULLSCREEN: + // The full screen mode is not supported. Ignore the request. + break; + + case SID_SHOW_TOOL_PANEL: + mpImpl->ProcessTaskPaneSlot(rRequest); + break; + + case SID_RESTORE_EDITING_VIEW: + mpImpl->ProcessRestoreEditingViewSlot(); + break; + + default: + // Ignore any other slot. + rRequest.Ignore (); + break; + } +} + + + + +void ViewShellBase::GetState (SfxItemSet& rSet) +{ + // The full screen mode is not supported. Disable the the slot so that + // it appears grayed out when somebody uses configures the menu to show + // an menu item for it. + // if (rSet.GetItemState(SID_WIN_FULLSCREEN) == SFX_ITEM_AVAILABLE) + // rSet.DisableItem(SID_WIN_FULLSCREEN); + + mpImpl->GetSlotState(rSet); + + FuBullet::GetSlotState( rSet, 0, GetViewFrame() ); +} + + + + +void ViewShellBase::WriteUserDataSequence ( + ::com::sun::star::uno::Sequence < + ::com::sun::star::beans::PropertyValue >& rSequence, + sal_Bool bBrowse) +{ + // Forward call to main sub shell. + ViewShell* pShell = GetMainViewShell().get(); + if (pShell != NULL) + pShell->WriteUserDataSequence (rSequence, bBrowse); +} + + + + +void ViewShellBase::ReadUserDataSequence ( + const ::com::sun::star::uno::Sequence < + ::com::sun::star::beans::PropertyValue >& rSequence, + sal_Bool bBrowse) +{ + // Forward call to main sub shell. + ViewShell* pShell = GetMainViewShell().get(); + if (pShell != NULL) + { + pShell->ReadUserDataSequence (rSequence, bBrowse); + + // For certain shell types ReadUserDataSequence may have changed the + // type to another one. Make sure that the center pane shows the + // right view shell. + switch (pShell->GetShellType()) + { + case ViewShell::ST_IMPRESS: + case ViewShell::ST_NOTES: + case ViewShell::ST_HANDOUT: + { + ::rtl::OUString sViewURL; + switch (PTR_CAST(DrawViewShell, pShell)->GetPageKind()) + { + default: + case PK_STANDARD: + sViewURL = framework::FrameworkHelper::msImpressViewURL; + break; + case PK_NOTES: + sViewURL = framework::FrameworkHelper::msNotesViewURL; + break; + case PK_HANDOUT: + sViewURL = framework::FrameworkHelper::msHandoutViewURL; + break; + } + if (sViewURL.getLength() > 0) + framework::FrameworkHelper::Instance(*this)->RequestView( + sViewURL, + framework::FrameworkHelper::msCenterPaneURL); + } + break; + + default: + break; + } + } +} + + + + +void ViewShellBase::Activate (BOOL bIsMDIActivate) +{ + SfxViewShell::Activate(bIsMDIActivate); + + Reference<XControllerManager> xControllerManager (GetController(), UNO_QUERY); + if (xControllerManager.is()) + { + Reference<XConfigurationController> xConfigurationController ( + xControllerManager->getConfigurationController()); + if (xConfigurationController.is()) + xConfigurationController->update(); + } + GetToolBarManager()->RequestUpdate(); +} + + + + +void ViewShellBase::Deactivate (BOOL bIsMDIActivate) +{ + SfxViewShell::Deactivate(bIsMDIActivate); +} + + + + +void ViewShellBase::SetZoomFactor ( + const Fraction &rZoomX, + const Fraction &rZoomY) +{ + SfxViewShell::SetZoomFactor (rZoomX, rZoomY); + // Forward call to main sub shell. + ViewShell* pShell = GetMainViewShell().get(); + if (pShell != NULL) + pShell->SetZoomFactor (rZoomX, rZoomY); +} + + + + +USHORT ViewShellBase::PrepareClose (BOOL bUI, BOOL bForBrowsing) +{ + USHORT nResult = SfxViewShell::PrepareClose (bUI, bForBrowsing); + + if (nResult == TRUE) + { + mpImpl->mbIsClosing = true; + + // Forward call to main sub shell. + ViewShell* pShell = GetMainViewShell().get(); + if (pShell != NULL) + nResult = pShell->PrepareClose (bUI, bForBrowsing); + } + + return nResult; +} + + + + +void ViewShellBase::WriteUserData (String& rString, BOOL bBrowse) +{ + SfxViewShell::WriteUserData (rString, bBrowse); + + // Forward call to main sub shell. + ViewShell* pShell = GetMainViewShell().get(); + if (pShell != NULL) + pShell->WriteUserData (rString); +} + + + + +void ViewShellBase::ReadUserData (const String& rString, BOOL bBrowse) +{ + SfxViewShell::ReadUserData (rString, bBrowse); + + // Forward call to main sub shell. + ViewShell* pShell = GetMainViewShell().get(); + if (pShell != NULL) + pShell->ReadUserData (rString); +} + + + + +SdrView* ViewShellBase::GetDrawView (void) const +{ + // Forward call to main sub shell. + ViewShell* pShell = GetMainViewShell().get(); + if (pShell != NULL) + return pShell->GetDrawView (); + else + return SfxViewShell::GetDrawView(); +} + + + + +void ViewShellBase::AdjustPosSizePixel (const Point &rOfs, const Size &rSize) +{ + SfxViewShell::AdjustPosSizePixel (rOfs, rSize); +} + + + + +void ViewShellBase::SetBusyState (bool bBusy) +{ + if (GetDocShell() != NULL) + GetDocShell()->SetWaitCursor (bBusy); +} + + + + +void ViewShellBase::UpdateBorder ( bool bForce /* = false */ ) +{ + // The following calls to SetBorderPixel() and InvalidateBorder() are + // made only for the main view shell. This not only avoids unnecessary + // calls for the views in side panes but prevents calling an already + // dying SfxViewShell base class. + // For issue #140703# we have to check the existence of the window, + // too. The SfxViewFrame accesses the window without checking it. + ViewShell* pMainViewShell = GetMainViewShell().get(); + if (pMainViewShell != NULL && GetWindow()!=NULL) + { + SvBorder aCurrentBorder (GetBorderPixel()); + bool bOuterResize ( ! GetDocShell()->IsInPlaceActive()); + SvBorder aBorder (GetBorder(bOuterResize)); + aBorder += pMainViewShell->GetBorder(bOuterResize); + + if (bForce || (aBorder != aCurrentBorder)) + { + SetBorderPixel (aBorder); + InvalidateBorder(); + } + } +} + + + + +void ViewShellBase::ShowUIControls (bool bVisible) +{ + if (mpImpl->mpViewTabBar.is()) + mpImpl->mpViewTabBar->GetTabControl()->Show(bVisible); + + ViewShell* pMainViewShell = GetMainViewShell().get(); + if (pMainViewShell != NULL) + pMainViewShell->ShowUIControls (bVisible); + + UpdateBorder(); + if (bVisible) + Rearrange(); +} + + + + +OUString ViewShellBase::GetInitialViewShellType (void) +{ + OUString sRequestedView (FrameworkHelper::msImpressViewURL); + + do + { + Reference<document::XViewDataSupplier> xViewDataSupplier ( + GetDocShell()->GetModel(), UNO_QUERY); + if ( ! xViewDataSupplier.is()) + break; + + Reference<container::XIndexAccess> xViewData (xViewDataSupplier->getViewData()); + if ( ! xViewData.is()) + break; + if (xViewData->getCount() == 0) + break; + + sal_Int32 nView = 0; + ::com::sun::star::uno::Any aAny = xViewData->getByIndex(nView); + Sequence<beans::PropertyValue> aProperties; + if ( ! (aAny >>= aProperties)) + break; + + // Search the properties for the one that tells us what page kind to + // use. + for (sal_Int32 n=0; n<aProperties.getLength(); n++) + { + const beans::PropertyValue& rProperty (aProperties[n]); + if (rProperty.Name.compareToAscii(sUNO_View_PageKind) == COMPARE_EQUAL) + { + sal_Int16 nPageKind = 0; + rProperty.Value >>= nPageKind; + switch ((PageKind)nPageKind) + { + case PK_STANDARD: + sRequestedView = FrameworkHelper::msImpressViewURL; + break; + + case PK_HANDOUT: + sRequestedView = FrameworkHelper::msHandoutViewURL; + break; + + case PK_NOTES: + sRequestedView = FrameworkHelper::msNotesViewURL; + break; + + default: + // The page kind is invalid. This is propably an + // error by the caller. We use the standard type to + // keep things going. + DBG_ASSERT(sal_False, "ViewShellBase::GetInitialViewShellType: invalid page kind"); + sRequestedView = FrameworkHelper::msImpressViewURL; + break; + } + break; + } + } + } + while (false); + + return sRequestedView; +} + + + + +/** this method starts the presentation by + executing the slot SID_PRESENTATION asynchronous */ +void ViewShellBase::StartPresentation() +{ + if( GetViewFrame() && GetViewFrame()->GetDispatcher() ) + GetViewFrame()->GetDispatcher()->Execute(SID_PRESENTATION, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD ); +} + + + + + +::boost::shared_ptr<tools::EventMultiplexer> ViewShellBase::GetEventMultiplexer (void) +{ + OSL_ASSERT(mpImpl.get()!=NULL); + OSL_ASSERT(mpImpl->mpEventMultiplexer.get()!=NULL); + + return mpImpl->mpEventMultiplexer; +} + + + + +const Rectangle& ViewShellBase::getClientRectangle (void) const +{ + return mpImpl->maClientArea; +} + + + + +::boost::shared_ptr<UpdateLockManager> ViewShellBase::GetUpdateLockManager (void) const +{ + OSL_ASSERT(mpImpl.get()!=NULL); + OSL_ASSERT(mpImpl->mpUpdateLockManager.get()!=NULL); + + return mpImpl->mpUpdateLockManager; +} + + + + +::boost::shared_ptr<ToolBarManager> ViewShellBase::GetToolBarManager (void) const +{ + OSL_ASSERT(mpImpl.get()!=NULL); + OSL_ASSERT(mpImpl->mpToolBarManager.get()!=NULL); + + return mpImpl->mpToolBarManager; +} + + + + +::boost::shared_ptr<FormShellManager> ViewShellBase::GetFormShellManager (void) const +{ + OSL_ASSERT(mpImpl.get()!=NULL); + OSL_ASSERT(mpImpl->mpFormShellManager.get()!=NULL); + + return mpImpl->mpFormShellManager; +} + + + + +DrawController& ViewShellBase::GetDrawController (void) const +{ + OSL_ASSERT(mpImpl.get()!=NULL); + + return *mpImpl->mpController; +} + + + + +void ViewShellBase::SetViewTabBar (const ::rtl::Reference<ViewTabBar>& rViewTabBar) +{ + OSL_ASSERT(mpImpl.get()!=NULL); + + mpImpl->mpViewTabBar = rViewTabBar; +} + + + + +::Window* ViewShellBase::GetViewWindow (void) +{ + OSL_ASSERT(mpImpl.get()!=NULL); + + return mpImpl->mpViewWindow.get(); +} + + +::rtl::OUString ImplRetrieveLabelFromCommand( const Reference< XFrame >& xFrame, const ::rtl::OUString& aCmdURL ) +{ + ::rtl::OUString aLabel; + + if ( aCmdURL.getLength() > 0 ) try + { + Reference< XMultiServiceFactory > xServiceManager( ::comphelper::getProcessServiceFactory(), UNO_QUERY_THROW ); + + Reference< XModuleManager > xModuleManager( xServiceManager->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.ModuleManager") ) ), UNO_QUERY_THROW ); + Reference< XInterface > xIfac( xFrame, UNO_QUERY_THROW ); + + ::rtl::OUString aModuleIdentifier( xModuleManager->identify( xIfac ) ); + + if( aModuleIdentifier.getLength() > 0 ) + { + Reference< XNameAccess > xNameAccess( xServiceManager->createInstance( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.frame.UICommandDescription" ) ) ), UNO_QUERY ); + if( xNameAccess.is() ) + { + Reference< ::com::sun::star::container::XNameAccess > m_xUICommandLabels( xNameAccess->getByName( aModuleIdentifier ), UNO_QUERY_THROW ); + Sequence< PropertyValue > aPropSeq; + if( m_xUICommandLabels->getByName( aCmdURL ) >>= aPropSeq ) + { + for( sal_Int32 i = 0; i < aPropSeq.getLength(); i++ ) + { + if( aPropSeq[i].Name.equalsAscii( "Name" )) + { + aPropSeq[i].Value >>= aLabel; + break; + } + } + } + } + } + } + catch ( Exception& ) + { + } + + return aLabel; +} + +::rtl::OUString ViewShellBase::RetrieveLabelFromCommand( const ::rtl::OUString& aCmdURL ) const +{ + Reference< XFrame > xFrame( GetMainViewShell()->GetViewFrame()->GetFrame().GetFrameInterface(), UNO_QUERY ); + return ImplRetrieveLabelFromCommand( xFrame, aCmdURL ); +} + + + +//===== ViewShellBase::Implementation ========================================= + +ViewShellBase::Implementation::Implementation (ViewShellBase& rBase) + : mpController(), + mpViewTabBar(), + maClientArea(), + mbIsClosing(false), + mpViewWindow(), + mpToolBarManager(), + mpViewShellManager(), + mpEventMultiplexer(), + mpUpdateLockManager(), + mpFormShellManager(), + mrBase(rBase), + mpPageCacheManager(slidesorter::cache::PageCacheManager::Instance()) +{ +} + + + + +ViewShellBase::Implementation::~Implementation (void) +{ + mpController = NULL; + mpViewTabBar = NULL; + mpViewWindow.reset(); + mpToolBarManager.reset(); +} + + + + +void ViewShellBase::Implementation::LateInit (void) +{ + mpController = new DrawController(mrBase); +} + + + + +void ViewShellBase::Implementation::ProcessRestoreEditingViewSlot (void) +{ + ViewShell* pViewShell = mrBase.GetMainViewShell().get(); + if (pViewShell != NULL) + { + FrameView* pFrameView = pViewShell->GetFrameView(); + if (pFrameView != NULL) + { + // Set view shell, edit mode, and page kind. + pFrameView->SetViewShEditMode( + pFrameView->GetViewShEditModeOnLoad(), + pFrameView->GetPageKindOnLoad()); + pFrameView->SetPageKind( + pFrameView->GetPageKindOnLoad()); + ::boost::shared_ptr<FrameworkHelper> pHelper (FrameworkHelper::Instance(mrBase)); + pHelper->RequestView( + pHelper->GetViewURL(pFrameView->GetViewShellTypeOnLoad()), + FrameworkHelper::msCenterPaneURL); + pHelper->RunOnConfigurationEvent( + ::rtl::OUString::createFromAscii("ConfigurationUpdateEnd"), + CurrentPageSetter(mrBase)); + } + } +} + + + + +void ViewShellBase::Implementation::ShowViewTabBar (bool bShow) +{ + if (mpViewTabBar.is() + && (mpViewTabBar->GetTabControl()->IsVisible()==TRUE) != bShow) + { + mpViewTabBar->GetTabControl()->Show(bShow ? TRUE : FALSE); + mrBase.Rearrange(); + } +} + + + + +void ViewShellBase::Implementation::ResizePixel ( + const Point& rOrigin, + const Size &rSize, + bool bOuterResize) +{ + if (mbIsClosing) + return; + + // Forward the call to both the base class and the main stacked sub + // shell only when main sub shell exists. + ViewShell* pMainViewShell = mrBase.GetMainViewShell().get(); + + // Set the ViewTabBar temporarily to full size so that, when asked + // later, it can return its true height. + mrBase.SetWindow (mpViewWindow.get()); + if (mpViewTabBar.is() && mpViewTabBar->GetTabControl()->IsVisible()) + mpViewTabBar->GetTabControl()->SetPosSizePixel (rOrigin, rSize); + + // Calculate and set the border before the controls are placed. + SvBorder aBorder; + if (pMainViewShell != NULL) + aBorder = pMainViewShell->GetBorder(bOuterResize); + aBorder += mrBase.GetBorder(bOuterResize); + if (mrBase.GetBorderPixel() != aBorder) + mrBase.SetBorderPixel(aBorder); + + // Place the ViewTabBar at the top. It is part of the border. + SvBorder aBaseBorder; + if (mpViewTabBar.is() && mpViewTabBar->GetTabControl()->IsVisible()) + { + aBaseBorder.Top() = mpViewTabBar->GetHeight(); + mpViewTabBar->GetTabControl()->SetPosSizePixel( + rOrigin, Size(rSize.Width(),aBaseBorder.Top())); + } + + // The view window gets the remaining space. + Point aViewWindowPosition ( + rOrigin.X()+aBaseBorder.Left(), + rOrigin.Y()+aBaseBorder.Top()); + Size aViewWindowSize ( + rSize.Width() - aBaseBorder.Left() - aBaseBorder.Right(), + rSize.Height() - aBaseBorder.Top() - aBaseBorder.Bottom()); + mpViewWindow->SetPosSizePixel(aViewWindowPosition, aViewWindowSize); + + maClientArea = Rectangle(Point(0,0), aViewWindowSize); +} + + + + +void ViewShellBase::Implementation::SetPaneVisibility ( + const SfxRequest& rRequest, + const ::rtl::OUString& rsPaneURL, + const ::rtl::OUString& rsViewURL) +{ + try + { + Reference<XControllerManager> xControllerManager (mrBase.GetController(), UNO_QUERY_THROW); + + const Reference< XComponentContext > xContext( + ::comphelper::getProcessComponentContext() ); + Reference<XResourceId> xPaneId (ResourceId::create( + xContext, rsPaneURL)); + Reference<XResourceId> xViewId (ResourceId::createWithAnchorURL( + xContext, rsViewURL, rsPaneURL)); + + // Determine the new visibility state. + const SfxItemSet* pArguments = rRequest.GetArgs(); + BOOL bShowChildWindow; + USHORT nSlotId = rRequest.GetSlot(); + if (pArguments != NULL) + bShowChildWindow = static_cast<const SfxBoolItem&>( + pArguments->Get(nSlotId)).GetValue(); + else + { + Reference<XConfigurationController> xConfigurationController ( + xControllerManager->getConfigurationController()); + if ( ! xConfigurationController.is()) + throw RuntimeException(); + Reference<XConfiguration> xConfiguration ( + xConfigurationController->getRequestedConfiguration()); + if ( ! xConfiguration.is()) + throw RuntimeException(); + + bShowChildWindow = ! xConfiguration->hasResource(xPaneId); + } + + // Set the desired visibility state at the current configuration + // and update it accordingly. + Reference<XConfigurationController> xConfigurationController ( + xControllerManager->getConfigurationController()); + if ( ! xConfigurationController.is()) + throw RuntimeException(); + if (bShowChildWindow) + { + xConfigurationController->requestResourceActivation( + xPaneId, + ResourceActivationMode_ADD); + xConfigurationController->requestResourceActivation( + xViewId, + ResourceActivationMode_REPLACE); + } + else + xConfigurationController->requestResourceDeactivation( + xPaneId); + } + catch (const Exception &) + { + DBG_UNHANDLED_EXCEPTION(); + } +} + + + + + +void ViewShellBase::Implementation::GetSlotState (SfxItemSet& rSet) +{ + try + { + // Get some frequently used values. + Reference<XControllerManager> xControllerManager (mrBase.GetController(), UNO_QUERY_THROW); + Reference<XConfigurationController> xConfigurationController ( + xControllerManager->getConfigurationController()); + if ( ! xConfigurationController.is()) + throw RuntimeException(); + Reference<XConfiguration> xConfiguration ( + xConfigurationController->getRequestedConfiguration()); + if ( ! xConfiguration.is()) + throw RuntimeException(); + + const Reference< XComponentContext > xContext( + ::comphelper::getProcessComponentContext() ); + SfxWhichIter aSetIterator (rSet); + sal_uInt16 nItemId (aSetIterator.FirstWhich()); + while (nItemId > 0) + { + bool bState (false); + Reference<XResourceId> xResourceId; + try + { + switch (nItemId) + { + case SID_LEFT_PANE_IMPRESS: + xResourceId = ResourceId::create( + xContext, FrameworkHelper::msLeftImpressPaneURL); + break; + + case SID_LEFT_PANE_DRAW: + xResourceId = ResourceId::create( + xContext, FrameworkHelper::msLeftDrawPaneURL); + break; + + case SID_TASKPANE: + xResourceId = ResourceId::create( + xContext, FrameworkHelper::msRightPaneURL); + break; + + case SID_NORMAL_MULTI_PANE_GUI: + xResourceId = ResourceId::createWithAnchorURL( + xContext, + FrameworkHelper::msImpressViewURL, + FrameworkHelper::msCenterPaneURL); + break; + + case SID_SLIDE_SORTER_MULTI_PANE_GUI: + case SID_DIAMODE: + xResourceId = ResourceId::createWithAnchorURL( + xContext, + FrameworkHelper::msSlideSorterURL, + FrameworkHelper::msCenterPaneURL); + break; + + case SID_OUTLINEMODE: + xResourceId = ResourceId::createWithAnchorURL( + xContext, + FrameworkHelper::msOutlineViewURL, + FrameworkHelper::msCenterPaneURL); + break; + + case SID_HANDOUTMODE: + // There is only the master page mode for the handout + // view so ignore the master page flag. + xResourceId = ResourceId::createWithAnchorURL( + xContext, + FrameworkHelper::msHandoutViewURL, + FrameworkHelper::msCenterPaneURL); + break; + + case SID_NOTESMODE: + xResourceId = ResourceId::createWithAnchorURL( + xContext, + FrameworkHelper::msNotesViewURL, + FrameworkHelper::msCenterPaneURL); + break; + + default: + // Ignore all other items. They are not meant to be + // handled by us. + break; + } + } + catch (DeploymentException) + { + } + + // Determine the state for the resource. + bState = xConfiguration->hasResource(xResourceId); + + // Take the master page mode into account. + switch (nItemId) + { + case SID_NORMAL_MULTI_PANE_GUI: + case SID_NOTESMODE: + { + // Determine the master page mode. + ViewShell* pCenterViewShell = FrameworkHelper::Instance(mrBase)->GetViewShell( + FrameworkHelper::msCenterPaneURL).get(); + bool bMasterPageMode (false); + if (pCenterViewShell!=NULL && pCenterViewShell->ISA(DrawViewShell)) + if (PTR_CAST(DrawViewShell,pCenterViewShell)->GetEditMode() + == EM_MASTERPAGE) + { + bMasterPageMode = true; + } + + bState &= !bMasterPageMode; + break; + } + + case SID_HANDOUTMODE: + // There is only the master page mode for the handout + // view so ignore the master page flag. + break; + } + + // And finally set the state. + rSet.Put(SfxBoolItem(nItemId, bState)); + + nItemId = aSetIterator.NextWhich(); + } + } + catch (RuntimeException&) + { + DBG_UNHANDLED_EXCEPTION(); + } + +} + + + + +void ViewShellBase::Implementation::ProcessTaskPaneSlot (SfxRequest& rRequest) +{ + // Set the visibility state of the toolpanel and one of its top + // level panels. + BOOL bShowToolPanel = TRUE; + toolpanel::PanelId nPanelId ( + toolpanel::PID_UNKNOWN); + bool bPanelIdGiven = false; + + // Extract the given arguments. + const SfxItemSet* pArgs = rRequest.GetArgs(); + if (pArgs) + { + if ((pArgs->Count() == 1) || (pArgs->Count() == 2)) + { + SFX_REQUEST_ARG (rRequest, pIsPanelVisible, + SfxBoolItem, ID_VAL_ISVISIBLE, FALSE); + if (pIsPanelVisible != NULL) + bShowToolPanel = pIsPanelVisible->GetValue(); + } + if (pArgs->Count() == 2) + { + SFX_REQUEST_ARG (rRequest, pPanelId, SfxUInt32Item, + ID_VAL_PANEL_INDEX, FALSE); + if (pPanelId != NULL) + { + nPanelId = static_cast< + toolpanel::PanelId>( + pPanelId->GetValue()); + bPanelIdGiven = true; + } + } + } + + // Ignore the request for some combinations of panels and view + // shell types. + if (bPanelIdGiven + && ! (nPanelId==toolpanel::PID_LAYOUT + && mrBase.GetMainViewShell()!=NULL + && mrBase.GetMainViewShell()->GetShellType()==ViewShell::ST_OUTLINE)) + { + framework::FrameworkHelper::Instance(mrBase)->RequestTaskPanel( + framework::FrameworkHelper::msLayoutTaskPanelURL); + } +} + + +} // end of namespace sd + + + + +//===== CurrentPageSetter =========================================== + +namespace { + +CurrentPageSetter::CurrentPageSetter (ViewShellBase& rBase) + : mrBase(rBase) +{ +} + + + + + +void CurrentPageSetter::operator() (bool) +{ + FrameView* pFrameView = NULL; + + if (mrBase.GetMainViewShell() != NULL) + { + pFrameView = mrBase.GetMainViewShell()->GetFrameView(); + } + + if (pFrameView!=NULL) + { + try + { + // Get the current page either from the DrawPagesSupplier or the + // MasterPagesSupplier. + Any aPage; + if (pFrameView->GetViewShEditModeOnLoad() == EM_PAGE) + { + Reference<drawing::XDrawPagesSupplier> xPagesSupplier ( + mrBase.GetController()->getModel(), UNO_QUERY_THROW); + Reference<container::XIndexAccess> xPages ( + xPagesSupplier->getDrawPages(), UNO_QUERY_THROW); + aPage = xPages->getByIndex(pFrameView->GetSelectedPageOnLoad()); + } + else + { + Reference<drawing::XMasterPagesSupplier> xPagesSupplier ( + mrBase.GetController()->getModel(), UNO_QUERY_THROW); + Reference<container::XIndexAccess> xPages ( + xPagesSupplier->getMasterPages(), UNO_QUERY_THROW); + aPage = xPages->getByIndex(pFrameView->GetSelectedPageOnLoad()); + } + // Switch to the page last edited by setting the CurrentPage + // property. + Reference<beans::XPropertySet> xSet (mrBase.GetController(), UNO_QUERY_THROW); + xSet->setPropertyValue (String::CreateFromAscii("CurrentPage"), aPage); + } + catch (RuntimeException aException) + { + // We have not been able to set the current page at the main view. + // This is sad but still leaves us in a valid state. Therefore, + // this exception is silently ignored. + } + catch (beans::UnknownPropertyException aException) + { + DBG_ASSERT(false,"CurrentPage property unknown"); + } + } +} + +} // end of anonymouse namespace + + + + +//===== FocusForwardingWindow ================================================= + +namespace sd { namespace { + +FocusForwardingWindow::FocusForwardingWindow ( + ::Window& rParentWindow, + ViewShellBase& rBase) + : ::Window(&rParentWindow, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)), + mrBase(rBase) +{ + OSL_TRACE("created FocusForwardingWindow at %x", this); +} + + + + +FocusForwardingWindow::~FocusForwardingWindow (void) +{ + OSL_TRACE("destroyed FocusForwardingWindow at %x", this); +} + + + + +void FocusForwardingWindow::KeyInput (const KeyEvent& rKEvt) +{ + ::boost::shared_ptr<ViewShell> pViewShell = mrBase.GetMainViewShell(); + if (pViewShell.get() != NULL) + { + ::Window* pWindow = pViewShell->GetActiveWindow(); + if (pWindow != NULL) + { + // Forward the focus so that the window is called directly the + // next time. + pWindow->GrabFocus(); + // Forward the key press as well. + pWindow->KeyInput(rKEvt); + } + } +} + + + + +void FocusForwardingWindow::Command (const CommandEvent& rEvent) +{ + ::boost::shared_ptr<ViewShell> pViewShell = mrBase.GetMainViewShell(); + if (pViewShell.get() != NULL) + { + ::Window* pWindow = pViewShell->GetActiveWindow(); + if (pWindow != NULL) + { + pWindow->Command(rEvent); + } + } +} + + +} // end of anonymouse namespace + +} // end of namespace sd diff --git a/sd/source/ui/view/ViewShellHint.cxx b/sd/source/ui/view/ViewShellHint.cxx new file mode 100644 index 000000000000..e23cc8964d23 --- /dev/null +++ b/sd/source/ui/view/ViewShellHint.cxx @@ -0,0 +1,52 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "ViewShellHint.hxx" + +namespace sd { + +TYPEINIT1(ViewShellHint, SfxHint); + +ViewShellHint::ViewShellHint (HintId eHintId) + : SfxHint(), + meHintId(eHintId) +{ +} + + + + +ViewShellHint::HintId ViewShellHint::GetHintId (void) const +{ + return meHintId; +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/ViewShellImplementation.cxx b/sd/source/ui/view/ViewShellImplementation.cxx new file mode 100755 index 000000000000..fdd7c530137f --- /dev/null +++ b/sd/source/ui/view/ViewShellImplementation.cxx @@ -0,0 +1,449 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "ViewShellImplementation.hxx" + +#include "sdpage.hxx" +#include "drawdoc.hxx" +#include "sdresid.hxx" +#include "glob.hrc" +#include "app.hrc" +#include "strings.hrc" +#include "strings.hrc" +#include "helpids.h" +#include "sdattr.hxx" +#include "sdabstdlg.hxx" +#include "unmodpg.hxx" +#include "Window.hxx" +#include "optsitem.hxx" +#include "DrawDocShell.hxx" +#include "DrawController.hxx" +#include "FactoryIds.hxx" +#include "slideshow.hxx" +#include "ViewShellBase.hxx" +#include "FrameView.hxx" +#include "DrawViewShell.hxx" +#include "ViewShellHint.hxx" +#include "taskpane/PanelId.hxx" +#include "framework/FrameworkHelper.hxx" + +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/request.hxx> +#include <svl/aeitem.hxx> +#include <svx/imapdlg.hxx> +#include <vcl/msgbox.hxx> +#include <basic/sbstar.hxx> +#include "undo/undoobjects.hxx" + +#include <com/sun/star/drawing/framework/XControllerManager.hpp> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::drawing::framework; +using ::sd::framework::FrameworkHelper; + +namespace sd { + +ViewShell::Implementation::Implementation (ViewShell& rViewShell) + : mbIsShowingUIControls(false), + mbIsMainViewShell(false), + mbIsInitialized(false), + mbArrangeActive(false), + mpSubShellFactory(), + mpUpdateLockForMouse(), + mrViewShell(rViewShell) +{ +} + + + + +ViewShell::Implementation::~Implementation (void) +{ + if ( ! mpUpdateLockForMouse.expired()) + { + ::boost::shared_ptr<ToolBarManagerLock> pLock(mpUpdateLockForMouse); + if (pLock.get() != NULL) + { + // Force the ToolBarManagerLock to be released even when the + // IsUICaptured() returns <TRUE/>. + pLock->Release(true); + } + } +} + + + + +void ViewShell::Implementation::ProcessModifyPageSlot ( + SfxRequest& rRequest, + SdPage* pCurrentPage, + PageKind ePageKind) +{ + SdDrawDocument* pDocument = mrViewShell.GetDoc(); + SdrLayerAdmin& rLayerAdmin = pDocument->GetLayerAdmin(); + BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE); + BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE); + SetOfByte aVisibleLayers; + BOOL bHandoutMode = FALSE; + SdPage* pHandoutMPage = NULL; + String aNewName; + + // #95981# + String aOldName; + + AutoLayout aNewAutoLayout; + + BOOL bBVisible; + BOOL bBObjsVisible; + const SfxItemSet* pArgs = rRequest.GetArgs(); + + if (pCurrentPage != NULL && pCurrentPage->TRG_HasMasterPage()) + aVisibleLayers = pCurrentPage->TRG_GetMasterPageVisibleLayers(); + else + aVisibleLayers.SetAll(); + + do + { + if (pCurrentPage == NULL) + break; + + if (!pArgs || pArgs->Count() == 1 || pArgs->Count() == 2 ) + { + if (pArgs && pArgs->Count() == 2) + { + // We have been called with a request that contains two + // arguments. One was used as preselected layout in a + // dialog. We could select that layout in the + // layout panel instead. + /* + SFX_REQUEST_ARG (rRequest, pNewAutoLayout, SfxUInt32Item, ID_VAL_WHATLAYOUT, FALSE); + eNewAutoLayout = (AutoLayout) pNewAutoLayout->GetValue + (); + */ + } + + // Make the layout menu visible in the tool pane. + SfxBoolItem aMakeToolPaneVisible (ID_VAL_ISVISIBLE, TRUE); + SfxUInt32Item aPanelId (ID_VAL_PANEL_INDEX, + ::sd::toolpanel::PID_LAYOUT); + SfxViewFrame* pFrame = mrViewShell.GetViewFrame(); + if (pFrame!=NULL && pFrame->GetDispatcher()!=NULL) + { + pFrame->GetDispatcher()->Execute ( + SID_SHOW_TOOL_PANEL, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, + &aMakeToolPaneVisible, + &aPanelId, + NULL); + } + else + { + DBG_ASSERT(pFrame!=NULL && pFrame->GetDispatcher()!=NULL, + "ViewShell::Implementation::ProcessModifyPageSlot(): can not get dispatcher"); + } + + // We have activated a non-modal control in the task pane. + // Because it does not return anything we can not do anything + // more right now and have to exit here. + break; + } + else if (pArgs->Count() == 4) + { + SFX_REQUEST_ARG (rRequest, pNewName, SfxStringItem, ID_VAL_PAGENAME, FALSE); + SFX_REQUEST_ARG (rRequest, pNewAutoLayout, SfxUInt32Item, ID_VAL_WHATLAYOUT, FALSE); + SFX_REQUEST_ARG (rRequest, pBVisible, SfxBoolItem, ID_VAL_ISPAGEBACK, FALSE); + SFX_REQUEST_ARG (rRequest, pBObjsVisible, SfxBoolItem, ID_VAL_ISPAGEOBJ, FALSE); + AutoLayout aLayout ((AutoLayout)pNewAutoLayout->GetValue ()); + if (aLayout >= AUTOLAYOUT__START + && aLayout < AUTOLAYOUT__END) + { + aNewName = pNewName->GetValue (); + aNewAutoLayout = (AutoLayout) pNewAutoLayout->GetValue (); + bBVisible = pBVisible->GetValue (); + bBObjsVisible = pBObjsVisible->GetValue (); + } + else + { + StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + rRequest.Ignore (); + break; + } + if (ePageKind == PK_HANDOUT) + { + bHandoutMode = TRUE; + pHandoutMPage = pDocument->GetMasterSdPage(0, PK_HANDOUT); + } + } + else + { + StarBASIC::FatalError (SbERR_WRONG_ARGS); + rRequest.Ignore (); + break; + } + + SdPage* pUndoPage = + bHandoutMode ? pHandoutMPage : pCurrentPage; + + SfxUndoManager* pUndoManager = mrViewShell.GetDocSh()->GetUndoManager(); + DBG_ASSERT(pUndoManager, "No UNDO MANAGER ?!?"); + + if( pUndoManager ) + { + String aComment( SdResId(STR_UNDO_MODIFY_PAGE) ); + pUndoManager->EnterListAction(aComment, aComment); + ModifyPageUndoAction* pAction = new ModifyPageUndoAction( + pUndoManager, pDocument, pUndoPage, aNewName, aNewAutoLayout, bBVisible, bBObjsVisible); + pUndoManager->AddUndoAction(pAction); + + // Clear the selection because the selectec object may be removed as + // a result of the ssignment of the layout. + mrViewShell.GetDrawView()->UnmarkAll(); + + if (!bHandoutMode) + { + if (pCurrentPage->GetName() != aNewName) + { + pCurrentPage->SetName(aNewName); + + if (ePageKind == PK_STANDARD) + { + USHORT nPage = (pCurrentPage->GetPageNum()-1) / 2; + SdPage* pNotesPage = pDocument->GetSdPage(nPage, PK_NOTES); + if (pNotesPage != NULL) + pNotesPage->SetName(aNewName); + } + } + + pCurrentPage->SetAutoLayout(aNewAutoLayout, TRUE); + + aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE); + aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE); + aVisibleLayers.Set(aBckgrnd, bBVisible); + aVisibleLayers.Set(aBckgrndObj, bBObjsVisible); + pCurrentPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers); + } + else + { + pHandoutMPage->SetAutoLayout(aNewAutoLayout, TRUE); + } + + mrViewShell.GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHPAGE, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + + BOOL bSetModified = TRUE; + + if (pArgs && pArgs->Count() == 1) + { + bSetModified = (BOOL) ((SfxBoolItem&) pArgs->Get(SID_MODIFYPAGE)).GetValue(); + } + + pUndoManager->AddUndoAction( new UndoAutoLayoutPosAndSize( *pUndoPage ) ); + pUndoManager->LeaveListAction(); + + pDocument->SetChanged(bSetModified); + } + } + while (false); + + mrViewShell.Cancel(); + rRequest.Done (); +} + +void ViewShell::Implementation::AssignLayout ( SfxRequest& rRequest, PageKind ePageKind ) +{ + const SfxUInt32Item* pWhatPage = static_cast< const SfxUInt32Item* > ( rRequest.GetArg( ID_VAL_WHATPAGE, FALSE, TYPE(SfxUInt32Item) ) ); + const SfxUInt32Item* pWhatLayout = static_cast< const SfxUInt32Item* > ( rRequest.GetArg( ID_VAL_WHATLAYOUT, FALSE, TYPE(SfxUInt32Item) ) ); + + SdDrawDocument* pDocument = mrViewShell.GetDoc(); + if( !pDocument ) + return; + + SdPage* pPage = 0; + if( pWhatPage ) + { + pPage = pDocument->GetSdPage(static_cast<USHORT>(pWhatPage->GetValue()), ePageKind); + } + + if( pPage == 0 ) + pPage = mrViewShell.getCurrentPage(); + + if( pPage ) + { + AutoLayout eLayout = pPage->GetAutoLayout(); + + if( pWhatLayout ) + eLayout = static_cast< AutoLayout >( pWhatLayout->GetValue() ); + + // Transform the given request into the four argument form that is + // understood by ProcessModifyPageSlot(). + SdrLayerAdmin& rLayerAdmin (mrViewShell.GetViewShellBase().GetDocument()->GetLayerAdmin()); + BYTE aBackground (rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE)); + BYTE aBackgroundObject (rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE)); + + SetOfByte aVisibleLayers; + + if( pPage->GetPageKind() == PK_HANDOUT ) + aVisibleLayers.SetAll(); + else + aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers(); + + SfxRequest aRequest (mrViewShell.GetViewShellBase().GetViewFrame(), SID_MODIFYPAGE); + aRequest.AppendItem(SfxStringItem (ID_VAL_PAGENAME, pPage->GetName())); + aRequest.AppendItem(SfxUInt32Item (ID_VAL_WHATLAYOUT, eLayout)); + aRequest.AppendItem(SfxBoolItem(ID_VAL_ISPAGEBACK, aVisibleLayers.IsSet(aBackground))); + aRequest.AppendItem(SfxBoolItem(ID_VAL_ISPAGEOBJ, aVisibleLayers.IsSet(aBackgroundObject))); + + // Forward the call with the new arguments. + ProcessModifyPageSlot( aRequest, pPage, pPage->GetPageKind()); + } +} + + + + +sal_uInt16 ViewShell::Implementation::GetViewId (void) +{ + switch (mrViewShell.GetShellType()) + { + case ViewShell::ST_IMPRESS: + case ViewShell::ST_NOTES: + case ViewShell::ST_HANDOUT: + return IMPRESS_FACTORY_ID; + + case ViewShell::ST_DRAW: + return DRAW_FACTORY_ID; + + case ViewShell::ST_OUTLINE: + return OUTLINE_FACTORY_ID; + + case ViewShell::ST_SLIDE_SORTER: + return SLIDE_SORTER_FACTORY_ID; + + case ViewShell::ST_PRESENTATION: + return PRESENTATION_FACTORY_ID; + + // Since we have to return a view id for every possible shell type + // and there is not (yet) a proper ViewShellBase sub class for the + // remaining types we chose the Impress factory as a fall back. + case ViewShell::ST_TASK_PANE: + case ViewShell::ST_NONE: + default: + return IMPRESS_FACTORY_ID; + } +} + + + + +SvxIMapDlg* ViewShell::Implementation::GetImageMapDialog (void) +{ + SvxIMapDlg* pDialog = NULL; + SfxChildWindow* pChildWindow = SfxViewFrame::Current()->GetChildWindow( + SvxIMapDlgChildWindow::GetChildWindowId()); + if (pChildWindow != NULL) + pDialog = dynamic_cast<SvxIMapDlg*>(pChildWindow->GetWindow()); + return pDialog; +} + + + +//===== ToolBarManagerLock ==================================================== + +class ViewShell::Implementation::ToolBarManagerLock::Deleter { public: + void operator() (ToolBarManagerLock* pObject) { delete pObject; } +}; + +::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> + ViewShell::Implementation::ToolBarManagerLock::Create ( + const ::boost::shared_ptr<ToolBarManager>& rpManager) +{ + ::boost::shared_ptr<ToolBarManagerLock> pLock ( + new ViewShell::Implementation::ToolBarManagerLock(rpManager), + ViewShell::Implementation::ToolBarManagerLock::Deleter()); + pLock->mpSelf = pLock; + return pLock; +} + + + + +ViewShell::Implementation::ToolBarManagerLock::ToolBarManagerLock ( + const ::boost::shared_ptr<ToolBarManager>& rpManager) + : mpLock(new ToolBarManager::UpdateLock(rpManager)), + maTimer() +{ + // Start a timer that will unlock the ToolBarManager update lock when + // that is not done explicitly by calling Release(). + maTimer.SetTimeoutHdl(LINK(this,ToolBarManagerLock,TimeoutCallback)); + maTimer.SetTimeout(100); + maTimer.Start(); +} + + + + +IMPL_LINK(ViewShell::Implementation::ToolBarManagerLock,TimeoutCallback,Timer*,EMPTYARG) +{ + // If possible then release the lock now. Otherwise start the timer + // and try again later. + if (Application::IsUICaptured()) + { + maTimer.Start(); + } + else + { + mpSelf.reset(); + } + return 0; +} + + + + +void ViewShell::Implementation::ToolBarManagerLock::Release (bool bForce) +{ + // If possible then release the lock now. Otherwise try again when the + // timer expires. + if (bForce || ! Application::IsUICaptured()) + { + mpSelf.reset(); + } +} + + + + +ViewShell::Implementation::ToolBarManagerLock::~ToolBarManagerLock (void) +{ + mpLock.reset(); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/ViewShellManager.cxx b/sd/source/ui/view/ViewShellManager.cxx new file mode 100755 index 000000000000..c25c0f11270a --- /dev/null +++ b/sd/source/ui/view/ViewShellManager.cxx @@ -0,0 +1,1464 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "ViewShellManager.hxx" +#include "ViewShell.hxx" +#include "ViewShellBase.hxx" +#include "Window.hxx" +#include "DrawDocShell.hxx" +#include "FormShellManager.hxx" + +#include <sfx2/dispatch.hxx> +#include <svx/svxids.hrc> +#include <svx/fmshell.hxx> + +#include <hash_map> + +#undef VERBOSE +//#define VERBOSE 2 + +namespace sd { + +namespace { + +/** The ShellDescriptor class is used to shells together with their ids and + the factory that was used to create the shell. + + The shell pointer may be NULL. In that case the shell is created on + demand by a factory. + + The factory pointer may be NULL. In that case the shell pointer is + given to the ViewShellManager. + + Shell pointer and factory pointer can but should not be NULL at the same + time. +*/ +class ShellDescriptor { +public: + SfxShell* mpShell; + ShellId mnId; + ViewShellManager::SharedShellFactory mpFactory; + ShellDescriptor (); + ShellDescriptor (SfxShell* pShell, ShellId nId); + ShellDescriptor (const ShellDescriptor& rDescriptor); + ShellDescriptor& operator= (const ShellDescriptor& rDescriptor); + bool IsMainViewShell (void) const; + ::Window* GetWindow (void) const; +}; + + + + +/** This functor can be used to search for a shell in an STL container when the + shell pointer is given. +*/ +class IsShell : public ::std::unary_function<ShellDescriptor,bool> +{ +public: + IsShell (const SfxShell* pShell) : mpShell(pShell) {} + bool operator() (const ShellDescriptor& rDescriptor) + { return rDescriptor.mpShell == mpShell; } +private: + const SfxShell* mpShell; +}; + + + + +/** This functor can be used to search for a shell in an STL container when the + id of the shell is given. +*/ +class IsId : public ::std::unary_function<ShellDescriptor,bool> +{ +public: + IsId (ShellId nId) : mnId(nId) {} + bool operator() (const ShellDescriptor& rDescriptor) + { return rDescriptor.mnId == mnId; } +private: + ShellId mnId; +}; + +} // end of anonymous namespace + + + + +class ViewShellManager::Implementation +{ +public: + Implementation ( + ViewShellManager& rManager, + ViewShellBase& rBase); + ~Implementation (void); + + void AddShellFactory ( + const SfxShell* pViewShell, + const SharedShellFactory& rpFactory); + void RemoveShellFactory ( + const SfxShell* pViewShell, + const SharedShellFactory& rpFactory); + void ActivateViewShell ( + ViewShell* pViewShell); + void DeactivateViewShell (const ViewShell& rShell); + void ActivateShell (SfxShell& rShell); + void DeactivateShell (const SfxShell& rShell); + void ActivateShell (const ShellDescriptor& rDescriptor); + void SetFormShell (const ViewShell* pViewShell, FmFormShell* pFormShell, bool bAbove); + void ActivateSubShell (const SfxShell& rParentShell, ShellId nId); + void DeactivateSubShell (const SfxShell& rParentShell, ShellId nId); + void MoveSubShellToTop (const SfxShell& rParentShell, ShellId nId); + void MoveToTop (const SfxShell& rParentShell); + SfxShell* GetShell (ShellId nId) const; + SfxShell* GetTopShell (void) const; + void Shutdown (void); + void InvalidateAllSubShells (const SfxShell* pParentShell); + + /** Remove all shells from the SFX stack above and including the given + shell. + */ + void TakeShellsFromStack (const SfxShell* pShell); + + class UpdateLock + { + public: + UpdateLock (Implementation& rImpl) : mrImpl(rImpl) {mrImpl.LockUpdate();} + ~UpdateLock (void) {mrImpl.UnlockUpdate();}; + private: + Implementation& mrImpl; + }; + + + + /** Prevent updates of the shell stack. While the sub shell manager is + locked it will update its internal data structures but not alter the + shell stack. Use this method when there are several modifications + to the shell stack to prevent multiple rebuilds of the shell stack + and resulting broadcasts. + */ + void LockUpdate (void); + + /** Allow updates of the shell stack. This method has to be called the + same number of times as LockUpdate() to really allow a rebuild of + the shell stack. + */ + void UnlockUpdate (void); + +private: + ViewShellBase& mrBase; + mutable ::osl::Mutex maMutex; + + class ShellHash{public: size_t operator()(const SfxShell* p) const { return (size_t)p;} }; + typedef ::std::hash_multimap<const SfxShell*,SharedShellFactory,ShellHash> + FactoryList; + FactoryList maShellFactories; + + /** List of the active view shells. In order to create gather all shells + to put on the shell stack each view shell in this list is asked for + its sub-shells (typically toolbars). + */ + typedef ::std::list<ShellDescriptor> ActiveShellList; + ActiveShellList maActiveViewShells; + + typedef ::std::list<ShellDescriptor> SubShellSubList; + typedef ::std::hash_map<const SfxShell*,SubShellSubList,ShellHash> SubShellList; + SubShellList maActiveSubShells; + + /** In this member we remember what shells we have pushed on the shell + stack. + */ + typedef ::std::vector<SfxShell*> ShellStack; + + int mnUpdateLockCount; + + /** When this flag is set then the main view shell is always kept at the + top of the shell stack. + */ + bool mbKeepMainViewShellOnTop; + + /** The UpdateShellStack() method can be called recursively. This flag + is used to communicate between different levels of invocation: if + the stack has been updated in an inner call the outer call can (has + to) stop and return immediately. + */ + bool mbShellStackIsUpToDate; + + SfxShell* mpFormShell; + const ViewShell* mpFormShellParent; + bool mbFormShellAboveParent; + + SfxShell* mpTopShell; + + void GatherActiveShells (ShellStack& rShellList); + + void UpdateShellStack (void); + + void CreateShells (void); + + /** This method rebuilds the stack of shells that are stacked upon the + view shell base. + */ + void CreateTargetStack (ShellStack& rStack) const; + + DECL_LINK(WindowEventHandler, VclWindowEvent*); + + void DumpShellStack (const ShellStack& rStack); + void DumpSfxShellStack (void); + + /** To be called before a shell is taken fom the SFX shell stack. This + method deactivates an active text editing to avoid problems with + undo managers. + Afterwards the Deactivate() of the shell is called. + */ + void Deactivate (SfxShell* pShell); + + ShellDescriptor CreateSubShell ( + SfxShell* pShell, + ShellId nShellId, + ::Window* pParentWindow, + FrameView* pFrameView); + void DestroyViewShell (const ShellDescriptor& rDescriptor); + void DestroySubShell ( + const SfxShell& rViewShell, + const ShellDescriptor& rDescriptor); +}; + + + + +//===== ViewShellManager ====================================================== + +ViewShellManager::ViewShellManager (ViewShellBase& rBase) + : mpImpl(new Implementation(*this,rBase)), + mbValid(true) +{ +} + + + + +ViewShellManager::~ViewShellManager (void) +{ +} + + + + +void ViewShellManager::AddSubShellFactory ( + ViewShell* pViewShell, + const SharedShellFactory& rpFactory) +{ + if (mbValid) + mpImpl->AddShellFactory(pViewShell, rpFactory); +} + + + + +void ViewShellManager::RemoveSubShellFactory ( + ViewShell* pViewShell, + const SharedShellFactory& rpFactory) +{ + if (mbValid) + mpImpl->RemoveShellFactory(pViewShell, rpFactory); +} + + + + +void ViewShellManager::ActivateViewShell (ViewShell* pViewShell) +{ + if (mbValid) + return mpImpl->ActivateViewShell(pViewShell); +} + + + + +void ViewShellManager::DeactivateViewShell (const ViewShell* pShell) +{ + if (mbValid && pShell!=NULL) + mpImpl->DeactivateViewShell(*pShell); +} + + + + +void ViewShellManager::MoveSubShellToTop ( + const ViewShell& rParentShell, + ShellId nId) +{ + if (mbValid) + mpImpl->MoveSubShellToTop(rParentShell, nId); +} + + + + +void ViewShellManager::SetFormShell ( + const ViewShell* pParentShell, + FmFormShell* pFormShell, + bool bAbove) +{ + if (mbValid) + mpImpl->SetFormShell(pParentShell,pFormShell,bAbove); +} + + + + +void ViewShellManager::ActivateSubShell (const ViewShell& rViewShell, ShellId nId) +{ + if (mbValid) + mpImpl->ActivateSubShell(rViewShell,nId); +} + + + + +void ViewShellManager::DeactivateSubShell (const ViewShell& rViewShell, ShellId nId) +{ + if (mbValid) + mpImpl->DeactivateSubShell(rViewShell,nId); +} + + + + +void ViewShellManager::InvalidateAllSubShells (ViewShell* pViewShell) +{ + if (mbValid) + mpImpl->InvalidateAllSubShells(pViewShell); +} + + + + +void ViewShellManager::ActivateShell (SfxShell* pShell) +{ + if (mbValid && pShell!=NULL) + mpImpl->ActivateShell(*pShell); +} + + + + +void ViewShellManager::DeactivateShell (const SfxShell* pShell) +{ + if (mbValid && pShell!=NULL) + mpImpl->DeactivateShell(*pShell); +} + + + + +void ViewShellManager::MoveToTop (const ViewShell& rParentShell) +{ + if (mbValid) + mpImpl->MoveToTop(rParentShell); +} + + + + +SfxShell* ViewShellManager::GetShell (ShellId nId) const +{ + if (mbValid) + return mpImpl->GetShell(nId); + else + return NULL; +} + + + + +SfxShell* ViewShellManager::GetTopShell (void) const +{ + if (mbValid) + return mpImpl->GetTopShell(); + else + return NULL; +} + + + + +void ViewShellManager::Shutdown (void) +{ + if (mbValid) + { + mpImpl->Shutdown(); + mbValid = false; + } +} + + + +void ViewShellManager::LockUpdate (void) +{ + mpImpl->LockUpdate(); +} + + + + +void ViewShellManager::UnlockUpdate (void) +{ + mpImpl->UnlockUpdate(); +} + + + + +//===== ViewShellManager::Implementation ====================================== + +ViewShellManager::Implementation::Implementation ( + ViewShellManager& rManager, + ViewShellBase& rBase) + : mrBase(rBase), + maMutex(), + maShellFactories(), + maActiveViewShells(), + mnUpdateLockCount(0), + mbKeepMainViewShellOnTop(false), + mbShellStackIsUpToDate(true), + mpFormShell(NULL), + mpFormShellParent(NULL), + mbFormShellAboveParent(true), + mpTopShell(NULL) +{ + (void)rManager; +} + + + + +ViewShellManager::Implementation::~Implementation (void) +{ + Shutdown(); +} + + + + +void ViewShellManager::Implementation::AddShellFactory ( + const SfxShell* pViewShell, + const SharedShellFactory& rpFactory) +{ + bool bAlreadyAdded (false); + + // Check that the given factory has not already been added. + ::std::pair<FactoryList::iterator,FactoryList::iterator> aRange( + maShellFactories.equal_range(pViewShell)); + for (FactoryList::const_iterator iFactory=aRange.first; iFactory!=aRange.second; ++iFactory) + if (iFactory->second == rpFactory) + { + bAlreadyAdded = true; + break; + } + + // Add the factory if it is not already present. + if ( ! bAlreadyAdded) + maShellFactories.insert(FactoryList::value_type(pViewShell, rpFactory)); +} + + + + +void ViewShellManager::Implementation::RemoveShellFactory ( + const SfxShell* pViewShell, + const SharedShellFactory& rpFactory) +{ + ::std::pair<FactoryList::iterator,FactoryList::iterator> aRange( + maShellFactories.equal_range(pViewShell)); + for (FactoryList::iterator iFactory=aRange.first; iFactory!=aRange.second; ++iFactory) + if (iFactory->second == rpFactory) + { + maShellFactories.erase(iFactory); + break; + } +} + + + + +void ViewShellManager::Implementation::ActivateViewShell (ViewShell* pViewShell) +{ + ::osl::MutexGuard aGuard (maMutex); + + ShellDescriptor aResult; + aResult.mpShell = pViewShell; + + // Register as window listener so that the shells of the current + // window can be moved to the top of the shell stack. + if (aResult.mpShell != NULL) + { + ::Window* pWindow = aResult.GetWindow(); + if (pWindow != NULL) + pWindow->AddEventListener( + LINK(this, ViewShellManager::Implementation, WindowEventHandler)); + else + { + DBG_ASSERT(false, + "ViewShellManager::ActivateViewShell: " + "new view shell has no active window"); + } + } + + ActivateShell(aResult); +} + + + + +void ViewShellManager::Implementation::DeactivateViewShell (const ViewShell& rShell) +{ + ::osl::MutexGuard aGuard (maMutex); + + ActiveShellList::iterator iShell (::std::find_if ( + maActiveViewShells.begin(), + maActiveViewShells.end(), + IsShell(&rShell))); + if (iShell != maActiveViewShells.end()) + { + UpdateLock aLocker (*this); + + ShellDescriptor aDescriptor(*iShell); + mrBase.GetDocShell()->Disconnect(dynamic_cast<ViewShell*>(aDescriptor.mpShell)); + maActiveViewShells.erase(iShell); + TakeShellsFromStack(aDescriptor.mpShell); + + // Deactivate sub shells. + SubShellList::iterator iList (maActiveSubShells.find(&rShell)); + if (iList != maActiveSubShells.end()) + { + SubShellSubList& rList (iList->second); + while ( ! rList.empty()) + DeactivateSubShell(rShell, rList.front().mnId); + } + + DestroyViewShell(aDescriptor); + } +} + + + + +void ViewShellManager::Implementation::ActivateShell (SfxShell& rShell) +{ + ::osl::MutexGuard aGuard (maMutex); + + // Create a new shell or recycle on in the cache. + ShellDescriptor aDescriptor; + aDescriptor.mpShell = &rShell; + + ActivateShell(aDescriptor); +} + + + + +void ViewShellManager::Implementation::ActivateShell (const ShellDescriptor& rDescriptor) +{ + // Put shell on top of the active view shells. + if (rDescriptor.mpShell != NULL) + { + // Determine where to put the view shell on the stack. By default + // it is put on top of the stack. When the view shell of the center + // pane is to be kept top most and the new view shell is not + // displayed in the center pane then it is inserted at the position + // one below the top. + ActiveShellList::iterator iInsertPosition (maActiveViewShells.begin()); + if (iInsertPosition != maActiveViewShells.end() + && mbKeepMainViewShellOnTop + && ! rDescriptor.IsMainViewShell() + && iInsertPosition->IsMainViewShell()) + { + ++iInsertPosition; + } + maActiveViewShells.insert( + iInsertPosition, + rDescriptor); + } +} + + + + +void ViewShellManager::Implementation::DeactivateShell (const SfxShell& rShell) +{ + ::osl::MutexGuard aGuard (maMutex); + + ActiveShellList::iterator iShell (::std::find_if ( + maActiveViewShells.begin(), + maActiveViewShells.end(), + IsShell(&rShell))); + if (iShell != maActiveViewShells.end()) + { + UpdateLock aLocker (*this); + + ShellDescriptor aDescriptor(*iShell); + mrBase.GetDocShell()->Disconnect(dynamic_cast<ViewShell*>(aDescriptor.mpShell)); + maActiveViewShells.erase(iShell); + TakeShellsFromStack(aDescriptor.mpShell); + + // Deactivate sub shells. + SubShellList::iterator iList (maActiveSubShells.find(&rShell)); + if (iList != maActiveSubShells.end()) + { + SubShellSubList& rList (iList->second); + while ( ! rList.empty()) + DeactivateSubShell(rShell, rList.front().mnId); + } + + DestroyViewShell(aDescriptor); + } +} + + + + +void ViewShellManager::Implementation::ActivateSubShell ( + const SfxShell& rParentShell, + ShellId nId) +{ + ::osl::MutexGuard aGuard (maMutex); + + do + { + // Check that the given view shell is active. + ActiveShellList::iterator iShell (::std::find_if ( + maActiveViewShells.begin(), + maActiveViewShells.end(), + IsShell(&rParentShell))); + if (iShell == maActiveViewShells.end()) + break; + + // Create the sub shell list if it does not yet exist. + SubShellList::iterator iList (maActiveSubShells.find(&rParentShell)); + if (iList == maActiveSubShells.end()) + iList = maActiveSubShells.insert( + SubShellList::value_type(&rParentShell,SubShellSubList())).first; + + // Do not activate an object bar that is already active. Requesting + // this is not exactly an error but may be an indication of one. + SubShellSubList& rList (iList->second); + if (::std::find_if(rList.begin(),rList.end(), IsId(nId)) != rList.end()) + break; + + // Add just the id of the sub shell. The actual shell is created + // later in CreateShells(). + UpdateLock aLock (*this); + rList.push_back(ShellDescriptor(NULL, nId)); + } + while (false); +} + + + + +void ViewShellManager::Implementation::DeactivateSubShell ( + const SfxShell& rParentShell, + ShellId nId) +{ + ::osl::MutexGuard aGuard (maMutex); + + do + { + // Check that the given view shell is active. + SubShellList::iterator iList (maActiveSubShells.find(&rParentShell)); + if (iList == maActiveSubShells.end()) + break; + + // Look up the sub shell. + SubShellSubList& rList (iList->second); + SubShellSubList::iterator iShell ( + ::std::find_if(rList.begin(),rList.end(), IsId(nId))); + if (iShell == rList.end()) + break; + SfxShell* pShell = iShell->mpShell; + if (pShell == NULL) + break; + + UpdateLock aLock (*this); + + ShellDescriptor aDescriptor(*iShell); + // Remove the sub shell from both the internal structure as well as the + // SFX shell stack above and including the sub shell. + rList.erase(iShell); + TakeShellsFromStack(pShell); + + DestroySubShell(rParentShell, aDescriptor); + } + while (false); +} + + + + +void ViewShellManager::Implementation::MoveSubShellToTop ( + const SfxShell& rParentShell, + ShellId nId) +{ + SubShellList::iterator iList (maActiveSubShells.find(&rParentShell)); + if (iList != maActiveSubShells.end()) + { + // Look up the sub shell. + SubShellSubList& rList (iList->second); + SubShellSubList::iterator iShell ( + ::std::find_if(rList.begin(),rList.end(), IsId(nId))); + if (iShell!=rList.end() && iShell!=rList.begin()) + { + SubShellSubList::value_type aEntry (*iShell); + rList.erase(iShell); + rList.push_front(aEntry); + } + } + else + { + // Ignore this call when there are no sub shells for the given + // parent shell. We could remember the sub shell to move to the top + // but we do not. Do call this method at a later time instead. + } +} + + + +void ViewShellManager::Implementation::MoveToTop (const SfxShell& rShell) +{ + ::osl::MutexGuard aGuard (maMutex); + + // Check that we have access to a dispatcher. If not, then we are + // (probably) called while the view shell is still being created or + // initialized. Without dispatcher we can not rebuild the shell stack + // to move the requested shell to the top. So return right away instead + // of making a mess without being able to clean up afterwards. + if (mrBase.GetDispatcher() == NULL) + return; + + ActiveShellList::iterator iShell (::std::find_if ( + maActiveViewShells.begin(), + maActiveViewShells.end(), + IsShell(&rShell))); + bool bMove = true; + if (iShell != maActiveViewShells.end()) + { + // Is the shell already at the top of the stack? We have to keep + // the case in mind that mbKeepMainViewShellOnTop is true. Shells + // that are not the main view shell are placed on the second-to-top + // position in this case. + if (iShell == maActiveViewShells.begin() + && (iShell->IsMainViewShell() || ! mbKeepMainViewShellOnTop)) + { + // The shell is at the top position and is either a) the main + // view shell or b) another shell but the main view shell is not + // kept at the top position. We do not have to move the shell. + bMove = false; + } + else if (iShell == ++maActiveViewShells.begin() + && ! iShell->IsMainViewShell() + && mbKeepMainViewShellOnTop) + { + // The shell is a the second-to-top position, not the main view + // shell and the main view shell is kept at the top position. + // Therefore we do not have to move the shell. + bMove = false; + } + } + else + { + // The shell is not on the stack. Therefore it can not be moved. + // We could insert it but we don't. Use ActivateViewShell() for + // that. + bMove = false; + } + + // When the shell is not at the right position it is removed from the + // internal list of shells and inserted at the correct position. + if (bMove) + { + UpdateLock aLock (*this); + + ShellDescriptor aDescriptor(*iShell); + + TakeShellsFromStack(&rShell); + maActiveViewShells.erase(iShell); + + // Find out whether to insert at the top or one below. + ActiveShellList::iterator aInsertPosition (maActiveViewShells.begin()); + if (mbKeepMainViewShellOnTop && ! aDescriptor.IsMainViewShell()) + { + if (maActiveViewShells.back().IsMainViewShell()) + aInsertPosition++; + } + + maActiveViewShells.insert(aInsertPosition, aDescriptor); + } +} + + + + +SfxShell* ViewShellManager::Implementation::GetShell (ShellId nId) const +{ + ::osl::MutexGuard aGuard (maMutex); + + SfxShell* pShell = NULL; + + // First search the active view shells. + ActiveShellList::const_iterator iShell ( + ::std::find_if ( + maActiveViewShells.begin(), + maActiveViewShells.end(), + IsId(nId))); + if (iShell != maActiveViewShells.end()) + pShell = iShell->mpShell; + else + { + // Now search the active sub shells of every active view shell. + SubShellList::const_iterator iList; + for (iList=maActiveSubShells.begin(); iList!=maActiveSubShells.end(); ++iList) + { + const SubShellSubList& rList (iList->second); + SubShellSubList::const_iterator iSubShell( + ::std::find_if(rList.begin(),rList.end(), IsId(nId))); + if (iSubShell != rList.end()) + { + pShell = iSubShell->mpShell; + break; + } + } + } + + return pShell; +} + + + + +SfxShell* ViewShellManager::Implementation::GetTopShell (void) const +{ + OSL_ASSERT(mpTopShell == mrBase.GetSubShell(0)); + return mpTopShell; +} + + + + +void ViewShellManager::Implementation::LockUpdate (void) +{ + mnUpdateLockCount++; +} + + + + +void ViewShellManager::Implementation::UnlockUpdate (void) +{ + ::osl::MutexGuard aGuard (maMutex); + + mnUpdateLockCount--; + if (mnUpdateLockCount < 0) + { + // This should not happen. + OSL_ASSERT (mnUpdateLockCount>=0); + mnUpdateLockCount = 0; + } + if (mnUpdateLockCount == 0) + UpdateShellStack(); +} + + + + +/** Update the SFX shell stack (the portion that is visible to us) so that + it matches the internal shell stack. This is done in six steps: + 1. Create the missing view shells and sub shells. + 2. Set up the internal shell stack. + 3. Get the SFX shell stack. + 4. Find the lowest shell in which the two stacks differ. + 5. Remove all shells above and including that shell from the SFX stack. + 6. Push all shells of the internal stack on the SFX shell stack that are + not already present on the later. +*/ +void ViewShellManager::Implementation::UpdateShellStack (void) +{ + ::osl::MutexGuard aGuard (maMutex); + + // Remember the undo manager from the top-most shell on the stack. + SfxShell* pTopMostShell = mrBase.GetSubShell(0); + SfxUndoManager* pUndoManager = (pTopMostShell!=NULL) + ? pTopMostShell->GetUndoManager() + : NULL; + + // 1. Create the missing shells. + CreateShells(); + + + // 2. Create the internal target stack. + ShellStack aTargetStack; + CreateTargetStack(aTargetStack); + + + // 3. Get SFX shell stack. + ShellStack aSfxShellStack; + USHORT nIndex (0); + while (mrBase.GetSubShell(nIndex)!=NULL) + ++nIndex; + aSfxShellStack.reserve(nIndex); + while (nIndex-- > 0) + aSfxShellStack.push_back(mrBase.GetSubShell(nIndex)); + + +#ifdef VERBOSE + OSL_TRACE("Current SFX Stack\r"); + DumpShellStack(aSfxShellStack); + OSL_TRACE("Target Stack\r"); + DumpShellStack(aTargetStack); +#endif + + + // 4. Find the lowest shell in which the two stacks differ. + ShellStack::const_iterator iSfxShell (aSfxShellStack.begin()); + ShellStack::iterator iTargetShell (aTargetStack.begin()); + while (iSfxShell != aSfxShellStack.end() + && iTargetShell!=aTargetStack.end() + && (*iSfxShell)==(*iTargetShell)) + { + ++iSfxShell; + ++iTargetShell; + } + + + // 5. Remove all shells above and including the differing shell from the + // SFX stack starting with the shell on top of the stack. + while (iSfxShell != aSfxShellStack.end()) + { + SfxShell* pShell = aSfxShellStack.back(); + aSfxShellStack.pop_back(); +#ifdef VERBOSE + OSL_TRACE("removing shell %p from stack\r", pShell); +#endif + mrBase.RemoveSubShell(pShell); + } + + + // 6. Push shells from the given stack onto the SFX stack. + mbShellStackIsUpToDate = false; + while (iTargetShell != aTargetStack.end()) + { +#ifdef VERBOSE + OSL_TRACE("pushing shell %p on stack\r", *iTargetShell); +#endif + mrBase.AddSubShell(**iTargetShell); + ++iTargetShell; + + // The pushing of the shell on to the shell stack may have lead to + // another invocation of this method. In this case we have to abort + // pushing shells on the stack and return immediately. + if (mbShellStackIsUpToDate) + break; + } + if (mrBase.GetDispatcher() != NULL) + mrBase.GetDispatcher()->Flush(); + + // Update the pointer to the top-most shell and set its undo manager + // to the one of the previous top-most shell. + mpTopShell = mrBase.GetSubShell(0); + if (mpTopShell!=NULL && pUndoManager!=NULL && mpTopShell->GetUndoManager()==NULL) + mpTopShell->SetUndoManager(pUndoManager); + + // Finally tell an invocation of this method on a higher level that it can (has + // to) abort and return immediately. + mbShellStackIsUpToDate = true; + +#ifdef VERBOSE + OSL_TRACE("New current stack\r"); + DumpSfxShellStack(); +#endif +} + + + + +void ViewShellManager::Implementation::TakeShellsFromStack (const SfxShell* pShell) +{ + ::osl::MutexGuard aGuard (maMutex); + + // Remember the undo manager from the top-most shell on the stack. + SfxShell* pTopMostShell = mrBase.GetSubShell(0); + SfxUndoManager* pUndoManager = (pTopMostShell!=NULL) + ? pTopMostShell->GetUndoManager() + : NULL; + +#ifdef VERBOSE + OSL_TRACE("TakeShellsFromStack(%p)\r", pShell); + DumpSfxShellStack(); +#endif + + // 0.Make sure that the given shell is on the stack. This is a + // preparation for the following assertion. + for (USHORT nIndex=0; true; nIndex++) + { + SfxShell* pShellOnStack = mrBase.GetSubShell(nIndex); + if (pShellOnStack == NULL) + { + // Set pShell to NULL to indicate the following code that the + // shell is not on the stack. + pShell = NULL; + break; + } + else if (pShellOnStack == pShell) + break; + } + + if (pShell != NULL) + { + // 1. Deactivate our shells on the stack before they are removed so + // that during the Deactivation() calls the stack is still intact. + for (USHORT nIndex=0; true; nIndex++) + { + SfxShell* pShellOnStack = mrBase.GetSubShell(nIndex); + Deactivate(pShellOnStack); + if (pShellOnStack == pShell) + break; + } + + // 2. Remove the shells from the stack. + while (true) + { + SfxShell* pShellOnStack = mrBase.GetSubShell(0); +#ifdef VERBOSE + OSL_TRACE("removing shell %p from stack\r", pShellOnStack); +#endif + mrBase.RemoveSubShell(pShellOnStack); + if (pShellOnStack == pShell) + break; + } + + // 3. Update the stack. + if (mrBase.GetDispatcher() != NULL) + mrBase.GetDispatcher()->Flush(); + + // Update the pointer to the top-most shell and set its undo manager + // to the one of the previous top-most shell. + mpTopShell = mrBase.GetSubShell(0); + if (mpTopShell!=NULL && pUndoManager!=NULL && mpTopShell->GetUndoManager()==NULL) + mpTopShell->SetUndoManager(pUndoManager); + } + +#ifdef VERBOSE + OSL_TRACE("Sfx shell stack is:\r"); + DumpSfxShellStack(); +#endif +} + + + + +void ViewShellManager::Implementation::CreateShells (void) +{ + ::osl::MutexGuard aGuard (maMutex); + + // Iterate over all view shells. + ShellStack aShellStack; + ActiveShellList::reverse_iterator iShell; + for (iShell=maActiveViewShells.rbegin(); iShell!=maActiveViewShells.rend(); ++iShell) + { + // Get the list of associated sub shells. + SubShellList::iterator iList (maActiveSubShells.find(iShell->mpShell)); + if (iList != maActiveSubShells.end()) + { + SubShellSubList& rList (iList->second); + + // Iterate over all sub shells of the current view shell. + SubShellSubList::iterator iSubShell; + for (iSubShell=rList.begin(); iSubShell!=rList.end(); ++iSubShell) + { + if (iSubShell->mpShell == NULL) + { + *iSubShell = CreateSubShell(iShell->mpShell,iSubShell->mnId,NULL,NULL); + } + } + } + } +} + + + + +void ViewShellManager::Implementation::CreateTargetStack (ShellStack& rStack) const +{ + // Create a local stack of the shells that are to push on the shell + // stack. We can thus safly create the required shells wile still + // having a valid shell stack. + for (ActiveShellList::const_reverse_iterator iViewShell (maActiveViewShells.rbegin()); + iViewShell != maActiveViewShells.rend(); + ++iViewShell) + { + // Possibly place the form shell below the current view shell. + if ( ! mbFormShellAboveParent + && mpFormShell!=NULL + && iViewShell->mpShell==mpFormShellParent) + { + rStack.push_back(mpFormShell); + } + + // Put the view shell itself on the local stack. + rStack.push_back (iViewShell->mpShell); + + // Possibly place the form shell above the current view shell. + if (mbFormShellAboveParent + && mpFormShell!=NULL + && iViewShell->mpShell==mpFormShellParent) + { + rStack.push_back(mpFormShell); + } + + // Add all other sub shells. + SubShellList::const_iterator iList (maActiveSubShells.find(iViewShell->mpShell)); + if (iList != maActiveSubShells.end()) + { + const SubShellSubList& rList (iList->second); + SubShellSubList::const_reverse_iterator iSubShell; + for (iSubShell=rList.rbegin(); iSubShell!=rList.rend(); ++iSubShell) + if (iSubShell->mpShell != mpFormShell) + rStack.push_back(iSubShell->mpShell); + } + } +} + + + + +IMPL_LINK(ViewShellManager::Implementation, WindowEventHandler, VclWindowEvent*, pEvent) +{ + if (pEvent != NULL) + { + ::Window* pEventWindow + = static_cast<VclWindowEvent*>(pEvent)->GetWindow(); + + switch (pEvent->GetId()) + { + case VCLEVENT_WINDOW_GETFOCUS: + { + for (ActiveShellList::iterator aI(maActiveViewShells.begin()); + aI!=maActiveViewShells.end(); + aI++) + { + if (pEventWindow == static_cast< ::Window*>(aI->GetWindow())) + { + MoveToTop(*aI->mpShell); + break; + } + } + } + break; + + case VCLEVENT_WINDOW_LOSEFOCUS: + break; + } + } + return TRUE; +} + + + + +ShellDescriptor ViewShellManager::Implementation::CreateSubShell ( + SfxShell* pParentShell, + ShellId nShellId, + ::Window* pParentWindow, + FrameView* pFrameView) +{ + ::osl::MutexGuard aGuard (maMutex); + ShellDescriptor aResult; + + // Look up the factories for the parent shell. + ::std::pair<FactoryList::iterator,FactoryList::iterator> aRange( + maShellFactories.equal_range(pParentShell)); + + // Try all factories to create the shell. + for (FactoryList::const_iterator iFactory=aRange.first; iFactory!=aRange.second; ++iFactory) + { + SharedShellFactory pFactory = iFactory->second; + if (pFactory != NULL) + aResult.mpShell = pFactory->CreateShell(nShellId, pParentWindow, pFrameView); + + // Exit the loop when the shell has been successfully created. + if (aResult.mpShell != NULL) + { + aResult.mpFactory = pFactory; + aResult.mnId = nShellId; + break; + } + } + + return aResult; +} + + + + +void ViewShellManager::Implementation::DestroyViewShell ( + const ShellDescriptor& rDescriptor) +{ + OSL_ASSERT(rDescriptor.mpShell != NULL); + + ::Window* pWindow = rDescriptor.GetWindow(); + if (pWindow != NULL) + { + pWindow->RemoveEventListener( + LINK(this, ViewShellManager::Implementation, WindowEventHandler)); + } + + // Destroy the sub shell factories. + ::std::pair<FactoryList::iterator,FactoryList::iterator> aRange( + maShellFactories.equal_range(rDescriptor.mpShell)); + if (aRange.first != maShellFactories.end()) + maShellFactories.erase(aRange.first, aRange.second); + + // Release the shell. + if (rDescriptor.mpFactory.get() != NULL) + rDescriptor.mpFactory->ReleaseShell(rDescriptor.mpShell); +} + + + + +void ViewShellManager::Implementation::DestroySubShell ( + const SfxShell& rParentShell, + const ShellDescriptor& rDescriptor) +{ + (void)rParentShell; + OSL_ASSERT(rDescriptor.mpFactory.get() != NULL); + rDescriptor.mpFactory->ReleaseShell(rDescriptor.mpShell); +} + + + + +void ViewShellManager::Implementation::InvalidateAllSubShells (const SfxShell* pParentShell) +{ + ::osl::MutexGuard aGuard (maMutex); + + SubShellList::iterator iList (maActiveSubShells.find(pParentShell)); + if (iList != maActiveSubShells.end()) + { + SubShellSubList& rList (iList->second); + SubShellSubList::iterator iShell; + for (iShell=rList.begin(); iShell!=rList.end(); ++iShell) + if (iShell->mpShell != NULL) + iShell->mpShell->Invalidate(); + } +} + + + + +void ViewShellManager::Implementation::Shutdown (void) +{ + ::osl::MutexGuard aGuard (maMutex); + + // Take stacked shells from stack. + if ( ! maActiveViewShells.empty()) + { + UpdateLock aLock (*this); + + + while ( ! maActiveViewShells.empty()) + { + SfxShell* pShell = maActiveViewShells.front().mpShell; + if (pShell != NULL) + { + ViewShell* pViewShell = dynamic_cast<ViewShell*>(pShell); + if (pViewShell != NULL) + DeactivateViewShell(*pViewShell); + else + DeactivateShell(*pShell); + } + else + { + DBG_ASSERT(false, + "ViewShellManager::Implementation::Shutdown(): empty active shell descriptor"); + maActiveViewShells.pop_front(); + } + } + } + mrBase.RemoveSubShell (NULL); + + maShellFactories.clear(); +} + + + + +void ViewShellManager::Implementation::DumpShellStack (const ShellStack& rStack) +{ + ShellStack::const_reverse_iterator iEntry; + for (iEntry=rStack.rbegin(); iEntry!=rStack.rend(); ++iEntry) + if (*iEntry != NULL) + OSL_TRACE (" %p : %s\r", + *iEntry, + ::rtl::OUStringToOString((*iEntry)->GetName(),RTL_TEXTENCODING_UTF8).getStr()); + else + OSL_TRACE(" null\r"); +} + + + + +void ViewShellManager::Implementation::DumpSfxShellStack (void) +{ + ShellStack aSfxShellStack; + USHORT nIndex (0); + while (mrBase.GetSubShell(nIndex)!=NULL) + ++nIndex; + aSfxShellStack.reserve(nIndex); + while (nIndex-- > 0) + aSfxShellStack.push_back(mrBase.GetSubShell(nIndex)); + DumpShellStack(aSfxShellStack); +} + + + + +void ViewShellManager::Implementation::Deactivate (SfxShell* pShell) +{ + OSL_ASSERT(pShell!=NULL); + + // We have to end a text edit for view shells that are to be taken from + // the shell stack. + ViewShell* pViewShell = dynamic_cast<ViewShell*>(pShell); + if (pViewShell != NULL) + { + sd::View* pView = pViewShell->GetView(); + if (pView!=NULL && pView->IsTextEdit()) + { + pView->SdrEndTextEdit(); + pView->UnmarkAll(); + pViewShell->GetViewFrame()->GetDispatcher()->Execute( + SID_OBJECT_SELECT, + SFX_CALLMODE_ASYNCHRON); + } + } + + // Now we can deactivate the shell. + pShell->Deactivate(TRUE); +} + + + + +void ViewShellManager::Implementation::SetFormShell ( + const ViewShell* pFormShellParent, + FmFormShell* pFormShell, + bool bFormShellAboveParent) +{ + ::osl::MutexGuard aGuard (maMutex); + + mpFormShellParent = pFormShellParent; + mpFormShell = pFormShell; + mbFormShellAboveParent = bFormShellAboveParent; +} + + + + +namespace { + +ShellDescriptor::ShellDescriptor (void) + : mpShell(NULL), + mnId(0), + mpFactory() +{ +} + + + + +ShellDescriptor::ShellDescriptor ( + SfxShell* pShell, + ShellId nId) + : mpShell(pShell), + mnId(nId), + mpFactory() +{ +} + + + + +ShellDescriptor::ShellDescriptor (const ShellDescriptor& rDescriptor) + : mpShell(rDescriptor.mpShell), + mnId(rDescriptor.mnId), + mpFactory(rDescriptor.mpFactory) +{ +} + + + + +ShellDescriptor& ShellDescriptor::operator= (const ShellDescriptor& rDescriptor) +{ + mpShell = rDescriptor.mpShell; + mnId = rDescriptor.mnId; + mpFactory = rDescriptor.mpFactory; + return *this; +} + + + + +bool ShellDescriptor::IsMainViewShell (void) const +{ + ViewShell* pViewShell = dynamic_cast<ViewShell*>(mpShell); + if (pViewShell != NULL) + return pViewShell->IsMainViewShell(); + else + return false; +} + + + + +::Window* ShellDescriptor::GetWindow (void) const +{ + ViewShell* pViewShell = dynamic_cast<ViewShell*>(mpShell); + if (pViewShell != NULL) + return pViewShell->GetActiveWindow(); + else + return NULL; +} + + + +} // end of anonymous namespace + +} // end of namespace sd diff --git a/sd/source/ui/view/ViewTabBar.cxx b/sd/source/ui/view/ViewTabBar.cxx new file mode 100755 index 000000000000..a12412bf7f7d --- /dev/null +++ b/sd/source/ui/view/ViewTabBar.cxx @@ -0,0 +1,716 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "ViewTabBar.hxx" + +#define USE_TAB_CONTROL + +#include "ViewShell.hxx" +#include "ViewShellBase.hxx" +#include "DrawViewShell.hxx" +#include "FrameView.hxx" +#include "EventMultiplexer.hxx" +#include "framework/FrameworkHelper.hxx" +#include "framework/Pane.hxx" +#include "DrawController.hxx" + +#include "sdresid.hxx" +#include "strings.hrc" +#include "helpids.h" +#include "Client.hxx" +#include <vcl/svapp.hxx> +#include <vcl/tabpage.hxx> +#include <vos/mutex.hxx> +#include <sfx2/viewfrm.hxx> +#include <com/sun/star/drawing/framework/ResourceId.hpp> +#include <com/sun/star/drawing/framework/XControllerManager.hpp> +#include <com/sun/star/lang/XUnoTunnel.hpp> +#include <com/sun/star/lang/DisposedException.hpp> +#include <comphelper/processfactory.hxx> +#include <tools/diagnose_ex.h> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::drawing::framework; +using ::sd::framework::FrameworkHelper; +using ::sd::tools::EventMultiplexerEvent; +using ::rtl::OUString; + +namespace sd { + +namespace { +bool IsEqual (const TabBarButton& rButton1, const TabBarButton& rButton2) +{ + return ( + (rButton1.ResourceId.is() + && rButton2.ResourceId.is() + && rButton1.ResourceId->compareTo(rButton2.ResourceId)==0) + || rButton1.ButtonLabel == rButton2.ButtonLabel); +} + +class TabBarControl : public ::TabControl +{ +public: + TabBarControl ( + ::Window* pParentWindow, + const ::rtl::Reference<ViewTabBar>& rpViewTabBar); + virtual void Paint (const Rectangle& rRect); + virtual void ActivatePage (void); +private: + ::rtl::Reference<ViewTabBar> mpViewTabBar; +}; + +} // end of anonymous namespace + + + + + +class ViewTabPage : public TabPage +{ +public: + ViewTabPage (Window* pParent) : TabPage(pParent) {} + virtual void Resize (void) + { SetPosSizePixel(Point(0,0),GetParent()->GetOutputSizePixel()); } +}; + + + + +//===== ViewTabBar ============================================================ + +ViewTabBar::ViewTabBar ( + const Reference<XResourceId>& rxViewTabBarId, + const Reference<frame::XController>& rxController) + : ViewTabBarInterfaceBase(maMutex), + mpTabControl(new TabBarControl(GetAnchorWindow(rxViewTabBarId,rxController), this)), + mxController(rxController), + maTabBarButtons(), + mpTabPage(NULL), + mxViewTabBarId(rxViewTabBarId), + mpViewShellBase(NULL) +{ + // Set one new tab page for all tab entries. We need it only to + // determine the height of the tab bar. + mpTabPage.reset(new TabPage (mpTabControl.get())); + mpTabPage->Hide(); + + // add some space before the tabitems + mpTabControl->SetItemsOffset(Point(5, 3)); + + // Tunnel through the controller and use the ViewShellBase to obtain the + // view frame. + try + { + Reference<lang::XUnoTunnel> xTunnel (mxController, UNO_QUERY_THROW); + DrawController* pController = reinterpret_cast<DrawController*>( + xTunnel->getSomething(DrawController::getUnoTunnelId())); + mpViewShellBase = pController->GetViewShellBase(); + } + catch(RuntimeException&) + {} + + // Register as listener at XConfigurationController. + Reference<XControllerManager> xControllerManager (mxController, UNO_QUERY); + if (xControllerManager.is()) + { + mxConfigurationController = xControllerManager->getConfigurationController(); + if (mxConfigurationController.is()) + { + mxConfigurationController->addConfigurationChangeListener( + this, + FrameworkHelper::msResourceActivationEvent, + Any()); + } + } + + mpTabControl->Show(); + + if (mpViewShellBase != NULL + && rxViewTabBarId->isBoundToURL( + FrameworkHelper::msCenterPaneURL, AnchorBindingMode_DIRECT)) + { + mpViewShellBase->SetViewTabBar(this); + } +} + + + + +ViewTabBar::~ViewTabBar (void) +{ +} + + + + +void ViewTabBar::disposing (void) +{ + if (mpViewShellBase != NULL + && mxViewTabBarId->isBoundToURL( + FrameworkHelper::msCenterPaneURL, AnchorBindingMode_DIRECT)) + { + mpViewShellBase->SetViewTabBar(NULL); + } + + if (mxConfigurationController.is()) + { + // Unregister listener from XConfigurationController. + try + { + mxConfigurationController->removeConfigurationChangeListener(this); + } + catch (lang::DisposedException e) + { + // Receiving a disposed exception is the normal case. Is there + // a way to avoid it? + } + mxConfigurationController = NULL; + } + + { + const ::vos::OGuard aSolarGuard (Application::GetSolarMutex()); + // Set all references to the one tab page to NULL and delete the page. + for (USHORT nIndex=0; nIndex<mpTabControl->GetPageCount(); ++nIndex) + mpTabControl->SetTabPage(nIndex, NULL); + mpTabPage.reset(); + mpTabControl.reset(); + } + + mxController = NULL; +} + + + + +::boost::shared_ptr< ::TabControl> ViewTabBar::GetTabControl (void) const +{ + return mpTabControl; +} + + + + +::Window* ViewTabBar::GetAnchorWindow( + const Reference<XResourceId>& rxViewTabBarId, + const Reference<frame::XController>& rxController) +{ + ::Window* pWindow = NULL; + ViewShellBase* pBase = NULL; + + // Tunnel through the controller and use the ViewShellBase to obtain the + // view frame. + try + { + Reference<lang::XUnoTunnel> xTunnel (rxController, UNO_QUERY_THROW); + DrawController* pController = reinterpret_cast<DrawController*>( + xTunnel->getSomething(DrawController::getUnoTunnelId())); + pBase = pController->GetViewShellBase(); + } + catch(RuntimeException&) + {} + + // The ViewTabBar supports at the moment only the center pane. + if (rxViewTabBarId.is() + && rxViewTabBarId->isBoundToURL( + FrameworkHelper::msCenterPaneURL, AnchorBindingMode_DIRECT)) + { + if (pBase != NULL && pBase->GetViewFrame() != NULL) + pWindow = &pBase->GetViewFrame()->GetWindow(); + } + + // The rest is (at the moment) just for the emergency case. + if (pWindow == NULL) + { + Reference<XPane> xPane; + try + { + Reference<XControllerManager> xControllerManager (rxController, UNO_QUERY_THROW); + Reference<XConfigurationController> xCC ( + xControllerManager->getConfigurationController()); + if (xCC.is()) + xPane = Reference<XPane>(xCC->getResource(rxViewTabBarId->getAnchor()), UNO_QUERY); + } + catch (RuntimeException&) + {} + + // Tunnel through the XWindow to the VCL side. + try + { + Reference<lang::XUnoTunnel> xTunnel (xPane, UNO_QUERY_THROW); + framework::Pane* pPane = reinterpret_cast<framework::Pane*>( + xTunnel->getSomething(framework::Pane::getUnoTunnelId())); + if (pPane != NULL) + pWindow = pPane->GetWindow()->GetParent(); + } + catch (RuntimeException&) + {} + } + + return pWindow; +} + + + + +//----- XConfigurationChangeListener ------------------------------------------ + +void SAL_CALL ViewTabBar::notifyConfigurationChange ( + const ConfigurationChangeEvent& rEvent) + throw (RuntimeException) +{ + if (rEvent.Type.equals(FrameworkHelper::msResourceActivationEvent) + && rEvent.ResourceId->getResourceURL().match(FrameworkHelper::msViewURLPrefix) + && rEvent.ResourceId->isBoundTo(mxViewTabBarId->getAnchor(), AnchorBindingMode_DIRECT)) + { + UpdateActiveButton(); + } +} + + + + +//----- XEventListener -------------------------------------------------------- + +void SAL_CALL ViewTabBar::disposing( + const lang::EventObject& rEvent) + throw (RuntimeException) +{ + if (rEvent.Source == mxConfigurationController) + { + mxConfigurationController = NULL; + mxController = NULL; + } +} + + + + +//----- XTabBar --------------------------------------------------------------- + +void SAL_CALL ViewTabBar::addTabBarButtonAfter ( + const TabBarButton& rButton, + const TabBarButton& rAnchor) + throw (::com::sun::star::uno::RuntimeException) +{ + const ::vos::OGuard aSolarGuard (Application::GetSolarMutex()); + AddTabBarButton(rButton, rAnchor); +} + + + + +void SAL_CALL ViewTabBar::appendTabBarButton (const TabBarButton& rButton) + throw (::com::sun::star::uno::RuntimeException) +{ + const ::vos::OGuard aSolarGuard (Application::GetSolarMutex()); + AddTabBarButton(rButton); +} + + + +void SAL_CALL ViewTabBar::removeTabBarButton (const TabBarButton& rButton) + throw (::com::sun::star::uno::RuntimeException) +{ + const ::vos::OGuard aSolarGuard (Application::GetSolarMutex()); + RemoveTabBarButton(rButton); +} + + + + +sal_Bool SAL_CALL ViewTabBar::hasTabBarButton (const TabBarButton& rButton) + throw (::com::sun::star::uno::RuntimeException) +{ + const ::vos::OGuard aSolarGuard (Application::GetSolarMutex()); + return HasTabBarButton(rButton); +} + + + + +Sequence<TabBarButton> SAL_CALL ViewTabBar::getTabBarButtons (void) + throw (::com::sun::star::uno::RuntimeException) +{ + const ::vos::OGuard aSolarGuard (Application::GetSolarMutex()); + return GetTabBarButtons(); +} + + + + +//----- XResource ------------------------------------------------------------- + +Reference<XResourceId> SAL_CALL ViewTabBar::getResourceId (void) + throw (RuntimeException) +{ + return mxViewTabBarId; +} + + + + +sal_Bool SAL_CALL ViewTabBar::isAnchorOnly (void) + throw (RuntimeException) +{ + return false; +} + + + + +//----- XUnoTunnel ------------------------------------------------------------ + +const Sequence<sal_Int8>& ViewTabBar::getUnoTunnelId (void) +{ + static Sequence<sal_Int8>* pSequence = NULL; + if (pSequence == NULL) + { + const ::vos::OGuard aSolarGuard (Application::GetSolarMutex()); + if (pSequence == NULL) + { + static ::com::sun::star::uno::Sequence<sal_Int8> aSequence (16); + rtl_createUuid((sal_uInt8*)aSequence.getArray(), 0, sal_True); + pSequence = &aSequence; + } + } + return *pSequence; +} + + + + +sal_Int64 SAL_CALL ViewTabBar::getSomething (const Sequence<sal_Int8>& rId) + throw (RuntimeException) +{ + sal_Int64 nResult = 0; + + if (rId.getLength() == 16 + && rtl_compareMemory(getUnoTunnelId().getConstArray(), rId.getConstArray(), 16) == 0) + { + nResult = reinterpret_cast<sal_Int64>(this); + } + + return nResult; +} + + + + +//----------------------------------------------------------------------------- + +bool ViewTabBar::ActivatePage (void) +{ + try + { + Reference<XControllerManager> xControllerManager (mxController,UNO_QUERY_THROW); + Reference<XConfigurationController> xConfigurationController ( + xControllerManager->getConfigurationController()); + if ( ! xConfigurationController.is()) + throw RuntimeException(); + Reference<XView> xView; + try + { + xView = Reference<XView>(xConfigurationController->getResource( + ResourceId::create( + ::comphelper::getProcessComponentContext(), + FrameworkHelper::msCenterPaneURL)), + UNO_QUERY); + } + catch (DeploymentException) + { + } + + Client* pIPClient = NULL; + if (mpViewShellBase != NULL) + pIPClient = dynamic_cast<Client*>(mpViewShellBase->GetIPClient()); + if (pIPClient==NULL || ! pIPClient->IsObjectInPlaceActive()) + { + USHORT nIndex (mpTabControl->GetCurPageId() - 1); + if (nIndex < maTabBarButtons.size()) + { + xConfigurationController->requestResourceActivation( + maTabBarButtons[nIndex].ResourceId, + ResourceActivationMode_REPLACE); + } + + return true; + } + else + { + // When we run into this else branch then we have an active OLE + // object. We ignore the request to switch views. Additionally + // we put the active tab back to the one for the current view. + UpdateActiveButton(); + } + } + catch (RuntimeException&) + { + DBG_UNHANDLED_EXCEPTION(); + } + + return false; +} + + + + +int ViewTabBar::GetHeight (void) +{ + int nHeight (0); + + if (maTabBarButtons.size() > 0) + { + TabPage* pActivePage (mpTabControl->GetTabPage( + mpTabControl->GetCurPageId())); + if (pActivePage!=NULL && mpTabControl->IsReallyVisible()) + nHeight = pActivePage->GetPosPixel().Y(); + + if (nHeight <= 0) + // Using a default when the real height can not be determined. + // To get correct height this method should be called when the + // control is visible. + nHeight = 21; + } + + return nHeight; +} + + + + +void ViewTabBar::AddTabBarButton ( + const ::com::sun::star::drawing::framework::TabBarButton& rButton, + const ::com::sun::star::drawing::framework::TabBarButton& rAnchor) +{ + sal_uInt32 nIndex; + + if ( ! rAnchor.ResourceId.is() + || (rAnchor.ResourceId->getResourceURL().getLength() == 0 + && rAnchor.ButtonLabel.getLength() == 0)) + { + nIndex = 0; + } + else + { + for (nIndex=0; nIndex<maTabBarButtons.size(); ++nIndex) + { + if (IsEqual(maTabBarButtons[nIndex], rAnchor)) + { + ++nIndex; + break; + } + } + } + + AddTabBarButton(rButton,nIndex); +} + + + + +void ViewTabBar::AddTabBarButton ( + const ::com::sun::star::drawing::framework::TabBarButton& rButton) +{ + AddTabBarButton(rButton, maTabBarButtons.size()); +} + + + + +void ViewTabBar::AddTabBarButton ( + const ::com::sun::star::drawing::framework::TabBarButton& rButton, + sal_Int32 nPosition) +{ + if (nPosition>=0 + && nPosition<=mpTabControl->GetPageCount()) + { + USHORT nIndex ((USHORT)nPosition); + + // Insert the button into our local array. + maTabBarButtons.insert(maTabBarButtons.begin()+nIndex, rButton); + UpdateTabBarButtons(); + UpdateActiveButton(); + } +} + + + + +void ViewTabBar::RemoveTabBarButton ( + const ::com::sun::star::drawing::framework::TabBarButton& rButton) +{ + USHORT nIndex; + for (nIndex=0; nIndex<maTabBarButtons.size(); ++nIndex) + { + if (IsEqual(maTabBarButtons[nIndex], rButton)) + { + maTabBarButtons.erase(maTabBarButtons.begin()+nIndex); + UpdateTabBarButtons(); + UpdateActiveButton(); + break; + } + } +} + + + + +bool ViewTabBar::HasTabBarButton ( + const ::com::sun::star::drawing::framework::TabBarButton& rButton) +{ + bool bResult (false); + + for (sal_uInt32 nIndex=0; nIndex<maTabBarButtons.size(); ++nIndex) + { + if (IsEqual(maTabBarButtons[nIndex], rButton)) + { + bResult = true; + break; + } + } + + return bResult; +} + + + + +::com::sun::star::uno::Sequence<com::sun::star::drawing::framework::TabBarButton> + ViewTabBar::GetTabBarButtons (void) +{ + sal_uInt32 nCount (maTabBarButtons.size()); + ::com::sun::star::uno::Sequence<com::sun::star::drawing::framework::TabBarButton> + aList (nCount); + + for (sal_uInt32 nIndex=0; nIndex<nCount; ++nIndex) + aList[nIndex] = maTabBarButtons[nIndex]; + + return aList; +} + + + + +void ViewTabBar::UpdateActiveButton (void) +{ + Reference<XView> xView; + if (mpViewShellBase != NULL) + xView = FrameworkHelper::Instance(*mpViewShellBase)->GetView( + mxViewTabBarId->getAnchor()); + if (xView.is()) + { + Reference<XResourceId> xViewId (xView->getResourceId()); + for (USHORT nIndex=0; nIndex<maTabBarButtons.size(); ++nIndex) + { + if (maTabBarButtons[nIndex].ResourceId->compareTo(xViewId) == 0) + { + mpTabControl->SetCurPageId(nIndex+1); + mpTabControl->::TabControl::ActivatePage(); + break; + } + } + } +} + + + + +void ViewTabBar::UpdateTabBarButtons (void) +{ + TabBarButtonList::const_iterator iTab; + USHORT nPageCount (mpTabControl->GetPageCount()); + USHORT nIndex; + for (iTab=maTabBarButtons.begin(),nIndex=1; iTab!=maTabBarButtons.end(); ++iTab,++nIndex) + { + // Create a new tab when there are not enough. + if (nPageCount < nIndex) + mpTabControl->InsertPage(nIndex, iTab->ButtonLabel); + + // Update the tab. + mpTabControl->SetPageText(nIndex, iTab->ButtonLabel); + mpTabControl->SetHelpText(nIndex, iTab->HelpText); + mpTabControl->SetTabPage(nIndex, mpTabPage.get()); + } + + // Delete tabs that are no longer used. + for (; nIndex<=nPageCount; ++nIndex) + mpTabControl->RemovePage(nIndex); + + mpTabPage->Hide(); +} + + + + +//===== TabBarControl ========================================================= + +TabBarControl::TabBarControl ( + ::Window* pParentWindow, + const ::rtl::Reference<ViewTabBar>& rpViewTabBar) + : ::TabControl(pParentWindow), + mpViewTabBar(rpViewTabBar) +{ +} + + + + +void TabBarControl::Paint (const Rectangle& rRect) +{ + Color aOriginalFillColor (GetFillColor()); + Color aOriginalLineColor (GetLineColor()); + + // Because the actual window background is transparent--to avoid + // flickering due to multiple background paintings by this and by child + // windows--we have to paint the background for this control explicitly: + // the actual control is not painted over its whole bounding box. + SetFillColor (GetSettings().GetStyleSettings().GetDialogColor()); + SetLineColor (); + DrawRect (rRect); + ::TabControl::Paint (rRect); + + SetFillColor (aOriginalFillColor); + SetLineColor (aOriginalLineColor); +} + + + + +void TabBarControl::ActivatePage (void) +{ + if (mpViewTabBar->ActivatePage()) + { + // Call the parent so that the correct tab is highlighted. + this->::TabControl::ActivatePage(); + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/WindowUpdater.cxx b/sd/source/ui/view/WindowUpdater.cxx new file mode 100644 index 000000000000..3e074e0108ad --- /dev/null +++ b/sd/source/ui/view/WindowUpdater.cxx @@ -0,0 +1,189 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "WindowUpdater.hxx" +#include "ViewShell.hxx" +#include "Window.hxx" +#include "drawdoc.hxx" +#include "View.hxx" + +#ifndef _SPLIT_HXX +#include <vcl/split.hxx> +#endif +#include <sfx2/childwin.hxx> +#include <sfx2/viewfrm.hxx> +#include <svl/smplhint.hxx> + +#include <algorithm> + +namespace sd { + +WindowUpdater::WindowUpdater (void) + : mpViewShell (NULL), + mpDocument (NULL) +{ + maCTLOptions.AddListener(this); +} + + + + +WindowUpdater::~WindowUpdater (void) throw () +{ + maCTLOptions.RemoveListener(this); +} + + + + +void WindowUpdater::RegisterWindow (::Window* pWindow) +{ + if (pWindow != NULL) + { + tWindowList::iterator aWindowIterator ( + ::std::find ( + maWindowList.begin(), maWindowList.end(), pWindow)); + if (aWindowIterator == maWindowList.end()) + { + // Update the device once right now and add it to the list. + Update (pWindow); + maWindowList.push_back (pWindow); + } + } +} + + + + +void WindowUpdater::UnregisterWindow (::Window* pWindow) +{ + tWindowList::iterator aWindowIterator ( + ::std::find ( + maWindowList.begin(), maWindowList.end(), pWindow)); + if (aWindowIterator != maWindowList.end()) + { + maWindowList.erase (aWindowIterator); + } +} + + + +void WindowUpdater::SetViewShell (ViewShell& rViewShell) +{ + mpViewShell = &rViewShell; +} + + + + +void WindowUpdater::SetDocument (SdDrawDocument* pDocument) +{ + mpDocument = pDocument; +} + + + + +void WindowUpdater::Update ( + OutputDevice* pDevice, + SdDrawDocument* pDocument) const +{ + if (pDevice != NULL) + { + UpdateWindow (pDevice); + if (pDocument != NULL) + pDocument->ReformatAllTextObjects(); + } +} + + + + +void WindowUpdater::UpdateWindow (OutputDevice* pDevice) const +{ + if (pDevice != NULL) + { + SvtCTLOptions::TextNumerals aNumeralMode (maCTLOptions.GetCTLTextNumerals()); + + LanguageType aLanguage; + // Now this is a bit confusing. The numerals in arabic languages + // are Hindi numerals and what the western world generally uses are + // arabic numerals. The digits used in the Hindi language are not + // used at all. + switch (aNumeralMode) + { + case SvtCTLOptions::NUMERALS_HINDI: + aLanguage = LANGUAGE_ARABIC_SAUDI_ARABIA; + break; + + case SvtCTLOptions::NUMERALS_SYSTEM: + aLanguage = LANGUAGE_SYSTEM; + break; + + case SvtCTLOptions::NUMERALS_ARABIC: + default: + aLanguage = LANGUAGE_ENGLISH; + break; + } + + pDevice->SetDigitLanguage (aLanguage); + } +} + + + + +void WindowUpdater::ConfigurationChanged( utl::ConfigurationBroadcaster*, sal_uInt32 ) +{ + // #110094#-7 + // Clear the master page cache so that master pages will be redrawn. + //if (mpViewShell != NULL) + //{ + // SdView* pView = mpViewShell->GetView(); + // if (pView != NULL) + // pView->ReleaseMasterPagePaintCache (); + //} + // Set the current state at all registered output devices. + tWindowList::iterator aWindowIterator (maWindowList.begin()); + while (aWindowIterator != maWindowList.end()) + Update (*aWindowIterator++); + + // Reformat the document for the modified state to take effect. + if (mpDocument != NULL) + mpDocument->ReformatAllTextObjects(); + + // Invalidate the windows to make the modified state visible. + aWindowIterator = maWindowList.begin(); + while (aWindowIterator != maWindowList.end()) + (*aWindowIterator++)->Invalidate(); +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/bmcache.cxx b/sd/source/ui/view/bmcache.cxx new file mode 100755 index 000000000000..c7f313037ff8 --- /dev/null +++ b/sd/source/ui/view/bmcache.cxx @@ -0,0 +1,78 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + + +#include <limits.h> // LONG_MAX +#include <tools/solar.h> +#include <svtools/grfmgr.hxx> +#include "bmcache.hxx" + +// eine Struktur fuer die Cache-Eintraege +struct BitmapCacheEntry +{ + const SdPage* pPage; + GraphicObject* pGraphicObject; + sal_uInt32 nSizeBytes; + long nZoom; +}; + +/************************************************************************* +|* +|* Destruktor, loescht die gespeicherten Bitmaps +|* +\************************************************************************/ + +BitmapCache::~BitmapCache() +{ + for( void* pEntry = aEntries.First(); pEntry; pEntry = aEntries.Next() ) + { + delete static_cast< BitmapCacheEntry* >( pEntry )->pGraphicObject; + delete static_cast< BitmapCacheEntry* >( pEntry ); + } +} + +void BitmapCache::Remove( const SdPage* pPage ) +{ + for( ULONG nPos = 0; nPos < aEntries.Count(); ) + { + BitmapCacheEntry* pCand = (BitmapCacheEntry*) aEntries.GetObject( nPos ); + + if( pCand->pPage == pPage ) + { + pCand = (BitmapCacheEntry*) aEntries.Remove((ULONG)nPos); + delete pCand->pGraphicObject; + delete pCand; + } + else + nPos++; + } +} + + diff --git a/sd/source/ui/view/clview.cxx b/sd/source/ui/view/clview.cxx new file mode 100644 index 000000000000..3d6197d00db5 --- /dev/null +++ b/sd/source/ui/view/clview.cxx @@ -0,0 +1,107 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" +#include <sfx2/app.hxx> + + +#include "ClientView.hxx" +#include "drawview.hxx" +#include "sdpage.hxx" + +class DrawDocShell; + +namespace sd { + +class DrawViewShell; + + +/************************************************************************* +|* +|* Ctor: Die ClientView wird fuer DrawDocShell::Draw() verwendet +|* +\************************************************************************/ + +ClientView::ClientView( + DrawDocShell* pDocSh, + OutputDevice* pOutDev, + DrawViewShell* pShell) + : DrawView (pDocSh, pOutDev, pShell) +{ +} + + +/************************************************************************* +|* +|* Dtor +|* +\************************************************************************/ + +ClientView::~ClientView() +{ +} + +/************************************************************************* +|* +|* Wenn die View kein Invalidate() an den Fenstern durchfuehren soll, muss +|* man diese Methode ueberladen und entsprechend anders reagieren. +|* +\************************************************************************/ + +void ClientView::InvalidateOneWin(::Window& rWin) +{ + Region aRegion; + CompleteRedraw(&rWin, aRegion); +} + +/************************************************************************* +|* +|* Wenn die View kein Invalidate() an den Fenstern durchfuehren soll, muss +|* man diese Methode ueberladen und entsprechend anders reagieren. +|* +\************************************************************************/ + +void ClientView::InvalidateOneWin(::Window& rWin, const Rectangle& rRect) +{ + CompleteRedraw(&rWin, rRect); +} + + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void ClientView::CompleteRedraw(OutputDevice* pOutDev, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector ) +{ + DrawView::CompleteRedraw(pOutDev, rReg, pRedirector); +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/drawview.cxx b/sd/source/ui/view/drawview.cxx new file mode 100755 index 000000000000..b32cd1fe023a --- /dev/null +++ b/sd/source/ui/view/drawview.cxx @@ -0,0 +1,651 @@ + /************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" +#include <sfx2/dispatch.hxx> +#ifndef _MSGBOX_HXX //autogen +#include <vcl/msgbox.hxx> +#endif +#include <svx/svdpagv.hxx> +#include <sfx2/request.hxx> +#include <svl/style.hxx> +#include <editeng/outliner.hxx> +#ifndef _VIEW3D_HXX //autogen +#include <svx/view3d.hxx> +#endif +#ifndef _SVXIDS_HRC //autogen +#include <svx/svxids.hrc> +#endif +#include <svx/svdotext.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdogrp.hxx> +#include <svx/svdorect.hxx> +#include <svl/poolitem.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/bulitem.hxx> +#include <svl/itempool.hxx> +#include <editeng/numitem.hxx> +#include <svl/whiter.hxx> + +#include <sfx2/viewfrm.hxx> +#include <sfx2/objface.hxx> +#include "stlsheet.hxx" + +#include <svx/svdoutl.hxx> +#undef BMP_OLEOBJ +#include <svx/svdstr.hrc> +#include <svx/dialmgr.hxx> + +#include "glob.hrc" +#include "strings.hrc" +#include "View.hxx" +#include "sdattr.hxx" +#include "drawview.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "sdpage.hxx" +#include "DrawViewShell.hxx" +#include "pres.hxx" +#include "sdresid.hxx" +#include "Window.hxx" +#include "unchss.hxx" +#ifndef SD_FRAME_VIEW +#include "FrameView.hxx" +#endif +#include "anminfo.hxx" +#include "slideshow.hxx" +#include <vcl/virdev.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <svx/sdr/contact/displayinfo.hxx> + +#include "undo/undomanager.hxx" + +using namespace ::com::sun::star; + +namespace sd { + +TYPEINIT1(DrawView, View); + +/************************************************************************* +|* +|* Konstruktor +|* zeigt die erste Seite des Dokuments auf Position 0,0 an; +|* falls noch keine Seite vorhanden ist, wird eine erzeugt +|* +\************************************************************************/ + +DrawView::DrawView( DrawDocShell* pDocSh, OutputDevice* pOutDev, DrawViewShell* pShell) +: ::sd::View(pDocSh->GetDoc(), pOutDev, pShell) +, mpDocShell(pDocSh) +, mpDrawViewShell(pShell) +, mpVDev(NULL) +, mnPOCHSmph(0) +{ + SetCurrentObj(OBJ_RECT, SdrInventor); +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +DrawView::~DrawView() +{ + delete mpVDev; +} + +/************************************************************************* +|* +|* virtuelle Methode von SdrView, wird bei Selektionsaenderung gerufen +|* +\************************************************************************/ + +void DrawView::MarkListHasChanged() +{ + ::sd::View::MarkListHasChanged(); + + if (mpDrawViewShell) + mpDrawViewShell->SelectionHasChanged(); +} + +/************************************************************************* +|* +|* virtuelle Methode von SdrView, wird bei Modelaenderung gerufen +|* +\************************************************************************/ + +void DrawView::ModelHasChanged() +{ + ::sd::View::ModelHasChanged(); + + // den Gestalter zur Neudarstellung zwingen + SfxStyleSheetBasePool* pSSPool = mpDoc->GetStyleSheetPool(); + pSSPool->Broadcast(SfxStyleSheetPoolHint(SFX_STYLESHEETPOOL_CHANGES)); + + if( mpDrawViewShell ) + mpDrawViewShell->ModelHasChanged(); + +} + +/************************************************************************* +|* +|* Attribute auf Titel- und Gliederungtext und Hintergrundrechteck einer +|* Masterpage in Vorlagen umlenken, sonst an Basisklasse weitergeben +|* +\************************************************************************/ + +BOOL DrawView::SetAttributes(const SfxItemSet& rSet, + BOOL bReplaceAll) +{ + BOOL bOk = FALSE; + + // wird eine Masterpage bearbeitet? + if ( mpDrawViewShell && mpDrawViewShell->GetEditMode() == EM_MASTERPAGE ) + { + SfxStyleSheetBasePool* pStShPool = mpDoc->GetStyleSheetPool(); + SdPage& rPage = *mpDrawViewShell->getCurrentPage(); + String aLayoutName = rPage.GetName(); + SdrTextObj* pEditObject = static_cast< SdrTextObj* >( GetTextEditObject() ); + + if (pEditObject) + { + // Textedit + String aTemplateName(aLayoutName); + + UINT32 nInv = pEditObject->GetObjInventor(); + + if (nInv == SdrInventor) + { + UINT16 eObjKind = pEditObject->GetObjIdentifier(); + PresObjKind ePresObjKind = rPage.GetPresObjKind(pEditObject); + + if ( ePresObjKind == PRESOBJ_TITLE || + ePresObjKind == PRESOBJ_NOTES ) + { + // Presentation object (except outline) + SfxStyleSheet* pSheet = rPage.GetStyleSheetForPresObj( ePresObjKind ); + DBG_ASSERT(pSheet, "StyleSheet nicht gefunden"); + + SfxItemSet aTempSet( pSheet->GetItemSet() ); + aTempSet.Put( rSet ); + aTempSet.ClearInvalidItems(); + + // Undo-Action + StyleSheetUndoAction* pAction = new StyleSheetUndoAction(mpDoc, pSheet, &aTempSet); + mpDocSh->GetUndoManager()->AddUndoAction(pAction); + + pSheet->GetItemSet().Put(aTempSet); + pSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); + bOk = TRUE; + } + else if (eObjKind == OBJ_OUTLINETEXT) + { + // Presentation object outline + OutlinerView* pOV = GetTextEditOutlinerView(); + ::Outliner* pOutliner = pOV->GetOutliner(); + List* pList = (List*)pOV->CreateSelectionList(); + aTemplateName += String(SdResId(STR_LAYOUT_OUTLINE)); + + pOutliner->SetUpdateMode(FALSE); + mpDocSh->SetWaitCursor( TRUE ); + + // Platzhalter durch Vorlagennamen ersetzen + String aComment(SdResId(STR_UNDO_CHANGE_PRES_OBJECT)); + xub_StrLen nPos = aComment.Search( (sal_Unicode)'$' ); + aComment.Erase(nPos, 1); + aComment.Insert( String((SdResId(STR_PSEUDOSHEET_OUTLINE))), nPos); + mpDocSh->GetUndoManager()->EnterListAction( aComment, String() ); + + Paragraph* pPara = (Paragraph*)pList->Last(); + while (pPara) + { + ULONG nParaPos = pOutliner->GetAbsPos( pPara ); + sal_Int16 nDepth = pOutliner->GetDepth( (USHORT) nParaPos ); + String aName(rPage.GetLayoutName()); + aName += (sal_Unicode)(' '); + aName += String::CreateFromInt32( (nDepth <= 0) ? 1 : nDepth + 1 ); + SfxStyleSheet* pSheet = (SfxStyleSheet*)pStShPool->Find(aName, SD_STYLE_FAMILY_MASTERPAGE); + DBG_ASSERT(pSheet, "StyleSheet nicht gefunden"); + + SfxItemSet aTempSet( pSheet->GetItemSet() ); + aTempSet.Put( rSet ); + aTempSet.ClearInvalidItems(); + + if( nDepth > 0 && aTempSet.GetItemState( EE_PARA_NUMBULLET ) == SFX_ITEM_ON ) + { + // no SvxNumBulletItem in outline level 1 to 8! + aTempSet.ClearItem( EE_PARA_NUMBULLET ); + } + + // Undo-Action + StyleSheetUndoAction* pAction = new StyleSheetUndoAction(mpDoc, pSheet, &aTempSet); + mpDocSh->GetUndoManager()->AddUndoAction(pAction); + + pSheet->GetItemSet().Put(aTempSet); + pSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); + + // now also broadcast any child sheets + sal_Int16 nChild; + for( nChild = nDepth + 1; nChild < 9; nChild++ ) + { + String aSheetName(rPage.GetLayoutName()); + aSheetName += (sal_Unicode)(' '); + aSheetName += String::CreateFromInt32( nChild <= 0 ? 1 : nChild + 1 ); + SfxStyleSheet* pOutlSheet = static_cast< SfxStyleSheet* >(pStShPool->Find(aSheetName, SD_STYLE_FAMILY_MASTERPAGE)); + + if( pOutlSheet ) + pOutlSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); + } + + pPara = (Paragraph*)pList->Prev(); + + if( !pPara && nDepth > 0 && rSet.GetItemState( EE_PARA_NUMBULLET ) == SFX_ITEM_ON && + pOutliner->GetDepth( (USHORT) pOutliner->GetAbsPos( (Paragraph*) pList->First() ) ) > 0 ) + pPara = pOutliner->GetParagraph( 0 ); // Put NumBulletItem in outline level 1 + } + + mpDocSh->SetWaitCursor( FALSE ); + pOV->GetOutliner()->SetUpdateMode(TRUE); + + mpDocSh->GetUndoManager()->LeaveListAction(); + + delete pList; + bOk = TRUE; + } + else + { + bOk = ::sd::View::SetAttributes(rSet, bReplaceAll); + } + } + } + else + { + // Selection + const SdrMarkList& rList = GetMarkedObjectList(); + ULONG nMarkCount = rList.GetMarkCount(); + for (ULONG nMark = 0; nMark < nMarkCount; nMark++) + { + SdrObject* pObject = rList.GetMark(nMark)->GetMarkedSdrObj(); + UINT32 nInv = pObject->GetObjInventor(); + + if (nInv == SdrInventor) + { + UINT16 eObjKind = pObject->GetObjIdentifier(); + PresObjKind ePresObjKind = rPage.GetPresObjKind(pObject); + String aTemplateName(aLayoutName); + + if (ePresObjKind == PRESOBJ_TITLE || + ePresObjKind == PRESOBJ_NOTES) + { + // Presentation object (except outline) + SfxStyleSheet* pSheet = rPage.GetStyleSheetForPresObj( ePresObjKind ); + DBG_ASSERT(pSheet, "StyleSheet not found"); + + SfxItemSet aTempSet( pSheet->GetItemSet() ); + aTempSet.Put( rSet ); + aTempSet.ClearInvalidItems(); + + // Undo-Action + StyleSheetUndoAction* pAction = new StyleSheetUndoAction(mpDoc, pSheet, &aTempSet); + mpDocSh->GetUndoManager()->AddUndoAction(pAction); + + pSheet->GetItemSet().Put(aTempSet,false); + pSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); + bOk = TRUE; + } + else if (eObjKind == OBJ_OUTLINETEXT) + { + // Presentation object outline + aTemplateName += String(SdResId(STR_LAYOUT_OUTLINE)); + for (USHORT nLevel = 9; nLevel > 0; nLevel--) + { + String aName(rPage.GetLayoutName()); + aName += (sal_Unicode)(' '); + aName += String::CreateFromInt32( (sal_Int32)nLevel ); + SfxStyleSheet* pSheet = (SfxStyleSheet*)pStShPool-> + Find(aName, SD_STYLE_FAMILY_MASTERPAGE); + DBG_ASSERT(pSheet, "StyleSheet nicht gefunden"); + + SfxItemSet aTempSet( pSheet->GetItemSet() ); + + if( nLevel > 1 ) + { + // for all levels over 1, clear all items that will be + // hard set to level 1 + SfxWhichIter aWhichIter(rSet); + sal_uInt16 nWhich(aWhichIter.FirstWhich()); + while( nWhich ) + { + if( SFX_ITEM_ON == rSet.GetItemState( nWhich ) ) + aTempSet.ClearItem( nWhich ); + nWhich = aWhichIter.NextWhich(); + } + + } + else + { + // put the items hard into level one + aTempSet.Put( rSet ); + } + + aTempSet.ClearInvalidItems(); + + // Undo-Action + StyleSheetUndoAction* pAction = new StyleSheetUndoAction(mpDoc, pSheet, &aTempSet); + mpDocSh->GetUndoManager()->AddUndoAction(pAction); + + pSheet->GetItemSet().Set(aTempSet,false); + pSheet->Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); + } + + // remove all hard set items from shape that are now set in style + SfxWhichIter aWhichIter(rSet); + sal_uInt16 nWhich(aWhichIter.FirstWhich()); + while( nWhich ) + { + if( SFX_ITEM_ON == rSet.GetItemState( nWhich ) ) + pObject->ClearMergedItem( nWhich ); + nWhich = aWhichIter.NextWhich(); + } + + bOk = TRUE; + } + } + } + + if(!bOk) + bOk = ::sd::View::SetAttributes(rSet, bReplaceAll); + } + } + else // nicht auf der Masterpage + { + bOk = ::sd::View::SetAttributes(rSet, bReplaceAll); + } + + return (bOk); +} + +/************************************************************************* +|* +|* Notify fuer Aenderung der Seitenanordnung +|* +\************************************************************************/ + +void DrawView::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) +{ + if ( mpDrawViewShell && rHint.ISA(SdrHint) ) + { + SdrHintKind eHintKind = ( (SdrHint&) rHint).GetKind(); + + if ( mnPOCHSmph == 0 && eHintKind == HINT_PAGEORDERCHG ) + { + mpDrawViewShell->ResetActualPage(); + } + else if ( eHintKind == HINT_LAYERCHG || eHintKind == HINT_LAYERORDERCHG ) + { + mpDrawViewShell->ResetActualLayer(); + } + + // #94278# switch to that page when it's not a master page + if(HINT_SWITCHTOPAGE == eHintKind) + { + const SdrPage* pPage = ((const SdrHint&)rHint).GetPage(); + + if(pPage && !pPage->IsMasterPage()) + { + if(mpDrawViewShell->GetActualPage() != pPage) + { + sal_uInt16 nPageNum = (pPage->GetPageNum() - 1) / 2; // Sdr --> Sd + mpDrawViewShell->SwitchPage(nPageNum); + } + } + } + } + + ::sd::View::Notify(rBC, rHint); +} + +/************************************************************************* +|* +|* PageOrderChangedHint blockieren/freigeben +|* +\************************************************************************/ + +void DrawView::BlockPageOrderChangedHint(BOOL bBlock) +{ + if (bBlock) + mnPOCHSmph++; + else + { + DBG_ASSERT(mnPOCHSmph, "Zaehlerunterlauf"); + mnPOCHSmph--; + } +} + +/************************************************************************* +|* +|* StyleSheet-Setzen auf der Masterpage abfangen, wenn Praesentationsobjekte +|* selektiert sind +|* +\************************************************************************/ + +BOOL DrawView::SetStyleSheet(SfxStyleSheet* pStyleSheet, BOOL bDontRemoveHardAttr) +{ + BOOL bResult = TRUE; + + // wird eine Masterpage bearbeitet? + if (mpDrawViewShell && mpDrawViewShell->GetEditMode() == EM_MASTERPAGE) + { + if (IsPresObjSelected(FALSE, TRUE)) + { + + InfoBox(mpDrawViewShell->GetActiveWindow(), + String(SdResId(STR_ACTION_NOTPOSSIBLE))).Execute(); + bResult = FALSE; + } + else + { + bResult = ::sd::View::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr); + } + } + else + { + bResult = ::sd::View::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr); + } + return bResult; +} + +/************************************************************************* +|* +|* Paint-Methode: das Ereignis wird an die View weitergeleitet +|* +\************************************************************************/ + +void DrawView::CompleteRedraw(OutputDevice* pOutDev, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector /*=0L*/) +{ + if( mpVDev ) + { + delete mpVDev; + mpVDev = NULL; + } + + BOOL bStandardPaint = TRUE; + + SdDrawDocument* pDoc = mpDocShell->GetDoc(); + if( pDoc && pDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS) + { + rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( pDoc ) ); + if(xSlideshow.is() && xSlideshow->isRunning()) + { + OutputDevice* pShowWindow = ( OutputDevice* )xSlideshow->getShowWindow(); + if( (pShowWindow == pOutDev) || (xSlideshow->getAnimationMode() == ANIMATIONMODE_PREVIEW) ) + { + if( pShowWindow == pOutDev ) + PresPaint(rReg); + bStandardPaint = FALSE; + } + } + } + + if(bStandardPaint) + { + ::sd::View::CompleteRedraw(pOutDev, rReg, pRedirector); + } +} + +/************************************************************************* +|* +|* Paint-Event during running slide show +|* +\************************************************************************/ + +void DrawView::PresPaint(const Region& rRegion) +{ + if(mpViewSh) + { + rtl::Reference< SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) ); + if( xSlideshow.is() && xSlideshow->isRunning() ) + xSlideshow->paint( rRegion.GetBoundRect() ); + } +} + +/************************************************************************* +|* entscheidet, ob ein Objekt markiert werden kann (z. B. noch nicht +|* erschienene Animationsobjekte in der Diashow) +\************************************************************************/ + +BOOL DrawView::IsObjMarkable(SdrObject* pObj, SdrPageView* pPV) const +{ + return FmFormView::IsObjMarkable(pObj, pPV);; +} + +/************************************************************************* +|* +|* Uebergebenen Bereich sichtbar machen (es wird ggf. gescrollt) +|* +\************************************************************************/ + +void DrawView::MakeVisible(const Rectangle& rRect, ::Window& rWin) +{ + if (!rRect.IsEmpty()) + { + mpDrawViewShell->MakeVisible(rRect, rWin); + } +} +/************************************************************************* +|* +|* Seite wird gehided +|* +\************************************************************************/ + +void DrawView::HideSdrPage() +{ + if (mpDrawViewShell) + { + mpDrawViewShell->HidePage(); + } + + ::sd::View::HideSdrPage(); +} + +void DrawView::DeleteMarked() +{ + OSL_TRACE( "DrawView::DeleteMarked() - enter" ); + + sd::UndoManager* pUndoManager = mpDoc->GetUndoManager(); + DBG_ASSERT( pUndoManager, "sd::DrawView::DeleteMarked(), ui action without undo manager!?" ); + + if( pUndoManager ) + { + String aUndo( SVX_RES(STR_EditDelete) ); + String aSearchString(RTL_CONSTASCII_USTRINGPARAM("%1")); + aUndo.SearchAndReplace(aSearchString, GetDescriptionOfMarkedObjects()); + pUndoManager->EnterListAction(aUndo, aUndo); + } + + SdPage* pPage = 0; + bool bResetLayout = false; + + const ULONG nMarkCount = GetMarkedObjectList().GetMarkCount(); + if( nMarkCount ) + { + SdrMarkList aList( GetMarkedObjectList() ); + for (ULONG nMark = 0; nMark < nMarkCount; nMark++) + { + SdrObject* pObj = aList.GetMark(nMark)->GetMarkedSdrObj(); + if( pObj && !pObj->IsEmptyPresObj() && pObj->GetUserCall() ) + { + pPage = static_cast< SdPage* >( pObj->GetPage() ); + PresObjKind ePresObjKind; + if( pPage && ((ePresObjKind = pPage->GetPresObjKind(pObj)) != PRESOBJ_NONE)) + { + switch( ePresObjKind ) + { + case PRESOBJ_GRAPHIC: + case PRESOBJ_OBJECT: + case PRESOBJ_CHART: + case PRESOBJ_ORGCHART: + case PRESOBJ_TABLE: + case PRESOBJ_CALC: + case PRESOBJ_IMAGE: + case PRESOBJ_MEDIA: + ePresObjKind = PRESOBJ_OUTLINE; + break; + default: + break; + } + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj ); + bool bVertical = pTextObj && pTextObj->IsVerticalWriting(); + Rectangle aRect( pObj->GetLogicRect() ); + SdrObject* pNewObj = pPage->InsertAutoLayoutShape( 0, ePresObjKind, bVertical, aRect, true ); + + pPage->SetObjectOrdNum( pNewObj->GetOrdNum(), pObj->GetOrdNum() ); + + bResetLayout = true; + + OSL_TRACE( "DrawView::InsertAutoLayoutShape() - InsertAutoLayoutShape" ); + } + } + } + } + + ::sd::View::DeleteMarked(); + + if( pPage && bResetLayout ) + pPage->SetAutoLayout( pPage->GetAutoLayout() ); + + if( pUndoManager ) + pUndoManager->LeaveListAction(); + + OSL_TRACE( "DrawView::InsertAutoLayoutShape() - leave" ); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drbezob.cxx b/sd/source/ui/view/drbezob.cxx new file mode 100644 index 000000000000..ae512b0441d9 --- /dev/null +++ b/sd/source/ui/view/drbezob.cxx @@ -0,0 +1,365 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "BezierObjectBar.hxx" +#include <sfx2/app.hxx> +#include <sfx2/msg.hxx> + +#include <sfx2/viewfrm.hxx> +#include <sfx2/objface.hxx> + +#include <svx/svxids.hrc> +#include <svl/eitem.hxx> +#include <sfx2/request.hxx> +#include <svx/svdopath.hxx> +#include <svl/aeitem.hxx> +#include <svx/svdundo.hxx> +#include <sfx2/dispatch.hxx> + + +#include "sdresid.hxx" + + + +#include "res_bmp.hrc" +#include "glob.hrc" +#include "strings.hrc" + +#include "DrawDocShell.hxx" +#include "ViewShell.hxx" +#include "Window.hxx" +#include "drawview.hxx" +#include "drawdoc.hxx" +#include "sdresid.hxx" +#include "fusel.hxx" +#include "fuconbez.hxx" + + +using namespace sd; +#define BezierObjectBar +#include "sdslots.hxx" + +namespace sd { + +/************************************************************************* +|* +|* Standardinterface deklarieren (Die Slotmap darf nicht leer sein) +|* +\************************************************************************/ + + + +SFX_IMPL_INTERFACE(BezierObjectBar, ::SfxShell, SdResId(STR_BEZIEROBJECTBARSHELL)) +{ +} + +TYPEINIT1(BezierObjectBar, ::SfxShell); + +/************************************************************************* +|* +|* Standard-Konstruktor +|* +\************************************************************************/ + +BezierObjectBar::BezierObjectBar( + ViewShell* pSdViewShell, + ::sd::View* pSdView) + : SfxShell(pSdViewShell->GetViewShell()), + mpView(pSdView), + mpViewSh(pSdViewShell) +{ + DrawDocShell* pDocShell = mpViewSh->GetDocSh(); + SetPool(&pDocShell->GetPool()); + SetUndoManager(pDocShell->GetUndoManager()); + SetRepeatTarget(mpView); + + SetHelpId( SD_IF_SDDRAWBEZIEROBJECTBAR ); +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +BezierObjectBar::~BezierObjectBar() +{ + SetRepeatTarget(NULL); +} + + +/************************************************************************* +|* +|* Status der Attribut-Items +|* +\************************************************************************/ + +void BezierObjectBar::GetAttrState(SfxItemSet& rSet) +{ + SfxItemSet aAttrSet( mpView->GetDoc()->GetPool() ); + mpView->GetAttributes( aAttrSet ); + rSet.Put(aAttrSet, FALSE); // <- FALSE, damit DontCare-Status uebernommen wird + + FunctionReference xFunc( mpViewSh->GetCurrentFunction() ); + + if(xFunc.is()) + { + if(xFunc->ISA(FuSelection)) + { + USHORT nEditMode = static_cast<FuSelection*>(xFunc.get())->GetEditMode(); + rSet.Put(SfxBoolItem(nEditMode, TRUE)); + } + else if (xFunc->ISA(FuConstructBezierPolygon)) + { + USHORT nEditMode = static_cast<FuConstructBezierPolygon*>(xFunc.get())->GetEditMode(); + rSet.Put(SfxBoolItem(nEditMode, TRUE)); + } + } + + if(!mpView->IsMoveAllowed() || !mpView->IsResizeAllowed()) + { + // #i77187# if object is move and/or size protected, do not allow point editing at all + rSet.DisableItem(SID_BEZIER_MOVE); + rSet.DisableItem(SID_BEZIER_INSERT); + + rSet.DisableItem(SID_BEZIER_DELETE); + rSet.DisableItem(SID_BEZIER_CUTLINE); + rSet.DisableItem(SID_BEZIER_CONVERT); + + rSet.DisableItem(SID_BEZIER_EDGE); + rSet.DisableItem(SID_BEZIER_SMOOTH); + rSet.DisableItem(SID_BEZIER_SYMMTR); + + rSet.DisableItem(SID_BEZIER_CLOSE); + + rSet.DisableItem(SID_BEZIER_ELIMINATE_POINTS); + } + else + { + IPolyPolygonEditorController* pIPPEC = 0; + if( mpView->GetMarkedObjectList().GetMarkCount() ) + pIPPEC = mpView; + else + pIPPEC = dynamic_cast< IPolyPolygonEditorController* >( mpView->getSmartTags().getSelected().get() ); + + if ( !pIPPEC || !pIPPEC->IsRipUpAtMarkedPointsPossible()) + { + rSet.DisableItem(SID_BEZIER_CUTLINE); + } + if (!pIPPEC || !pIPPEC->IsDeleteMarkedPointsPossible()) + { + rSet.DisableItem(SID_BEZIER_DELETE); + } + if (!pIPPEC || !pIPPEC->IsSetMarkedSegmentsKindPossible()) + { + rSet.DisableItem(SID_BEZIER_CONVERT); + } + else + { + SdrPathSegmentKind eSegm = pIPPEC->GetMarkedSegmentsKind(); + switch (eSegm) + { + case SDRPATHSEGMENT_DONTCARE: rSet.InvalidateItem(SID_BEZIER_CONVERT); break; + case SDRPATHSEGMENT_LINE : rSet.Put(SfxBoolItem(SID_BEZIER_CONVERT,FALSE)); break; // Button reingedrueckt = Kurve + case SDRPATHSEGMENT_CURVE : rSet.Put(SfxBoolItem(SID_BEZIER_CONVERT,TRUE)); break; + default: break; + } + } + if (!pIPPEC || !pIPPEC->IsSetMarkedPointsSmoothPossible()) + { + rSet.DisableItem(SID_BEZIER_EDGE); + rSet.DisableItem(SID_BEZIER_SMOOTH); + rSet.DisableItem(SID_BEZIER_SYMMTR); + } + else + { + SdrPathSmoothKind eSmooth = pIPPEC->GetMarkedPointsSmooth(); + switch (eSmooth) + { + case SDRPATHSMOOTH_DONTCARE : break; + case SDRPATHSMOOTH_ANGULAR : rSet.Put(SfxBoolItem(SID_BEZIER_EDGE, TRUE)); break; + case SDRPATHSMOOTH_ASYMMETRIC: rSet.Put(SfxBoolItem(SID_BEZIER_SMOOTH,TRUE)); break; + case SDRPATHSMOOTH_SYMMETRIC : rSet.Put(SfxBoolItem(SID_BEZIER_SYMMTR,TRUE)); break; + } + } + if (!pIPPEC || !pIPPEC->IsOpenCloseMarkedObjectsPossible()) + { + rSet.DisableItem(SID_BEZIER_CLOSE); + } + else + { + SdrObjClosedKind eClose = pIPPEC->GetMarkedObjectsClosedState(); + switch (eClose) + { + case SDROBJCLOSED_DONTCARE: rSet.InvalidateItem(SID_BEZIER_CLOSE); break; + case SDROBJCLOSED_OPEN : rSet.Put(SfxBoolItem(SID_BEZIER_CLOSE,FALSE)); break; + case SDROBJCLOSED_CLOSED : rSet.Put(SfxBoolItem(SID_BEZIER_CLOSE,TRUE)); break; + default: break; + } + } + + if(pIPPEC == mpView) + rSet.Put(SfxBoolItem(SID_BEZIER_ELIMINATE_POINTS, mpView->IsEliminatePolyPoints())); + else + rSet.DisableItem( SID_BEZIER_ELIMINATE_POINTS ); // only works for views + } +} + + +/************************************************************************* +|* +|* Bearbeitung der SfxRequests +|* +\************************************************************************/ + +void BezierObjectBar::Execute(SfxRequest& rReq) +{ + USHORT nSId = rReq.GetSlot(); + + switch (nSId) + { + case SID_BEZIER_CUTLINE: + case SID_BEZIER_CONVERT: + case SID_BEZIER_DELETE: + case SID_BEZIER_EDGE: + case SID_BEZIER_SMOOTH: + case SID_BEZIER_SYMMTR: + case SID_BEZIER_CLOSE: + { + const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); + + IPolyPolygonEditorController* pIPPEC = 0; + if( rMarkList.GetMarkCount() ) + pIPPEC = mpView; + else + pIPPEC = dynamic_cast< IPolyPolygonEditorController* >( mpView->getSmartTags().getSelected().get() ); + + if( pIPPEC && !mpView->IsAction()) + { + switch (nSId) + { + case SID_BEZIER_DELETE: + pIPPEC->DeleteMarkedPoints(); + break; + + case SID_BEZIER_CUTLINE: + pIPPEC->RipUpAtMarkedPoints(); + break; + + case SID_BEZIER_CONVERT: + { + pIPPEC->SetMarkedSegmentsKind(SDRPATHSEGMENT_TOGGLE); + break; + } + + case SID_BEZIER_EDGE: + case SID_BEZIER_SMOOTH: + case SID_BEZIER_SYMMTR: + { + SdrPathSmoothKind eKind; + + switch (nSId) + { + default: + case SID_BEZIER_EDGE: eKind = SDRPATHSMOOTH_ANGULAR; break; + case SID_BEZIER_SMOOTH: eKind = SDRPATHSMOOTH_ASYMMETRIC; break; + case SID_BEZIER_SYMMTR: eKind = SDRPATHSMOOTH_SYMMETRIC; break; + } + + pIPPEC->SetMarkedPointsSmooth(eKind); + break; + } + + case SID_BEZIER_CLOSE: + { + SdrPathObj* pPathObj = (SdrPathObj*) rMarkList.GetMark(0)->GetMarkedSdrObj(); + const bool bUndo = mpView->IsUndoEnabled(); + if( bUndo ) + mpView->BegUndo(String(SdResId(STR_UNDO_BEZCLOSE))); + + mpView->UnmarkAllPoints(); + + if( bUndo ) + mpView->AddUndo(mpView->GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pPathObj)); + + pPathObj->ToggleClosed(); + + if( bUndo ) + mpView->EndUndo(); + break; + } + } + } + + if( (pIPPEC == mpView) && !mpView->AreObjectsMarked() ) + mpViewSh->GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + + rReq.Ignore(); + } + break; + + case SID_BEZIER_ELIMINATE_POINTS: + { + mpView->SetEliminatePolyPoints(!mpView->IsEliminatePolyPoints()); + Invalidate(SID_BEZIER_ELIMINATE_POINTS); + rReq.Done(); + } + break; + + case SID_BEZIER_MOVE: + case SID_BEZIER_INSERT: + { + FunctionReference xFunc( mpViewSh->GetCurrentFunction() ); + + if(xFunc.is()) + { + if(xFunc->ISA(FuSelection)) + { + static_cast<FuSelection*>(xFunc.get())->SetEditMode(rReq.GetSlot()); + } + else if(xFunc->ISA(FuConstructBezierPolygon)) + { + static_cast<FuConstructBezierPolygon*>(xFunc.get())->SetEditMode(rReq.GetSlot()); + } + } + + rReq.Ignore (); + } + break; + + default: + break; + } + + Invalidate(); +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/drtxtob.cxx b/sd/source/ui/view/drtxtob.cxx new file mode 100755 index 000000000000..9eb0a3b2ff8c --- /dev/null +++ b/sd/source/ui/view/drtxtob.cxx @@ -0,0 +1,591 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "TextObjectBar.hxx" + +#include <svx/svxids.hrc> + +#include <i18npool/mslangid.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/lspcitem.hxx> +#include <editeng/adjitem.hxx> +#include <editeng/editview.hxx> +#include <editeng/editeng.hxx> +#include <editeng/outliner.hxx> +#include <editeng/unolingu.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/lspcitem.hxx> +#include <editeng/adjitem.hxx> +#include <vcl/vclenum.hxx> +#include <sfx2/app.hxx> +#include <svl/whiter.hxx> +#include <svl/itempool.hxx> +#include <svl/stritem.hxx> +#include <svl/style.hxx> +#include <svl/languageoptions.hxx> +#include <sfx2/tplpitem.hxx> +#include <editeng/escpitem.hxx> +#include <svx/svdoutl.hxx> +#include <svl/intitem.hxx> +#include <editeng/scripttypeitem.hxx> +#include <editeng/outlobj.hxx> +#include <editeng/writingmodeitem.hxx> +#include <editeng/frmdiritem.hxx> + + +#include <sfx2/objface.hxx> + +#include "app.hrc" +#include "glob.hrc" +#include "res_bmp.hrc" + +#include "eetext.hxx" + +#include "drawdoc.hxx" +#include "DrawViewShell.hxx" +#include "OutlineViewShell.hxx" +#include "ViewShellBase.hxx" +#include "ToolBarManager.hxx" +#include "futempl.hxx" +#include "sdresid.hxx" +#include "Window.hxx" +#include "OutlineView.hxx" + + +using namespace sd; +using namespace ::com::sun::star; + +#define TextObjectBar +#include "sdslots.hxx" + +namespace sd { + +/************************************************************************* +|* +|* Standardinterface deklarieren (Die Slotmap darf nicht leer sein, also +|* tragen wir etwas ein, was hier (hoffentlich) nie vorkommt). +|* +\************************************************************************/ + + +SFX_IMPL_INTERFACE( TextObjectBar, SfxShell, SdResId(STR_TEXTOBJECTBARSHELL) ) +{ +} + +TYPEINIT1( TextObjectBar, SfxShell ); + +/************************************************************************* +|* +|* Standard-Konstruktor +|* +\************************************************************************/ + +TextObjectBar::TextObjectBar ( + ViewShell* pSdViewSh, + SfxItemPool& rItemPool, + ::sd::View* pSdView ) + : SfxShell(pSdViewSh->GetViewShell()), + mpViewShell( pSdViewSh ), + mpView( pSdView ) +{ + SetPool(&rItemPool); + + if( mpView ) + { + OutlineView* pOutlinerView = dynamic_cast< OutlineView* >( mpView ); + if( pOutlinerView ) + { + SetUndoManager(&pOutlinerView->GetOutliner()->GetUndoManager()); + } + else + { + SdDrawDocument* pDoc = mpView->GetDoc(); + if( pDoc ) + { + DrawDocShell* pDocShell = pDoc->GetDocSh(); + if( pDocShell ) + { + SetUndoManager(pDocShell->GetUndoManager()); + DrawViewShell* pDrawViewShell = dynamic_cast< DrawViewShell* >( pSdViewSh ); + if ( pDrawViewShell ) + SetRepeatTarget(pSdView); + } + } + } + } + + SetName( String( RTL_CONSTASCII_USTRINGPARAM( "TextObjectBar" ))); + + // SetHelpId( SD_IF_SDDRAWTEXTOBJECTBAR ); +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +TextObjectBar::~TextObjectBar() +{ + SetRepeatTarget(NULL); +} + +/************************************************************************* +|* +|* Status der Attribut-Items +|* +\************************************************************************/ + +void TextObjectBar::GetAttrState( SfxItemSet& rSet ) +{ + SfxWhichIter aIter( rSet ); + USHORT nWhich = aIter.FirstWhich(); + BOOL bTemplate = FALSE; + SfxItemSet aAttrSet( mpView->GetDoc()->GetPool() ); + SvtLanguageOptions aLangOpt; + sal_Bool bDisableParagraphTextDirection = !aLangOpt.IsCTLFontEnabled(); + sal_Bool bDisableVerticalText = !aLangOpt.IsVerticalTextEnabled(); + + mpView->GetAttributes( aAttrSet ); + + while ( nWhich ) + { + USHORT nSlotId = SfxItemPool::IsWhich(nWhich) + ? GetPool().GetSlotId(nWhich) + : nWhich; + + switch ( nSlotId ) + { + case SID_ATTR_CHAR_FONT: + case SID_ATTR_CHAR_FONTHEIGHT: + case SID_ATTR_CHAR_WEIGHT: + case SID_ATTR_CHAR_POSTURE: + { + SvxScriptSetItem aSetItem( nSlotId, GetPool() ); + aSetItem.GetItemSet().Put( aAttrSet, FALSE ); + + USHORT nScriptType = mpView->GetScriptType(); + + if( (nSlotId == SID_ATTR_CHAR_FONT) || (nSlotId == SID_ATTR_CHAR_FONTHEIGHT) ) + { + // #42732# input language should be preferred over + // current cursor position to detect script type + OutlinerView* pOLV = mpView->GetTextEditOutlinerView(); + + if (mpView->ISA(OutlineView)) + { + pOLV = static_cast<OutlineView*>(mpView)->GetViewByWindow( + mpViewShell->GetActiveWindow()); + } + + if(pOLV && !pOLV->GetSelection().HasRange()) + { + if( mpViewShell && mpViewShell->GetViewShell() && mpViewShell->GetViewShell()->GetWindow() ) + { + LanguageType nInputLang = mpViewShell->GetViewShell()->GetWindow()->GetInputLanguage(); + if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM) + nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang ); + } + } + } + + const SfxPoolItem* pI = aSetItem.GetItemOfScript( nScriptType ); + if( pI ) + aAttrSet.Put( *pI, nWhich ); + else + aAttrSet.InvalidateItem( nWhich ); + } + break; + + + case SID_STYLE_APPLY: + case SID_STYLE_FAMILY2: + { + SfxStyleSheet* pStyleSheet = mpView->GetStyleSheetFromMarked(); + if( pStyleSheet ) + rSet.Put( SfxTemplateItem( nWhich, pStyleSheet->GetName() ) ); + else + { + rSet.Put( SfxTemplateItem( nWhich, String() ) ); + } + bTemplate = TRUE; + } + break; + + case SID_OUTLINE_LEFT: + case SID_OUTLINE_RIGHT: + case SID_OUTLINE_UP: + case SID_OUTLINE_DOWN: + { + BOOL bDisableLeft = TRUE; + BOOL bDisableRight = TRUE; + BOOL bDisableUp = TRUE; + BOOL bDisableDown = TRUE; + OutlinerView* pOLV = mpView->GetTextEditOutlinerView(); + + if (mpView->ISA(OutlineView)) + { + pOLV = static_cast<OutlineView*>(mpView)->GetViewByWindow( + mpViewShell->GetActiveWindow()); + } + + BOOL bOutlineViewSh = mpViewShell->ISA(OutlineViewShell); + + if (pOLV && + ( pOLV->GetOutliner()->GetMode() == OUTLINERMODE_OUTLINEOBJECT || bOutlineViewSh ) ) + { + // Outliner im Gliederungsmodus + ::Outliner* pOutl = pOLV->GetOutliner(); + List* pList = pOLV->CreateSelectionList(); + Paragraph* pPara = (Paragraph*) pList->First(); + + // #96539# find out if we are a OutlineView + BOOL bIsOutlineView(OUTLINERMODE_OUTLINEVIEW == pOLV->GetOutliner()->GetMode()); + + // #96539# This is ONLY for OutlineViews + if(bIsOutlineView) + { + // #96250# and #78665# + // allow move up if position is 2 or greater OR it + // is a title object (and thus depth==1) + if(pOutl->GetAbsPos(pPara) > 1 || ( pOutl->HasParaFlag(pPara,PARAFLAG_ISPAGE) && pOutl->GetAbsPos(pPara) > 0 ) ) + { + // Nicht ganz oben + bDisableUp = FALSE; + } + } + else + { + // #96539# old behaviour for OUTLINERMODE_OUTLINEOBJECT + if(pOutl->GetAbsPos(pPara) > 0) + { + // Nicht ganz oben + bDisableUp = FALSE; + } + } + + while (pPara) + { + sal_Int16 nDepth = pOutl->GetDepth( (USHORT) pOutl->GetAbsPos( pPara ) ); + + if (nDepth > 0 || (bOutlineViewSh && (nDepth <= 0) && !pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE )) ) + { + // Nicht minimale Tiefe + bDisableLeft = FALSE; + } + + if( (nDepth < pOLV->GetOutliner()->GetMaxDepth() && ( !bOutlineViewSh || pOutl->GetAbsPos(pPara) != 0 )) || + (bOutlineViewSh && (nDepth <= 0) && pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE ) && pOutl->GetAbsPos(pPara) != 0) ) + { + // Nicht maximale Tiefe und nicht ganz oben + bDisableRight = FALSE; + } + + pPara = static_cast<Paragraph*>( pList->Next() ); + } + + if ( ( pOutl->GetAbsPos((Paragraph*) pList->Last()) < pOutl->GetParagraphCount() - 1 ) && + ( pOutl->GetParagraphCount() > 1 || !bOutlineViewSh) ) + { + // Nicht letzter Absatz + bDisableDown = FALSE; + } + + // #96250# and #78665# + // disable when first para and 2nd is not a title + pPara = static_cast< Paragraph* >( pList->First() ); + if(!bDisableDown && bIsOutlineView + && pPara + && 0 == pOutl->GetAbsPos(pPara) + && pOutl->GetParagraphCount() > 1 + && !pOutl->HasParaFlag( pOutl->GetParagraph(1), PARAFLAG_ISPAGE ) ) + { + // Needs to be disabled + bDisableDown = TRUE; + } + + delete pList; + } + + if (bDisableLeft) + rSet.DisableItem(SID_OUTLINE_LEFT); + if (bDisableRight) + rSet.DisableItem(SID_OUTLINE_RIGHT); + if (bDisableUp) + rSet.DisableItem(SID_OUTLINE_UP); + if (bDisableDown) + rSet.DisableItem(SID_OUTLINE_DOWN); + } + break; + + case SID_TEXTDIRECTION_LEFT_TO_RIGHT: + case SID_TEXTDIRECTION_TOP_TO_BOTTOM: + { + if ( bDisableVerticalText ) + { + rSet.DisableItem( SID_TEXTDIRECTION_LEFT_TO_RIGHT ); + rSet.DisableItem( SID_TEXTDIRECTION_TOP_TO_BOTTOM ); + } + else + { + BOOL bLeftToRight = TRUE; + + SdrOutliner* pOutl = mpView->GetTextEditOutliner(); + if( pOutl ) + { + if( pOutl->IsVertical() ) + bLeftToRight = FALSE; + } + else + bLeftToRight = ( (const SvxWritingModeItem&) aAttrSet.Get( SDRATTR_TEXTDIRECTION ) ).GetValue() == com::sun::star::text::WritingMode_LR_TB; + + rSet.Put( SfxBoolItem( SID_TEXTDIRECTION_LEFT_TO_RIGHT, bLeftToRight ) ); + rSet.Put( SfxBoolItem( SID_TEXTDIRECTION_TOP_TO_BOTTOM, !bLeftToRight ) ); + + if( !bLeftToRight ) + bDisableParagraphTextDirection = sal_True; + } + } + break; + + case SID_GROW_FONT_SIZE: + case SID_SHRINK_FONT_SIZE: + { + // todo + } + break; + + case SID_THES: + { + if( mpView && mpView->GetTextEditOutlinerView() ) + { + EditView & rEditView = mpView->GetTextEditOutlinerView()->GetEditView();; + String aStatusVal; + LanguageType nLang = LANGUAGE_NONE; + bool bIsLookUpWord = GetStatusValueForThesaurusFromContext( aStatusVal, nLang, rEditView ); + rSet.Put( SfxStringItem( SID_THES, aStatusVal ) ); + + // disable "Thesaurus" context menu entry if there is nothing to look up + lang::Locale aLocale( SvxCreateLocale( nLang ) ); + uno::Reference< linguistic2::XThesaurus > xThes( LinguMgr::GetThesaurus() ); + if (!bIsLookUpWord || + !xThes.is() || nLang == LANGUAGE_NONE || !xThes->hasLocale( aLocale )) + rSet.DisableItem( SID_THES ); + } + else + { + rSet.DisableItem( SID_THES ); + } + //! avoid puting the same item as SfxBoolItem at the end of this function + nSlotId = 0; + } + break; + + default: + break; + } + + nWhich = aIter.NextWhich(); + } + + rSet.Put( aAttrSet, FALSE ); // <- FALSE, damit DontCare-Status uebernommen wird + + + // die sind im Gliederungsmodus disabled + if (!mpViewShell->ISA(DrawViewShell)) + { + rSet.DisableItem( SID_ATTR_PARA_ADJUST_LEFT ); + rSet.DisableItem( SID_ATTR_PARA_ADJUST_RIGHT ); + rSet.DisableItem( SID_ATTR_PARA_ADJUST_CENTER ); + rSet.DisableItem( SID_ATTR_PARA_ADJUST_BLOCK ); + rSet.DisableItem( SID_ATTR_PARA_LINESPACE_10 ); + rSet.DisableItem( SID_ATTR_PARA_LINESPACE_15 ); + rSet.DisableItem( SID_ATTR_PARA_LINESPACE_20 ); + rSet.DisableItem( SID_PARASPACE_INCREASE ); + rSet.DisableItem( SID_PARASPACE_DECREASE ); + rSet.DisableItem( SID_TEXTDIRECTION_TOP_TO_BOTTOM ); + rSet.DisableItem( SID_TEXTDIRECTION_LEFT_TO_RIGHT ); + rSet.DisableItem( SID_ATTR_PARA_LEFT_TO_RIGHT ); + rSet.DisableItem( SID_ATTR_PARA_RIGHT_TO_LEFT ); + } + else + { + // Absatzabstand + OutlinerView* pOLV = mpView->GetTextEditOutlinerView(); + if( pOLV ) + { + ESelection aSel = pOLV->GetSelection(); + aSel.Adjust(); + ULONG nStartPara = aSel.nStartPara; + ULONG nEndPara = aSel.nEndPara; + if( !aSel.HasRange() ) + { + nStartPara = 0; + nEndPara = pOLV->GetOutliner()->GetParagraphCount() - 1; + } + long nUpper = 0L; + for( ULONG nPara = nStartPara; nPara <= nEndPara; nPara++ ) + { + const SfxItemSet& rItems = pOLV->GetOutliner()->GetParaAttribs( (USHORT)nPara ); + const SvxULSpaceItem& rItem = (const SvxULSpaceItem&) rItems.Get( EE_PARA_ULSPACE ); + nUpper = Max( nUpper, (long)rItem.GetUpper() ); + } + if( nUpper == 0L ) + rSet.DisableItem( SID_PARASPACE_DECREASE ); + } + else + { + // Wird zur Zeit nie disabled ! + //rSet.DisableItem( SID_PARASPACE_INCREASE ); + //rSet.DisableItem( SID_PARASPACE_DECREASE ); + } + + // Absatzausrichtung + SvxAdjust eAdj = ( (const SvxAdjustItem&) aAttrSet.Get( EE_PARA_JUST ) ).GetAdjust(); + switch( eAdj ) + { + case SVX_ADJUST_LEFT: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_ADJUST_LEFT, TRUE ) ); + break; + case SVX_ADJUST_CENTER: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_ADJUST_CENTER, TRUE ) ); + break; + case SVX_ADJUST_RIGHT: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_ADJUST_RIGHT, TRUE ) ); + break; + case SVX_ADJUST_BLOCK: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_ADJUST_BLOCK, TRUE ) ); + break; + default: + break; + } + + // paragraph text direction + if( bDisableParagraphTextDirection ) + { + rSet.DisableItem( SID_ATTR_PARA_LEFT_TO_RIGHT ); + rSet.DisableItem( SID_ATTR_PARA_RIGHT_TO_LEFT ); + } + else + { + switch( ( ( (SvxFrameDirectionItem&) aAttrSet.Get( EE_PARA_WRITINGDIR ) ) ).GetValue() ) + { + case FRMDIR_VERT_TOP_LEFT: + case FRMDIR_VERT_TOP_RIGHT: + { + rSet.DisableItem( SID_ATTR_PARA_LEFT_TO_RIGHT ); + rSet.DisableItem( SID_ATTR_PARA_RIGHT_TO_LEFT ); + } + break; + + case FRMDIR_HORI_LEFT_TOP: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_LEFT_TO_RIGHT, TRUE ) ); + rSet.Put( SfxBoolItem( SID_ATTR_PARA_RIGHT_TO_LEFT, FALSE ) ); + break; + + case FRMDIR_HORI_RIGHT_TOP: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_LEFT_TO_RIGHT, FALSE ) ); + rSet.Put( SfxBoolItem( SID_ATTR_PARA_RIGHT_TO_LEFT, TRUE ) ); + break; + + // #107865# + // The case for the superordinate object is missing. + case FRMDIR_ENVIRONMENT: + { + SdDrawDocument* pDoc = mpView->GetDoc(); + ::com::sun::star::text::WritingMode eMode = pDoc->GetDefaultWritingMode(); + sal_Bool bIsLeftToRight(sal_False); + + if(::com::sun::star::text::WritingMode_LR_TB == eMode + || ::com::sun::star::text::WritingMode_TB_RL == eMode) + { + bIsLeftToRight = sal_True; + } + + rSet.Put( SfxBoolItem( SID_ATTR_PARA_LEFT_TO_RIGHT, bIsLeftToRight ) ); + rSet.Put( SfxBoolItem( SID_ATTR_PARA_RIGHT_TO_LEFT, !bIsLeftToRight ) ); + } + break; + } + } + +/* #i35937# + if (aAttrSet.GetItemState(EE_PARA_BULLETSTATE) == SFX_ITEM_ON) + { + SfxUInt16Item aBulletState((const SfxUInt16Item&) aAttrSet.Get(EE_PARA_BULLETSTATE)); + + if (aBulletState.GetValue() != 0) + { + rSet.Put(SfxBoolItem(FN_NUM_BULLET_ON, TRUE)); + } + else + { + rSet.Put(SfxBoolItem(FN_NUM_BULLET_ON, FALSE)); + } + } +*/ + USHORT nLineSpace = (USHORT) ( (const SvxLineSpacingItem&) aAttrSet. + Get( EE_PARA_SBL ) ).GetPropLineSpace(); + switch( nLineSpace ) + { + case 100: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_LINESPACE_10, TRUE ) ); + break; + case 150: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_LINESPACE_15, TRUE ) ); + break; + case 200: + rSet.Put( SfxBoolItem( SID_ATTR_PARA_LINESPACE_20, TRUE ) ); + break; + } + } + + // Ausrichtung (hoch/tief) wird auch im Gliederungsmodus gebraucht + SvxEscapement eEsc = (SvxEscapement ) ( (const SvxEscapementItem&) + aAttrSet.Get( EE_CHAR_ESCAPEMENT ) ).GetEnumValue(); + + if( eEsc == SVX_ESCAPEMENT_SUPERSCRIPT ) + rSet.Put( SfxBoolItem( SID_SET_SUPER_SCRIPT, TRUE ) ); + else if( eEsc == SVX_ESCAPEMENT_SUBSCRIPT ) + rSet.Put( SfxBoolItem( SID_SET_SUB_SCRIPT, TRUE ) ); +} + +/************************************************************************* +|* +|* Command event +|* +\************************************************************************/ + +void TextObjectBar::Command( const CommandEvent& ) +{ +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/drtxtob1.cxx b/sd/source/ui/view/drtxtob1.cxx new file mode 100755 index 000000000000..4a6d83e376e7 --- /dev/null +++ b/sd/source/ui/view/drtxtob1.cxx @@ -0,0 +1,612 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "TextObjectBar.hxx" + + +#include <svx/svxids.hrc> + +#include <editeng/editview.hxx> +#include <editeng/editeng.hxx> +#include <editeng/unolingu.hxx> +#include <editeng/outliner.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/lspcitem.hxx> +#include <editeng/adjitem.hxx> +#include <vcl/vclenum.hxx> +#include <sfx2/app.hxx> +#include <svl/whiter.hxx> +#include <svl/itempool.hxx> +#include <svl/style.hxx> +#include <sfx2/tplpitem.hxx> +#include <sfx2/request.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/dispatch.hxx> +#include <editeng/escpitem.hxx> +#include <editeng/wghtitem.hxx> +#include <editeng/postitem.hxx> +#include <editeng/udlnitem.hxx> +#include <editeng/crsditem.hxx> +#include <editeng/cntritem.hxx> +#include <editeng/shdditem.hxx> +#include <svx/xtable.hxx> +#include <svx/svdobj.hxx> +#include <editeng/outlobj.hxx> +#include <editeng/flstitem.hxx> +#include <editeng/editeng.hxx> +#include <svl/intitem.hxx> +#include <editeng/scripttypeitem.hxx> +#include <svx/svdoutl.hxx> +#include <editeng/writingmodeitem.hxx> +#include <editeng/frmdiritem.hxx> +#include <svl/itemiter.hxx> + + +#include "app.hrc" + +#include "eetext.hxx" +#include "ViewShell.hxx" +#include "drawview.hxx" +#include "drawdoc.hxx" +#include "OutlineView.hxx" +#include "Window.hxx" +#include "futempl.hxx" +#include "DrawDocShell.hxx" +#include "Outliner.hxx" +#include "futext.hxx" + +namespace sd { + +/************************************************************************* +|* +|* Bearbeitung der SfxRequests +|* +\************************************************************************/ + +void TextObjectBar::Execute( SfxRequest &rReq ) +{ + const SfxItemSet* pArgs = rReq.GetArgs(); + const SfxPoolItem* pPoolItem = NULL; + USHORT nSlot = rReq.GetSlot(); + BOOL bOutlineMode = FALSE; + OutlinerView* pOLV = mpView->GetTextEditOutlinerView(); + + std::auto_ptr< OutlineViewModelChangeGuard > aGuard; + + if (mpView->ISA(OutlineView)) + { + bOutlineMode = TRUE; + pOLV = static_cast<OutlineView*>(mpView) + ->GetViewByWindow(mpViewShell->GetActiveWindow()); + + aGuard.reset( new OutlineViewModelChangeGuard( static_cast<OutlineView&>(*mpView) ) ); + } + + switch (nSlot) + { + case SID_STYLE_APPLY: + { + if( pArgs ) + { + SdDrawDocument* pDoc = mpView->GetDoc(); + OSL_ASSERT (mpViewShell->GetViewShell()!=NULL); + FunctionReference xFunc( FuTemplate::Create( mpViewShell, static_cast< ::sd::Window*>( mpViewShell->GetViewShell()->GetWindow()), mpView, pDoc, rReq ) ); + + if(xFunc.is()) + { + xFunc->Activate(); + xFunc->Deactivate(); + + if( rReq.GetSlot() == SID_STYLE_APPLY ) + { + if( mpViewShell && mpViewShell->GetViewFrame() ) + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_STYLE_APPLY ); + } + } + } + else + { + if( mpViewShell && mpViewShell->GetViewFrame() ) + mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_STYLE_DESIGNER, SFX_CALLMODE_ASYNCHRON ); + } + + rReq.Done(); + } + break; + + case SID_PARASPACE_INCREASE: + case SID_PARASPACE_DECREASE: + { + if( pOLV ) + { + ESelection aSel = pOLV->GetSelection(); + aSel.Adjust(); + ULONG nStartPara = aSel.nStartPara; + ULONG nEndPara = aSel.nEndPara; + if( !aSel.HasRange() ) + { + nStartPara = 0; + nEndPara = pOLV->GetOutliner()->GetParagraphCount() - 1; + } + for( ULONG nPara = nStartPara; nPara <= nEndPara; nPara++ ) + { + SfxStyleSheet* pStyleSheet = NULL; + if (pOLV->GetOutliner() != NULL) + pStyleSheet = pOLV->GetOutliner()->GetStyleSheet(nPara); + if (pStyleSheet != NULL) + { + SfxItemSet aAttr( pStyleSheet->GetItemSet() ); + SfxItemSet aTmpSet( pOLV->GetOutliner()->GetParaAttribs( (USHORT) nPara ) ); + aAttr.Put( aTmpSet, FALSE ); // FALSE= InvalidItems nicht als Default, sondern als "Loecher" betrachten + const SvxULSpaceItem& rItem = (const SvxULSpaceItem&) aAttr.Get( EE_PARA_ULSPACE ); + SvxULSpaceItem* pNewItem = (SvxULSpaceItem*) rItem.Clone(); + + long nUpper = pNewItem->GetUpper(); + if( nSlot == SID_PARASPACE_INCREASE ) + nUpper += 100; + else + { + nUpper -= 100; + nUpper = Max( (long) nUpper, 0L ); + } + pNewItem->SetUpper( (USHORT) nUpper ); + + long nLower = pNewItem->GetLower(); + if( nSlot == SID_PARASPACE_INCREASE ) + nLower += 100; + else + { + nLower -= 100; + nLower = Max( (long) nLower, 0L ); + } + pNewItem->SetLower( (USHORT) nLower ); + + SfxItemSet aNewAttrs( aAttr ); + aNewAttrs.Put( *pNewItem ); + delete pNewItem; + pOLV->GetOutliner()->SetParaAttribs( (USHORT)nPara, aNewAttrs ); + } + } + } + else + { + // Der folgende Code kann enabled werden, wenn ich von + // JOE einen richtigen Status (DontCare) bekomme; + + // Wird enabled, obwohl es nicht richtig funktioniert (s.o.) + SfxItemSet aEditAttr( mpView->GetDoc()->GetPool() ); + mpView->GetAttributes( aEditAttr ); + if( aEditAttr.GetItemState( EE_PARA_ULSPACE ) >= SFX_ITEM_AVAILABLE ) + { + SfxItemSet aNewAttrs(*(aEditAttr.GetPool()), aEditAttr.GetRanges()); + const SvxULSpaceItem& rItem = (const SvxULSpaceItem&) aEditAttr.Get( EE_PARA_ULSPACE ); + SvxULSpaceItem* pNewItem = (SvxULSpaceItem*) rItem.Clone(); + long nUpper = pNewItem->GetUpper(); + + if( nSlot == SID_PARASPACE_INCREASE ) + nUpper += 100; + else + { + nUpper -= 100; + nUpper = Max( (long) nUpper, 0L ); + } + pNewItem->SetUpper( (USHORT) nUpper ); + + long nLower = pNewItem->GetLower(); + if( nSlot == SID_PARASPACE_INCREASE ) + nLower += 100; + else + { + nLower -= 100; + nLower = Max( (long) nLower, 0L ); + } + pNewItem->SetLower( (USHORT) nLower ); + + aNewAttrs.Put( *pNewItem ); + delete pNewItem; + + mpView->SetAttributes( aNewAttrs ); + } + } + rReq.Done(); + + Invalidate(); + // Um die Preview (im Gliederungsmodus) zu aktualisieren muss + // der Slot invalidiert werden: + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_PREVIEW_STATE, TRUE, FALSE ); + } + break; + + case SID_OUTLINE_LEFT: + { + if (pOLV) + { + pOLV->AdjustDepth( -1 ); + + // Ensure bold/italic etc. icon state updates + Invalidate(); + // #96551# trigger preview refresh + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_PREVIEW_STATE, TRUE, FALSE ); + } + rReq.Done(); + } + break; + + case SID_OUTLINE_RIGHT: + { + if (pOLV) + { + pOLV->AdjustDepth( 1 ); + + // Ensure bold/italic etc. icon state updates + Invalidate(); + // #96551# trigger preview refresh + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_PREVIEW_STATE, TRUE, FALSE ); + } + rReq.Done(); + } + break; + + case SID_OUTLINE_UP: + { + if (pOLV) + { + pOLV->AdjustHeight( -1 ); + + // #96551# trigger preview refresh + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_PREVIEW_STATE, TRUE, FALSE ); + } + rReq.Done(); + } + break; + + case SID_OUTLINE_DOWN: + { + if (pOLV) + { + pOLV->AdjustHeight( 1 ); + + // #96551# trigger preview refresh + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_PREVIEW_STATE, TRUE, FALSE ); + } + rReq.Done(); + } + break; + + case SID_TEXTDIRECTION_LEFT_TO_RIGHT: + case SID_TEXTDIRECTION_TOP_TO_BOTTOM: + { + mpView->SdrEndTextEdit(); + SfxItemSet aAttr( mpView->GetDoc()->GetPool(), SDRATTR_TEXTDIRECTION, SDRATTR_TEXTDIRECTION, 0 ); + aAttr.Put( SvxWritingModeItem( + nSlot == SID_TEXTDIRECTION_LEFT_TO_RIGHT ? + com::sun::star::text::WritingMode_LR_TB : com::sun::star::text::WritingMode_TB_RL, + SDRATTR_TEXTDIRECTION ) ); + rReq.Done( aAttr ); + mpView->SetAttributes( aAttr ); + Invalidate(); + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_PREVIEW_STATE, TRUE, FALSE ); + } + break; + + case FN_NUM_BULLET_ON: + if( pOLV ) + pOLV->ToggleBullets(); + break; + + case SID_GROW_FONT_SIZE: + case SID_SHRINK_FONT_SIZE: + { + const SvxFontListItem* pFonts = (const SvxFontListItem*)mpViewShell->GetDocSh()->GetItem( SID_ATTR_CHAR_FONTLIST ); + const FontList* pFontList = pFonts ? pFonts->GetFontList(): 0; + if( pFontList ) + { + FuText::ChangeFontSize( nSlot == SID_GROW_FONT_SIZE, pOLV, pFontList, mpView ); + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT ); + } + rReq.Done(); + } + break; + + case SID_THES: + { + String aReplaceText; + SFX_REQUEST_ARG( rReq, pItem2, SfxStringItem, SID_THES, sal_False ); + if (pItem2) + aReplaceText = pItem2->GetValue(); + if (aReplaceText.Len() > 0) + ReplaceTextWithSynonym( pOLV->GetEditView(), aReplaceText ); + } + break; + + default: + { + SfxItemSet aEditAttr( mpView->GetDoc()->GetPool() ); + mpView->GetAttributes( aEditAttr ); + SfxItemSet aNewAttr(*(aEditAttr.GetPool()), aEditAttr.GetRanges()); + + if( !pArgs ) + { + //aNewAttr.InvalidateAllItems(); <- Macht Probleme (#35465#) + + switch ( nSlot ) + { + case SID_ATTR_CHAR_WEIGHT: + { + FontWeight eFW = ( (const SvxWeightItem&) aEditAttr. + Get( EE_CHAR_WEIGHT ) ).GetWeight(); + aNewAttr.Put( SvxWeightItem( eFW == WEIGHT_NORMAL ? + WEIGHT_BOLD : WEIGHT_NORMAL, + EE_CHAR_WEIGHT ) ); + } + break; + case SID_ATTR_CHAR_POSTURE: + { + FontItalic eFI = ( (const SvxPostureItem&) aEditAttr. + Get( EE_CHAR_ITALIC ) ).GetPosture(); + aNewAttr.Put( SvxPostureItem( eFI == ITALIC_NORMAL ? + ITALIC_NONE : ITALIC_NORMAL, + EE_CHAR_ITALIC ) ); + } + break; + case SID_ATTR_CHAR_UNDERLINE: + { + FontUnderline eFU = ( (const SvxUnderlineItem&) aEditAttr. + Get( EE_CHAR_UNDERLINE ) ).GetLineStyle(); + aNewAttr.Put( SvxUnderlineItem( eFU == UNDERLINE_SINGLE ? + UNDERLINE_NONE : UNDERLINE_SINGLE, + EE_CHAR_UNDERLINE ) ); + } + break; + case SID_ATTR_CHAR_OVERLINE: + { + FontUnderline eFO = ( (const SvxOverlineItem&) aEditAttr. + Get( EE_CHAR_OVERLINE ) ).GetLineStyle(); + aNewAttr.Put( SvxOverlineItem( eFO == UNDERLINE_SINGLE ? + UNDERLINE_NONE : UNDERLINE_SINGLE, + EE_CHAR_OVERLINE ) ); + } + break; + case SID_ATTR_CHAR_CONTOUR: + { + aNewAttr.Put( SvxContourItem( !( (const SvxContourItem&) aEditAttr. + Get( EE_CHAR_OUTLINE ) ).GetValue(), EE_CHAR_OUTLINE ) ); + } + break; + case SID_ATTR_CHAR_SHADOWED: + { + aNewAttr.Put( SvxShadowedItem( !( (const SvxShadowedItem&) aEditAttr. + Get( EE_CHAR_SHADOW ) ).GetValue(), EE_CHAR_SHADOW ) ); + } + break; + case SID_ATTR_CHAR_STRIKEOUT: + { + FontStrikeout eFSO = ( ( (const SvxCrossedOutItem&) aEditAttr. + Get( EE_CHAR_STRIKEOUT ) ).GetStrikeout() ); + aNewAttr.Put( SvxCrossedOutItem( eFSO == STRIKEOUT_SINGLE ? + STRIKEOUT_NONE : STRIKEOUT_SINGLE, EE_CHAR_STRIKEOUT ) ); + } + break; + + case SID_ATTR_PARA_ADJUST_LEFT: + { + aNewAttr.Put( SvxAdjustItem( SVX_ADJUST_LEFT, EE_PARA_JUST ) ); + } + break; + case SID_ATTR_PARA_ADJUST_CENTER: + { + aNewAttr.Put( SvxAdjustItem( SVX_ADJUST_CENTER, EE_PARA_JUST ) ); + } + break; + case SID_ATTR_PARA_ADJUST_RIGHT: + { + aNewAttr.Put( SvxAdjustItem( SVX_ADJUST_RIGHT, EE_PARA_JUST ) ); + } + break; + case SID_ATTR_PARA_ADJUST_BLOCK: + { + aNewAttr.Put( SvxAdjustItem( SVX_ADJUST_BLOCK, EE_PARA_JUST ) ); + } + break; + case SID_ATTR_PARA_LINESPACE_10: + { + SvxLineSpacingItem aItem( SVX_LINESPACE_ONE_LINE, EE_PARA_SBL ); + aItem.SetPropLineSpace( 100 ); + aNewAttr.Put( aItem ); + } + break; + case SID_ATTR_PARA_LINESPACE_15: + { + SvxLineSpacingItem aItem( SVX_LINESPACE_ONE_POINT_FIVE_LINES, EE_PARA_SBL ); + aItem.SetPropLineSpace( 150 ); + aNewAttr.Put( aItem ); + } + break; + case SID_ATTR_PARA_LINESPACE_20: + { + SvxLineSpacingItem aItem( SVX_LINESPACE_TWO_LINES, EE_PARA_SBL ); + aItem.SetPropLineSpace( 200 ); + aNewAttr.Put( aItem ); + } + break; + case SID_SET_SUPER_SCRIPT: + { + SvxEscapementItem aItem( EE_CHAR_ESCAPEMENT ); + SvxEscapement eEsc = (SvxEscapement ) ( (const SvxEscapementItem&) + aEditAttr.Get( EE_CHAR_ESCAPEMENT ) ).GetEnumValue(); + + if( eEsc == SVX_ESCAPEMENT_SUPERSCRIPT ) + aItem.SetEscapement( SVX_ESCAPEMENT_OFF ); + else + aItem.SetEscapement( SVX_ESCAPEMENT_SUPERSCRIPT ); + aNewAttr.Put( aItem ); + } + break; + case SID_SET_SUB_SCRIPT: + { + SvxEscapementItem aItem( EE_CHAR_ESCAPEMENT ); + SvxEscapement eEsc = (SvxEscapement ) ( (const SvxEscapementItem&) + aEditAttr.Get( EE_CHAR_ESCAPEMENT ) ).GetEnumValue(); + + if( eEsc == SVX_ESCAPEMENT_SUBSCRIPT ) + aItem.SetEscapement( SVX_ESCAPEMENT_OFF ); + else + aItem.SetEscapement( SVX_ESCAPEMENT_SUBSCRIPT ); + aNewAttr.Put( aItem ); + } + break; + + // Attribute fuer die TextObjectBar + case SID_ATTR_CHAR_FONT: + { + if( pArgs ) + { + if( SFX_ITEM_SET == pArgs->GetItemState( EE_CHAR_FONTINFO, TRUE, &pPoolItem ) ) + aNewAttr.Put( *pPoolItem ); + } + else + mpViewShell->GetViewFrame()->GetDispatcher()-> + Execute( SID_CHAR_DLG, SFX_CALLMODE_ASYNCHRON ); + } + break; + case SID_ATTR_CHAR_FONTHEIGHT: + { + if( pArgs ) + { + if( SFX_ITEM_SET == pArgs->GetItemState( EE_CHAR_FONTHEIGHT, TRUE, &pPoolItem ) ) + aNewAttr.Put( *pPoolItem ); + } + else + mpViewShell->GetViewFrame()->GetDispatcher()-> + Execute( SID_CHAR_DLG, SFX_CALLMODE_ASYNCHRON ); + } + break; + case SID_ATTR_CHAR_COLOR: + { + if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( EE_CHAR_COLOR, TRUE, &pPoolItem ) ) + aNewAttr.Put( *pPoolItem ); + } + break; +/* #i35937# + case FN_NUM_BULLET_ON: + { + if (aEditAttr.GetItemState(EE_PARA_BULLETSTATE) == SFX_ITEM_ON) + { + SfxUInt16Item aBulletState((const SfxUInt16Item&) aEditAttr.Get(EE_PARA_BULLETSTATE)); + + if (aBulletState.GetValue() != 0) + { + // Ausschalten + aNewAttr.Put(SfxUInt16Item(EE_PARA_BULLETSTATE, 0)); + } + else + { + // Einschalten + aNewAttr.Put(SfxUInt16Item(EE_PARA_BULLETSTATE, 1)); + } + } + else + { + // Einschalten + aNewAttr.Put(SfxUInt16Item(EE_PARA_BULLETSTATE, 1)); + } + } + break; +*/ + } + + rReq.Done( aNewAttr ); + pArgs = rReq.GetArgs(); + } + else if ( nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT || + nSlot == SID_ATTR_PARA_RIGHT_TO_LEFT ) + { + sal_Bool bLeftToRight = nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT; + + USHORT nAdjust = SVX_ADJUST_LEFT; + if( SFX_ITEM_ON == aEditAttr.GetItemState(EE_PARA_JUST, TRUE, &pPoolItem ) ) + nAdjust = ( (SvxAdjustItem*)pPoolItem)->GetEnumValue(); + + if( bLeftToRight ) + { + aNewAttr.Put( SvxFrameDirectionItem( FRMDIR_HORI_LEFT_TOP, EE_PARA_WRITINGDIR ) ); + if( nAdjust == SVX_ADJUST_RIGHT ) + aNewAttr.Put( SvxAdjustItem( SVX_ADJUST_LEFT, EE_PARA_JUST ) ); + } + else + { + aNewAttr.Put( SvxFrameDirectionItem( FRMDIR_HORI_RIGHT_TOP, EE_PARA_WRITINGDIR ) ); + if( nAdjust == SVX_ADJUST_LEFT ) + aNewAttr.Put( SvxAdjustItem( SVX_ADJUST_RIGHT, EE_PARA_JUST ) ); + } + + rReq.Done( aNewAttr ); + pArgs = rReq.GetArgs(); + + Invalidate( SID_RULER_TEXT_RIGHT_TO_LEFT ); + } + else if ( nSlot == SID_ATTR_CHAR_FONT || + nSlot == SID_ATTR_CHAR_FONTHEIGHT || + nSlot == SID_ATTR_CHAR_POSTURE || + nSlot == SID_ATTR_CHAR_WEIGHT ) + { + // #i78017 establish the same behaviour as in Writer + USHORT nScriptType = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX; + if (nSlot == SID_ATTR_CHAR_FONT) + nScriptType = mpView->GetScriptType(); + + SfxItemPool& rPool = mpView->GetDoc()->GetPool(); + SvxScriptSetItem aSvxScriptSetItem( nSlot, rPool ); + aSvxScriptSetItem.PutItemForScriptType( nScriptType, pArgs->Get( rPool.GetWhich( nSlot ) ) ); + aNewAttr.Put( aSvxScriptSetItem.GetItemSet() ); + rReq.Done( aNewAttr ); + pArgs = rReq.GetArgs(); + } + + mpView->SetAttributes(*pArgs); + + // Aus Performance- und Erweiterungsgruenden wird + // jetzt die komplette Shell invalidiert + Invalidate(); + + // Um die Preview (im Gliederungsmodus) zu aktualisieren muss + // der Slot invalidiert werden: + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_PREVIEW_STATE, TRUE, FALSE ); + } + break; + } + + Invalidate( SID_OUTLINE_LEFT ); + Invalidate( SID_OUTLINE_RIGHT ); + Invalidate( SID_OUTLINE_UP ); + Invalidate( SID_OUTLINE_DOWN ); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviews1.cxx b/sd/source/ui/view/drviews1.cxx new file mode 100755 index 000000000000..98d0b7551705 --- /dev/null +++ b/sd/source/ui/view/drviews1.cxx @@ -0,0 +1,1448 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include "ViewShellImplementation.hxx" + +#include "DrawController.hxx" +#include <com/sun/star/embed/EmbedStates.hpp> + +#include "comphelper/anytostring.hxx" +#include "comphelper/scopeguard.hxx" +#include "cppuhelper/exc_hlp.hxx" +#include "rtl/ref.hxx" + +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <svx/svdpagv.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/bindings.hxx> +#include <svx/svdoole2.hxx> +#include <sfx2/dispatch.hxx> +#include <vcl/scrbar.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdopage.hxx> +#include <vcl/msgbox.hxx> +#include <sot/storage.hxx> +#include <svx/fmshell.hxx> +#include <svx/globl3d.hxx> +#include <svx/fmglob.hxx> +#include <editeng/outliner.hxx> + + +#include "misc.hxx" + +#ifdef STARIMAGE_AVAILABLE +#ifndef _SIMDLL_HXX +#include <sim2/simdll.hxx> +#endif +#endif + +#include <svx/dialogs.hrc> + +#include "view/viewoverlaymanager.hxx" + +#include "glob.hrc" +#include "app.hrc" +#include "res_bmp.hrc" +#include "strings.hrc" +#include "helpids.h" + +#include "app.hxx" +#include "fupoor.hxx" +#include "sdresid.hxx" +#include "fusel.hxx" +#include "sdpage.hxx" +#include "FrameView.hxx" +#include "stlpool.hxx" +#include "Window.hxx" +#ifndef SD_DRAWVIEW_HXX +#include "drawview.hxx" +#endif +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "Ruler.hxx" +#include "Client.hxx" +#include "slideshow.hxx" +#include "optsitem.hxx" +#include "fusearch.hxx" +#include "Outliner.hxx" +#include "AnimationChildWindow.hxx" +#include "SdUnoDrawView.hxx" +#include "ToolBarManager.hxx" +#include "FormShellManager.hxx" +#include "ViewShellBase.hxx" +#include "LayerDialogChildWindow.hxx" +#include "LayerTabBar.hxx" +#include "ViewShellManager.hxx" +#include "ViewShellHint.hxx" + +#include <sfx2/request.hxx> +#include <boost/bind.hpp> + +#ifdef _MSC_VER +#if (_MSC_VER < 1400) +#pragma optimize ( "", off ) +#endif +#endif + +using namespace com::sun::star; + +namespace sd { + +void DrawViewShell::Activate(BOOL bIsMDIActivate) +{ + ViewShell::Activate(bIsMDIActivate); +} + +void DrawViewShell::UIActivating( SfxInPlaceClient* pCli ) +{ + ViewShell::UIActivating(pCli); + + // #94252# Disable own controls + maTabControl.Disable(); + if (GetLayerTabControl() != NULL) + GetLayerTabControl()->Disable(); +} + +void DrawViewShell::UIDeactivated( SfxInPlaceClient* pCli ) +{ + // #94252# Enable own controls + maTabControl.Enable(); + if (GetLayerTabControl() != NULL) + GetLayerTabControl()->Enable(); + + ViewShell::UIDeactivated(pCli); +} + + +/************************************************************************* +|* +|* Deactivate() +|* +\************************************************************************/ + +void DrawViewShell::Deactivate(BOOL bIsMDIActivate) +{ + ViewShell::Deactivate(bIsMDIActivate); +} + +namespace +{ + class LockUI + { + private: + void Lock(bool bLock); + SfxViewFrame *mpFrame; + public: + LockUI(SfxViewFrame *pFrame) : mpFrame(pFrame) { Lock(true); } + ~LockUI() { Lock(false); } + + }; + + void LockUI::Lock(bool bLock) + { + if (!mpFrame) + return; + mpFrame->Enable( !bLock ); + } +} + +/************************************************************************* +|* +|* Wird gerufen, wenn sich der Selektionszustand der View aendert +|* +\************************************************************************/ +void DrawViewShell::SelectionHasChanged (void) +{ + Invalidate(); + + //Update3DWindow(); // 3D-Controller + SfxBoolItem aItem( SID_3D_STATE, TRUE ); + GetViewFrame()->GetDispatcher()->Execute( + SID_3D_STATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); + + SdrOle2Obj* pOleObj = NULL; + SdrGrafObj* pGrafObj = NULL; + + if ( mpDrawView->AreObjectsMarked() ) + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + + if (rMarkList.GetMarkCount() == 1) + { + SdrMark* pMark = rMarkList.GetMark(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + + UINT32 nInv = pObj->GetObjInventor(); + UINT16 nSdrObjKind = pObj->GetObjIdentifier(); + + if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2) + { + pOleObj = (SdrOle2Obj*) pObj; + UpdateIMapDlg( pObj ); + } + else if (nSdrObjKind == OBJ_GRAF) + { + pGrafObj = (SdrGrafObj*) pObj; + UpdateIMapDlg( pObj ); + } + } + } + + ViewShellBase& rBase = GetViewShellBase(); + rBase.SetVerbs(0); + + try + { + Client* pIPClient = static_cast<Client*>(rBase.GetIPClient()); + if ( pIPClient && pIPClient->IsObjectInPlaceActive() ) + { + /********************************************************************** + * Ggf. OLE-Objekt beruecksichtigen und deaktivieren + **********************************************************************/ + + // this means we recently deselected an inplace active ole object so + // we need to deselect it now + if (!pOleObj) + { + //#i47279# disable frame until after object has completed unload + LockUI aUILock(GetViewFrame()); + pIPClient->DeactivateObject(); + //HMHmpDrView->ShowMarkHdl(); + } + else + { + uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef(); + if ( xObj.is() ) + { + rBase.SetVerbs( xObj->getSupportedVerbs() ); + } + else + { + rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() ); + } + } + } + else + { + if ( pOleObj ) + { + uno::Reference < embed::XEmbeddedObject > xObj = pOleObj->GetObjRef(); + if ( xObj.is() ) + { + rBase.SetVerbs( xObj->getSupportedVerbs() ); + } + else + { + rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() ); + } + } + else + { + rBase.SetVerbs( uno::Sequence < embed::VerbDescriptor >() ); + } + } + } + catch( ::com::sun::star::uno::Exception& e ) + { + (void)e; + DBG_ERROR( + (rtl::OString("sd::DrawViewShell::SelectionHasChanged(), " + "exception caught: ") + + rtl::OUStringToOString( + comphelper::anyToString( cppu::getCaughtException() ), + RTL_TEXTENCODING_UTF8 )).getStr() ); + } + + if( HasCurrentFunction() ) + { + GetCurrentFunction()->SelectionHasChanged(); + } + else + { + GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this,*mpDrawView); + } + + // #96124# Invalidate for every subshell + GetViewShellBase().GetViewShellManager()->InvalidateAllSubShells(this); + + mpDrawView->UpdateSelectionClipboard( FALSE ); + + GetViewShellBase().GetDrawController().FireSelectionChangeListener(); +} + + +/************************************************************************* +|* +|* Zoomfaktor setzen +|* +\************************************************************************/ + +void DrawViewShell::SetZoom( long nZoom ) +{ + // Make sure that the zoom factor will not be recalculated on + // following window resizings. + mbZoomOnPage = FALSE; + ViewShell::SetZoom( nZoom ); + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM ); + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER ); + mpViewOverlayManager->onZoomChanged(); +} + +/************************************************************************* +|* +|* Zoomrechteck fuer aktives Fenster einstellen +|* +\************************************************************************/ + +void DrawViewShell::SetZoomRect( const Rectangle& rZoomRect ) +{ + ViewShell::SetZoomRect( rZoomRect ); + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM ); + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER ); + mpViewOverlayManager->onZoomChanged(); +} + +/************************************************************************* +|* +|* PrepareClose, ggfs. Texteingabe beenden, damit andere Viewshells ein +|* aktualisiertes Textobjekt vorfinden +|* +\************************************************************************/ + +USHORT DrawViewShell::PrepareClose( BOOL bUI, BOOL bForBrowsing ) +{ + if ( ViewShell::PrepareClose(bUI, bForBrowsing) != TRUE ) + return FALSE; + + BOOL bRet = TRUE; + + if( bRet && HasCurrentFunction() ) + { + USHORT nID = GetCurrentFunction()->GetSlotID(); + if (nID == SID_TEXTEDIT || nID == SID_ATTR_CHAR) + { + mpDrawView->SdrEndTextEdit(); + } + } + else if( !bRet ) + { + maCloseTimer.SetTimeoutHdl( LINK( this, DrawViewShell, CloseHdl ) ); + maCloseTimer.SetTimeout( 20 ); + maCloseTimer.Start(); + } + + return bRet; +} + +/************************************************************************* +|* +|* Status (Enabled/Disabled) von Menue-SfxSlots setzen +|* +\************************************************************************/ + +void DrawViewShell::ChangeEditMode(EditMode eEMode, bool bIsLayerModeActive) +{ + if (meEditMode != eEMode || mbIsLayerModeActive != bIsLayerModeActive) + { + ViewShellManager::UpdateLock aLock (GetViewShellBase().GetViewShellManager()); + + USHORT nActualPageNum = 0; + + GetViewShellBase().GetDrawController().FireChangeEditMode (eEMode == EM_MASTERPAGE); + GetViewShellBase().GetDrawController().FireChangeLayerMode (bIsLayerModeActive); + + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + LayerTabBar* pLayerBar = GetLayerTabControl(); + if (pLayerBar != NULL) + pLayerBar->EndEditMode(); + maTabControl.EndEditMode(); + + if (mePageKind == PK_HANDOUT) + { + // Bei Handzetteln nur MasterPage zulassen + eEMode = EM_MASTERPAGE; + } + + meEditMode = eEMode; + mbIsLayerModeActive = bIsLayerModeActive; + + // Determine whether to show the master view toolbar. The master + // page mode has to be active and the shell must not be a handout + // view. + bool bShowMasterViewToolbar (meEditMode == EM_MASTERPAGE + && GetShellType() != ViewShell::ST_HANDOUT); + + // If the master view toolbar is not shown we hide it before + // switching the edit mode. + if (::sd::ViewShell::mpImpl->mbIsInitialized + && IsMainViewShell() + && ! bShowMasterViewToolbar) + { + GetViewShellBase().GetToolBarManager()->ResetToolBars(ToolBarManager::TBG_MASTER_MODE); + } + + if (meEditMode == EM_PAGE) + { + /****************************************************************** + * PAGEMODE + ******************************************************************/ + + maTabControl.Clear(); + + SdPage* pPage; + String aPageName; + USHORT nPageCnt = GetDoc()->GetSdPageCount(mePageKind); + + for (USHORT i = 0; i < nPageCnt; i++) + { + pPage = GetDoc()->GetSdPage(i, mePageKind); + aPageName = pPage->GetName(); + maTabControl.InsertPage(i + 1, aPageName); + + if ( pPage->IsSelected() && nActualPageNum == 0 ) + { + nActualPageNum = i; + } + } + + maTabControl.SetCurPageId(nActualPageNum + 1); + + SwitchPage(nActualPageNum); + } + else + { + /****************************************************************** + * MASTERPAGE + ******************************************************************/ + GetViewFrame()->SetChildWindow( + AnimationChildWindow::GetChildWindowId(), FALSE ); + + if (!mpActualPage) + { + // Sofern es keine mpActualPage gibt, wird die erste genommen + mpActualPage = GetDoc()->GetSdPage(0, mePageKind); + } + + maTabControl.Clear(); + USHORT nActualMasterPageNum = 0; + USHORT nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind); + + for (USHORT i = 0; i < nMasterPageCnt; i++) + { + SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind); + String aLayoutName(pMaster->GetLayoutName()); + aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR)); + + maTabControl.InsertPage(i + 1, aLayoutName); + + if (&(mpActualPage->TRG_GetMasterPage()) == pMaster) + { + nActualMasterPageNum = i; + } + } + + maTabControl.SetCurPageId(nActualMasterPageNum + 1); + SwitchPage(nActualMasterPageNum); + } + + // If the master view toolbar is to be shown we turn it on after the + // edit mode has been changed. + if (::sd::ViewShell::mpImpl->mbIsInitialized + && IsMainViewShell() + && bShowMasterViewToolbar) + { + GetViewShellBase().GetToolBarManager()->SetToolBar( + ToolBarManager::TBG_MASTER_MODE, + ToolBarManager::msMasterViewToolBar); + } + + if ( ! mbIsLayerModeActive) + { + maTabControl.Show(); + // Set the tab control only for draw pages. For master page + // this has been done already above. + if (meEditMode == EM_PAGE) + maTabControl.SetCurPageId (nActualPageNum + 1); + } + /*AF: The LayerDialogChildWindow is not used anymore (I hope). + if (GetViewFrame()->KnowsChildWindow( + LayerDialogChildWindow::GetChildWindowId())) + { + GetViewFrame()->SetChildWindow( + LayerDialogChildWindow::GetChildWindowId(), + IsLayerModeActive()); + } + */ + ResetActualLayer(); + + Invalidate( SID_PAGEMODE ); + Invalidate( SID_LAYERMODE ); + Invalidate( SID_MASTERPAGE ); + Invalidate( SID_DELETE_MASTER_PAGE ); + Invalidate( SID_DELETE_PAGE ); + Invalidate( SID_SLIDE_MASTERPAGE ); + Invalidate( SID_TITLE_MASTERPAGE ); + Invalidate( SID_NOTES_MASTERPAGE ); + Invalidate( SID_HANDOUT_MASTERPAGE ); + } +} + + + + +bool DrawViewShell::IsLayerModeActive (void) const +{ + return mbIsLayerModeActive; +} + + + + +/************************************************************************* +|* +|* Groesse des TabControls und der ModeButtons zurueckgeben +|* +\************************************************************************/ + +long DrawViewShell::GetHCtrlWidth() +{ + // return maTabControl.GetSizePixel().Width(); + return 0; +} + + +/************************************************************************* +|* +|* Horizontales Lineal erzeugen +|* +\************************************************************************/ + +SvxRuler* DrawViewShell::CreateHRuler (::sd::Window* pWin, BOOL bIsFirst) +{ + Ruler* pRuler; + WinBits aWBits; + USHORT nFlags = SVXRULER_SUPPORT_OBJECT; + + if ( bIsFirst ) + { + aWBits = WB_HSCROLL | WB_3DLOOK | WB_BORDER | WB_EXTRAFIELD; + nFlags |= ( SVXRULER_SUPPORT_SET_NULLOFFSET | + SVXRULER_SUPPORT_TABS | + SVXRULER_SUPPORT_PARAGRAPH_MARGINS ); // Neu + } + else + aWBits = WB_HSCROLL | WB_3DLOOK | WB_BORDER; + + pRuler = new Ruler (*this, GetParentWindow(), pWin, nFlags, + GetViewFrame()->GetBindings(), aWBits); + pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit()); + + // Metric ... + UINT16 nMetric = (UINT16)GetDoc()->GetUIUnit(); + + if( nMetric == 0xffff ) + nMetric = (UINT16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit(); + + pRuler->SetUnit( FieldUnit( nMetric ) ); + + // ... und auch DefTab am Lineal einstellen + pRuler->SetDefTabDist( GetDoc()->GetDefaultTabulator() ); // Neu + + Fraction aUIScale(pWin->GetMapMode().GetScaleX()); + aUIScale *= GetDoc()->GetUIScale(); + pRuler->SetZoom(aUIScale); + + return pRuler; +} + +/************************************************************************* +|* +|* Vertikales Lineal erzeugen +|* +\************************************************************************/ + +SvxRuler* DrawViewShell::CreateVRuler(::sd::Window* pWin) +{ + Ruler* pRuler; + WinBits aWBits = WB_VSCROLL | WB_3DLOOK | WB_BORDER; + USHORT nFlags = SVXRULER_SUPPORT_OBJECT; + + pRuler = new Ruler(*this, GetParentWindow(), pWin, nFlags, + GetViewFrame()->GetBindings(), aWBits); + pRuler->SetSourceUnit(pWin->GetMapMode().GetMapUnit()); + + // #96629# Metric same as HRuler, use document setting + UINT16 nMetric = (UINT16)GetDoc()->GetUIUnit(); + + if( nMetric == 0xffff ) + nMetric = (UINT16)GetViewShellBase().GetViewFrame()->GetDispatcher()->GetModule()->GetFieldUnit(); + + pRuler->SetUnit( FieldUnit( nMetric ) ); + + Fraction aUIScale(pWin->GetMapMode().GetScaleY()); + aUIScale *= GetDoc()->GetUIScale(); + pRuler->SetZoom(aUIScale); + + return pRuler; +} + +/************************************************************************* +|* +|* Horizontales Lineal aktualisieren +|* +\************************************************************************/ + +void DrawViewShell::UpdateHRuler() +{ + Invalidate( SID_ATTR_LONG_LRSPACE ); + Invalidate( SID_RULER_PAGE_POS ); + Invalidate( SID_RULER_OBJECT ); + Invalidate( SID_RULER_TEXT_RIGHT_TO_LEFT ); + + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->ForceUpdate(); +} + +/************************************************************************* +|* +|* Vertikales Lineal aktualisieren +|* +\************************************************************************/ + +void DrawViewShell::UpdateVRuler() +{ + Invalidate( SID_ATTR_LONG_LRSPACE ); + Invalidate( SID_RULER_PAGE_POS ); + Invalidate( SID_RULER_OBJECT ); + + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->ForceUpdate(); +} + +/************************************************************************* +|* +|* Metrik setzen +|* +\************************************************************************/ + +void DrawViewShell::SetUIUnit(FieldUnit eUnit) +{ + ViewShell::SetUIUnit(eUnit); +} + +/************************************************************************* +|* +|* TabControl nach Splitteraenderung aktualisieren +|* +\************************************************************************/ + +IMPL_LINK( DrawViewShell, TabSplitHdl, TabBar *, pTab ) +{ + const long int nMax = maViewSize.Width() - maScrBarWH.Width() + - maTabControl.GetPosPixel().X() ; + + Size aTabSize = maTabControl.GetSizePixel(); + aTabSize.Width() = Min(pTab->GetSplitSize(), (long)(nMax-1)); + + maTabControl.SetSizePixel(aTabSize); + GetLayerTabControl()->SetSizePixel(aTabSize); + + Point aPos = maTabControl.GetPosPixel(); + aPos.X() += aTabSize.Width(); + + Size aScrSize(nMax - aTabSize.Width(), maScrBarWH.Height()); + mpHorizontalScrollBar->SetPosSizePixel(aPos, aScrSize); + + return 0; +} + +/// inherited from sd::ViewShell +SdPage* DrawViewShell::getCurrentPage() const +{ + const sal_Int32 nPageCount = (meEditMode == EM_PAGE)? + GetDoc()->GetSdPageCount(mePageKind): + GetDoc()->GetMasterSdPageCount(mePageKind); + + sal_Int32 nCurrentPage = maTabControl.GetCurPageId() - 1; + DBG_ASSERT( (nPageCount>0) && (nCurrentPage<nPageCount), "sd::DrawViewShell::getCurrentPage(), illegal page index!" ); + if( (nPageCount < 0) || (nCurrentPage>=nPageCount) ) + nCurrentPage = 0; // play safe here + + if (meEditMode == EM_PAGE) + { + return GetDoc()->GetSdPage((USHORT)nCurrentPage, mePageKind); + } + else // EM_MASTERPAGE + { + return GetDoc()->GetMasterSdPage((USHORT)nCurrentPage, mePageKind); + } +} + +/************************************************************************* +|* +|* neue aktuelle Seite auswaehlen, falls sich die Seitenfolge geaendert +|* hat (z. B. durch Undo) +|* +\************************************************************************/ + +void DrawViewShell::ResetActualPage() +{ + USHORT nCurrentPage = maTabControl.GetCurPageId() - 1; + USHORT nPageCount = (meEditMode == EM_PAGE)?GetDoc()->GetSdPageCount(mePageKind):GetDoc()->GetMasterSdPageCount(mePageKind); + if (nPageCount > 0) + nCurrentPage = Min((USHORT)(nPageCount - 1), nCurrentPage); + else + nCurrentPage = 0; + + if (meEditMode == EM_PAGE) + { + + // Update fuer TabControl + maTabControl.Clear(); + + SdPage* pPage = NULL; + String aPageName; + + for (USHORT i = 0; i < nPageCount; i++) + { + pPage = GetDoc()->GetSdPage(i, mePageKind); + aPageName = pPage->GetName(); + maTabControl.InsertPage(i + 1, aPageName); + + // Selektionskennungen der Seiten korrigieren + GetDoc()->SetSelected(pPage, i == nCurrentPage); + } + + maTabControl.SetCurPageId(nCurrentPage + 1); + } + else // EM_MASTERPAGE + { + SdPage* pActualPage = GetDoc()->GetMasterSdPage(nCurrentPage, mePageKind); + maTabControl.Clear(); + USHORT nActualMasterPageNum = 0; + + USHORT nMasterPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind); + for (USHORT i = 0; i < nMasterPageCnt; i++) + { + SdPage* pMaster = GetDoc()->GetMasterSdPage(i, mePageKind); + String aLayoutName(pMaster->GetLayoutName()); + aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR)); + maTabControl.InsertPage(i + 1, aLayoutName); + + if (pActualPage == pMaster) + nActualMasterPageNum = i; + } + + maTabControl.SetCurPageId(nActualMasterPageNum + 1); + SwitchPage(nActualMasterPageNum); + } + + GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHPAGE, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); +} + +/************************************************************************* +|* +|* Verb auf OLE-Objekt anwenden +|* +\************************************************************************/ + + +ErrCode DrawViewShell::DoVerb(long nVerb) +{ + if ( mpDrawView->AreObjectsMarked() ) + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + + if (rMarkList.GetMarkCount() == 1) + { + SdrMark* pMark = rMarkList.GetMark(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + + UINT32 nInv = pObj->GetObjInventor(); + UINT16 nSdrObjKind = pObj->GetObjIdentifier(); + + if (nInv == SdrInventor && nSdrObjKind == OBJ_OLE2) + { + ActivateObject( (SdrOle2Obj*) pObj, nVerb); + } +#ifdef STARIMAGE_AVAILABLE + else if (nInv = SdrInventor && nSdrObjKind == OBJ_GRAF && + ((SdrGrafObj*) pObj)->GetGraphicType() == GRAPHIC_BITMAP && + SFX_APP()->HasFeature(SFX_FEATURE_SIMAGE)) + { + SdrGrafObj* pSdrGrafObj = (SdrGrafObj*) pObj; + short nOK = RET_YES; + + if ( pSdrGrafObj->GetFileName().Len() ) + { + // Graphik ist gelinkt, soll der Link aufgehoben werden? + QueryBox aBox(pWindow, WB_YES_NO | WB_DEF_YES, + String( SdResId(STR_REMOVE_LINK) ) ); + nOK = aBox.Execute(); + + if (nOK == RET_YES) + { + // Link aufheben (File- und Filtername zuruecksetzen) + pSdrGrafObj->SetGraphicLink(String(), String()); + } + } + + if (nOK == RET_YES) + { + /************************************************************** + * OLE-Objekt erzeugen, StarImage starten + * Grafik-Objekt loeschen (durch OLE-Objekt ersetzt) + **************************************************************/ + //HMHmpDrView->HideMarkHdl(); + + SvStorageRef aStor = new SvStorage(String()); + SvInPlaceObjectRef aNewIPObj = &((SvFactory*)SvInPlaceObject::ClassFactory()) + ->CreateAndInit(SimModuleDummy::GetID(SOFFICE_FILEFORMAT_CURRENT), aStor); + if ( aNewIPObj.Is() ) + { + SdrGrafObj* pTempSdrGrafObj = (SdrGrafObj*) pSdrGrafObj->Clone (); + + SvEmbeddedInfoObject * pInfo; + pInfo = GetViewFrame()->GetObjectShell()-> + InsertObject( aNewIPObj, String() ); + + String aName; + if (pInfo) + { + aName = pInfo->GetObjName(); + } + + Rectangle aRect = pObj->GetLogicRect(); + SdrOle2Obj* pSdrOle2Obj = new SdrOle2Obj( aNewIPObj, + aName, aRect ); + + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + + pPV->GetObjList()->InsertObject( pSdrOle2Obj ); + mpDrawView->ReplaceObjectAtView( pObj, *pPV, pTempSdrGrafObj ); + + pSdrOle2Obj->SetLogicRect(aRect); + aNewIPObj->SetVisAreaSize(aRect.GetSize()); + + SimDLL::Update(aNewIPObj, pTempSdrGrafObj->GetGraphic(), pWindow); + ActivateObject(pSdrOle2Obj, SVVERB_SHOW); + + Client* pClient = (Client*) GetIPClient(); + + if (pClient) + pClient->SetSdrGrafObj( pTempSdrGrafObj ); + } + } + } +#endif + } + } + + return 0; +} + + +/************************************************************************* +|* +|* OLE-Object aktivieren +|* +\************************************************************************/ + +BOOL DrawViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb) +{ + BOOL bActivated = FALSE; + + if ( !GetDocSh()->IsUIActive() ) + { + ToolBarManager::UpdateLock aLock (GetViewShellBase().GetToolBarManager()); + + bActivated = ViewShell::ActivateObject(pObj, nVerb); + + OSL_ASSERT(GetViewShell()!=NULL); + Client* pClient = static_cast<Client*>(GetViewShell()->GetIPClient()); + if (pClient) + pClient->SetSdrGrafObj(NULL); + } + + return(bActivated); +} + +/************************************************************************* +|* +|* Auf gewuenschte Seite schalten +|* Der Parameter nSelectedPage bezieht sich auf den aktuellen EditMode +|* +\************************************************************************/ + +void LclResetFlag (bool& rbFlag) {rbFlag = false;} + +BOOL DrawViewShell::SwitchPage(USHORT nSelectedPage) +{ + /** Under some circumstances there are nested calls to SwitchPage() and + may crash the application (activation of form controls when the + shell of the edit view is not on top of the shell stack, see issue + 83888 for details.) Therefore the nested calls are ignored (they + would jump to the wrong page anyway.) + */ + if (mbIsInSwitchPage) + return FALSE; + mbIsInSwitchPage = true; + comphelper::ScopeGuard aGuard (::boost::bind(LclResetFlag, ::boost::ref(mbIsInSwitchPage))); + + if (GetActiveWindow()->IsInPaint()) + { + // Switching the current page while a Paint is being executed is + // dangerous. So, post it for later execution and return. + maAsynchronousSwitchPageCall.Post(::boost::bind( + ::std::mem_fun(&DrawViewShell::SwitchPage), + this, + nSelectedPage)); + return FALSE; + } + + BOOL bOK = FALSE; + + // With the current implementation of FuSlideShow there is a problem + // when it dsplays the show in a window: When the show is stopped it + // returns at one point in time SDRPAGE_NOTFOUND as current page index. + // Because FuSlideShow is currently being rewritten this bug is fixed + // here. + // This is not as bad a hack as it may look because making SwitchPage() + // more robust with respect to invalid page numbers is a good thing + // anyway. + if (nSelectedPage == SDRPAGE_NOTFOUND) + { + nSelectedPage = 0; + } + else + { + // Make sure that the given page index points to an existing page. Move + // the index into the valid range if necessary. + USHORT nPageCount = (meEditMode == EM_PAGE) + ? GetDoc()->GetSdPageCount(mePageKind) + : GetDoc()->GetMasterSdPageCount(mePageKind); + if (nSelectedPage >= nPageCount) + nSelectedPage = nPageCount-1; + } + + if (IsSwitchPageAllowed()) + { + ModifyGuard aGuard2( GetDoc() ); + + bOK = TRUE; + + if (mpActualPage) + { + SdPage* pNewPage = NULL; + + if (meEditMode == EM_MASTERPAGE) + { + if( GetDoc()->GetMasterSdPageCount(mePageKind) > nSelectedPage ) + pNewPage = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind); + + if( pNewPage ) + { + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + + String sPageText (pNewPage->GetLayoutName()); + sPageText.Erase(sPageText.SearchAscii(SD_LT_SEPARATOR)); + if (pPV + && pNewPage == dynamic_cast< SdPage* >( pPV->GetPage() ) + && sPageText == maTabControl.GetPageText(nSelectedPage+1)) + { + // this slide is already visible + return TRUE; + } + } + } + else + { + OSL_ASSERT(mpFrameView!=NULL); + mpFrameView->SetSelectedPage(nSelectedPage); + + if (GetDoc()->GetSdPageCount(mePageKind) > nSelectedPage) + pNewPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind); + + if (mpActualPage == pNewPage) + { + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + + SdPage* pCurrentPage = dynamic_cast< SdPage* >( pPV->GetPage()); + if (pPV + && pNewPage == pCurrentPage + && pNewPage->GetName() == maTabControl.GetPageText(nSelectedPage+1)) + { + // this slide is already visible + return TRUE; + } + } + } + } + + if( mpDrawView ) + mpDrawView->SdrEndTextEdit(); + + mpActualPage = NULL; + + if (meEditMode == EM_PAGE) + { + mpActualPage = GetDoc()->GetSdPage(nSelectedPage, mePageKind); + } + else + { + SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind); + + // Passt die selektierte Seite zur MasterPage? + USHORT nPageCount = GetDoc()->GetSdPageCount(mePageKind); + for (USHORT i = 0; i < nPageCount; i++) + { + SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind); + if(pPage && pPage->IsSelected() && pMaster == &(pPage->TRG_GetMasterPage())) + { + mpActualPage = pPage; + break; + } + } + + if (!mpActualPage) + { + // Die erste Seite nehmen, welche zur MasterPage passt + for (USHORT i = 0; i < nPageCount; i++) + { + SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind); + if(pPage && pMaster == &(pPage->TRG_GetMasterPage())) + { + mpActualPage = pPage; + break; + } + } + } + } + + for (USHORT i = 0; i < GetDoc()->GetSdPageCount(mePageKind); i++) + { + // Alle Seiten deselektieren + GetDoc()->SetSelected( GetDoc()->GetSdPage(i, mePageKind), FALSE); + } + + if (!mpActualPage) + { + // Sofern es keine mpActualPage gibt, wird die erste genommen + mpActualPage = GetDoc()->GetSdPage(0, mePageKind); + } + + // diese Seite auch selektieren (mpActualPage zeigt immer auf Zeichenseite, + // nie auf eine Masterpage) + GetDoc()->SetSelected(mpActualPage, TRUE); + + rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) ); + if( !xSlideshow.is() || !xSlideshow->isRunning() || ( xSlideshow->getAnimationMode() != ANIMATIONMODE_SHOW ) ) + { + // VisArea zuziehen, um ggf. Objekte zu deaktivieren + // !!! only if we are not in presentation mode (#96279) !!! + OSL_ASSERT (GetViewShell()!=NULL); + GetViewShell()->DisconnectAllClients(); + VisAreaChanged(Rectangle(Point(), Size(1, 1))); + } + + if (meEditMode == EM_PAGE) + { + /********************************************************************** + * PAGEMODE + **********************************************************************/ + GetDoc()->SetSelected(mpActualPage, TRUE); + + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + + if (pPageView) + { + mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() ); + mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() ); + mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() ); + + if (mePageKind == PK_NOTES) + { + mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() ); + } + else if (mePageKind == PK_HANDOUT) + { + mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() ); + } + else + { + mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() ); + } + } + + mpDrawView->HideSdrPage(); + mpDrawView->ShowSdrPage(mpActualPage); + GetViewShellBase().GetDrawController().FireSwitchCurrentPage(mpActualPage); + + SdrPageView* pNewPageView = mpDrawView->GetSdrPageView(); + + if (pNewPageView) + { + pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() ); + pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() ); + pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() ); + + if (mePageKind == PK_NOTES) + { + pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() ); + } + else if (mePageKind == PK_HANDOUT) + { + pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() ); + } + else + { + pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() ); + } + } + + maTabControl.SetCurPageId(nSelectedPage+1); + String aPageName = mpActualPage->GetName(); + + if (maTabControl.GetPageText(nSelectedPage+1) != aPageName) + { + maTabControl.SetPageText(nSelectedPage+1, aPageName); + } + } + else + { + /********************************************************************** + * MASTERPAGE + **********************************************************************/ + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + + if (pPageView) + { + mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() ); + mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() ); + mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() ); + + if (mePageKind == PK_NOTES) + { + mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() ); + } + else if (mePageKind == PK_HANDOUT) + { + mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() ); + } + else + { + mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() ); + } + } + + mpDrawView->HideSdrPage(); + + SdPage* pMaster = GetDoc()->GetMasterSdPage(nSelectedPage, mePageKind); + + if( !pMaster ) // Falls es diese Page nicht geben sollte + pMaster = GetDoc()->GetMasterSdPage(0, mePageKind); + + USHORT nNum = pMaster->GetPageNum(); + mpDrawView->ShowSdrPage(mpDrawView->GetModel()->GetMasterPage(nNum)); + + GetViewShellBase().GetDrawController().FireSwitchCurrentPage(pMaster); + + SdrPageView* pNewPageView = mpDrawView->GetSdrPageView(); + + if (pNewPageView) + { + pNewPageView->SetVisibleLayers( mpFrameView->GetVisibleLayers() ); + pNewPageView->SetPrintableLayers( mpFrameView->GetPrintableLayers() ); + pNewPageView->SetLockedLayers( mpFrameView->GetLockedLayers() ); + + if (mePageKind == PK_NOTES) + { + pNewPageView->SetHelpLines( mpFrameView->GetNotesHelpLines() ); + } + else if (mePageKind == PK_HANDOUT) + { + pNewPageView->SetHelpLines( mpFrameView->GetHandoutHelpLines() ); + } + else + { + pNewPageView->SetHelpLines( mpFrameView->GetStandardHelpLines() ); + } + } + + String aLayoutName(pMaster->GetLayoutName()); + aLayoutName.Erase(aLayoutName.SearchAscii(SD_LT_SEPARATOR)); + + maTabControl.SetCurPageId(nSelectedPage+1); + + if (maTabControl.GetPageText(nSelectedPage+1) != aLayoutName) + { + maTabControl.SetPageText(nSelectedPage+1, aLayoutName); + } + + if( mePageKind == PK_HANDOUT ) + { + // set pages for all available handout presentation objects + sd::ShapeList& rShapeList = pMaster->GetPresentationShapeList(); + SdrObject* pObj = 0; + + while( (pObj = rShapeList.getNextShape(pObj)) != 0 ) + { + if( pMaster->GetPresObjKind(pObj) == PRESOBJ_HANDOUT ) + { + // #i105146# We want no content to be displayed for PK_HANDOUT, + // so just never set a page as content + static_cast<SdrPageObj*>(pObj)->SetReferencedPage(0); + } + } + } + } + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + VisAreaChanged(aVisAreaWin); + mpDrawView->VisAreaChanged(GetActiveWindow()); + + // Damit der Navigator (und das Effekte-Window) das mitbekommt (/-men) + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate(SID_NAVIGATOR_PAGENAME, TRUE, FALSE); + rBindings.Invalidate(SID_STATUS_PAGE, TRUE, FALSE); + rBindings.Invalidate(SID_DELETE_MASTER_PAGE, TRUE, FALSE); + rBindings.Invalidate(SID_DELETE_PAGE, TRUE, FALSE); + rBindings.Invalidate(SID_ASSIGN_LAYOUT,TRUE,FALSE); + UpdatePreview( mpActualPage ); + + mpDrawView->AdjustMarkHdl(); + } + + return (bOK); +} + + +/************************************************************************* +|* +|* Pruefen, ob ein Seitenwechsel erlaubt ist +|* +\************************************************************************/ + +BOOL DrawViewShell::IsSwitchPageAllowed() const +{ + bool bOK = true; + + FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell(); + if (pFormShell!=NULL && !pFormShell->PrepareClose (FALSE)) + bOK = false; + + return bOK; +} + +/************************************************************************* +|* +|* neue aktuelle Seite auswaehlen, falls sich die Seitenfolge geaendert +|* hat (z. B. durch Undo) +|* +\************************************************************************/ + +void DrawViewShell::ResetActualLayer() +{ + LayerTabBar* pLayerBar = GetLayerTabControl(); + if (pLayerBar != NULL) + { + // remember old layer cound and current layer id + // this is needed when one layer is renamed to + // restore current layer + USHORT nOldLayerCnt = pLayerBar->GetPageCount(); + USHORT nOldLayerId = pLayerBar->GetCurPageId(); + + /************************************************************* + * Update fuer LayerTab + *************************************************************/ + pLayerBar->Clear(); + + String aName; + String aActiveLayer = mpDrawView->GetActiveLayer(); + String aBackgroundLayer( SdResId(STR_LAYER_BCKGRND) ); + String aBackgroundObjLayer( SdResId(STR_LAYER_BCKGRNDOBJ) ); + String aLayoutLayer( SdResId(STR_LAYER_LAYOUT) ); + String aControlsLayer( SdResId(STR_LAYER_CONTROLS) ); + String aMeasureLinesLayer( SdResId(STR_LAYER_MEASURELINES) ); + USHORT nActiveLayer = SDRLAYER_NOTFOUND; + SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin(); + USHORT nLayerCnt = rLayerAdmin.GetLayerCount(); + + for ( USHORT nLayer = 0; nLayer < nLayerCnt; nLayer++ ) + { + aName = rLayerAdmin.GetLayer(nLayer)->GetName(); + + if ( aName == aActiveLayer ) + { + nActiveLayer = nLayer; + } + + if ( aName != aBackgroundLayer ) + { + if (meEditMode == EM_MASTERPAGE) + { + // Layer der Page nicht auf MasterPage anzeigen + if (aName != aLayoutLayer && + aName != aControlsLayer && + aName != aMeasureLinesLayer) + { + pLayerBar->InsertPage(nLayer+1, aName); + + TabBarPageBits nBits = 0; + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + + if (pPV && !pPV->IsLayerVisible(aName)) + { + // Unsichtbare Layer werden anders dargestellt + nBits = TPB_SPECIAL; + } + + pLayerBar->SetPageBits(nLayer+1, nBits); + } + } + else + { + // Layer der MasterPage nicht auf Page anzeigen + if ( aName != aBackgroundObjLayer ) + { + pLayerBar->InsertPage(nLayer+1, aName); + + TabBarPageBits nBits = 0; + + if (!mpDrawView->GetSdrPageView()->IsLayerVisible(aName)) + { + // Unsichtbare Layer werden anders dargestellt + nBits = TPB_SPECIAL; + } + + pLayerBar->SetPageBits(nLayer+1, nBits); + } + } + } + } + + if ( nActiveLayer == SDRLAYER_NOTFOUND ) + { + if( nOldLayerCnt == pLayerBar->GetPageCount() ) + { + nActiveLayer = nOldLayerId - 1; + } + else + { + nActiveLayer = ( meEditMode == EM_MASTERPAGE ) ? 2 : 0; + } + + mpDrawView->SetActiveLayer( pLayerBar->GetPageText(nActiveLayer + 1) ); + } + + pLayerBar->SetCurPageId(nActiveLayer + 1); + GetViewFrame()->GetBindings().Invalidate( SID_MODIFYLAYER ); + GetViewFrame()->GetBindings().Invalidate( SID_DELETE_LAYER ); + } +} + +/************************************************************************* +|* +|* Verzoegertes Close ausfuehren +|* +\************************************************************************/ + +IMPL_LINK( DrawViewShell, CloseHdl, Timer*, pTimer ) +{ + pTimer->Stop(); + GetViewFrame()->GetBindings().Execute( SID_CLOSEWIN ); + return 0L; +} + +/************************************************************************* +|* +|* AcceptDrop +|* +\************************************************************************/ + +sal_Int8 DrawViewShell::AcceptDrop ( + const AcceptDropEvent& rEvt, + DropTargetHelper& rTargetHelper, + ::sd::Window* pTargetWindow, + USHORT nPage, + USHORT nLayer ) +{ + if( nPage != SDRPAGE_NOTFOUND ) + nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum(); + + if( SlideShow::IsRunning( GetViewShellBase() ) ) + return DND_ACTION_NONE; + + return mpDrawView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ); +} + +/************************************************************************* +|* +|* ExecuteDrop +|* +\************************************************************************/ + +sal_Int8 DrawViewShell::ExecuteDrop ( + const ExecuteDropEvent& rEvt, + DropTargetHelper& rTargetHelper, + ::sd::Window* pTargetWindow, + USHORT nPage, + USHORT nLayer) +{ + if( nPage != SDRPAGE_NOTFOUND ) + nPage = GetDoc()->GetSdPage( nPage, mePageKind )->GetPageNum(); + + if( SlideShow::IsRunning( GetViewShellBase() ) ) + return DND_ACTION_NONE; + + Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_START)); + sal_Int8 nResult (mpDrawView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer )); + Broadcast(ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_END)); + + return nResult; +} + +} // end of namespace sd + +#ifdef _MSC_VER +#if (_MSC_VER < 1400) +#pragma optimize ( "", on ) +#endif +#endif + diff --git a/sd/source/ui/view/drviews2.cxx b/sd/source/ui/view/drviews2.cxx new file mode 100755 index 000000000000..3102dc726a61 --- /dev/null +++ b/sd/source/ui/view/drviews2.cxx @@ -0,0 +1,975 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include "ViewShellImplementation.hxx" +#include <vcl/waitobj.hxx> +#include <svx/svdograf.hxx> +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <svx/svdpagv.hxx> +#include <svx/svdundo.hxx> +#ifndef _ZOOMITEM_HXX +#include <svx/zoomitem.hxx> +#endif +#ifndef _EDITDATA_HXX +#include <editeng/editdata.hxx> +#endif +#include <basic/sberrors.hxx> +#include <vcl/msgbox.hxx> +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <svl/aeitem.hxx> +#include <editeng/eeitem.hxx> +#include <basic/sbstar.hxx> +#include <editeng/flditem.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xfillit0.hxx> + +#ifndef _SDOUTL_HXX //autogen +#include <svx/svdoutl.hxx> +#endif +#include <svx/xlnwtit.hxx> +#include <svx/svdoattr.hxx> +#include <svx/xlnstwit.hxx> +#include <svx/sdtmfitm.hxx> +#include <svx/sdtagitm.hxx> +#include <svx/xlnedwit.hxx> +#include <svx/fontworkbar.hxx> + +#include <svx/svxdlg.hxx> +#include <svx/dialogs.hrc> + +#include <sfx2/viewfrm.hxx> +#include "sdgrffilter.hxx" + +#include "app.hrc" +#include "glob.hrc" +#include "helpids.h" +#include "sdattr.hxx" +#include "drawview.hxx" +#include "Window.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "sdpage.hxx" +#include "fuscale.hxx" +#include "sdresid.hxx" +#include "GraphicViewShell.hxx" +#include "unmodpg.hxx" +#include "slideshow.hxx" +#include "fuvect.hxx" +#include "stlpool.hxx" + +// #90356# +#include "optsitem.hxx" +#include "sdabstdlg.hxx" +#include <com/sun/star/drawing/XMasterPagesSupplier.hpp> +#include <com/sun/star/drawing/XDrawPages.hpp> + +#include <strings.hrc> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +namespace sd { + +/************************************************************************* +|* +|* SfxRequests fuer temporaere Funktionen +|* +\************************************************************************/ + +void DrawViewShell::FuTemporary(SfxRequest& rReq) +{ + // Waehrend einer Native-Diashow wird nichts ausgefuehrt! + if(SlideShow::IsRunning( GetViewShellBase() ) && (rReq.GetSlot() != SID_NAVIGATOR)) + return; + + DBG_ASSERT( mpDrawView, "sd::DrawViewShell::FuTemporary(), no draw view!" ); + if( !mpDrawView ) + return; + + CheckLineTo (rReq); + + DeactivateCurrentFunction(); + + USHORT nSId = rReq.GetSlot(); + + // Slot wird gemapped (ToolboxImages/-Slots) + MapSlot( nSId ); + + switch ( nSId ) + { + // Flaechen und Linien-Attribute: + // Sollten (wie StateMethode) eine eigene + // Execute-Methode besitzen + case SID_ATTR_FILL_STYLE: + case SID_ATTR_FILL_COLOR: + case SID_ATTR_FILL_GRADIENT: + case SID_ATTR_FILL_HATCH: + case SID_ATTR_FILL_BITMAP: + case SID_ATTR_FILL_SHADOW: + + case SID_ATTR_LINE_STYLE: + case SID_ATTR_LINE_DASH: + case SID_ATTR_LINE_WIDTH: + case SID_ATTR_LINE_COLOR: + case SID_ATTR_LINEEND_STYLE: + + case SID_ATTR_TEXT_FITTOSIZE: + { + if( rReq.GetArgs() ) + { + BOOL bMergeUndo = FALSE; + SfxUndoManager* pUndoManager = GetDocSh()->GetUndoManager(); + + // Anpassungen Start/EndWidth #63083# + if(nSId == SID_ATTR_LINE_WIDTH) + { + SdrObject* pObj = NULL; + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + ULONG nCount = rMarkList.GetMarkCount(); + + INT32 nNewLineWidth = ((const XLineWidthItem&)rReq.GetArgs()->Get(XATTR_LINEWIDTH)).GetValue(); + + for (ULONG i=0; i<nCount; i++) + { + SfxItemSet aAttr(GetDoc()->GetPool()); + pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + aAttr.Put(pObj->GetMergedItemSet()); + + INT32 nActLineWidth = ((const XLineWidthItem&)aAttr.Get(XATTR_LINEWIDTH)).GetValue(); + + if(nActLineWidth != nNewLineWidth) + { + BOOL bSetItemSet(FALSE); + + // #86265# do this for SFX_ITEM_DEFAULT and for SFX_ITEM_SET + if(SFX_ITEM_DONTCARE != aAttr.GetItemState(XATTR_LINESTARTWIDTH)) + { + INT32 nValAct = ((const XLineStartWidthItem&)aAttr.Get(XATTR_LINESTARTWIDTH)).GetValue(); + INT32 nValNew = nValAct + (((nNewLineWidth - nActLineWidth) * 15) / 10); + if(nValNew < 0) + nValNew = 0; + bSetItemSet = TRUE; + aAttr.Put(XLineStartWidthItem(nValNew)); + } + + // #86265# do this for SFX_ITEM_DEFAULT and for SFX_ITEM_SET + if(SFX_ITEM_DONTCARE != aAttr.GetItemState(XATTR_LINEENDWIDTH)) + { + INT32 nValAct = ((const XLineEndWidthItem&)aAttr.Get(XATTR_LINEENDWIDTH)).GetValue(); + INT32 nValNew = nValAct + (((nNewLineWidth - nActLineWidth) * 15) / 10); + if(nValNew < 0) + nValNew = 0; + bSetItemSet = TRUE; + aAttr.Put(XLineEndWidthItem(nValNew)); + } + + if(bSetItemSet) + pObj->SetMergedItemSet(aAttr); + } + } + } + + if (nSId == SID_ATTR_FILL_SHADOW) + { + // Ggf. werden transparente Objekte wei?gefuellt + SdrObject* pObj = NULL; + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + ULONG nCount = rMarkList.GetMarkCount(); + + const bool bUndo = mpDrawView->IsUndoEnabled(); + + for (ULONG i=0; i<nCount; i++) + { + SfxItemSet aAttr(GetDoc()->GetPool()); + pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + + // #i25616# + if(!pObj->ISA(SdrGrafObj)) + { + aAttr.Put(pObj->GetMergedItemSet()); + + const XFillStyleItem& rFillStyle = + (const XFillStyleItem&) aAttr.Get(XATTR_FILLSTYLE); + + if (rFillStyle.GetValue() == XFILL_NONE) + { + if( bUndo ) + { + // Vorlage hat keine Fuellung, + // daher hart attributieren: Fuellung setzen + if (!bMergeUndo) + { + bMergeUndo = TRUE; + pUndoManager->EnterListAction( String(), String() ); + mpDrawView->BegUndo(); + } + + mpDrawView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoAttrObject(*pObj)); + } + + aAttr.Put(XFillStyleItem(XFILL_SOLID)); + aAttr.Put(XFillColorItem(String(), COL_WHITE)); + + pObj->SetMergedItemSet(aAttr); + } + } + } + + if (bMergeUndo) + { + mpDrawView->EndUndo(); + } + } + + mpDrawView->SetAttributes(*rReq.GetArgs()); + + if (bMergeUndo) + { + pUndoManager->LeaveListAction(); + } + + rReq.Done(); + } + else + { + switch( rReq.GetSlot() ) + { + case SID_ATTR_FILL_SHADOW: + case SID_ATTR_FILL_STYLE: + case SID_ATTR_FILL_COLOR: + case SID_ATTR_FILL_GRADIENT: + case SID_ATTR_FILL_HATCH: + case SID_ATTR_FILL_BITMAP: + GetViewFrame()->GetDispatcher()->Execute( SID_ATTRIBUTES_AREA, SFX_CALLMODE_ASYNCHRON ); + break; + case SID_ATTR_LINE_STYLE: + case SID_ATTR_LINE_DASH: + case SID_ATTR_LINE_WIDTH: + case SID_ATTR_LINE_COLOR: + GetViewFrame()->GetDispatcher()->Execute( SID_ATTRIBUTES_LINE, SFX_CALLMODE_ASYNCHRON ); + break; + case SID_ATTR_TEXT_FITTOSIZE: + GetViewFrame()->GetDispatcher()->Execute( SID_TEXTATTR_DLG, SFX_CALLMODE_ASYNCHRON ); + break; + } + } + Cancel(); + } + break; + + case SID_HYPHENATION: + { + // const SfxPoolItem* pItem = rReq.GetArg( SID_HYPHENATION ); + // ^-- Soll so nicht benutzt werden (Defaults sind falsch) ! + SFX_REQUEST_ARG( rReq, pItem, SfxBoolItem, SID_HYPHENATION, FALSE); + + if( pItem ) + { + SfxItemSet aSet( GetPool(), EE_PARA_HYPHENATE, EE_PARA_HYPHENATE ); + BOOL bValue = ( (const SfxBoolItem*) pItem)->GetValue(); + aSet.Put( SfxBoolItem( EE_PARA_HYPHENATE, bValue ) ); + mpDrawView->SetAttributes( aSet ); + } + else // nur zum Test + { + DBG_ERROR(" Kein Wert fuer Silbentrennung!"); + SfxItemSet aSet( GetPool(), EE_PARA_HYPHENATE, EE_PARA_HYPHENATE ); + BOOL bValue = TRUE; + aSet.Put( SfxBoolItem( EE_PARA_HYPHENATE, bValue ) ); + mpDrawView->SetAttributes( aSet ); + } + rReq.Done(); + Cancel(); + } + break; + + case SID_INSERTPAGE: + case SID_INSERTPAGE_QUICK: + case SID_DUPLICATE_PAGE: + { + SdPage* pNewPage = CreateOrDuplicatePage (rReq, mePageKind, GetActualPage()); + Cancel(); + if(HasCurrentFunction(SID_BEZIER_EDIT) ) + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + if (pNewPage != NULL) + SwitchPage((pNewPage->GetPageNum()-1)/2); + rReq.Done (); + } + break; + + case SID_INSERT_MASTER_PAGE: + { + // Use the API to create a new page. + Reference<drawing::XMasterPagesSupplier> xMasterPagesSupplier ( + GetDoc()->getUnoModel(), UNO_QUERY); + if (xMasterPagesSupplier.is()) + { + Reference<drawing::XDrawPages> xMasterPages ( + xMasterPagesSupplier->getMasterPages()); + if (xMasterPages.is()) + { + USHORT nIndex = GetCurPageId(); + xMasterPages->insertNewByIndex (nIndex); + + // Create shapes for the default layout. + SdPage* pMasterPage = GetDoc()->GetMasterSdPage( + nIndex, PK_STANDARD); + pMasterPage->CreateTitleAndLayout (TRUE,TRUE); + } + } + + Cancel(); + if(HasCurrentFunction(SID_BEZIER_EDIT)) + GetViewFrame()->GetDispatcher()->Execute( + SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + rReq.Done (); + } + break; + + case SID_MODIFYPAGE: + { + if (mePageKind==PK_STANDARD || mePageKind==PK_NOTES || + (mePageKind==PK_HANDOUT && meEditMode==EM_MASTERPAGE) ) + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + USHORT nPage = maTabControl.GetCurPageId() - 1; + mpActualPage = GetDoc()->GetSdPage(nPage, mePageKind); + ::sd::ViewShell::mpImpl->ProcessModifyPageSlot ( + rReq, + mpActualPage, + mePageKind); + } + + Cancel(); + rReq.Done (); + } + break; + + case SID_ASSIGN_LAYOUT: + { + if (mePageKind==PK_STANDARD || mePageKind==PK_NOTES || (mePageKind==PK_HANDOUT && meEditMode==EM_MASTERPAGE)) + { + if ( mpDrawView->IsTextEdit() ) + mpDrawView->SdrEndTextEdit(); + + ::sd::ViewShell::mpImpl->AssignLayout(rReq, mePageKind); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_RENAMEPAGE: + case SID_RENAME_MASTER_PAGE: + { + if (mePageKind==PK_STANDARD || mePageKind==PK_NOTES ) + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + USHORT nPageId = maTabControl.GetCurPageId(); + SdPage* pCurrentPage = ( GetEditMode() == EM_PAGE ) + ? GetDoc()->GetSdPage( nPageId - 1, GetPageKind() ) + : GetDoc()->GetMasterSdPage( nPageId - 1, GetPageKind() ); + + String aTitle( SdResId( STR_TITLE_RENAMESLIDE ) ); + String aDescr( SdResId( STR_DESC_RENAMESLIDE ) ); + String aPageName = pCurrentPage->GetName(); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + DBG_ASSERT(pFact, "Dialogdiet fail!"); + AbstractSvxNameDialog* aNameDlg = pFact->CreateSvxNameDialog( GetActiveWindow(), aPageName, aDescr ); + DBG_ASSERT(aNameDlg, "Dialogdiet fail!"); + aNameDlg->SetText( aTitle ); + aNameDlg->SetCheckNameHdl( LINK( this, DrawViewShell, RenameSlideHdl ), true ); + aNameDlg->SetEditHelpId( HID_SD_NAMEDIALOG_PAGE ); + + if( aNameDlg->Execute() == RET_OK ) + { + String aNewName; + aNameDlg->GetName( aNewName ); + if( ! aNewName.Equals( aPageName ) ) + { +#ifdef DBG_UTIL + bool bResult = +#endif + RenameSlide( nPageId, aNewName ); + DBG_ASSERT( bResult, "Couldn't rename slide" ); + } + } + delete aNameDlg; + } + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_RENAMEPAGE_QUICK: + { + if (mePageKind==PK_STANDARD || mePageKind==PK_NOTES ) + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + maTabControl.StartEditMode( maTabControl.GetCurPageId() ); + } + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_PAGESIZE : // entweder dieses (kein menueeintrag o. ae. !!) + { + const SfxItemSet *pArgs = rReq.GetArgs (); + + if (pArgs) + if (pArgs->Count () == 3) + { + SFX_REQUEST_ARG (rReq, pWidth, SfxUInt32Item, ID_VAL_PAGEWIDTH, FALSE); + SFX_REQUEST_ARG (rReq, pHeight, SfxUInt32Item, ID_VAL_PAGEHEIGHT, FALSE); + SFX_REQUEST_ARG (rReq, pScaleAll, SfxBoolItem, ID_VAL_SCALEOBJECTS, FALSE); + + Size aSize (pWidth->GetValue (), pHeight->GetValue ()); + + SetupPage (aSize, 0, 0, 0, 0, TRUE, FALSE, pScaleAll->GetValue ()); + rReq.Ignore (); + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + rReq.Ignore (); + break; + } + + case SID_PAGEMARGIN : // oder dieses (kein menueeintrag o. ae. !!) + { + const SfxItemSet *pArgs = rReq.GetArgs (); + + if (pArgs) + if (pArgs->Count () == 5) + { + SFX_REQUEST_ARG (rReq, pLeft, SfxUInt32Item, ID_VAL_PAGELEFT, FALSE); + SFX_REQUEST_ARG (rReq, pRight, SfxUInt32Item, ID_VAL_PAGERIGHT, FALSE); + SFX_REQUEST_ARG (rReq, pUpper, SfxUInt32Item, ID_VAL_PAGETOP, FALSE); + SFX_REQUEST_ARG (rReq, pLower, SfxUInt32Item, ID_VAL_PAGEBOTTOM, FALSE); + SFX_REQUEST_ARG (rReq, pScaleAll, SfxBoolItem, ID_VAL_SCALEOBJECTS, FALSE); + + Size aEmptySize (0, 0); + + SetupPage (aEmptySize, pLeft->GetValue (), pRight->GetValue (), + pUpper->GetValue (), pLower->GetValue (), + FALSE, TRUE, pScaleAll->GetValue ()); + rReq.Ignore (); + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + rReq.Ignore (); + break; + } + + case SID_ATTR_ZOOMSLIDER: + { + const SfxItemSet* pArgs = rReq.GetArgs(); + + if (pArgs && pArgs->Count () == 1 ) + { + SFX_REQUEST_ARG (rReq, pScale, SfxUInt16Item, SID_ATTR_ZOOMSLIDER, FALSE); + if (CHECK_RANGE (5, pScale->GetValue (), 3000)) + { + SetZoom (pScale->GetValue ()); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_ATTR_ZOOM ); + rBindings.Invalidate( SID_ZOOM_IN ); + rBindings.Invalidate( SID_ZOOM_OUT ); + rBindings.Invalidate( SID_ATTR_ZOOMSLIDER ); + + } + } + + Cancel(); + rReq.Done (); + break; + } + case SID_ZOOMING : // kein Menueintrag, sondern aus dem Zoomdialog generiert + { + const SfxItemSet* pArgs = rReq.GetArgs(); + + if (pArgs) + if (pArgs->Count () == 1) + { + SFX_REQUEST_ARG (rReq, pScale, SfxUInt32Item, ID_VAL_ZOOM, FALSE); + if (CHECK_RANGE (10, pScale->GetValue (), 1000)) + { + SetZoom (pScale->GetValue ()); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_ATTR_ZOOM ); + rBindings.Invalidate( SID_ZOOM_IN ); + rBindings.Invalidate( SID_ZOOM_OUT ); + rBindings.Invalidate( SID_ATTR_ZOOMSLIDER ); + } + else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + + rReq.Ignore (); + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + rReq.Ignore (); + break; + } + + case SID_ATTR_ZOOM: + { + const SfxItemSet* pArgs = rReq.GetArgs(); + mbZoomOnPage = FALSE; + + if ( pArgs ) + { + SvxZoomType eZT = ( ( const SvxZoomItem& ) pArgs-> + Get( SID_ATTR_ZOOM ) ).GetType(); + switch( eZT ) + { + case SVX_ZOOM_PERCENT: + SetZoom( (long) ( ( const SvxZoomItem& ) pArgs-> + Get( SID_ATTR_ZOOM ) ).GetValue() ); + break; + + case SVX_ZOOM_OPTIMAL: + GetViewFrame()->GetDispatcher()->Execute( SID_SIZE_ALL, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD ); + break; + + case SVX_ZOOM_PAGEWIDTH: + GetViewFrame()->GetDispatcher()->Execute( SID_SIZE_PAGE_WIDTH, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD ); + break; + + case SVX_ZOOM_WHOLEPAGE: + GetViewFrame()->GetDispatcher()->Execute( SID_SIZE_PAGE, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD ); + break; + case SVX_ZOOM_PAGEWIDTH_NOBORDER: + DBG_ERROR("sd::DrawViewShell::FuTemporary(), SVX_ZOOM_PAGEWIDTH_NOBORDER not handled!" ); + break; + } + rReq.Ignore (); + } + else + { + // hier den Zoom-Dialog oeffnen + SetCurrentFunction( FuScale::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + } + Cancel(); + } + break; + + case SID_CHANGEBEZIER: + case SID_CHANGEPOLYGON: + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + } + + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + if( rReq.GetSlot() == SID_CHANGEBEZIER ) + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->ConvertMarkedToPathObj(FALSE); + } + else + { + if( mpDrawView->IsVectorizeAllowed() ) + SetCurrentFunction( FuVectorize::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + else + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->ConvertMarkedToPolyObj(FALSE); + } + } + + Invalidate(SID_CHANGEBEZIER); + Invalidate(SID_CHANGEPOLYGON); + } + Cancel(); + + if( HasCurrentFunction(SID_BEZIER_EDIT) ) + { // ggf. die richtige Editfunktion aktivieren + GetViewFrame()->GetDispatcher()->Execute(SID_SWITCH_POINTEDIT, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + } + rReq.Ignore (); + break; + + case SID_CONVERT_TO_CONTOUR: + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + } + + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->ConvertMarkedToPathObj(TRUE); + + Invalidate(SID_CONVERT_TO_CONTOUR); + } + Cancel(); + + rReq.Ignore (); + break; + + case SID_CONVERT_TO_METAFILE: + case SID_CONVERT_TO_BITMAP: + { + // End text edit mode when it is active because the metafile or + // bitmap that will be created does not support it. + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + } + + if ( mpDrawView->IsPresObjSelected(true,true,true) ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + WaitObject aWait( (Window*)GetActiveWindow() ); + + // switch on undo for the next operations + mpDrawView->BegUndo( + String( + SdResId (nSId==SID_CONVERT_TO_METAFILE ? STR_UNDO_CONVERT_TO_METAFILE : STR_UNDO_CONVERT_TO_BITMAP))); + + // create SdrGrafObj from metafile/bitmap + Graphic aGraphic; + switch (nSId) + { + case SID_CONVERT_TO_METAFILE: + { + GDIMetaFile aMetaFile(mpDrawView->GetAllMarkedMetaFile ()); + aGraphic = Graphic(aMetaFile); + } + break; + case SID_CONVERT_TO_BITMAP: + { + Bitmap aBitmap (mpDrawView->GetAllMarkedBitmap ()); + aGraphic = Graphic(aBitmap); + } + break; + } + + // create new object + SdrGrafObj* pGraphicObj = new SdrGrafObj (aGraphic); + + // get some necessary info and ensure it + const SdrMarkList& rMarkList(mpDrawView->GetMarkedObjectList()); + const sal_uInt32 nMarkCount(rMarkList.GetMarkCount()); + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + OSL_ENSURE(nMarkCount, "DrawViewShell::FuTemporary: SID_CONVERT_TO_BITMAP with empty selection (!)"); + OSL_ENSURE(pPageView, "DrawViewShell::FuTemporary: SID_CONVERT_TO_BITMAP without SdrPageView (!)"); + + // fit rectangle of new graphic object to selection's mark rect + Rectangle aAllMarkedRect; + rMarkList.TakeBoundRect(pPageView, aAllMarkedRect); + pGraphicObj->SetLogicRect(aAllMarkedRect); + + // #i71540# to keep the order, it is necessary to replace the lowest object + // of the selection with the new object. This also means that with multi + // selection, all other objects need to be deleted first + SdrMark* pFirstMark = rMarkList.GetMark(0L); + SdrObject* pReplacementCandidate = pFirstMark->GetMarkedSdrObj(); + + if(nMarkCount > 1L) + { + // take first object out of selection + mpDrawView->MarkObj(pReplacementCandidate, pPageView, true, true); + + // clear remaining selection + mpDrawView->DeleteMarkedObj(); + } + + // now replace lowest object with new one + mpDrawView->ReplaceObjectAtView(pReplacementCandidate, *pPageView, pGraphicObj); + + // switch off undo + mpDrawView->EndUndo(); + } + } + + Cancel(); + + rReq.Done (); + break; + + case SID_SET_DEFAULT: + { + SfxItemSet* pSet = NULL; + + if (mpDrawView->IsTextEdit()) + { + ::Outliner* pOutl = mpDrawView->GetTextEditOutliner(); + if (pOutl) + { + pOutl->RemoveFields(TRUE, (TypeId) SvxURLField::StaticType()); + } + + pSet = new SfxItemSet( GetPool(), EE_ITEMS_START, EE_ITEMS_END ); + mpDrawView->SetAttributes( *pSet, TRUE ); + } + else + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + ULONG nCount = rMarkList.GetMarkCount(); + + // In diese Liste werden fuer jedes Praesentationsobjekt ein SfxItemSet + // der harten Attribute sowie der UserCall eingetragen, da diese beim nachfolgenden + // mpDrawView->SetAttributes( *pSet, TRUE ) verloren gehen und spaeter restauriert + // werden muessen + List* pAttrList = new List(); + SdPage* pPresPage = (SdPage*) mpDrawView->GetSdrPageView()->GetPage(); + ULONG i; + + for ( i = 0; i < nCount; i++ ) + { + SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + + if( pPresPage->IsPresObj( pObj ) ) + { + SfxItemSet* pNewSet = new SfxItemSet( GetDoc()->GetPool(), SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_AUTOGROWHEIGHT, 0 ); + pNewSet->Put(pObj->GetMergedItemSet()); + pAttrList->Insert( pNewSet, LIST_APPEND ); + pAttrList->Insert( pObj->GetUserCall(), LIST_APPEND ); + } + } + + pSet = new SfxItemSet( GetPool() ); + mpDrawView->SetAttributes( *pSet, TRUE ); + + ULONG j = 0; + + for ( i = 0; i < nCount; i++ ) + { + SfxStyleSheet* pSheet = NULL; + SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + + if (pObj->GetObjIdentifier() == OBJ_TITLETEXT) + { + pSheet = mpActualPage->GetStyleSheetForPresObj(PRESOBJ_TITLE); + if (pSheet) + pObj->SetStyleSheet(pSheet, FALSE); + } + else if(pObj->GetObjIdentifier() == OBJ_OUTLINETEXT) + { + for (USHORT nLevel = 1; nLevel < 10; nLevel++) + { + pSheet = mpActualPage->GetStyleSheetForPresObj( PRESOBJ_OUTLINE ); + DBG_ASSERT(pSheet, "Vorlage fuer Gliederungsobjekt nicht gefunden"); + if (pSheet) + { + pObj->StartListening(*pSheet); + + if( nLevel == 1 ) + // Textrahmen hoert auf StyleSheet der Ebene1 + pObj->NbcSetStyleSheet(pSheet, FALSE); + + } + } + } + + if( pPresPage->IsPresObj( pObj ) ) + { + SfxItemSet* pNewSet = (SfxItemSet*) pAttrList->GetObject(j++); + SdrObjUserCall* pUserCall = (SdrObjUserCall*) pAttrList->GetObject(j++); + + if ( pNewSet && pNewSet->GetItemState( SDRATTR_TEXT_MINFRAMEHEIGHT ) == SFX_ITEM_ON ) + { + pObj->SetMergedItem(pNewSet->Get(SDRATTR_TEXT_MINFRAMEHEIGHT)); + } + + if ( pNewSet && pNewSet->GetItemState( SDRATTR_TEXT_AUTOGROWHEIGHT ) == SFX_ITEM_ON ) + { + pObj->SetMergedItem(pNewSet->Get(SDRATTR_TEXT_AUTOGROWHEIGHT)); + } + + if( pUserCall ) + pObj->SetUserCall( pUserCall ); + + delete pNewSet; + } + } + + delete pAttrList; + } + + delete pSet; + Cancel(); + } + break; + + case SID_DELETE_SNAPITEM: + { + SdrPageView* pPV; + Point aMPos = GetActiveWindow()->PixelToLogic( maMousePos ); + USHORT nHitLog = (USHORT) GetActiveWindow()->PixelToLogic( Size( + FuPoor::HITPIX, 0 ) ).Width(); + USHORT nHelpLine; + + mbMousePosFreezed = FALSE; + + if( mpDrawView->PickHelpLine( aMPos, nHitLog, *GetActiveWindow(), nHelpLine, pPV) ) + { + pPV->DeleteHelpLine( nHelpLine ); + } + Cancel(); + rReq.Ignore (); + } + break; + + case SID_DELETE_PAGE: + case SID_DELETE_MASTER_PAGE: + DeleteActualPage(); + Cancel(); + rReq.Ignore (); + break; + + case SID_DELETE_LAYER: + DeleteActualLayer(); + Cancel(); + rReq.Ignore (); + break; + + case SID_ORIGINAL_SIZE: + mpDrawView->SetMarkedOriginalSize(); + Cancel(); + rReq.Done(); + break; + + case SID_DRAW_FONTWORK: + case SID_DRAW_FONTWORK_VERTICAL: + { + svx::FontworkBar::execute( mpView, rReq, GetViewFrame()->GetBindings() ); // SJ: can be removed (I think) + Cancel(); + rReq.Done(); + } + break; + + case SID_SAVEGRAPHIC: + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + if( rMarkList.GetMarkCount() == 1 ) + { + SdrGrafObj *pGrafObj = dynamic_cast< SdrGrafObj* >( rMarkList.GetMark( 0 )->GetMarkedSdrObj() ); + if(pGrafObj ) + { + ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > xShape( pGrafObj->getUnoShape(), com::sun::star::uno::UNO_QUERY ); + SdGRFFilter::SaveGraphic( xShape ); + } + } + Cancel(); + rReq.Ignore(); + } + break; + + default: + { + // switch Anweisung wegen CLOOKS aufgeteilt. Alle case-Anweisungen die + // eine Fu???? -Funktion aufrufen, sind in die Methode FuTemp01 (drviews8) + // gewandert. + FuTemp01(rReq); + } + break; + } + + if(HasCurrentFunction()) + { + GetCurrentFunction()->Activate(); + } +} + + + + +/** This method consists basically of three parts: + 1. Process the arguments of the SFX request. + 2. Use the model to create a new page or duplicate an existing one. + 3. Update the tab control and switch to the new page. +*/ +SdPage* DrawViewShell::CreateOrDuplicatePage ( + SfxRequest& rRequest, + PageKind ePageKind, + SdPage* pPage) +{ + SdPage* pNewPage = NULL; + if (ePageKind == PK_STANDARD && meEditMode != EM_MASTERPAGE) + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + pNewPage = ViewShell::CreateOrDuplicatePage (rRequest, ePageKind, pPage); + } + return pNewPage; +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviews3.cxx b/sd/source/ui/view/drviews3.cxx new file mode 100755 index 000000000000..28f8d909031b --- /dev/null +++ b/sd/source/ui/view/drviews3.cxx @@ -0,0 +1,950 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" + +#include <sfx2/viewfrm.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/tstpitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/protitem.hxx> +#include <editeng/frmdiritem.hxx> +#include <svx/ruler.hxx> +#ifndef _SVX_RULERITEM_HXX +#include <svx/rulritem.hxx> +#endif +#include <svx/zoomitem.hxx> +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <svx/svdpagv.hxx> +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <tools/urlobj.hxx> +#include <svl/aeitem.hxx> +#include <svl/eitem.hxx> +#include <svl/rectitem.hxx> +#include <svl/stritem.hxx> +#include <svx/svdoole2.hxx> +#include <svl/itempool.hxx> +#include <svl/ptitem.hxx> +#include <basic/sbstar.hxx> +#include <basic/sberrors.hxx> +#include <svx/fmshell.hxx> +#include <svx/f3dchild.hxx> +#include <svx/float3d.hxx> +#include "optsitem.hxx" + +#include "app.hrc" +#include "glob.hrc" +#include "strings.hrc" +#include "res_bmp.hrc" + +#include "sdundogr.hxx" +#include "undopage.hxx" +#include "glob.hxx" +#include "app.hxx" +#include "fupoor.hxx" +#include "slideshow.hxx" +#ifndef SD_FRAME_VIEW +#include "FrameView.hxx" +#endif +#include "sdpage.hxx" +#include "Window.hxx" +#include "sdresid.hxx" +#include "drawview.hxx" +#include "drawdoc.hxx" +#include "DrawViewShell.hxx" +#include "Ruler.hxx" +#include "DrawDocShell.hxx" +#include "headerfooterdlg.hxx" +#include "masterlayoutdlg.hxx" +#include "Ruler.hxx" +#include "DrawDocShell.hxx" +#include "sdabstdlg.hxx" +#include <sfx2/ipclient.hxx> +#include <tools/diagnose_ex.h> +#include "ViewShellBase.hxx" +#include "FormShellManager.hxx" +#include "LayerTabBar.hxx" +#include "sdabstdlg.hxx" +#include "sdpage.hxx" +#include <com/sun/star/drawing/framework/XControllerManager.hpp> +#include <com/sun/star/drawing/framework/XConfigurationController.hpp> +#include <com/sun/star/drawing/framework/XConfiguration.hpp> +#include <com/sun/star/frame/XFrame.hpp> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::drawing::framework; +using ::com::sun::star::frame::XFrame; +using ::com::sun::star::frame::XController; + +namespace sd { + +#ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED +#define SO2_DECL_SVINPLACEOBJECT_DEFINED +SO2_DECL_REF(SvInPlaceObject) +#endif + + + +/************************************************************************* +|* +|* SfxRequests fuer Controller bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecCtrl(SfxRequest& rReq) +{ + // waehrend einer Diashow wird nichts ausser dem Seitenwechsel und dem + // Sprung zur Bookmark ausgefuehrt! + if( HasCurrentFunction(SID_PRESENTATION) && + rReq.GetSlot() != SID_SWITCHPAGE && + rReq.GetSlot() != SID_JUMPTOMARK) + return; + + CheckLineTo (rReq); + + // End text edit mode for some requests. + USHORT nSlot = rReq.GetSlot(); + switch (nSlot) + { + case SID_OUTPUT_QUALITY_COLOR: + case SID_OUTPUT_QUALITY_GRAYSCALE: + case SID_OUTPUT_QUALITY_BLACKWHITE: + case SID_OUTPUT_QUALITY_CONTRAST: + // Do nothing. + break; + default: + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + } + + // USHORT nSlot = rReq.GetSlot(); + switch (nSlot) + { + case SID_SWITCHPAGE: // BASIC + { + BOOL bWasBasic = FALSE; + + // switch page in running slide show + if(SlideShow::IsRunning(GetViewShellBase()) && rReq.GetArgs()) + { + SFX_REQUEST_ARG(rReq, pWhatPage, SfxUInt32Item, ID_VAL_WHATPAGE, FALSE); + SlideShow::GetSlideShow(GetViewShellBase())->jumpToPageNumber((sal_Int32)((pWhatPage->GetValue()-1)>>1)); + } + else + { + const SfxItemSet *pArgs = rReq.GetArgs (); + USHORT nSelectedPage = 0; + + if (! pArgs) + { + nSelectedPage = maTabControl.GetCurPageId() - 1; + } + else if (pArgs->Count () == 2) + { + SFX_REQUEST_ARG (rReq, pWhatPage, SfxUInt32Item, ID_VAL_WHATPAGE, FALSE); + SFX_REQUEST_ARG (rReq, pWhatKind, SfxUInt32Item, ID_VAL_WHATKIND, FALSE); + + sal_Int32 nWhatPage = (sal_Int32)pWhatPage->GetValue (); + sal_Int32 nWhatKind = (sal_Int32)pWhatKind->GetValue (); + if (! CHECK_RANGE (PK_STANDARD, nWhatKind, PK_HANDOUT)) + { + StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + rReq.Ignore (); + break; + } + else if (meEditMode != EM_MASTERPAGE) + { + if (! CHECK_RANGE (0, nWhatPage, GetDoc()->GetSdPageCount((PageKind)nWhatKind))) + { + StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + rReq.Ignore (); + break; + } + + nSelectedPage = (short) nWhatPage; + mePageKind = (PageKind) nWhatKind; + bWasBasic = TRUE; + } + } + else + { + StarBASIC::FatalError (SbERR_WRONG_ARGS); + rReq.Ignore (); + break; + } + + + if( GetDocSh() && (GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED)) + GetDocSh()->SetModified(); + + SwitchPage(nSelectedPage); + + if(HasCurrentFunction(SID_BEZIER_EDIT)) + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + + Invalidate(); + InvalidateWindows(); + rReq.Done (); + } + break; + } + + case SID_SWITCHLAYER: // BASIC + { + const SfxItemSet *pArgs = rReq.GetArgs (); + USHORT nCurPage = GetLayerTabControl()->GetCurPageId (); + + if( pArgs && pArgs->Count () == 1) + { + SFX_REQUEST_ARG (rReq, pWhatLayer, SfxUInt32Item, ID_VAL_WHATLAYER, FALSE); + if( pWhatLayer ) + nCurPage = (short) pWhatLayer->GetValue (); + } + + mpDrawView->SetActiveLayer( GetLayerTabControl()->GetPageText(nCurPage) ); + Invalidate(); + rReq.Done (); + + break; + } + + case SID_PAGEMODE: // BASIC + { + + const SfxItemSet *pArgs = rReq.GetArgs (); + + if ( pArgs && pArgs->Count () == 2) + { + SFX_REQUEST_ARG (rReq, pIsActive, SfxBoolItem, ID_VAL_ISACTIVE, FALSE); + SFX_REQUEST_ARG (rReq, pWhatKind, SfxUInt32Item, ID_VAL_WHATKIND, FALSE); + + sal_Int32 nWhatKind = (sal_Int32)pWhatKind->GetValue (); + if (CHECK_RANGE (PK_STANDARD, nWhatKind, PK_HANDOUT)) + { + mbIsLayerModeActive = pIsActive->GetValue (); + mePageKind = (PageKind) nWhatKind; + } + } + + // Default-Layer der Page einschalten + mpDrawView->SetActiveLayer( String( SdResId(STR_LAYER_LAYOUT) ) ); + + ChangeEditMode(EM_PAGE, mbIsLayerModeActive); + + Invalidate(); + rReq.Done (); + + break; + } + + case SID_LAYERMODE: // BASIC + { + const SfxItemSet *pArgs = rReq.GetArgs (); + + if ( pArgs && pArgs->Count () == 2) + { + SFX_REQUEST_ARG (rReq, pWhatLayerMode, SfxBoolItem, ID_VAL_ISACTIVE, FALSE); + SFX_REQUEST_ARG (rReq, pWhatLayer, SfxUInt32Item, ID_VAL_WHATLAYER, FALSE); + + sal_Int32 nWhatLayer = (sal_Int32)pWhatLayer->GetValue (); + if (CHECK_RANGE (EM_PAGE, nWhatLayer, EM_MASTERPAGE)) + { + mbIsLayerModeActive = pWhatLayerMode->GetValue (); + meEditMode = (EditMode) nWhatLayer; + } + } + + ChangeEditMode(meEditMode, !mbIsLayerModeActive); + + Invalidate(); + rReq.Done (); + + break; + } + + case SID_HEADER_AND_FOOTER: + case SID_INSERT_PAGE_NUMBER: + case SID_INSERT_DATE_TIME: + { + SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); + AbstractHeaderFooterDialog* pDlg = pFact ? pFact->CreateHeaderFooterDialog( (::ViewShell*)this, GetActiveWindow(), GetDoc(), mpActualPage ) : 0; + if( pDlg ) + { + pDlg->Execute(); + delete pDlg; + + GetActiveWindow()->Invalidate(); + UpdatePreview( mpActualPage ); + } + + Invalidate(); + rReq.Done (); + + break; + } + + case SID_MASTER_LAYOUTS: + { + SdPage* pPage = GetActualPage(); + if (meEditMode == EM_MASTERPAGE) + // Use the master page of the current page. + pPage = static_cast<SdPage*>(&pPage->TRG_GetMasterPage()); + + SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); + VclAbstractDialog* pDlg = pFact ? pFact->CreateMasterLayoutDialog( GetActiveWindow(), GetDoc(), pPage ) : 0; + if( pDlg ) + { + pDlg->Execute(); + delete pDlg; + Invalidate(); + } + rReq.Done (); + break; + } + case SID_OBJECTRESIZE: + { + /****************************************************************** + * Der Server moechte die Clientgrosse verandern + ******************************************************************/ + OSL_ASSERT (GetViewShell()!=NULL); + SfxInPlaceClient* pIPClient = GetViewShell()->GetIPClient(); + + if ( pIPClient && pIPClient->IsObjectInPlaceActive() ) + { + const SfxRectangleItem& rRect = + (SfxRectangleItem&)rReq.GetArgs()->Get(SID_OBJECTRESIZE); + Rectangle aRect( GetActiveWindow()->PixelToLogic( rRect.GetValue() ) ); + + if ( mpDrawView->AreObjectsMarked() ) + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + + if (rMarkList.GetMarkCount() == 1) + { + SdrMark* pMark = rMarkList.GetMark(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + + SdrOle2Obj* pOle2Obj = dynamic_cast< SdrOle2Obj* >( pObj ); + if(pOle2Obj) + { + if( pOle2Obj->GetObjRef().is() ) + { + pOle2Obj->SetLogicRect(aRect); + } + } + } + } + } + rReq.Ignore (); + break; + } + + case SID_RELOAD: + { + // #83951# + USHORT nId = Svx3DChildWindow::GetChildWindowId(); + SfxViewFrame* pFrame = GetViewFrame(); + + try + { + Reference< XFrame > xFrame( pFrame->GetFrame().GetFrameInterface(), UNO_SET_THROW ); + + // Save the current configuration of panes and views. + Reference<XControllerManager> xControllerManager ( + GetViewShellBase().GetController(), UNO_QUERY_THROW); + Reference<XConfigurationController> xConfigurationController ( + xControllerManager->getConfigurationController(), UNO_QUERY_THROW ); + Reference<XConfiguration> xConfiguration ( + xConfigurationController->getRequestedConfiguration(), UNO_SET_THROW ); + + SfxChildWindow* pWindow = pFrame->GetChildWindow(nId); + if(pWindow) + { + Svx3DWin* p3DWin = (Svx3DWin*)(pWindow->GetWindow()); + if(p3DWin) + p3DWin->DocumentReload(); + } + + // Normale Weiterleitung an ViewFrame zur Ausfuehrung + GetViewFrame()->ExecuteSlot(rReq); + + // From here on we must cope with this object and the frame already being + // deleted. Do not call any methods or use data members. + Reference<XController> xController( xFrame->getController(), UNO_SET_THROW ); + + // Restore the configuration. + xControllerManager = Reference<XControllerManager>( xController, UNO_QUERY_THROW); + xConfigurationController = Reference<XConfigurationController>( + xControllerManager->getConfigurationController()); + if ( ! xConfigurationController.is()) + throw RuntimeException(); + xConfigurationController->restoreConfiguration(xConfiguration); + } + catch (RuntimeException&) + { + DBG_UNHANDLED_EXCEPTION(); + } + + // We have to return immediately to avoid accessing this object. + return; + } + + case SID_JUMPTOMARK: + { + if( rReq.GetArgs() ) + { + SFX_REQUEST_ARG(rReq, pBookmark, SfxStringItem, SID_JUMPTOMARK, FALSE); + + if (pBookmark) + { + UniString sBookmark( INetURLObject::decode( pBookmark->GetValue(), '%', INetURLObject::DECODE_WITH_CHARSET ) ); + + rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if(xSlideshow.is() && xSlideshow->isRunning()) + { + xSlideshow->jumpToBookmark(sBookmark); + } + else + { + GotoBookmark( sBookmark ); + } + } + } + rReq.Done(); + break; + } + + case SID_OUTPUT_QUALITY_COLOR: + case SID_OUTPUT_QUALITY_GRAYSCALE: + case SID_OUTPUT_QUALITY_BLACKWHITE: + case SID_OUTPUT_QUALITY_CONTRAST: + { + ExecReq( rReq ); + break; + } + + case SID_MAIL_SCROLLBODY_PAGEDOWN: + { + ExecReq( rReq ); + break; + } + + case SID_ATTR_YEAR2000: + { + FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell(); + if (pFormShell != NULL) + { + const SfxPoolItem* pItem; + if (rReq.GetArgs()->GetItemState( + SID_ATTR_YEAR2000, TRUE, &pItem) == SFX_ITEM_SET) + pFormShell->SetY2KState ( + static_cast<const SfxUInt16Item*>(pItem)->GetValue()); + } + + rReq.Done(); + } + break; + + case SID_OPT_LOCALE_CHANGED: + { + GetActiveWindow()->Invalidate(); + UpdatePreview( mpActualPage ); + rReq.Done(); + } + + default: + break; + } +} + +/************************************************************************* +|* +|* SfxRequests fuer Lineale bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecRuler(SfxRequest& rReq) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if(HasCurrentFunction(SID_PRESENTATION)) + return; + + CheckLineTo (rReq); + + const SfxItemSet* pArgs = rReq.GetArgs(); + const Point aPagePos( GetActiveWindow()->GetViewOrigin() ); + Size aPageSize = mpActualPage->GetSize(); + Size aViewSize = GetActiveWindow()->GetViewSize(); + SdUndoGroup* pUndoGroup = NULL; + + if ( rReq.GetSlot() == SID_ATTR_LONG_LRSPACE || + rReq.GetSlot() == SID_ATTR_LONG_ULSPACE ) + { + pUndoGroup = new SdUndoGroup(GetDoc()); + String aString(SdResId(STR_UNDO_CHANGE_PAGEBORDER)); + pUndoGroup->SetComment(aString); + } + + switch ( rReq.GetSlot() ) + { + case SID_ATTR_LONG_LRSPACE: + { + const SvxLongLRSpaceItem& rLRSpace = (const SvxLongLRSpaceItem&) + pArgs->Get(GetPool().GetWhich(SID_ATTR_LONG_LRSPACE)); + + if( mpDrawView->IsTextEdit() ) + { + Rectangle aRect = maMarkRect; + aRect.SetPos(aRect.TopLeft() + aPagePos); + aRect.Left() = rLRSpace.GetLeft(); + aRect.Right() = aViewSize.Width() - rLRSpace.GetRight(); + aRect.SetPos(aRect.TopLeft() - aPagePos); + if ( aRect != maMarkRect) + { + mpDrawView->SetAllMarkedRect(aRect); + maMarkRect = mpDrawView->GetAllMarkedRect(); + Invalidate( SID_RULER_OBJECT ); + } + } + else + { + long nLeft = Max(0L, rLRSpace.GetLeft() - aPagePos.X()); + long nRight = Max(0L, rLRSpace.GetRight() + aPagePos.X() + + aPageSize.Width() - aViewSize.Width()); + + USHORT nPageCnt = GetDoc()->GetSdPageCount(mePageKind); + USHORT i; + for ( i = 0; i < nPageCnt; i++) + { + SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind); + SdUndoAction* pUndo = new SdPageLRUndoAction(GetDoc(), + pPage, + pPage->GetLftBorder(), + pPage->GetRgtBorder(), + nLeft, nRight); + pUndoGroup->AddAction(pUndo); + pPage->SetLftBorder(nLeft); + pPage->SetRgtBorder(nRight); + } + nPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind); + + for (i = 0; i < nPageCnt; i++) + { + SdPage* pPage = GetDoc()->GetMasterSdPage(i, mePageKind); + SdUndoAction* pUndo = new SdPageLRUndoAction(GetDoc(), + pPage, + pPage->GetLftBorder(), + pPage->GetRgtBorder(), + nLeft, nRight); + pUndoGroup->AddAction(pUndo); + pPage->SetLftBorder(nLeft); + pPage->SetRgtBorder(nRight); + } + InvalidateWindows(); + } + break; + } + case SID_ATTR_LONG_ULSPACE: + { + const SvxLongULSpaceItem& rULSpace = (const SvxLongULSpaceItem&) + pArgs->Get(GetPool().GetWhich(SID_ATTR_LONG_ULSPACE)); + + if( mpDrawView->IsTextEdit() ) + { + Rectangle aRect = maMarkRect; + aRect.SetPos(aRect.TopLeft() + aPagePos); + aRect.Top() = rULSpace.GetUpper(); + aRect.Bottom() = aViewSize.Height() - rULSpace.GetLower(); + aRect.SetPos(aRect.TopLeft() - aPagePos); + + if ( aRect != maMarkRect) + { + mpDrawView->SetAllMarkedRect(aRect); + maMarkRect = mpDrawView->GetAllMarkedRect(); + Invalidate( SID_RULER_OBJECT ); + } + } + else + { + long nUpper = Max(0L, rULSpace.GetUpper() - aPagePos.Y()); + long nLower = Max(0L, rULSpace.GetLower() + aPagePos.Y() + + aPageSize.Height() - aViewSize.Height()); + + USHORT nPageCnt = GetDoc()->GetSdPageCount(mePageKind); + USHORT i; + for ( i = 0; i < nPageCnt; i++) + { + SdPage* pPage = GetDoc()->GetSdPage(i, mePageKind); + SdUndoAction* pUndo = new SdPageULUndoAction(GetDoc(), + pPage, + pPage->GetUppBorder(), + pPage->GetLwrBorder(), + nUpper, nLower); + pUndoGroup->AddAction(pUndo); + pPage->SetUppBorder(nUpper); + pPage->SetLwrBorder(nLower); + } + nPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind); + + for (i = 0; i < nPageCnt; i++) + { + SdPage* pPage = GetDoc()->GetMasterSdPage(i, mePageKind); + SdUndoAction* pUndo = new SdPageULUndoAction(GetDoc(), + pPage, + pPage->GetUppBorder(), + pPage->GetLwrBorder(), + nUpper, nLower); + pUndoGroup->AddAction(pUndo); + pPage->SetUppBorder(nUpper); + pPage->SetLwrBorder(nLower); + } + InvalidateWindows(); + } + break; + } + + case SID_RULER_OBJECT: + { + Rectangle aRect = maMarkRect; + aRect.SetPos(aRect.TopLeft() + aPagePos); + + const SvxObjectItem& rOI = (const SvxObjectItem&) + pArgs->Get(GetPool().GetWhich(SID_RULER_OBJECT)); + + if ( rOI.GetStartX() != rOI.GetEndX() ) + { + aRect.Left() = rOI.GetStartX(); + aRect.Right() = rOI.GetEndX(); + } + if ( rOI.GetStartY() != rOI.GetEndY() ) + { + aRect.Top() = rOI.GetStartY(); + aRect.Bottom() = rOI.GetEndY(); + } + aRect.SetPos(aRect.TopLeft() - aPagePos); + if ( aRect != maMarkRect) + { + mpDrawView->SetAllMarkedRect(aRect); + maMarkRect = mpDrawView->GetAllMarkedRect(); + Invalidate( SID_RULER_OBJECT ); + } + break; + } + + case SID_ATTR_TABSTOP: + { + if( mpDrawView->IsTextEdit() ) + { + const SvxTabStopItem& rItem = (const SvxTabStopItem&) + pArgs->Get( EE_PARA_TABS ); + + SfxItemSet aEditAttr( GetPool(), EE_PARA_TABS, EE_PARA_TABS ); + + aEditAttr.Put( rItem ); + mpDrawView->SetAttributes( aEditAttr ); + + // #91081# Invalidate is missing here + Invalidate(SID_ATTR_TABSTOP); + } + break; + } + + case SID_ATTR_PARA_LRSPACE: + { + if( mpDrawView->IsTextEdit() ) + { + USHORT nId = SID_ATTR_PARA_LRSPACE; + const SvxLRSpaceItem& rItem = (const SvxLRSpaceItem&) + pArgs->Get( nId ); + + SfxItemSet aEditAttr( GetPool(), EE_PARA_LRSPACE, EE_PARA_LRSPACE ); + + nId = EE_PARA_LRSPACE; + SvxLRSpaceItem aLRSpaceItem( rItem.GetLeft(), + rItem.GetRight(), rItem.GetTxtLeft(), + rItem.GetTxtFirstLineOfst(), nId ); + aEditAttr.Put( aLRSpaceItem ); + mpDrawView->SetAttributes( aEditAttr ); + + // #92557# Invalidate is missing here + Invalidate(SID_ATTR_PARA_LRSPACE); + } + break; + } + } + if ( pUndoGroup ) + // Undo Gruppe dem Undo Manager uebergeben + GetViewFrame()->GetObjectShell()->GetUndoManager()-> + AddUndoAction(pUndoGroup); +} + +/************************************************************************* +|* +|* Statuswerte der Lineale bestimmen +|* +\************************************************************************/ +void DrawViewShell::GetRulerState(SfxItemSet& rSet) +{ + Point aOrigin; + + if (mpDrawView->GetSdrPageView()) + { + aOrigin = mpDrawView->GetSdrPageView()->GetPageOrigin(); + } + + Size aViewSize = GetActiveWindow()->GetViewSize(); + + const Point aPagePos( GetActiveWindow()->GetViewOrigin() ); + Size aPageSize = mpActualPage->GetSize(); + + Rectangle aRect(aPagePos, Point( aViewSize.Width() - (aPagePos.X() + aPageSize.Width()), + aViewSize.Height() - (aPagePos.Y() + aPageSize.Height()))); + + if( mpDrawView->IsTextEdit() ) + { + Point aPnt1 = GetActiveWindow()->GetWinViewPos(); + Point aPnt2 = GetActiveWindow()->GetViewOrigin(); + Rectangle aMinMaxRect = Rectangle( aPnt1, Size(ULONG_MAX, ULONG_MAX) ); + rSet.Put( SfxRectangleItem(SID_RULER_LR_MIN_MAX, aMinMaxRect) ); + } + else + { + rSet.Put( SfxRectangleItem(SID_RULER_LR_MIN_MAX, aRect) ); + } + + SvxLongLRSpaceItem aLRSpace(aPagePos.X() + mpActualPage->GetLftBorder(), + aRect.Right() + mpActualPage->GetRgtBorder(), + GetPool().GetWhich(SID_ATTR_LONG_LRSPACE)); + SvxLongULSpaceItem aULSpace(aPagePos.Y() + mpActualPage->GetUppBorder(), + aRect.Bottom() + mpActualPage->GetLwrBorder(), + GetPool().GetWhich(SID_ATTR_LONG_ULSPACE)); + rSet.Put(SvxPagePosSizeItem(Point(0,0) - aPagePos, aViewSize.Width(), + aViewSize.Height())); + SfxPointItem aPointItem( SID_RULER_NULL_OFFSET, aPagePos + aOrigin ); + + SvxProtectItem aProtect( SID_RULER_PROTECT ); + + maMarkRect = mpDrawView->GetAllMarkedRect(); + + const sal_Bool bRTL = GetDoc() && GetDoc()->GetDefaultWritingMode() == ::com::sun::star::text::WritingMode_RL_TB; + rSet.Put(SfxBoolItem(SID_RULER_TEXT_RIGHT_TO_LEFT, bRTL)); + + if( mpDrawView->AreObjectsMarked() ) + { + if( mpDrawView->IsTextEdit() ) + { + SdrObject* pObj = mpDrawView->GetMarkedObjectList().GetMark( 0 )->GetMarkedSdrObj(); + if( pObj->GetObjInventor() == SdrInventor) + { + SfxItemSet aEditAttr( GetDoc()->GetPool() ); + mpDrawView->GetAttributes( aEditAttr ); + if( aEditAttr.GetItemState( EE_PARA_TABS ) >= SFX_ITEM_AVAILABLE ) + { + const SvxTabStopItem& rItem = (const SvxTabStopItem&) aEditAttr.Get( EE_PARA_TABS ); + rSet.Put( rItem ); + + //Rectangle aRect = maMarkRect; + + const SvxLRSpaceItem& rLRSpaceItem = (const SvxLRSpaceItem&) aEditAttr.Get( EE_PARA_LRSPACE ); + USHORT nId = SID_ATTR_PARA_LRSPACE; + SvxLRSpaceItem aLRSpaceItem( rLRSpaceItem.GetLeft(), + rLRSpaceItem.GetRight(), rLRSpaceItem.GetTxtLeft(), + rLRSpaceItem.GetTxtFirstLineOfst(), nId ); + rSet.Put( aLRSpaceItem ); + + Point aPos( aPagePos + maMarkRect.TopLeft() ); + + if ( aEditAttr.GetItemState( SDRATTR_TEXT_LEFTDIST ) == SFX_ITEM_ON ) + { + const SdrTextLeftDistItem& rTLDItem = (const SdrTextLeftDistItem&) + aEditAttr.Get( SDRATTR_TEXT_LEFTDIST ); + long nLD = rTLDItem.GetValue(); + aPos.X() += nLD; + } + + aPointItem.SetValue( aPos ); + + aLRSpace.SetLeft( aPagePos.X() + maMarkRect.Left() ); + + if ( aEditAttr.GetItemState( SDRATTR_TEXT_LEFTDIST ) == SFX_ITEM_ON ) + { + const SdrTextLeftDistItem& rTLDItem = (const SdrTextLeftDistItem&) + aEditAttr.Get( SDRATTR_TEXT_LEFTDIST ); + long nLD = rTLDItem.GetValue(); + aLRSpace.SetLeft( aLRSpace.GetLeft() + nLD ); + } + + aLRSpace.SetRight( aRect.Right() + aPageSize.Width() - maMarkRect.Right() ); + aULSpace.SetUpper( aPagePos.Y() + maMarkRect.Top() ); + aULSpace.SetLower( aRect.Bottom() + aPageSize.Height() - maMarkRect.Bottom() ); + + rSet.DisableItem( SID_RULER_OBJECT ); + + // Seitenraender werden gelocked + aProtect.SetSizeProtect( TRUE ); + aProtect.SetPosProtect( TRUE ); + } + + if( aEditAttr.GetItemState( EE_PARA_WRITINGDIR ) >= SFX_ITEM_AVAILABLE ) + { + const SvxFrameDirectionItem& rItem = (const SvxFrameDirectionItem&) aEditAttr.Get( EE_PARA_WRITINGDIR ); + rSet.Put(SfxBoolItem(SID_RULER_TEXT_RIGHT_TO_LEFT, rItem.GetValue() == ::com::sun::star::text::WritingMode_RL_TB)); + } + } + } + else + { + rSet.DisableItem( EE_PARA_TABS ); + rSet.DisableItem( SID_RULER_TEXT_RIGHT_TO_LEFT ); + + if( mpDrawView->IsResizeAllowed(TRUE) ) + { + Rectangle aResizeRect( maMarkRect ); + + aResizeRect.SetPos(aResizeRect.TopLeft() + aPagePos); + SvxObjectItem aObjItem(aResizeRect.Left(), aResizeRect.Right(), + aResizeRect.Top(), aResizeRect.Bottom()); + rSet.Put(aObjItem); + rSet.DisableItem( EE_PARA_TABS ); + } + else + { + rSet.DisableItem( SID_RULER_OBJECT ); + } + } + } + else + { + rSet.DisableItem( SID_RULER_OBJECT ); + rSet.DisableItem( EE_PARA_TABS ); +// rSet.DisableItem( SID_RULER_TEXT_RIGHT_TO_LEFT ); + } + + rSet.Put( aLRSpace ); + rSet.Put( aULSpace ); + + rSet.Put( aPointItem ); + rSet.Put( aProtect ); +} + +/************************************************************************* +|* +|* SfxRequests fuer StatusBar bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecStatusBar(SfxRequest& rReq) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if(HasCurrentFunction(SID_PRESENTATION)) + return; + + CheckLineTo (rReq); + + switch ( rReq.GetSlot() ) + { + case SID_ATTR_SIZE: + { + GetViewFrame()->GetDispatcher()->Execute( SID_ATTR_TRANSFORM, SFX_CALLMODE_ASYNCHRON ); + } + break; + + case SID_STATUS_LAYOUT: + { + GetViewFrame()->GetDispatcher()->Execute( SID_PRESENTATION_LAYOUT, SFX_CALLMODE_ASYNCHRON ); + } + break; + } +} + +/************************************************************************* +|* +|* Status der Snap-Objekt-Eintraege im Popup setzen +|* +\************************************************************************/ + +void DrawViewShell::GetSnapItemState( SfxItemSet &rSet ) +{ + SdrPageView* pPV; + Point aMPos = GetActiveWindow()->PixelToLogic(maMousePos); + USHORT nHitLog = (USHORT) GetActiveWindow()->PixelToLogic( + Size(FuPoor::HITPIX,0)).Width(); + USHORT nHelpLine; + + if ( mpDrawView->PickHelpLine(aMPos, nHitLog, *GetActiveWindow(), nHelpLine, pPV) ) + { + const SdrHelpLine& rHelpLine = (pPV->GetHelpLines())[nHelpLine]; + + if ( rHelpLine.GetKind() == SDRHELPLINE_POINT ) + { + rSet.Put( SfxStringItem( SID_SET_SNAPITEM, + String( SdResId( STR_POPUP_EDIT_SNAPPOINT))) ); + rSet.Put( SfxStringItem( SID_DELETE_SNAPITEM, + String( SdResId( STR_POPUP_DELETE_SNAPPOINT))) ); + } + else + { + rSet.Put( SfxStringItem( SID_SET_SNAPITEM, + String( SdResId( STR_POPUP_EDIT_SNAPLINE))) ); + rSet.Put( SfxStringItem( SID_DELETE_SNAPITEM, + String( SdResId( STR_POPUP_DELETE_SNAPLINE))) ); + } + } +} + + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void DrawViewShell::AddWindow (::sd::Window* pWin) +{ + mpDrawView->AddWindowToPaintView(pWin); +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void DrawViewShell::RemoveWindow(::sd::Window* pWin) +{ + mpDrawView->DeleteWindowFromPaintView(pWin); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviews4.cxx b/sd/source/ui/view/drviews4.cxx new file mode 100644 index 000000000000..88027d360806 --- /dev/null +++ b/sd/source/ui/view/drviews4.cxx @@ -0,0 +1,1007 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include <com/sun/star/drawing/XDrawPagesSupplier.hpp> + +#include "DrawViewShell.hxx" +#include <vcl/msgbox.hxx> +#include <svl/urlbmk.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdundo.hxx> +#include <svx/fmglob.hxx> +#include <editeng/eeitem.hxx> +#ifndef _FLDITEM_HXX +#include <editeng/flditem.hxx> +#endif +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <svx/ruler.hxx> +#ifndef _GLOBL3D_HXX +#include <svx/globl3d.hxx> +#endif +#include <editeng/outliner.hxx> +#ifndef _SFX_CLIENTSH_HXX +#include <sfx2/ipclient.hxx> +#endif +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/svdopath.hxx> +#include <sfx2/viewfrm.hxx> +#include <editeng/editview.hxx> +#include <vcl/cursor.hxx> + + +#include "app.hrc" +#include "glob.hrc" +#include "strings.hrc" +#include "res_bmp.hrc" +#include "DrawDocShell.hxx" +#include "drawdoc.hxx" +#include "Window.hxx" +#include "fupoor.hxx" +#include "fusnapln.hxx" +#include "app.hxx" +#include "Ruler.hxx" +#include "sdresid.hxx" +#include "GraphicViewShell.hxx" +#include "sdpage.hxx" +#include "slideshow.hxx" +#include "anminfo.hxx" +#include "sdpopup.hxx" +#include "drawview.hxx" +#include <svx/bmpmask.hxx> +#include "LayerTabBar.hxx" + +// #97016# IV +#include <svx/svditer.hxx> + +namespace sd { + +#define PIPETTE_RANGE 0 + +#ifdef _MSC_VER +#pragma optimize ( "", off ) +#endif + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::drawing; + +/************************************************************************* +|* +|* aktuelle Seite loeschen +|* +\************************************************************************/ + +void DrawViewShell::DeleteActualPage() +{ + USHORT nPage = maTabControl.GetCurPageId() - 1; + + mpDrawView->SdrEndTextEdit(); + + try + { + Reference<XDrawPagesSupplier> xDrawPagesSupplier( GetDoc()->getUnoModel(), UNO_QUERY_THROW ); + Reference<XDrawPages> xPages( xDrawPagesSupplier->getDrawPages(), UNO_QUERY_THROW ); + Reference< XDrawPage > xPage( xPages->getByIndex( nPage ), UNO_QUERY_THROW ); + xPages->remove( xPage ); + } + catch( Exception& ) + { + DBG_ERROR("SelectionManager::DeleteSelectedMasterPages(), exception caught!"); + } +} + +/************************************************************************* +|* +|* aktuelle Ebene loeschen +|* +\************************************************************************/ + +void DrawViewShell::DeleteActualLayer() +{ + SdrLayerAdmin& rAdmin = GetDoc()->GetLayerAdmin(); + const String& rName = GetLayerTabControl()->GetPageText(GetLayerTabControl()->GetCurPageId()); + String aString(SdResId(STR_ASK_DELETE_LAYER)); + + // Platzhalter ersetzen + USHORT nPos = aString.Search(sal_Unicode('$')); + aString.Erase(nPos, 1); + aString.Insert(rName, nPos); + + if (QueryBox(GetActiveWindow(), WB_YES_NO, aString).Execute() == RET_YES) + { + const SdrLayer* pLayer = rAdmin.GetLayer(rName, FALSE); + mpDrawView->DeleteLayer( pLayer->GetName() ); + + // damit TabBar und Window neu gezeichnet werden; + // sollte spaeter wie beim Aendern der Layerfolge durch einen + // Hint von Joe angestossen werden + // ( View::Notify() --> ViewShell::ResetActualLayer() ) + + mbIsLayerModeActive = false; // damit ChangeEditMode() ueberhaupt was tut + ChangeEditMode(GetEditMode(), true); + } +} + + +/************************************************************************* +|* +|* Keyboard event +|* +\************************************************************************/ + +BOOL DrawViewShell::KeyInput (const KeyEvent& rKEvt, ::sd::Window* pWin) +{ + BOOL bRet = FALSE; + + if ( !IsInputLocked() || ( rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE ) ) + { + // #97016# IV + if(KEY_RETURN == rKEvt.GetKeyCode().GetCode() + && rKEvt.GetKeyCode().IsMod1() + && GetView()->IsTextEdit()) + { + // this should be used for cursor travelling. + SdPage* pActualPage = GetActualPage(); + const SdrMarkList& rMarkList = GetView()->GetMarkedObjectList(); + SdrTextObj* pCandidate = 0L; + + if(pActualPage && 1 == rMarkList.GetMarkCount()) + { + SdrMark* pMark = rMarkList.GetMark(0); + + // remember which object was the text in edit mode + SdrObject* pOldObj = pMark->GetMarkedSdrObj(); + + // end text edit now + GetView()->SdrEndTextEdit(); + + // look for a new candidate, a successor of pOldObj + SdrObjListIter aIter(*pActualPage, IM_DEEPNOGROUPS); + BOOL bDidVisitOldObject(FALSE); + + while(aIter.IsMore() && !pCandidate) + { + SdrObject* pObj = aIter.Next(); + + if(pObj && pObj->ISA(SdrTextObj)) + { + sal_uInt32 nInv(pObj->GetObjInventor()); + sal_uInt16 nKnd(pObj->GetObjIdentifier()); + + if(SdrInventor == nInv && + (OBJ_TITLETEXT == nKnd || OBJ_OUTLINETEXT == nKnd || OBJ_TEXT == nKnd) + && bDidVisitOldObject) + { + pCandidate = (SdrTextObj*)pObj; + } + + if(pObj == pOldObj) + { + bDidVisitOldObject = TRUE; + } + } + } + } + + if(pCandidate) + { + // set the new candidate to text edit mode + GetView()->UnMarkAll(); + GetView()->MarkObj(pCandidate, GetView()->GetSdrPageView()); + + GetViewFrame()->GetDispatcher()->Execute( + SID_ATTR_CHAR, SFX_CALLMODE_ASYNCHRON); + } + else + { + // insert a new page with the same page layout + GetViewFrame()->GetDispatcher()->Execute( + SID_INSERTPAGE_QUICK, SFX_CALLMODE_ASYNCHRON); + } + } + else + { + bRet = ViewShell::KeyInput(rKEvt, pWin); + } + } + + return bRet; +} + +/************************************************************************* +|* +|* Vom Lineal ausgehenden Drag (Hilflinien, Ursprung) beginnen +|* +\************************************************************************/ + +void DrawViewShell::StartRulerDrag ( + const Ruler& rRuler, + const MouseEvent& rMEvt) +{ + GetActiveWindow()->CaptureMouse(); + + Point aWPos = GetActiveWindow()->PixelToLogic(GetActiveWindow()->GetPointerPosPixel()); + + if ( rRuler.GetExtraRect().IsInside(rMEvt.GetPosPixel()) ) + { + mpDrawView->BegSetPageOrg(aWPos); + mbIsRulerDrag = TRUE; + } + else + { + // #i34536# if no guide-lines are visible yet, that show them + if( ! mpDrawView->IsHlplVisible()) + mpDrawView->SetHlplVisible( TRUE ); + + SdrHelpLineKind eKind; + + if ( rMEvt.IsMod1() ) + eKind = SDRHELPLINE_POINT; + else if ( rRuler.IsHorizontal() ) + eKind = SDRHELPLINE_HORIZONTAL; + else + eKind = SDRHELPLINE_VERTICAL; + + mpDrawView->BegDragHelpLine(aWPos, eKind); + mbIsRulerDrag = TRUE; + } +} + +/************************************************************************* +|* +|* MouseButtonDown event +|* +\************************************************************************/ + +void DrawViewShell::MouseButtonDown(const MouseEvent& rMEvt, + ::sd::Window* pWin) +{ + // We have to check if a context menu is shown and we have an UI + // active inplace client. In that case we have to ignore the mouse + // button down event. Otherwise we would crash (context menu has been + // opened by inplace client and we would deactivate the inplace client, + // the contex menu is closed by VCL asynchronously which in the end + // would work on deleted objects or the context menu has no parent anymore) + // See #126086# and #128122# + SfxInPlaceClient* pIPClient = GetViewShell()->GetIPClient(); + BOOL bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() ); + + if ( bIsOleActive && PopupMenu::IsInExecute() ) + return; + + if ( !IsInputLocked() ) + { + ViewShell::MouseButtonDown(rMEvt, pWin); + + if ( mbPipette ) + ( (SvxBmpMask*) GetViewFrame()->GetChildWindow( SvxBmpMaskChildWindow::GetChildWindowId() )->GetWindow() )->PipetteClicked(); + } +} + +/************************************************************************* +|* +|* MouseMove event +|* +\************************************************************************/ + + +void DrawViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin) +{ + if ( !IsInputLocked() ) + { + if ( mpDrawView->IsAction() ) + { + Rectangle aOutputArea(Point(0,0), GetActiveWindow()->GetOutputSizePixel()); + + if ( !aOutputArea.IsInside(rMEvt.GetPosPixel()) ) + { + BOOL bInsideOtherWindow = FALSE; + + if (mpContentWindow.get() != NULL) + { + aOutputArea = Rectangle(Point(0,0), + mpContentWindow->GetOutputSizePixel()); + + Point aPos = mpContentWindow->GetPointerPosPixel(); + if ( aOutputArea.IsInside(aPos) ) + bInsideOtherWindow = TRUE; + } + + if (! GetActiveWindow()->HasFocus ()) + { + GetActiveWindow()->ReleaseMouse (); + mpDrawView->BrkAction (); + return; + } + else if ( bInsideOtherWindow ) + { + GetActiveWindow()->ReleaseMouse(); + pWin->CaptureMouse (); + } + } + else if ( pWin != GetActiveWindow() ) + pWin->CaptureMouse(); + } + + // #109585# + // Since the next MouseMove may execute a IsSolidDraggingNow() in + // SdrCreateView::MovCreateObj and there the ApplicationBackgroundColor + // is needed it is necessary to set it here. + if(mpDrawView!=NULL && GetDoc()!=NULL) + { + svtools::ColorConfig aColorConfig; + Color aFillColor; + + if(DOCUMENT_TYPE_IMPRESS == GetDoc()->GetDocumentType()) + { + aFillColor = Color( aColorConfig.GetColorValue( svtools::APPBACKGROUND ).nColor ); + } + else + { + aFillColor = Color( aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor ); + } + + mpDrawView->SetApplicationBackgroundColor(aFillColor); + } + + ViewShell::MouseMove(rMEvt, pWin); + + if( !mbMousePosFreezed ) + maMousePos = rMEvt.GetPosPixel(); + + Rectangle aRect; + + if ( mbIsRulerDrag ) + { + Point aLogPos = GetActiveWindow()->PixelToLogic(maMousePos); + mpDrawView->MovAction(aLogPos); + } + + if ( mpDrawView->IsAction() ) + { + mpDrawView->TakeActionRect(aRect); + aRect = GetActiveWindow()->LogicToPixel(aRect); + } + else + { + aRect = Rectangle(maMousePos, maMousePos); + } + + ShowMousePosInfo(aRect, pWin); + + if ( mbPipette && GetViewFrame()->HasChildWindow( SvxBmpMaskChildWindow::GetChildWindowId() ) ) + { + const long nStartX = maMousePos.X() - PIPETTE_RANGE; + const long nEndX = maMousePos.X() + PIPETTE_RANGE; + const long nStartY = maMousePos.Y() - PIPETTE_RANGE; + const long nEndY = maMousePos.Y() + PIPETTE_RANGE; + long nRed = 0; + long nGreen = 0; + long nBlue = 0; + const double fDiv = ( ( PIPETTE_RANGE << 1 ) + 1 ) * ( ( PIPETTE_RANGE << 1 ) + 1 ); + + for ( long nY = nStartY; nY <= nEndY; nY++ ) + { + for( long nX = nStartX; nX <= nEndX; nX++ ) + { + const Color aCol( pWin->GetPixel( pWin->PixelToLogic( Point( nX, nY ) ) ) ); + + nRed += aCol.GetRed(); + nGreen += aCol.GetGreen(); + nBlue += aCol.GetBlue(); + } + } + + ( (SvxBmpMask*) GetViewFrame()->GetChildWindow( SvxBmpMaskChildWindow::GetChildWindowId() )->GetWindow() )-> + SetColor( Color( (BYTE) ( nRed / fDiv + .5 ), + (BYTE) ( nGreen / fDiv + .5 ), + (BYTE) ( nBlue / fDiv + .5 ) ) ); + } + } +} + + +/************************************************************************* +|* +|* MouseButtonUp event +|* +\************************************************************************/ + +void DrawViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin) +{ + if ( !IsInputLocked() ) + { + FASTBOOL bIsSetPageOrg = mpDrawView->IsSetPageOrg(); + + if (mbIsRulerDrag) + { + Rectangle aOutputArea(Point(0,0), GetActiveWindow()->GetOutputSizePixel()); + + if (aOutputArea.IsInside(rMEvt.GetPosPixel())) + { + mpDrawView->EndAction(); + + if (bIsSetPageOrg) + GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET); + } + else if (rMEvt.IsLeft() && bIsSetPageOrg) + { + mpDrawView->BrkAction(); + SdPage* pPage = (SdPage*) mpDrawView->GetSdrPageView()->GetPage(); + Point aOrg(pPage->GetLftBorder(), pPage->GetUppBorder()); + mpDrawView->GetSdrPageView()->SetPageOrigin(aOrg); + GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET); + } + else + { + mpDrawView->BrkAction(); + } + + GetActiveWindow()->ReleaseMouse(); + mbIsRulerDrag = FALSE; + } + else + ViewShell::MouseButtonUp(rMEvt, pWin); + } +} + +/************************************************************************* +|* +|* Command event +|* +\************************************************************************/ + +void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin) +{ + // The command event is send to the window after a possible context + // menu from an inplace client is closed. Now we have the chance to + // deactivate the inplace client without any problem regarding parent + // windows and code on the stack. + // For more information, see #126086# and #128122# + SfxInPlaceClient* pIPClient = GetViewShell()->GetIPClient(); + BOOL bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() ); + if ( bIsOleActive && ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU )) + { + // Deactivate OLE object + mpDrawView->UnmarkAll(); + SelectionHasChanged(); + return; + } + + if ( !IsInputLocked() ) + { + if( GetView() &&GetView()->getSmartTags().Command(rCEvt) ) + return; + + const bool bNativeShow (SlideShow::IsRunning(GetViewShellBase())); + + if( rCEvt.GetCommand() == COMMAND_PASTESELECTION && !bNativeShow ) + { + TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSelection( GetActiveWindow() ) ); + + if( aDataHelper.GetTransferable().is() ) + { + Point aPos; + sal_Int8 nDnDAction = DND_ACTION_COPY; + + if( GetActiveWindow() ) + aPos = GetActiveWindow()->PixelToLogic( rCEvt.GetMousePosPixel() ); + + if( !mpDrawView->InsertData( aDataHelper, aPos, nDnDAction, FALSE ) ) + { + INetBookmark aINetBookmark( aEmptyStr, aEmptyStr ); + + if( ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, aINetBookmark ) ) || + ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR, aINetBookmark ) ) || + ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR, aINetBookmark ) ) ) + { + InsertURLField( aINetBookmark.GetURL(), aINetBookmark.GetDescription(), aEmptyStr, NULL ); + } + } + } + } + else if( rCEvt.GetCommand() == COMMAND_CONTEXTMENU && !bNativeShow && + pWin != NULL && !mpDrawView->IsAction() && !SD_MOD()->GetWaterCan() ) + { + USHORT nSdResId = 0; // ResourceID fuer Popup-Menue + BOOL bGraphicShell = this->ISA(GraphicViewShell); + + // Ist ein Fangobjekt unter dem Mauszeiger? + SdrPageView* pPV; + Point aMPos = pWin->PixelToLogic( maMousePos ); + USHORT nHitLog = (USHORT) GetActiveWindow()->PixelToLogic( + Size(FuPoor::HITPIX, 0 ) ).Width(); + USHORT nHelpLine; + // fuer Klebepunkt + SdrObject* pObj = NULL; + USHORT nPickId = 0; + // fuer Feldbefehl + OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView(); + const SvxFieldItem* pFldItem = NULL; + if( pOLV ) + pFldItem = pOLV->GetFieldAtSelection(); + //pFldItem = pOLV->GetFieldUnderMousePointer(); + + // Hilfslinie + if ( mpDrawView->PickHelpLine( aMPos, nHitLog, *GetActiveWindow(), nHelpLine, pPV) ) + { + nSdResId = RID_DRAW_SNAPOBJECT_POPUP; + ShowSnapLineContextMenu(*pPV, nHelpLine, rCEvt.GetMousePosPixel()); + return; + } + // Klebepunkt unter dem Mauszeiger markiert? + else if( mpDrawView->PickGluePoint( aMPos, pObj, nPickId, pPV ) && + mpDrawView->IsGluePointMarked( pObj, nPickId ) ) + { + nSdResId = RID_DRAW_GLUEPOINT_POPUP; + } + // Feldbefehl ? + else if( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) || + pFldItem->GetField()->ISA( SvxExtTimeField ) || + pFldItem->GetField()->ISA( SvxExtFileField ) || + pFldItem->GetField()->ISA( SvxAuthorField ) ) ) + { + LanguageType eLanguage( LANGUAGE_SYSTEM ); + + // #101743# Format popup with outliner language, if possible + if( pOLV->GetOutliner() ) + { + ESelection aSelection( pOLV->GetSelection() ); + eLanguage = pOLV->GetOutliner()->GetLanguage( aSelection.nStartPara, aSelection.nStartPos ); + } + + SdFieldPopup aFieldPopup( pFldItem->GetField(), eLanguage ); + + if ( rCEvt.IsMouseEvent() ) + aMPos = rCEvt.GetMousePosPixel(); + else + aMPos = Point( 20, 20 ); + aFieldPopup.Execute( pWin, aMPos ); + + SvxFieldData* pField = aFieldPopup.GetField(); + if( pField ) + { + SvxFieldItem aFieldItem( *pField, EE_FEATURE_FIELD ); + //pOLV->DeleteSelected(); <-- fehlt leider ! + // Feld selektieren, so dass es beim Insert geloescht wird + ESelection aSel = pOLV->GetSelection(); + BOOL bSel = TRUE; + if( aSel.nStartPos == aSel.nEndPos ) + { + bSel = FALSE; + aSel.nEndPos++; + } + pOLV->SetSelection( aSel ); + + pOLV->InsertField( aFieldItem ); + + // Selektion wird wieder in den Ursprungszustand gebracht + if( !bSel ) + aSel.nEndPos--; + pOLV->SetSelection( aSel ); + + delete pField; + } + } + else + { + // ist etwas selektiert? + if (mpDrawView->AreObjectsMarked() && + mpDrawView->GetMarkedObjectList().GetMarkCount() == 1 ) + { + pObj = mpDrawView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(); + if( HasCurrentFunction(SID_BEZIER_EDIT) && (dynamic_cast< SdrPathObj * >( pObj ) != 0 ) ) + { + nSdResId = RID_BEZIER_POPUP; + } + else + { + if( mpDrawView->GetTextEditObject() ) + { + OutlinerView* pOutlinerView = mpDrawView->GetTextEditOutlinerView(); + Point aPos(rCEvt.GetMousePosPixel()); + + if ( pOutlinerView ) + { + if( ( rCEvt.IsMouseEvent() && pOutlinerView->IsWrongSpelledWordAtPos(aPos) ) || + ( !rCEvt.IsMouseEvent() && pOutlinerView->IsCursorAtWrongSpelledWord() ) ) + { + // #91457# Popup for Online-Spelling now handled by DrawDocShell + // Link aLink = LINK(GetDoc(), SdDrawDocument, OnlineSpellCallback); + Link aLink = LINK(GetDocSh(), DrawDocShell, OnlineSpellCallback); + + if( !rCEvt.IsMouseEvent() ) + { + aPos = GetActiveWindow()->LogicToPixel( pOutlinerView->GetEditView().GetCursor()->GetPos() ); + } + // While showing the spell context menu + // we lock the input so that another + // context menu can not be opened during + // that time (crash #i43235#). In order + // to not lock the UI completely we + // first release the mouse. + GetActiveWindow()->ReleaseMouse(); + LockInput(); + pOutlinerView->ExecuteSpellPopup(aPos, &aLink); + UnlockInput(); + } + else + { + if( (pObj->GetObjInventor() == SdrInventor) && (pObj->GetObjIdentifier() == OBJ_TABLE) ) + { + nSdResId = RID_DRAW_TABLEOBJ_INSIDE_POPUP; + } + else + { + nSdResId = RID_DRAW_TEXTOBJ_INSIDE_POPUP; + } + } + } + } + else + { + UINT32 nInv = pObj->GetObjInventor(); + UINT16 nId = pObj->GetObjIdentifier(); + + if (nInv == SdrInventor) + { + switch ( nId ) + { + case OBJ_CAPTION: + case OBJ_TITLETEXT: + case OBJ_OUTLINETEXT: + case OBJ_TEXT: + nSdResId = bGraphicShell ? RID_GRAPHIC_TEXTOBJ_POPUP : + RID_DRAW_TEXTOBJ_POPUP; + break; + + case OBJ_PATHLINE: + case OBJ_PLIN: + nSdResId = bGraphicShell ? RID_GRAPHIC_POLYLINEOBJ_POPUP : + RID_DRAW_POLYLINEOBJ_POPUP; + break; + + case OBJ_FREELINE: + case OBJ_EDGE: // Connector + nSdResId = bGraphicShell ? RID_GRAPHIC_EDGEOBJ_POPUP : + RID_DRAW_EDGEOBJ_POPUP; + break; + + case OBJ_LINE: + nSdResId = bGraphicShell ? RID_GRAPHIC_LINEOBJ_POPUP : + RID_DRAW_LINEOBJ_POPUP; + break; + + case OBJ_MEASURE: + nSdResId = bGraphicShell ? RID_GRAPHIC_MEASUREOBJ_POPUP : + RID_DRAW_MEASUREOBJ_POPUP; + break; + + case OBJ_RECT: + case OBJ_CIRC: + case OBJ_FREEFILL: + case OBJ_PATHFILL: + case OBJ_POLY: + case OBJ_SECT: + case OBJ_CARC: + case OBJ_CCUT: + nSdResId = bGraphicShell ? RID_GRAPHIC_GEOMOBJ_POPUP : + RID_DRAW_GEOMOBJ_POPUP; + break; + + case OBJ_CUSTOMSHAPE: + nSdResId = bGraphicShell ? RID_GRAPHIC_CUSTOMSHAPE_POPUP : + RID_DRAW_CUSTOMSHAPE_POPUP; + break; + + case OBJ_GRUP: + nSdResId = bGraphicShell ? RID_GRAPHIC_GROUPOBJ_POPUP : + RID_DRAW_GROUPOBJ_POPUP; + break; + + case OBJ_GRAF: + nSdResId = bGraphicShell ? RID_GRAPHIC_GRAPHIC_POPUP : + RID_DRAW_GRAPHIC_POPUP; + break; + + case OBJ_OLE2: + nSdResId = bGraphicShell ? RID_GRAPHIC_OLE2_POPUP : + RID_DRAW_OLE2_POPUP; + break; + case OBJ_MEDIA: + nSdResId = bGraphicShell ? RID_GRAPHIC_MEDIA_POPUP : + RID_DRAW_MEDIA_POPUP; + break; + case OBJ_TABLE: + nSdResId = bGraphicShell ? RID_GRAPHIC_TABLE_POPUP : + RID_DRAW_TABLE_POPUP; + break; + } + } + else if( nInv == E3dInventor /*&& nId == E3D_POLYSCENE_ID*/) + { + if( nId == E3D_POLYSCENE_ID || nId == E3D_SCENE_ID ) + { + if( !mpDrawView->IsGroupEntered() ) + nSdResId = bGraphicShell ? RID_GRAPHIC_3DSCENE_POPUP : + RID_DRAW_3DSCENE_POPUP; + else + nSdResId = bGraphicShell ? RID_GRAPHIC_3DSCENE2_POPUP : + RID_DRAW_3DSCENE2_POPUP; + } + else + nSdResId = bGraphicShell ? RID_GRAPHIC_3DOBJ_POPUP : + RID_DRAW_3DOBJ_POPUP; + } + else if( nInv == FmFormInventor ) + { + nSdResId = RID_FORM_CONTROL_POPUP; + } + } + } + } + + // Mehrfachselektion + else if (mpDrawView->AreObjectsMarked() && + mpDrawView->GetMarkedObjectList().GetMarkCount() > 1 ) + { + nSdResId = bGraphicShell ? RID_GRAPHIC_MULTISELECTION_POPUP : + RID_DRAW_MULTISELECTION_POPUP; + } + + // nichts selektiert + else + { + nSdResId = bGraphicShell ? RID_GRAPHIC_NOSEL_POPUP : + RID_DRAW_NOSEL_POPUP; + } + } + // Popup-Menue anzeigen + if (nSdResId) + { + GetActiveWindow()->ReleaseMouse(); + + if(rCEvt.IsMouseEvent()) + GetViewFrame()->GetDispatcher()->ExecutePopup(SdResId(nSdResId)); + else + { + //#106326# don't open contextmenu at mouse position if not opened via mouse + + //middle of the window if nothing is marked + Point aMenuPos(GetActiveWindow()->GetSizePixel().Width()/2 + ,GetActiveWindow()->GetSizePixel().Height()/2); + + //middle of the bounding rect if something is marked + if( mpDrawView->AreObjectsMarked() && mpDrawView->GetMarkedObjectList().GetMarkCount() >= 1 ) + { + Rectangle aMarkRect; + mpDrawView->GetMarkedObjectList().TakeBoundRect(NULL,aMarkRect); + aMenuPos = GetActiveWindow()->LogicToPixel( aMarkRect.Center() ); + + //move the point into the visible window area + if( aMenuPos.X() < 0 ) + aMenuPos.X() = 0; + if( aMenuPos.Y() < 0 ) + aMenuPos.Y() = 0; + if( aMenuPos.X() > GetActiveWindow()->GetSizePixel().Width() ) + aMenuPos.X() = GetActiveWindow()->GetSizePixel().Width(); + if( aMenuPos.Y() > GetActiveWindow()->GetSizePixel().Height() ) + aMenuPos.Y() = GetActiveWindow()->GetSizePixel().Height(); + } + + //open context menu at that point + GetViewFrame()->GetDispatcher()->ExecutePopup(SdResId(nSdResId),GetActiveWindow(),&aMenuPos); + } + mbMousePosFreezed = FALSE; + } + } + else + { + ViewShell::Command(rCEvt, pWin); + } + } +} + +/************************************************************************* +|* +|* Linealmarkierungen anzeigen +|* +\************************************************************************/ + +void DrawViewShell::ShowMousePosInfo(const Rectangle& rRect, + ::sd::Window* pWin) +{ + if (mbHasRulers && pWin ) + { + RulerLine pHLines[2]; + RulerLine pVLines[2]; + long nHOffs = 0L; + long nVOffs = 0L; + USHORT nCnt; + + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->SetLines(); + + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->SetLines(); + + if (mpHorizontalRuler.get() != NULL) + { + nHOffs = mpHorizontalRuler->GetNullOffset() + + mpHorizontalRuler->GetPageOffset(); + } + + if (mpVerticalRuler.get() != NULL) + { + nVOffs = mpVerticalRuler->GetNullOffset() + + mpVerticalRuler->GetPageOffset(); + } + + nCnt = 1; + pHLines[0].nPos = rRect.Left() - nHOffs; + pVLines[0].nPos = rRect.Top() - nVOffs; + pHLines[0].nStyle = 0; + pVLines[0].nStyle = 0; + + if ( rRect.Right() != rRect.Left() || rRect.Bottom() != rRect.Top() ) + { + pHLines[1].nPos = rRect.Right() - nHOffs; + pVLines[1].nPos = rRect.Bottom() - nVOffs; + pHLines[1].nStyle = 0; + pVLines[1].nStyle = 0; + nCnt++; + } + + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->SetLines(nCnt, pHLines); + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->SetLines(nCnt, pVLines); + } + + // StatusBar Koordinatenanzeige + OSL_ASSERT (GetViewShell()!=NULL); + if ( !GetViewShell()->GetUIActiveClient() ) + { + SfxItemSet aSet(GetPool(), SID_CONTEXT, SID_CONTEXT, + SID_ATTR_POSITION, SID_ATTR_POSITION, + SID_ATTR_SIZE, SID_ATTR_SIZE, + 0L); + +// GetStatusBarState(aSet); nicht performant bei gedrueckter Modifiertaste!! + + aSet.Put( SfxStringItem( SID_CONTEXT, mpDrawView->GetStatusText() ) ); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.SetState(aSet); + rBindings.Invalidate(SID_CONTEXT); + rBindings.Invalidate(SID_ATTR_POSITION); + rBindings.Invalidate(SID_ATTR_SIZE); + } +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void DrawViewShell::LockInput() +{ + mnLockCount++; +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void DrawViewShell::UnlockInput() +{ + DBG_ASSERT( mnLockCount, "Input for this shell is not locked!" ); + if ( mnLockCount ) + mnLockCount--; +} + + + + +void DrawViewShell::ShowSnapLineContextMenu ( + SdrPageView& rPageView, + const USHORT nSnapLineIndex, + const Point& rMouseLocation) +{ + const SdrHelpLine& rHelpLine (rPageView.GetHelpLines()[nSnapLineIndex]); + ::boost::scoped_ptr<PopupMenu> pMenu (new PopupMenu ()); + + if (rHelpLine.GetKind() == SDRHELPLINE_POINT) + { + pMenu->InsertItem( + SID_SET_SNAPITEM, + String(SdResId(STR_POPUP_EDIT_SNAPPOINT))); + pMenu->InsertSeparator(); + pMenu->InsertItem( + SID_DELETE_SNAPITEM, + String(SdResId(STR_POPUP_DELETE_SNAPPOINT))); + } + else + { + pMenu->InsertItem( + SID_SET_SNAPITEM, + String(SdResId(STR_POPUP_EDIT_SNAPLINE))); + pMenu->InsertSeparator(); + pMenu->InsertItem( + SID_DELETE_SNAPITEM, + String(SdResId(STR_POPUP_DELETE_SNAPLINE))); + } + + pMenu->RemoveDisabledEntries(FALSE, FALSE); + + const USHORT nResult = pMenu->Execute( + GetActiveWindow(), + Rectangle(rMouseLocation, Size(10,10)), + POPUPMENU_EXECUTE_DOWN); + switch (nResult) + { + case SID_SET_SNAPITEM: + { + SfxUInt32Item aHelpLineItem (ID_VAL_INDEX, nSnapLineIndex); + const SfxPoolItem* aArguments[] = {&aHelpLineItem, NULL}; + GetViewFrame()->GetDispatcher()->Execute( + SID_SET_SNAPITEM, + SFX_CALLMODE_SLOT, + aArguments); + } + break; + + case SID_DELETE_SNAPITEM: + { + rPageView.DeleteHelpLine(nSnapLineIndex); + } + break; + + default: + break; + } +} + + + + +#ifdef _MSC_VER +#pragma optimize ( "", on ) +#endif + +} // end of namespace sd diff --git a/sd/source/ui/view/drviews5.cxx b/sd/source/ui/view/drviews5.cxx new file mode 100644 index 000000000000..18ff686fc612 --- /dev/null +++ b/sd/source/ui/view/drviews5.cxx @@ -0,0 +1,746 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include "PresentationViewShell.hxx" +#include <editeng/outliner.hxx> +#ifndef _SVXIDS_HXX +#include <svx/svxids.hrc> +#endif +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/svdpagv.hxx> +#include <vcl/scrbar.hxx> +#include <tools/poly.hxx> +#include <svx/fmshell.hxx> +#include <editeng/eeitem.hxx> +#include <svtools/colorcfg.hxx> +#include "AccessibleDrawDocumentView.hxx" + +#include <sfx2/viewfrm.hxx> +#include "LayerTabBar.hxx" + +#include "strings.hrc" +#include "res_bmp.hrc" +#include "glob.hrc" +#include "app.hrc" + +#include "optsitem.hxx" +#include "app.hxx" +#include "FrameView.hxx" +#include "sdattr.hxx" +#include "futext.hxx" +#include "sdpage.hxx" +#include "stlpool.hxx" +#include "prntopts.hxx" +#include "sdresid.hxx" +#include "Window.hxx" +#include "drawview.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "Outliner.hxx" +#include "Client.hxx" +#include "slideshow.hxx" +#include "unokywds.hxx" +#include "SdUnoDrawView.hxx" +#include "ViewShellBase.hxx" +#include "FormShellManager.hxx" +#include "LayerDialogContent.hxx" +#include "DrawController.hxx" + +namespace sd { + +static const int TABCONTROL_INITIAL_SIZE = 350; +static const int PAPER_SHADOW_EXT_PIXEL = 2; + + +/************************************************************************* +|* +|* Wird gerufen, wenn sich das Model aendert +|* +\************************************************************************/ + +void DrawViewShell::ModelHasChanged() +{ + Invalidate(); + // Damit der Navigator auch einen aktuellen Status bekommt + GetViewFrame()->GetBindings().Invalidate( SID_NAVIGATOR_STATE, TRUE, FALSE ); + + //Update3DWindow(); + SfxBoolItem aItem( SID_3D_STATE, TRUE ); + GetViewFrame()->GetDispatcher()->Execute( + SID_3D_STATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); + + // jetzt den von der Drawing Engine neu erzeugten TextEditOutliner + // initialisieren + ::Outliner* pOutliner = mpDrawView->GetTextEditOutliner(); + if (pOutliner) + { + SfxStyleSheetPool* pSPool = (SfxStyleSheetPool*) GetDocSh()->GetStyleSheetPool(); + pOutliner->SetStyleSheetPool(pSPool); + } +} + + + + +void DrawViewShell::Resize (void) +{ + ViewShell::Resize(); + + if ( GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ) + { + SetZoomRect( GetDocSh()->GetVisArea(ASPECT_CONTENT) ); + } + + rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if( xSlideshow.is() && xSlideshow->isRunning() && !xSlideshow->isFullScreen() ) + { + xSlideshow->resize(maViewSize); + } +} + + + + +void DrawViewShell::ArrangeGUIElements (void) +{ + // Retrieve the current size (thickness) of the scroll bars. That is + // the width of the vertical and the height of the horizontal scroll + // bar. + int nScrollBarSize = + GetParentWindow()->GetSettings().GetStyleSettings().GetScrollBarSize(); + maScrBarWH = Size (nScrollBarSize, nScrollBarSize); + + Point aHPos = maViewPos; + aHPos.Y() += maViewSize.Height(); + + + ViewShell::ArrangeGUIElements (); + + maTabControl.Hide(); + + OSL_ASSERT (GetViewShell()!=NULL); + Client* pIPClient = static_cast<Client*>(GetViewShell()->GetIPClient()); + BOOL bClientActive = FALSE; + if ( pIPClient && pIPClient->IsObjectInPlaceActive() ) + bClientActive = TRUE; + + BOOL bInPlaceActive = GetViewFrame()->GetFrame().IsInPlace(); + + if ( mbZoomOnPage && !bInPlaceActive && !bClientActive ) + { + // bei Split immer erstes Fenster resizen + //af pWindow = mpContentWindow.get(); + SfxRequest aReq(SID_SIZE_PAGE, 0, GetDoc()->GetItemPool()); + ExecuteSlot( aReq ); + } +} + +/************************************************************************* +|* +|* Daten der FrameView auf die aktuelle View uebertragen +|* +\************************************************************************/ + +void DrawViewShell::ReadFrameViewData(FrameView* pView) +{ + ModifyGuard aGuard( GetDoc() ); + + // Diese Option wird am Model eingestellt + GetDoc()->SetPickThroughTransparentTextFrames( + SD_MOD()->GetSdOptions(GetDoc()->GetDocumentType())->IsPickThrough()); + + // Initialisierungen der Zeichen-(Bildschirm-)Attribute + if (HasRuler() != pView->HasRuler()) + SetRuler( pView->HasRuler() ); + + if (mpDrawView->GetGridCoarse() != pView->GetGridCoarse()) + mpDrawView->SetGridCoarse( pView->GetGridCoarse() ); + + if (mpDrawView->GetGridFine() != pView->GetGridFine()) + mpDrawView->SetGridFine( pView->GetGridFine() ); + + if (mpDrawView->GetSnapGridWidthX() != pView->GetSnapGridWidthX() || mpDrawView->GetSnapGridWidthY() != pView->GetSnapGridWidthY()) + mpDrawView->SetSnapGridWidth(pView->GetSnapGridWidthX(), pView->GetSnapGridWidthY()); + + if (mpDrawView->IsGridVisible() != pView->IsGridVisible()) + mpDrawView->SetGridVisible( pView->IsGridVisible() ); + + if (mpDrawView->IsGridFront() != pView->IsGridFront()) + mpDrawView->SetGridFront( pView->IsGridFront() ); + + if (mpDrawView->GetSnapAngle() != pView->GetSnapAngle()) + mpDrawView->SetSnapAngle( pView->GetSnapAngle() ); + + if (mpDrawView->IsGridSnap() != pView->IsGridSnap() ) + mpDrawView->SetGridSnap( pView->IsGridSnap() ); + + if (mpDrawView->IsBordSnap() != pView->IsBordSnap() ) + mpDrawView->SetBordSnap( pView->IsBordSnap() ); + + if (mpDrawView->IsHlplSnap() != pView->IsHlplSnap() ) + mpDrawView->SetHlplSnap( pView->IsHlplSnap() ); + + if (mpDrawView->IsOFrmSnap() != pView->IsOFrmSnap() ) + mpDrawView->SetOFrmSnap( pView->IsOFrmSnap() ); + + if (mpDrawView->IsOPntSnap() != pView->IsOPntSnap() ) + mpDrawView->SetOPntSnap( pView->IsOPntSnap() ); + + if (mpDrawView->IsOConSnap() != pView->IsOConSnap() ) + mpDrawView->SetOConSnap( pView->IsOConSnap() ); + + if (mpDrawView->IsHlplVisible() != pView->IsHlplVisible() ) + mpDrawView->SetHlplVisible( pView->IsHlplVisible() ); + + if (mpDrawView->IsDragStripes() != pView->IsDragStripes() ) + mpDrawView->SetDragStripes( pView->IsDragStripes() ); + + if (mpDrawView->IsPlusHandlesAlwaysVisible() != pView->IsPlusHandlesAlwaysVisible() ) + mpDrawView->SetPlusHandlesAlwaysVisible( pView->IsPlusHandlesAlwaysVisible() ); + + if (mpDrawView->GetSnapMagneticPixel() != pView->GetSnapMagneticPixel() ) + mpDrawView->SetSnapMagneticPixel( pView->GetSnapMagneticPixel() ); + + if (mpDrawView->IsMarkedHitMovesAlways() != pView->IsMarkedHitMovesAlways() ) + mpDrawView->SetMarkedHitMovesAlways( pView->IsMarkedHitMovesAlways() ); + + if (mpDrawView->IsMoveOnlyDragging() != pView->IsMoveOnlyDragging() ) + mpDrawView->SetMoveOnlyDragging( pView->IsMoveOnlyDragging() ); + +// mpDrawView->SetSlantButShear( pView->IsSlantButShear() ); + + if (mpDrawView->IsNoDragXorPolys() != pView->IsNoDragXorPolys() ) + mpDrawView->SetNoDragXorPolys( pView->IsNoDragXorPolys() ); + + if (mpDrawView->IsCrookNoContortion() != pView->IsCrookNoContortion() ) + mpDrawView->SetCrookNoContortion( pView->IsCrookNoContortion() ); + + if (mpDrawView->IsAngleSnapEnabled() != pView->IsAngleSnapEnabled() ) + mpDrawView->SetAngleSnapEnabled( pView->IsAngleSnapEnabled() ); + + if (mpDrawView->IsBigOrtho() != pView->IsBigOrtho() ) + mpDrawView->SetBigOrtho( pView->IsBigOrtho() ); + + if (mpDrawView->IsOrtho() != pView->IsOrtho() ) + mpDrawView->SetOrtho( pView->IsOrtho() ); + + if (mpDrawView->GetEliminatePolyPointLimitAngle() != pView->GetEliminatePolyPointLimitAngle() ) + mpDrawView->SetEliminatePolyPointLimitAngle( pView->GetEliminatePolyPointLimitAngle() ); + + if (mpDrawView->IsEliminatePolyPoints() != pView->IsEliminatePolyPoints() ) + mpDrawView->SetEliminatePolyPoints( pView->IsEliminatePolyPoints() ); + + if (mpDrawView->IsSolidMarkHdl() != pView->IsSolidMarkHdl() ) + mpDrawView->SetSolidMarkHdl( pView->IsSolidMarkHdl() ); + + if (mpDrawView->IsSolidDragging() != pView->IsSolidDragging() ) + mpDrawView->SetSolidDragging( pView->IsSolidDragging() ); + + if (mpDrawView->IsQuickTextEditMode() != pView->IsQuickEdit()) + mpDrawView->SetQuickTextEditMode( pView->IsQuickEdit() ); + + // #i26631# + if (mpDrawView->IsMasterPagePaintCaching() != pView->IsMasterPagePaintCaching()) + mpDrawView->SetMasterPagePaintCaching( pView->IsMasterPagePaintCaching() ); + + // Definition: + // grosse Handles: 9 + // kleine Handles: 7 + USHORT nTmp = mpDrawView->GetMarkHdlSizePixel(); + //DBG_ASSERT(nTmp != 7, "HandleSize != 7 oder 9"); + if( nTmp == 9 && !pView->IsBigHandles() ) + mpDrawView->SetMarkHdlSizePixel( 7 ); + else if( nTmp == 7 && pView->IsBigHandles() ) + mpDrawView->SetMarkHdlSizePixel( 9 ); + + + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + if (pPageView) + { + if ( pPageView->GetVisibleLayers() != pView->GetVisibleLayers() ) + pPageView->SetVisibleLayers( pView->GetVisibleLayers() ); + + if ( pPageView->GetPrintableLayers() != pView->GetPrintableLayers() ) + pPageView->SetPrintableLayers( pView->GetPrintableLayers() ); + + if ( pPageView->GetLockedLayers() != pView->GetLockedLayers() ) + pPageView->SetLockedLayers( pView->GetLockedLayers() ); + + if (mePageKind == PK_NOTES) + { + if (pPageView->GetHelpLines() != pView->GetNotesHelpLines()) + pPageView->SetHelpLines( pView->GetNotesHelpLines() ); + } + else if (mePageKind == PK_HANDOUT) + { + if (pPageView->GetHelpLines() != pView->GetHandoutHelpLines()) + pPageView->SetHelpLines( pView->GetHandoutHelpLines() ); + } + else + { + if (pPageView->GetHelpLines() != pView->GetStandardHelpLines()) + pPageView->SetHelpLines( pView->GetStandardHelpLines() ); + } + } + + if ( mpDrawView->GetActiveLayer() != pView->GetActiveLayer() ) + mpDrawView->SetActiveLayer( pView->GetActiveLayer() ); + + USHORT nSelectedPage = 0; + + if (mePageKind != PK_HANDOUT) + { + nSelectedPage = pView->GetSelectedPage(); + } + + EditMode eNewEditMode = pView->GetViewShEditMode(mePageKind); + BOOL bNewLayerMode = pView->IsLayerMode(); + ChangeEditMode(eNewEditMode, bNewLayerMode); + SwitchPage(nSelectedPage); + + // DrawMode fuer 'Normales' Fenster wiederherstellen + if(GetActiveWindow()->GetDrawMode() != pView->GetDrawMode()) + GetActiveWindow()->SetDrawMode(pView->GetDrawMode()); + + if ( mpDrawView->IsDesignMode() != pView->IsDesignMode() ) + { + SfxBoolItem aDesignModeItem( SID_FM_DESIGN_MODE, pView->IsDesignMode() ); + GetViewFrame()->GetDispatcher()->Execute( SID_FM_DESIGN_MODE, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD, &aDesignModeItem, 0L ); + } + + // Muss am Ende gerufen werden, da ein WriteFrameViewData() ausgeloest wird + if (mpDrawView->IsFrameDragSingles() != pView->IsFrameDragSingles() ) + mpDrawView->SetFrameDragSingles( pView->IsFrameDragSingles() ); +} + +/************************************************************************* +|* +|* Daten der aktuellen View auf die FrameView uebertragen +|* +\************************************************************************/ + +void DrawViewShell::WriteFrameViewData() +{ + // Zeichen-(Bildschirm-)Attribute an FrameView merken + mpFrameView->SetRuler( HasRuler() ); + mpFrameView->SetGridCoarse( mpDrawView->GetGridCoarse() ); + mpFrameView->SetGridFine( mpDrawView->GetGridFine() ); + mpFrameView->SetSnapGridWidth(mpDrawView->GetSnapGridWidthX(), mpDrawView->GetSnapGridWidthY()); + mpFrameView->SetGridVisible( mpDrawView->IsGridVisible() ); + mpFrameView->SetGridFront( mpDrawView->IsGridFront() ); + mpFrameView->SetSnapAngle( mpDrawView->GetSnapAngle() ); + mpFrameView->SetGridSnap( mpDrawView->IsGridSnap() ); + mpFrameView->SetBordSnap( mpDrawView->IsBordSnap() ); + mpFrameView->SetHlplSnap( mpDrawView->IsHlplSnap() ); + mpFrameView->SetOFrmSnap( mpDrawView->IsOFrmSnap() ); + mpFrameView->SetOPntSnap( mpDrawView->IsOPntSnap() ); + mpFrameView->SetOConSnap( mpDrawView->IsOConSnap() ); + mpFrameView->SetHlplVisible( mpDrawView->IsHlplVisible() ); + mpFrameView->SetDragStripes( mpDrawView->IsDragStripes() ); + mpFrameView->SetPlusHandlesAlwaysVisible( mpDrawView->IsPlusHandlesAlwaysVisible() ); + mpFrameView->SetFrameDragSingles( mpDrawView->IsFrameDragSingles() ); + mpFrameView->SetMarkedHitMovesAlways( mpDrawView->IsMarkedHitMovesAlways() ); + mpFrameView->SetMoveOnlyDragging( mpDrawView->IsMoveOnlyDragging() ); + mpFrameView->SetNoDragXorPolys( mpDrawView->IsNoDragXorPolys() ); + mpFrameView->SetCrookNoContortion( mpDrawView->IsCrookNoContortion() ); + mpFrameView->SetBigOrtho( mpDrawView->IsBigOrtho() ); + mpFrameView->SetEliminatePolyPointLimitAngle( mpDrawView->GetEliminatePolyPointLimitAngle() ); + mpFrameView->SetEliminatePolyPoints( mpDrawView->IsEliminatePolyPoints() ); + + mpFrameView->SetSolidMarkHdl( mpDrawView->IsSolidMarkHdl() ); + mpFrameView->SetSolidDragging( mpDrawView->IsSolidDragging() ); + mpFrameView->SetQuickEdit( mpDrawView->IsQuickTextEditMode() ); + + mpFrameView->SetDesignMode( mpDrawView->IsDesignMode() ); + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisArea = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + mpFrameView->SetVisArea(aVisArea); + + if( mePageKind == PK_HANDOUT ) + mpFrameView->SetSelectedPage(0); + else + { + mpFrameView->SetSelectedPage( maTabControl.GetCurPageId() - 1 ); + } + + mpFrameView->SetViewShEditMode(meEditMode, mePageKind); + mpFrameView->SetLayerMode(IsLayerModeActive()); + + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + + if (pPageView) + { + if ( mpFrameView->GetVisibleLayers() != pPageView->GetVisibleLayers() ) + mpFrameView->SetVisibleLayers( pPageView->GetVisibleLayers() ); + + if ( mpFrameView->GetPrintableLayers() != pPageView->GetPrintableLayers() ) + mpFrameView->SetPrintableLayers( pPageView->GetPrintableLayers() ); + + if ( mpFrameView->GetLockedLayers() != pPageView->GetLockedLayers() ) + mpFrameView->SetLockedLayers( pPageView->GetLockedLayers() ); + + if (mePageKind == PK_NOTES) + { + mpFrameView->SetNotesHelpLines( pPageView->GetHelpLines() ); + } + else if (mePageKind == PK_HANDOUT) + { + mpFrameView->SetHandoutHelpLines( pPageView->GetHelpLines() ); + } + else + { + mpFrameView->SetStandardHelpLines( pPageView->GetHelpLines() ); + } + } + + if ( mpFrameView->GetActiveLayer() != mpDrawView->GetActiveLayer() ) + mpFrameView->SetActiveLayer( mpDrawView->GetActiveLayer() ); + + // DrawMode fuer 'Normales' Fenster merken + if(mpFrameView->GetDrawMode() != GetActiveWindow()->GetDrawMode()) + mpFrameView->SetDrawMode(GetActiveWindow()->GetDrawMode()); +} + + + +/************************************************************************* +|* +|* PrePaint-Method +|* +\************************************************************************/ + +void DrawViewShell::PrePaint() +{ + mpDrawView->PrePaint(); +} + +/************************************************************************* +|* +|* Paint-Methode: das Ereignis wird vom Fenster pWin an +|* die Viewshell und die aktuelle Funktion weitergeleitet +|* +|* Anmerkung: pWin==NULL, wenn Paint() vom ShowWindow gerufen wird! +|* +\************************************************************************/ + +void DrawViewShell::Paint(const Rectangle& rRect, ::sd::Window* pWin) +{ + // #103834# Fill var FillColor here to have it available on later call + svtools::ColorConfig aColorConfig; + Color aFillColor; + + if(DOCUMENT_TYPE_IMPRESS == GetDoc()->GetDocumentType()) + { + aFillColor = Color( aColorConfig.GetColorValue( svtools::APPBACKGROUND ).nColor ); + } + else + { + aFillColor = Color( aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor ); + } + + /* #97517# This is done before each text edit, so why not do it before every paint. + The default language is only used if the outliner only contains one + character in a symbol font */ + GetDoc()->GetDrawOutliner( NULL ).SetDefaultLanguage( GetDoc()->GetLanguage( EE_CHAR_LANGUAGE ) ); + + // #103834# Set Application Background color for usage in SdrPaintView(s) + mpDrawView->SetApplicationBackgroundColor(aFillColor); + + /* #97517# This is done before each text edit, so why not do it before every paint. + The default language is only used if the outliner only contains one + character in a symbol font */ + GetDoc()->GetDrawOutliner( NULL ).SetDefaultLanguage( Application::GetSettings().GetLanguage() ); + + mpDrawView->CompleteRedraw( pWin, Region( rRect ) ); + + if( pWin ) + { + if( GetDocSh()->GetDocShellFunction().is() ) + GetDocSh()->GetDocShellFunction()->Paint( rRect, pWin ); + + if( HasCurrentFunction() ) + GetCurrentFunction()->Paint( rRect, pWin ); + } +} + +/************************************************************************* +|* +|* Zoom-Faktor fuer InPlace einstellen +|* +\************************************************************************/ + +void DrawViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction& rZoomY) +{ + ViewShell::SetZoomFactor(rZoomX, rZoomY); + mbZoomOnPage = FALSE; + Point aOrigin = GetActiveWindow()->GetViewOrigin(); + GetActiveWindow()->SetWinViewPos(aOrigin); +} + +/************************************************************************* +|* +|* Optimale Groesse zurueckgeben +|* +\************************************************************************/ + +Size DrawViewShell::GetOptimalSizePixel() const +{ + Size aSize; + + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + if (pPV) + { + SdPage* pPage = (SdPage*) pPV->GetPage(); + + if (pPage) + { + if (!mbZoomOnPage) + { + // Gegenwaertigen MapMode beruecksichtigen + aSize = GetActiveWindow()->LogicToPixel( pPage->GetSize() ); + } + else + { + // 1:1 Darstellung + MapMode aMapMode(MAP_100TH_MM); + aSize = GetActiveWindow()->LogicToPixel( pPage->GetSize(), aMapMode ); + const_cast< DrawViewShell* >(this)->mbZoomOnPage = TRUE; + } + } + } + + return(aSize); +} + + +/************************************************************************* +|* +|* Seite wird gehided +|* +\************************************************************************/ + +void DrawViewShell::HidePage() +{ + FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell(); + if (pFormShell != NULL) + pFormShell->PrepareClose (FALSE); +} + + + +void DrawViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse ) +{ + WriteFrameViewData(); + + ViewShell::WriteUserDataSequence( rSequence, bBrowse ); + + const sal_Int32 nIndex = rSequence.getLength(); + rSequence.realloc( nIndex + 1 ); + rSequence[nIndex].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_ZoomOnPage ) ); + rSequence[nIndex].Value <<= (sal_Bool)mbZoomOnPage; +} + +void DrawViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse ) +{ + WriteFrameViewData(); + + ViewShell::ReadUserDataSequence( rSequence, bBrowse ); + + const sal_Int32 nLength = rSequence.getLength(); + const com::sun::star::beans::PropertyValue *pValue = rSequence.getConstArray(); + for (sal_Int16 i = 0 ; i < nLength; i++, pValue++ ) + { + if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_ZoomOnPage ) ) ) + { + sal_Bool bZoomPage = sal_False; + if( pValue->Value >>= bZoomPage ) + { + mbZoomOnPage = bZoomPage; + } + } + } + + if( mpFrameView->GetPageKind() != mePageKind ) + { + mePageKind = mpFrameView->GetPageKind(); + + if (mePageKind == PK_NOTES) + { + SetHelpId( SID_NOTESMODE ); + GetActiveWindow()->SetHelpId( SID_NOTESMODE ); + GetActiveWindow()->SetUniqueId( SID_NOTESMODE ); + } + else if (mePageKind == PK_HANDOUT) + { + SetHelpId( SID_HANDOUTMODE ); + GetActiveWindow()->SetHelpId( SID_HANDOUTMODE ); + GetActiveWindow()->SetUniqueId( SID_HANDOUTMODE ); + } + else + { + SetHelpId( SD_IF_SDDRAWVIEWSHELL ); + GetActiveWindow()->SetHelpId( SD_IF_SDDRAWVIEWSHELL ); + GetActiveWindow()->SetUniqueId( SD_IF_SDDRAWVIEWSHELL ); + } + } + + ReadFrameViewData( mpFrameView ); + + if( !mbZoomOnPage ) + { + const Rectangle aVisArea( mpFrameView->GetVisArea() ); + + if ( GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ) + { + GetDocSh()->SetVisArea(aVisArea); + } + + VisAreaChanged(aVisArea); + + ::sd::View* pView = GetView(); + + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } + + SetZoomRect(aVisArea); + } + + ChangeEditMode (meEditMode, ! IsLayerModeActive()); + ChangeEditMode (meEditMode, ! IsLayerModeActive()); +} + +void DrawViewShell::VisAreaChanged(const Rectangle& rRect) +{ + ViewShell::VisAreaChanged( rRect ); + + DrawController& rController = GetViewShellBase().GetDrawController(); + rController.FireVisAreaChanged (rRect); +} + + + + +/** If there is a valid controller then create a new instance of + <type>AccessibleDrawDocumentView</type>. Otherwise delegate this call + to the base class to return a default object (probably an empty + reference). +*/ +::com::sun::star::uno::Reference< + ::com::sun::star::accessibility::XAccessible> + DrawViewShell::CreateAccessibleDocumentView (::sd::Window* pWindow) +{ + if (GetViewShellBase().GetController() != NULL) + { + accessibility::AccessibleDrawDocumentView* pDocumentView = + new accessibility::AccessibleDrawDocumentView ( + pWindow, + this, + GetViewShellBase().GetController(), + pWindow->GetAccessibleParentWindow()->GetAccessible()); + pDocumentView->Init(); + return ::com::sun::star::uno::Reference< + ::com::sun::star::accessibility::XAccessible> + (static_cast< ::com::sun::star::uno::XWeak*>(pDocumentView), + ::com::sun::star::uno::UNO_QUERY); + } + else + { + OSL_TRACE ("DrawViewShell::CreateAccessibleDocumentView: no controller"); + return ViewShell::CreateAccessibleDocumentView (pWindow); + } +} + + + + +int DrawViewShell::GetActiveTabLayerIndex (void) const +{ + const LayerTabBar* pBar + = const_cast<DrawViewShell*>(this)->GetLayerTabControl (); + if (pBar != NULL) + return pBar->GetPagePos (pBar->GetCurPageId()); + else + return -1; +} + + + + +void DrawViewShell::SetActiveTabLayerIndex (int nIndex) +{ + LayerTabBar* pBar = GetLayerTabControl (); + if (pBar != NULL) + { + // Ignore invalid indices silently. + if (nIndex>=0 && nIndex<pBar->GetPageCount()) + { + // Tell the draw view and the tab control of the new active layer. + mpDrawView->SetActiveLayer (pBar->GetPageText (pBar->GetPageId ((USHORT)nIndex))); + pBar->SetCurPageId (pBar->GetPageId ((USHORT)nIndex)); + } + } +} + + + + +TabControl* DrawViewShell::GetPageTabControl (void) +{ + return &maTabControl; +} + + + + +LayerTabBar* DrawViewShell::GetLayerTabControl (void) +{ + return mpLayerTabBar.get(); +} + + + + +int DrawViewShell::GetTabLayerCount (void) const +{ + const LayerTabBar* pBar + = const_cast<DrawViewShell*>(this)->GetLayerTabControl (); + if (pBar != NULL) + return pBar->GetPageCount(); + else + return 0; +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/drviews6.cxx b/sd/source/ui/view/drviews6.cxx new file mode 100755 index 000000000000..681192ff351b --- /dev/null +++ b/sd/source/ui/view/drviews6.cxx @@ -0,0 +1,742 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include <vcl/metaact.hxx> +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <vcl/msgbox.hxx> +#include <sfx2/viewfrm.hxx> +#include <svx/svdograf.hxx> +#ifndef _SVXIDS_HXX +#include <svx/svxids.hrc> +#endif +#ifndef _FONTWORK_HXX +#include <svx/fontwork.hxx> +#endif +#ifndef _BMPMASK_HXX +#include <svx/bmpmask.hxx> +#endif +#ifndef _SVX_GALBRWS_HXX +#include <svx/galbrws.hxx> +#endif +#ifndef _IMAPDLG_HXX +#include <svx/imapdlg.hxx> +#endif +#include <svx/xftsfit.hxx> +#include <svx/colrctrl.hxx> +#include <svx/f3dchild.hxx> +#include "optsitem.hxx" +#include <svx/extrusionbar.hxx> +#include <svx/fontworkbar.hxx> +#include <svx/tbxcustomshapes.hxx> +#ifndef _AVMEDIA_MEDIAPLAYER_HXX +#include <avmedia/mediaplayer.hxx> +#endif + +#include "app.hrc" +#include "strings.hrc" +#include "glob.hrc" + +#include "app.hxx" +#include "animobjs.hxx" +#include "AnimationChildWindow.hxx" +#include "NavigatorChildWindow.hxx" +#include "LayerDialogChildWindow.hxx" +#include "sdresid.hxx" +#include "fupoor.hxx" +#include "fusldlg.hxx" +#include "drawdoc.hxx" +#include "fuexpand.hxx" +#include "fusumry.hxx" +#include "fucushow.hxx" +#include "drawview.hxx" +#include "FrameView.hxx" +#include "Window.hxx" +#include "DrawDocShell.hxx" +#include "framework/FrameworkHelper.hxx" + +namespace sd { + +/************************************************************************* +|* +|* SfxRequests fuer FontWork bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecFormText(SfxRequest& rReq) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if(HasCurrentFunction(SID_PRESENTATION)) + return; + + CheckLineTo (rReq); + + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + + if ( rMarkList.GetMarkCount() == 1 && rReq.GetArgs() && + mpDrawView && !mpDrawView->IsPresObjSelected() ) + { + const SfxItemSet& rSet = *rReq.GetArgs(); + const SfxPoolItem* pItem; + + if ( mpDrawView->IsTextEdit() ) + mpDrawView->SdrEndTextEdit(); + + if ( rSet.GetItemState(XATTR_FORMTXTSTDFORM, TRUE, &pItem) == + SFX_ITEM_SET && + ((const XFormTextStdFormItem*) pItem)->GetValue() != XFTFORM_NONE ) + { + + USHORT nId = SvxFontWorkChildWindow::GetChildWindowId(); + + SvxFontWorkDialog* pDlg = (SvxFontWorkDialog*)GetViewFrame()-> + GetChildWindow(nId)->GetWindow(); + + pDlg->CreateStdFormObj(*mpDrawView, *mpDrawView->GetSdrPageView(), + rSet, *rMarkList.GetMark(0)->GetMarkedSdrObj(), + ((const XFormTextStdFormItem*) pItem)-> + GetValue()); + + if(HasCurrentFunction(SID_BEZIER_EDIT)) + { // ggf. die richtige Editfunktion aktivieren + GetViewFrame()->GetDispatcher()->Execute(SID_SWITCH_POINTEDIT, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + } + } + else + mpDrawView->SetAttributes(rSet); + } +} + +/************************************************************************* +|* +|* Statuswerte fuer FontWork zurueckgeben +|* +\************************************************************************/ + +void DrawViewShell::GetFormTextState(SfxItemSet& rSet) +{ + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + const SdrObject* pObj = NULL; + SvxFontWorkDialog* pDlg = NULL; + + USHORT nId = SvxFontWorkChildWindow::GetChildWindowId(); + + if ( GetViewFrame()->HasChildWindow(nId) ) + pDlg = (SvxFontWorkDialog*)(GetViewFrame()->GetChildWindow(nId)->GetWindow()); + + if ( rMarkList.GetMarkCount() == 1 ) + pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + + if ( pObj == NULL || !pObj->ISA(SdrTextObj) || + !((SdrTextObj*) pObj)->HasText() ) + { +// automatisches Auf/Zuklappen des FontWork-Dialog; erstmal deaktiviert +// if ( pDlg ) +// pDlg->SetActive(FALSE); + + rSet.DisableItem(XATTR_FORMTXTSTYLE); + rSet.DisableItem(XATTR_FORMTXTADJUST); + rSet.DisableItem(XATTR_FORMTXTDISTANCE); + rSet.DisableItem(XATTR_FORMTXTSTART); + rSet.DisableItem(XATTR_FORMTXTMIRROR); + rSet.DisableItem(XATTR_FORMTXTSTDFORM); + rSet.DisableItem(XATTR_FORMTXTHIDEFORM); + rSet.DisableItem(XATTR_FORMTXTOUTLINE); + rSet.DisableItem(XATTR_FORMTXTSHADOW); + rSet.DisableItem(XATTR_FORMTXTSHDWCOLOR); + rSet.DisableItem(XATTR_FORMTXTSHDWXVAL); + rSet.DisableItem(XATTR_FORMTXTSHDWYVAL); + } + else + { + if ( pDlg ) + { +// pDlg->SetActive(); + pDlg->SetColorTable(GetDoc()->GetColorTable()); + } + + SfxItemSet aSet( GetDoc()->GetPool() ); + mpDrawView->GetAttributes( aSet ); + rSet.Set( aSet ); + } +} + +/************************************************************************* +|* +|* SfxRequests fuer Animator bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecAnimationWin( SfxRequest& rReq ) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if (HasCurrentFunction(SID_PRESENTATION)) + return; + + CheckLineTo (rReq); + + USHORT nSId = rReq.GetSlot(); + + switch( nSId ) + { + case SID_ANIMATOR_INIT: + case SID_ANIMATOR_ADD: + case SID_ANIMATOR_CREATE: + { + AnimationWindow* pAnimWin; + USHORT nId = AnimationChildWindow::GetChildWindowId(); + //((const SfxUInt16Item&)(rReq.GetArgs()->Get(nSId))).GetValue(); + + pAnimWin = static_cast<AnimationWindow*>( + GetViewFrame()->GetChildWindow(nId)->GetWindow()); + + if ( pAnimWin ) + { + if( nSId == SID_ANIMATOR_ADD ) + pAnimWin->AddObj( *mpDrawView ); + else if( nSId == SID_ANIMATOR_CREATE ) + pAnimWin->CreateAnimObj( *mpDrawView ); + } + } + break; + + default: + break; + } +} + +/************************************************************************* +|* +|* Statuswerte fuer Animator zurueckgeben +|* +|* nValue == 0 -> Kein Button +|* nValue == 1 -> Button 'uebernehmen' +|* nValue == 2 -> Button 'einzeln uebernehmen' +|* nValue == 3 -> Buttons 'uebernehmen' und 'einzeln uebernehmen' +|* +\************************************************************************/ + +void DrawViewShell::GetAnimationWinState( SfxItemSet& rSet ) +{ + // Hier koennten Buttons etc. disabled werden + UINT16 nValue; + + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + ULONG nMarkCount = rMarkList.GetMarkCount(); + + if( nMarkCount == 0 ) + nValue = 0; + else if( nMarkCount > 1 ) + nValue = 3; + else // 1 Objekt + { + const SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + UINT32 nInv = pObj->GetObjInventor(); + UINT16 nId = pObj->GetObjIdentifier(); + // 1 selektiertes Gruppenobjekt + if( nInv == SdrInventor && nId == OBJ_GRUP ) + nValue = 3; + else if( nInv == SdrInventor && nId == OBJ_GRAF ) // Anim. GIF ? + { + USHORT nCount = 0; + + if( ( (SdrGrafObj*) pObj )->IsAnimated() ) + nCount = ( (SdrGrafObj*) pObj )->GetGraphic().GetAnimation().Count(); + if( nCount > 0 ) + nValue = 2; + else + nValue = 1; + } + else + nValue = 1; + } + rSet.Put( SfxUInt16Item( SID_ANIMATOR_STATE, nValue ) ); +} + +/************************************************************************* +|* +|* Statuswerte fuer SfxChildWindows setzen +|* +\************************************************************************/ + +void DrawViewShell::SetChildWindowState( SfxItemSet& rSet ) +{ + // Stati der SfxChild-Windows (Animator, Fontwork etc.) + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_FONTWORK ) ) + { + USHORT nId = SvxFontWorkChildWindow::GetChildWindowId(); + rSet.Put(SfxBoolItem(SID_FONTWORK, GetViewFrame()->HasChildWindow(nId))); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_COLOR_CONTROL ) ) + { + USHORT nId = SvxColorChildWindow::GetChildWindowId(); + rSet.Put(SfxBoolItem(SID_COLOR_CONTROL, GetViewFrame()->HasChildWindow(nId))); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ANIMATION_OBJECTS ) ) + { + USHORT nId = AnimationChildWindow::GetChildWindowId(); + rSet.Put( SfxBoolItem( SID_ANIMATION_OBJECTS, GetViewFrame()->HasChildWindow( nId ) ) ); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_NAVIGATOR ) ) + { + USHORT nId = SID_NAVIGATOR; + rSet.Put( SfxBoolItem( SID_NAVIGATOR, GetViewFrame()->HasChildWindow( nId ) ) ); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_BMPMASK ) ) + { + USHORT nId = SvxBmpMaskChildWindow::GetChildWindowId(); + rSet.Put( SfxBoolItem( SID_BMPMASK, GetViewFrame()->HasChildWindow( nId ) ) ); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GALLERY ) ) + { + USHORT nId = GalleryChildWindow::GetChildWindowId(); + rSet.Put( SfxBoolItem( SID_GALLERY, GetViewFrame()->HasChildWindow( nId ) ) ); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_IMAP ) ) + { + USHORT nId = SvxIMapDlgChildWindow::GetChildWindowId(); + rSet.Put( SfxBoolItem( SID_IMAP, GetViewFrame()->HasChildWindow( nId ) ) ); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_LAYER_DIALOG_WIN ) ) + { + USHORT nId = LayerDialogChildWindow::GetChildWindowId(); + rSet.Put( SfxBoolItem( SID_LAYER_DIALOG_WIN, GetViewFrame()->HasChildWindow( nId ) ) ); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_3D_WIN ) ) + { + USHORT nId = Svx3DChildWindow::GetChildWindowId(); + rSet.Put( SfxBoolItem( SID_3D_WIN, GetViewFrame()->HasChildWindow( nId ) ) ); + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_AVMEDIA_PLAYER ) ) + { + USHORT nId = ::avmedia::MediaPlayer::GetChildWindowId(); + rSet.Put( SfxBoolItem( SID_AVMEDIA_PLAYER, GetViewFrame()->HasChildWindow( nId ) ) ); + } +} + + +/************************************************************************* +|* +|* SfxRequests fuer Pipette bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecBmpMask( SfxRequest& rReq ) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if (HasCurrentFunction(SID_PRESENTATION)) + return; + + switch ( rReq.GetSlot() ) + { + case ( SID_BMPMASK_PIPETTE ) : + { + mbPipette = ( (const SfxBoolItem&) ( rReq.GetArgs()-> + Get( SID_BMPMASK_PIPETTE ) ) ).GetValue(); + } + break; + + case ( SID_BMPMASK_EXEC ) : + { + SdrGrafObj* pObj = 0; + if( mpDrawView && mpDrawView->GetMarkedObjectList().GetMarkCount() ) + pObj = dynamic_cast< SdrGrafObj* >( mpDrawView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj() ); + + if ( pObj && !mpDrawView->IsTextEdit() ) + { + SdrGrafObj* pNewObj = (SdrGrafObj*) pObj->Clone(); + BOOL bCont = TRUE; + + if( pNewObj->IsLinkedGraphic() ) + { + QueryBox aQBox( (Window*) GetActiveWindow(), WB_YES_NO | WB_DEF_YES, + String( SdResId( STR_RELEASE_GRAPHICLINK ) ) ); + + if( RET_YES == aQBox.Execute() ) + pNewObj->ReleaseGraphicLink(); + else + { + delete pNewObj; + bCont = FALSE; + } + } + + if( bCont ) + { + const Graphic& rOldGraphic = pNewObj->GetGraphic(); + const Graphic aNewGraphic( ( (SvxBmpMask*) GetViewFrame()->GetChildWindow( + SvxBmpMaskChildWindow::GetChildWindowId() )->GetWindow() )-> + Mask( rOldGraphic ) ); + + if( aNewGraphic != rOldGraphic ) + { + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + + pNewObj->SetEmptyPresObj( FALSE ); + pNewObj->SetGraphic( ( (SvxBmpMask*) GetViewFrame()->GetChildWindow( + SvxBmpMaskChildWindow::GetChildWindowId() )->GetWindow() )-> + Mask( pNewObj->GetGraphic() ) ); + + String aStr( mpDrawView->GetDescriptionOfMarkedObjects() ); + aStr += (sal_Unicode)( ' ' ), aStr += String( SdResId( STR_EYEDROPPER ) ); + + mpDrawView->BegUndo( aStr ); + mpDrawView->ReplaceObjectAtView( pObj, *pPV, pNewObj ); + mpDrawView->EndUndo(); + } + } + } + } + break; + + default: + break; + } +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void DrawViewShell::GetBmpMaskState( SfxItemSet& rSet ) +{ + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + const SdrObject* pObj = NULL; + USHORT nId = SvxBmpMaskChildWindow::GetChildWindowId(); + SvxBmpMask* pDlg = NULL; + BOOL bEnable = FALSE; + + if ( GetViewFrame()->HasChildWindow( nId ) ) + { + pDlg = (SvxBmpMask*) ( GetViewFrame()->GetChildWindow( nId )->GetWindow() ); + + if ( pDlg->NeedsColorTable() ) + pDlg->SetColorTable( GetDoc()->GetColorTable() ); + } + + if ( rMarkList.GetMarkCount() == 1 ) + pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + + // valid graphic object? + if( pObj && pObj->ISA( SdrGrafObj ) && !( (SdrGrafObj*) pObj )->IsEPS() && !mpDrawView->IsTextEdit() ) + bEnable = TRUE; + + // put value + rSet.Put( SfxBoolItem( SID_BMPMASK_EXEC, bEnable ) ); +} + +/************************************************************************* +|* +|* SfxRequests fuer temporaere Funktionen +|* +\************************************************************************/ + +void DrawViewShell::FuTemp04(SfxRequest& rReq) +{ + USHORT nSId = rReq.GetSlot(); + switch( nSId ) + { + case SID_FONTWORK: + { + if ( rReq.GetArgs() ) + { + GetViewFrame()->SetChildWindow(SvxFontWorkChildWindow::GetChildWindowId(), + ((const SfxBoolItem&) (rReq.GetArgs()-> + Get(SID_FONTWORK))).GetValue()); + } + else + { + GetViewFrame()->ToggleChildWindow( SvxFontWorkChildWindow::GetChildWindowId() ); + } + + GetViewFrame()->GetBindings().Invalidate(SID_FONTWORK); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_COLOR_CONTROL: + { + if ( rReq.GetArgs() ) + GetViewFrame()->SetChildWindow(SvxColorChildWindow::GetChildWindowId(), + ((const SfxBoolItem&) (rReq.GetArgs()-> + Get(SID_COLOR_CONTROL))).GetValue()); + else + GetViewFrame()->ToggleChildWindow(SvxColorChildWindow::GetChildWindowId() ); + + GetViewFrame()->GetBindings().Invalidate(SID_COLOR_CONTROL); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_EXTRUSION_TOOGLE: + case SID_EXTRUSION_TILT_DOWN: + case SID_EXTRUSION_TILT_UP: + case SID_EXTRUSION_TILT_LEFT: + case SID_EXTRUSION_TILT_RIGHT: + case SID_EXTRUSION_3D_COLOR: + case SID_EXTRUSION_DEPTH: + case SID_EXTRUSION_DIRECTION: + case SID_EXTRUSION_PROJECTION: + case SID_EXTRUSION_LIGHTING_DIRECTION: + case SID_EXTRUSION_LIGHTING_INTENSITY: + case SID_EXTRUSION_SURFACE: + case SID_EXTRUSION_DEPTH_FLOATER: + case SID_EXTRUSION_DIRECTION_FLOATER: + case SID_EXTRUSION_LIGHTING_FLOATER: + case SID_EXTRUSION_SURFACE_FLOATER: + case SID_EXTRUSION_DEPTH_DIALOG: + svx::ExtrusionBar::execute( mpDrawView, rReq, GetViewFrame()->GetBindings() ); + Cancel(); + rReq.Ignore (); + break; + + case SID_FONTWORK_SHAPE: + case SID_FONTWORK_SHAPE_TYPE: + case SID_FONTWORK_ALIGNMENT: + case SID_FONTWORK_SAME_LETTER_HEIGHTS: + case SID_FONTWORK_CHARACTER_SPACING: + case SID_FONTWORK_KERN_CHARACTER_PAIRS: + case SID_FONTWORK_GALLERY_FLOATER: + case SID_FONTWORK_CHARACTER_SPACING_FLOATER: + case SID_FONTWORK_ALIGNMENT_FLOATER: + case SID_FONTWORK_CHARACTER_SPACING_DIALOG: + svx::FontworkBar::execute( mpDrawView, rReq, GetViewFrame()->GetBindings() ); + Cancel(); + rReq.Ignore (); + break; + + case SID_BMPMASK: + { + GetViewFrame()->ToggleChildWindow( SvxBmpMaskChildWindow::GetChildWindowId() ); + GetViewFrame()->GetBindings().Invalidate( SID_BMPMASK ); + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_GALLERY: + { + GetViewFrame()->ToggleChildWindow( GalleryChildWindow::GetChildWindowId() ); + GetViewFrame()->GetBindings().Invalidate( SID_GALLERY ); + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_NAVIGATOR: + { + if ( rReq.GetArgs() ) + GetViewFrame()->SetChildWindow(SID_NAVIGATOR, + ((const SfxBoolItem&) (rReq.GetArgs()-> + Get(SID_NAVIGATOR))).GetValue()); + else + GetViewFrame()->ToggleChildWindow( SID_NAVIGATOR ); + + GetViewFrame()->GetBindings().Invalidate(SID_NAVIGATOR); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_ANIMATION_OBJECTS: + { + if ( rReq.GetArgs() ) + GetViewFrame()->SetChildWindow( + AnimationChildWindow::GetChildWindowId(), + ((const SfxBoolItem&) (rReq.GetArgs()-> + Get(SID_ANIMATION_OBJECTS))).GetValue()); + else + GetViewFrame()->ToggleChildWindow( + AnimationChildWindow::GetChildWindowId() ); + + GetViewFrame()->GetBindings().Invalidate(SID_ANIMATION_OBJECTS); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_CUSTOM_ANIMATION_PANEL: + { + // Make the slide transition panel visible (expand it) in the + // tool pane. + framework::FrameworkHelper::Instance(GetViewShellBase())->RequestTaskPanel( + framework::FrameworkHelper::msCustomAnimationTaskPanelURL); + + Cancel(); + rReq.Done (); + } + break; + + case SID_SLIDE_TRANSITIONS_PANEL: + { + // Make the slide transition panel visible (expand it) in the + // tool pane. + framework::FrameworkHelper::Instance(GetViewShellBase())->RequestTaskPanel( + framework::FrameworkHelper::msSlideTransitionTaskPanelURL); + + Cancel(); + rReq.Done (); + } + break; + + case SID_3D_WIN: + { + if ( rReq.GetArgs() ) + GetViewFrame()->SetChildWindow( Svx3DChildWindow::GetChildWindowId(), + ((const SfxBoolItem&) (rReq.GetArgs()-> + Get( SID_3D_WIN ))).GetValue()); + else + GetViewFrame()->ToggleChildWindow( Svx3DChildWindow::GetChildWindowId() ); + + GetViewFrame()->GetBindings().Invalidate( SID_3D_WIN ); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_CONVERT_TO_3D_LATHE_FAST: + { + // Der Aufruf ist ausreichend. Die Initialisierung per Start3DCreation und CreateMirrorPolygons + // ist nicht mehr noetig, falls der Parameter TRUE uebergeben wird. Dann wird sofort und + // ohne Benutzereingriff ein gekippter Rotationskoerper mit einer Achse links neben dem + // Umschliessenden Rechteck der slektierten Objekte gezeichnet. + mpDrawView->SdrEndTextEdit(); + if(GetActiveWindow()) + GetActiveWindow()->EnterWait(); + mpDrawView->End3DCreation(TRUE); + Cancel(); + rReq.Ignore(); + if(GetActiveWindow()) + GetActiveWindow()->LeaveWait(); + } + break; + + case SID_PRESENTATION_DLG: + { + SetCurrentFunction( FuSlideShowDlg::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_CUSTOMSHOW_DLG: + { + SetCurrentFunction( FuCustomShowDlg::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_EXPAND_PAGE: + { + SetCurrentFunction( FuExpandPage::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_SUMMARY_PAGE: + { + mpDrawView->SdrEndTextEdit(); + SetCurrentFunction( FuSummaryPage::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_AVMEDIA_PLAYER: + { + GetViewFrame()->ToggleChildWindow( ::avmedia::MediaPlayer::GetChildWindowId() ); + GetViewFrame()->GetBindings().Invalidate( SID_AVMEDIA_PLAYER ); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_LAYER_DIALOG_WIN: + { + if ( rReq.GetArgs() ) + { + GetViewFrame()->SetChildWindow( + LayerDialogChildWindow::GetChildWindowId(), + ((const SfxBoolItem&) (rReq.GetArgs()-> + Get(SID_LAYER_DIALOG_WIN))).GetValue()); + } + else + { + GetViewFrame()->ToggleChildWindow( + LayerDialogChildWindow::GetChildWindowId()); + } + + GetViewFrame()->GetBindings().Invalidate(SID_LAYER_DIALOG_WIN); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_DISPLAY_MASTER_BACKGROUND: + case SID_DISPLAY_MASTER_OBJECTS: + { + // Determine current page and toggle visibility of layers + // associated with master page background or master page shapes. + SdPage* pPage = GetActualPage(); + if (pPage != NULL + && GetDoc() != NULL) + { + SetOfByte aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers(); + SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin(); + BYTE aLayerId; + if (nSId == SID_DISPLAY_MASTER_BACKGROUND) + aLayerId = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE); + else + aLayerId = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE); + aVisibleLayers.Set(aLayerId, !aVisibleLayers.IsSet(aLayerId)); + pPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers); + } + Cancel(); + rReq.Ignore (); + } + break; + + default: + { + DBG_ASSERT( 0, "Slot ohne Funktion" ); + Cancel(); + rReq.Ignore (); + } + break; + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviews7.cxx b/sd/source/ui/view/drviews7.cxx new file mode 100755 index 000000000000..e853d3944ce0 --- /dev/null +++ b/sd/source/ui/view/drviews7.cxx @@ -0,0 +1,1741 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/lang/Locale.hpp> +#include <com/sun/star/linguistic2/XThesaurus.hpp> +#include <svx/fmglob.hxx> +#include <svx/globl3d.hxx> +#include <svx/svdouno.hxx> +#include <editeng/eeitem.hxx> +#ifndef _FLDITEM_HXX +#include <editeng/flditem.hxx> +#endif +#ifndef _SVXIDS_HXX +#include <svx/svxids.hrc> +#endif +#include <svx/svdpagv.hxx> +#include <svx/clipfmtitem.hxx> +#include <svx/fmshell.hxx> +#include <svl/eitem.hxx> +#include <svl/aeitem.hxx> +#include <svl/stritem.hxx> +#include <svl/visitem.hxx> +#include <svl/whiter.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/svdograf.hxx> +#include <editeng/unolingu.hxx> +#include <svx/extrusionbar.hxx> +#include <svx/fontworkbar.hxx> + +// #UndoRedo# +#include <svl/slstitm.hxx> +#include <sfx2/app.hxx> +#include <svtools/insdlg.hxx> +#include <unotools/moduleoptions.hxx> +#include <svl/languageoptions.hxx> +#include <comphelper/processfactory.hxx> +#include <sfx2/request.hxx> + + +#include <svx/pfiledlg.hxx> +#include <svx/grafctrl.hxx> +#include <svtools/cliplistener.hxx> +#include <sfx2/viewfrm.hxx> + +#include "app.hrc" +#include "glob.hrc" +#include "res_bmp.hrc" +#include "PresentationViewShell.hxx" + +#include "misc.hxx" +#include "Outliner.hxx" +#include "drawdoc.hxx" +#include "sdresid.hxx" +#include "sdpage.hxx" +#include "Client.hxx" +#include "DrawDocShell.hxx" +#include "zoomlist.hxx" +#include "slideshow.hxx" +#include "drawview.hxx" +#include "ViewShellBase.hxx" +#include "ViewShellManager.hxx" +#include "LayerTabBar.hxx" +#include "fupoor.hxx" +#include "Window.hxx" +#include "fuediglu.hxx" +#include "fubullet.hxx" +#include "fuformatpaintbrush.hxx" + +using ::rtl::OUString; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::linguistic2; + +/** Create a list of clipboard formats that are supported both from the + current clipboard content and the DrawViewShell. + The list is stored in a new instance of SvxClipboardFmtItem. +*/ +::std::auto_ptr<SvxClipboardFmtItem> GetSupportedClipboardFormats ( + TransferableDataHelper& rDataHelper) +{ + ::std::auto_ptr<SvxClipboardFmtItem> pResult ( + new SvxClipboardFmtItem(SID_CLIPBOARD_FORMAT_ITEMS)); + + sal_uInt32 nFormatCount (rDataHelper.GetFormatCount()); + for (sal_uInt32 i=0; i<nFormatCount; i++) + { + const SotFormatStringId nTestFormat = rDataHelper.GetFormat(i); + + // Check if the current format is the same as one that has already + // been handled. + bool bDuplicate (false); + for (sal_uInt32 j=0; j<i; j++) + { + if (nTestFormat == rDataHelper.GetFormat(j)) + { + bDuplicate = true; + break; + } + } + + // Look up the format among those that are supported by the + // DrawViewShell. + if ( ! bDuplicate) + { + switch (nTestFormat) + { + case SOT_FORMATSTR_ID_EMBED_SOURCE: + { + String sName; + + TransferableObjectDescriptor aDescriptor; + if (rDataHelper.GetTransferableObjectDescriptor( + SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aDescriptor)) + { + sName = aDescriptor.maTypeName; + } + if (sName.Len() > 0) + pResult->AddClipbrdFormat(nTestFormat, sName); + else + pResult->AddClipbrdFormat(nTestFormat); + + break; + } + + case SOT_FORMATSTR_ID_LINK_SOURCE: + case SOT_FORMATSTR_ID_DRAWING: + case SOT_FORMATSTR_ID_SVXB: + case FORMAT_GDIMETAFILE: + case FORMAT_BITMAP: + case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK: + case FORMAT_STRING: + case SOT_FORMATSTR_ID_HTML: + case FORMAT_RTF: + case SOT_FORMATSTR_ID_EDITENGINE: + pResult->AddClipbrdFormat(nTestFormat); + break; + } + } + } + + // Check some OLE formats whose names are handled differently. + SotFormatStringId nFormat (SOT_FORMATSTR_ID_EMBED_SOURCE_OLE); + bool bHasFormat (rDataHelper.HasFormat(nFormat)); + if ( ! bHasFormat) + { + bHasFormat = rDataHelper.HasFormat(nFormat); + } + if (bHasFormat) + { + String sName; + String sSource; + if (SvPasteObjectHelper::GetEmbeddedName (rDataHelper, sName, sSource, nFormat)) + pResult->AddClipbrdFormat (nFormat, sName); + } + + return pResult; +} + +namespace sd { + +IMPL_LINK( DrawViewShell, ClipboardChanged, TransferableDataHelper*, pDataHelper ) +{ + if ( pDataHelper ) + { + mbPastePossible = ( pDataHelper->GetFormatCount() != 0 ); + + // Update the list of supported clipboard formats according to the + // new clipboard content. + // There are some stack traces that indicate the possibility of the + // DrawViewShell destructor called during the call to + // GetSupportedClipboardFormats(). If that really has happened then + // exit immediately. + TransferableDataHelper aDataHelper ( + TransferableDataHelper::CreateFromSystemClipboard(GetActiveWindow())); + ::std::auto_ptr<SvxClipboardFmtItem> pFormats (GetSupportedClipboardFormats(aDataHelper)); + if (mpDrawView == NULL) + return 0; + mpCurrentClipboardFormats = pFormats; + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_PASTE ); + rBindings.Invalidate( SID_PASTE_SPECIAL ); + rBindings.Invalidate( SID_CLIPBOARD_FORMAT_ITEMS ); + } + return 0; +} + +/************************************************************************* +|* +|* Status (Enabled/Disabled) von Menue-SfxSlots setzen +|* +\************************************************************************/ + +void DrawViewShell::GetMenuState( SfxItemSet &rSet ) +{ + if (mpDrawView == NULL) + { + // This assertion and return are here to prevent crashes like that + // of issue #126202#. + DBG_ASSERT(mpDrawView!=NULL, "Please report this assertion to the Impress team."); + return; + } + + ViewShell::GetMenuState(rSet); + BOOL bDisableVerticalText = !SvtLanguageOptions().IsVerticalTextEnabled(); + + if ( bDisableVerticalText ) + { + rSet.DisableItem( SID_DRAW_FONTWORK_VERTICAL ); + rSet.DisableItem( SID_DRAW_CAPTION_VERTICAL ); + rSet.DisableItem( SID_TEXT_FITTOSIZE_VERTICAL ); + rSet.DisableItem( SID_DRAW_TEXT_VERTICAL ); + } + + FASTBOOL bConvertToPathPossible = mpDrawView->IsConvertToPathObjPossible(FALSE); + + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + const ULONG nMarkCount = rMarkList.GetMarkCount(); + + //format paintbrush + FuFormatPaintBrush::GetMenuState( *this, rSet ); + + // Stati der SfxChild-Windows (Animator, Fontwork etc.) + SetChildWindowState( rSet ); + + // Images der Toolboxen mappen (nur Zoom) + UpdateToolboxImages( rSet, FALSE ); + + if(HasCurrentFunction()) + { + USHORT nSId = GetCurrentFunction()->GetSlotID(); + + rSet.Put( SfxBoolItem( nSId, TRUE ) ); + + // Bewirkt ein uncheck eines simulierten Slots + USHORT nId = GetIdBySubId( nSId ); + + // Images der Toolboxen mappen + UpdateToolboxImages( rSet ); + + if( nId != SID_ZOOM_TOOLBOX && + nSId != SID_DRAWTBX_INSERT && + nSId != SID_POSITION && + nSId != SID_OBJECT_ALIGN ) + { + if( nId != SID_OBJECT_CHOOSE_MODE ) + rSet.Put( TbxImageItem( SID_OBJECT_CHOOSE_MODE, 0 ) ); + if( nId != SID_DRAWTBX_TEXT ) + rSet.Put( TbxImageItem( SID_DRAWTBX_TEXT, 0 ) ); + if( nId != SID_DRAWTBX_RECTANGLES ) + rSet.Put( TbxImageItem( SID_DRAWTBX_RECTANGLES, 0 ) ); + if( nId != SID_DRAWTBX_ELLIPSES ) + rSet.Put( TbxImageItem( SID_DRAWTBX_ELLIPSES, 0 ) ); + if( nId != SID_DRAWTBX_LINES ) + rSet.Put( TbxImageItem( SID_DRAWTBX_LINES, 0 ) ); + if( nId != SID_DRAWTBX_ARROWS ) + rSet.Put( TbxImageItem( SID_DRAWTBX_ARROWS, 0 ) ); + if( nId != SID_DRAWTBX_3D_OBJECTS ) + rSet.Put( TbxImageItem( SID_DRAWTBX_3D_OBJECTS, 0 ) ); + if( nId != SID_DRAWTBX_CONNECTORS ) + rSet.Put( TbxImageItem( SID_DRAWTBX_CONNECTORS, 0 ) ); + } + } + + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + + GetMenuStateSel(rSet); + + if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_ASSIGN_LAYOUT)) + { + bool bDisable = true; + if( pPageView ) + { + SdPage* pPage = dynamic_cast< SdPage* >( pPageView->GetPage() ); + + if( pPage ) + { + rSet.Put( SfxUInt32Item( SID_ASSIGN_LAYOUT, static_cast< sal_uInt32 >(pPage->GetAutoLayout()) ) ); + bDisable = false; + } + } + + if(bDisable) + { + rSet.DisableItem(SID_EXPAND_PAGE); + } + } + + if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_EXPAND_PAGE)) + { + bool bDisable = true; + if( pPageView ) + { + SdPage* pPage = dynamic_cast< SdPage* >( pPageView->GetPage() ); + + if( pPage && (pPage->GetPageKind() == PK_STANDARD) && !pPage->IsMasterPage() ) + { + SdrObject* pObj = pPage->GetPresObj(PRESOBJ_OUTLINE); + + if(pObj && !pObj->IsEmptyPresObj()) + { + bDisable = false; + } + } + } + + if(bDisable) + { + rSet.DisableItem(SID_EXPAND_PAGE); + } + } + + if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_SUMMARY_PAGE)) + { + bool bDisable = true; + if( pPageView ) + { + SdPage* pPage = dynamic_cast< SdPage* >( pPageView->GetPage() ); + + if( pPage && (pPage->GetPageKind() == PK_STANDARD) && !pPage->IsMasterPage() ) + { + SdrObject* pObj = pPage->GetPresObj(PRESOBJ_TITLE); + + if(pObj && !pObj->IsEmptyPresObj()) + { + bDisable = false; + } + } + } + + if(bDisable) + { + rSet.DisableItem(SID_SUMMARY_PAGE); + } + } + + if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_ASSIGN_LAYOUT)) + { + bool bDisable = true; + if( pPageView ) + { + SdPage* pPage = dynamic_cast< SdPage* >( pPageView->GetPage() ); + + if( pPage && !pPage->IsMasterPage() ) + { + rSet.Put( SfxUInt32Item(SID_ASSIGN_LAYOUT, pPage->GetAutoLayout()) ); + bDisable = false; + } + } + + if(bDisable) + { + rSet.DisableItem(SID_ASSIGN_LAYOUT); + } + } + + // Starten der Praesentation moeglich? + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PRESENTATION ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_REHEARSE_TIMINGS ) ) + { + BOOL bDisable = TRUE; + USHORT nCount = GetDoc()->GetSdPageCount( PK_STANDARD ); + + for( USHORT i = 0; i < nCount && bDisable; i++ ) + { + SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD); + + if( !pPage->IsExcluded() ) + bDisable = FALSE; + } + + if( bDisable || GetDocSh()->IsPreview()) + { + rSet.DisableItem( SID_PRESENTATION ); + rSet.DisableItem( SID_REHEARSE_TIMINGS ); + } + } + + // Klebepunkte + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_EDITMODE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_INSERT_POINT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_PERCENT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_ESCDIR ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_ESCDIR_LEFT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_ESCDIR_RIGHT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_ESCDIR_TOP ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_ESCDIR_BOTTOM ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_HORZALIGN_CENTER ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_HORZALIGN_LEFT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_HORZALIGN_RIGHT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_VERTALIGN_CENTER ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_VERTALIGN_TOP ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GLUE_VERTALIGN_BOTTOM ) ) + { + // Prozent + TRISTATE eState = mpDrawView->IsMarkedGluePointsPercent(); + if( eState == STATE_DONTKNOW ) + rSet.InvalidateItem( SID_GLUE_PERCENT ); + else + rSet.Put( SfxBoolItem( SID_GLUE_PERCENT, eState == STATE_CHECK ) ); + + // Bei Prozent hat Alignment keinen Effekt + if( eState == STATE_CHECK ) + { + rSet.DisableItem( SID_GLUE_HORZALIGN_CENTER ); + rSet.DisableItem( SID_GLUE_HORZALIGN_LEFT ); + rSet.DisableItem( SID_GLUE_HORZALIGN_RIGHT ); + rSet.DisableItem( SID_GLUE_VERTALIGN_CENTER ); + rSet.DisableItem( SID_GLUE_VERTALIGN_TOP ); + rSet.DisableItem( SID_GLUE_VERTALIGN_BOTTOM ); + } + else + { + // Horizontale Ausrichtung + USHORT nHorz = mpDrawView->GetMarkedGluePointsAlign( FALSE ); + rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_CENTER, nHorz == SDRHORZALIGN_CENTER ) ); + rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_LEFT, nHorz == SDRHORZALIGN_LEFT ) ); + rSet.Put( SfxBoolItem( SID_GLUE_HORZALIGN_RIGHT, nHorz == SDRHORZALIGN_RIGHT ) ); + // Vertikale Ausrichtung + USHORT nVert = mpDrawView->GetMarkedGluePointsAlign( TRUE ); + rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_CENTER, nVert == SDRVERTALIGN_CENTER ) ); + rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_TOP, nVert == SDRVERTALIGN_TOP ) ); + rSet.Put( SfxBoolItem( SID_GLUE_VERTALIGN_BOTTOM, nVert == SDRVERTALIGN_BOTTOM ) ); + } + + // Punkt einfuegen + rSet.Put( SfxBoolItem( SID_GLUE_INSERT_POINT, mpDrawView->IsInsGluePointMode() ) ); + + // Autrittsrichtung + // Links + eState = mpDrawView->IsMarkedGluePointsEscDir( SDRESC_LEFT ); + if( eState == STATE_DONTKNOW ) + rSet.InvalidateItem( SID_GLUE_ESCDIR_LEFT ); + else + rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_LEFT, eState == STATE_CHECK ) ); + // Rechts + eState = mpDrawView->IsMarkedGluePointsEscDir( SDRESC_RIGHT ); + if( eState == STATE_DONTKNOW ) + rSet.InvalidateItem( SID_GLUE_ESCDIR_RIGHT ); + else + rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_RIGHT, eState == STATE_CHECK ) ); + // Oben + eState = mpDrawView->IsMarkedGluePointsEscDir( SDRESC_TOP ); + if( eState == STATE_DONTKNOW ) + rSet.InvalidateItem( SID_GLUE_ESCDIR_TOP ); + else + rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_TOP, eState == STATE_CHECK ) ); + // Unten + eState = mpDrawView->IsMarkedGluePointsEscDir( SDRESC_BOTTOM ); + if( eState == STATE_DONTKNOW ) + rSet.InvalidateItem( SID_GLUE_ESCDIR_BOTTOM ); + else + rSet.Put( SfxBoolItem( SID_GLUE_ESCDIR_BOTTOM, eState == STATE_CHECK ) ); + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_GRID_FRONT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_HELPLINES_FRONT ) ) + { + rSet.Put( SfxBoolItem( SID_GRID_FRONT, mpDrawView->IsGridFront() ) ); + rSet.Put( SfxBoolItem( SID_HELPLINES_FRONT, mpDrawView->IsHlplFront() ) ); + } + + if (!mpDrawView->IsFrameDragSingles()) + rSet.Put(SfxBoolItem(SID_BEZIER_EDIT, TRUE)); + else + rSet.Put(SfxBoolItem(SID_BEZIER_EDIT, FALSE)); + + if(dynamic_cast<FuEditGluePoints*>( GetCurrentFunction().get())) + rSet.Put(SfxBoolItem(SID_GLUE_EDITMODE, TRUE)); + else + rSet.Put(SfxBoolItem(SID_GLUE_EDITMODE, FALSE)); + + if( !mpDrawView->IsMirrorAllowed( TRUE, TRUE ) ) + { + rSet.DisableItem( SID_HORIZONTAL ); + rSet.DisableItem( SID_VERTICAL ); + } + + if( !mpDrawView->IsMirrorAllowed() ) + { + rSet.DisableItem( SID_OBJECT_MIRROR ); +// rSet.DisableItem( SID_CONVERT_TO_3D_LATHE ); +// rSet.DisableItem( SID_CONVERT_TO_3D_LATHE_FAST ); + } + + // interactive transparence control + if(!mpDrawView->IsTransparenceAllowed()) + { + rSet.DisableItem( SID_OBJECT_TRANSPARENCE ); + } + + // interactive gradient control + if(!mpDrawView->IsGradientAllowed()) + { + rSet.DisableItem( SID_OBJECT_GRADIENT ); + } + + // Morphen ggf. disablen + if ( !mpDrawView->IsMorphingAllowed() ) + rSet.DisableItem( SID_POLYGON_MORPHING ); + + // Vectorize ggf. disablen + if ( !mpDrawView->IsVectorizeAllowed() ) + rSet.DisableItem( SID_VECTORIZE ); + + if( !mpDrawView->IsReverseOrderPossible() ) + { + rSet.DisableItem( SID_REVERSE_ORDER ); + } + + if ( !bConvertToPathPossible && + !mpDrawView->IsCrookAllowed( mpDrawView->IsCrookNoContortion() ) ) + { + // Implizite Wandlung in Kurve nicht moeglich + rSet.DisableItem(SID_OBJECT_CROOK_ROTATE); + rSet.DisableItem(SID_OBJECT_CROOK_SLANT); + rSet.DisableItem(SID_OBJECT_CROOK_STRETCH); + } + + if ( !mpDrawView->IsGroupEntered() ) + { + rSet.DisableItem( SID_LEAVE_GROUP ); + rSet.Put( SfxBoolItem( SID_LEAVE_ALL_GROUPS, FALSE ) ); + rSet.ClearItem( SID_LEAVE_ALL_GROUPS ); + rSet.DisableItem( SID_LEAVE_ALL_GROUPS ); + } + else + rSet.Put( SfxBoolItem( SID_LEAVE_ALL_GROUPS, TRUE ) ); + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_THESAURUS ) ) + { + if ( !mpDrawView->IsTextEdit() ) + { + rSet.DisableItem( SID_THESAURUS ); + } + else + { + LanguageType eLang = GetDoc()->GetLanguage( EE_CHAR_LANGUAGE ); + Reference< XThesaurus > xThesaurus( LinguMgr::GetThesaurus() ); + Locale aLocale; + + SvxLanguageToLocale( aLocale, eLang ); + + if (!xThesaurus.is() || eLang == LANGUAGE_NONE || !xThesaurus->hasLocale(aLocale) ) + rSet.DisableItem( SID_THESAURUS ); + } + } + + if ( !mpDrawView->IsTextEdit() ) + { + rSet.DisableItem( SID_THESAURUS ); + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_SELECTALL ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_SIZE_ALL ) ) + { + if( pPageView && pPageView->GetObjList()->GetObjCount() == 0 ) + { + // Sollte disabled sein, wenn kein Objekt auf der Zeichenflaeche ist: + rSet.DisableItem( SID_SELECTALL ); + rSet.DisableItem( SID_SIZE_ALL ); + } + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONTEXT ) ) + rSet.Put( SfxStringItem( SID_CONTEXT, mpDrawView->GetStatusText() ) ); + + // clipboard (paste) + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PASTE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PASTE_SPECIAL ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CLIPBOARD_FORMAT_ITEMS ) ) + { + if ( !mpClipEvtLstnr ) + { + // SSA: #108717# avoid clipboard initialization for + // read-only presentation views (workaround for NT4.0 + // clipboard prob...) + if( !ISA(PresentationViewShell) ) + { + // create listener + mpClipEvtLstnr = new TransferableClipboardListener( LINK( this, DrawViewShell, ClipboardChanged ) ); + mpClipEvtLstnr->acquire(); + mpClipEvtLstnr->AddRemoveListener( GetActiveWindow(), TRUE ); + + // get initial state + TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( GetActiveWindow() ) ); + mbPastePossible = ( aDataHelper.GetFormatCount() != 0 ); + } + else + mbPastePossible = FALSE; + } + + if( !mbPastePossible ) + { + rSet.DisableItem( SID_PASTE ); + rSet.DisableItem( SID_PASTE_SPECIAL ); + rSet.DisableItem( SID_CLIPBOARD_FORMAT_ITEMS ); + } + else if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CLIPBOARD_FORMAT_ITEMS ) ) + { + if (mpCurrentClipboardFormats.get() != NULL) + rSet.Put(*mpCurrentClipboardFormats); + } + } + + if ( !bConvertToPathPossible ) + { + rSet.DisableItem(SID_CHANGEBEZIER); + } + + if (mpDrawView == NULL) + { + // When we come to this line then we probably have another + // incarnation of issue #126202#. The mpDrawView was not NULL but is + // now. The reason for this may be that the DrawViewShell has been + // destroyed in the mean time. + // We can only return immediately and hope that the deleted + // DrawViewShell is not called again. + DBG_ASSERT(mpDrawView!=NULL, "Please report this assertion to the Impress team."); + return; + } + + if( !( mpDrawView->IsConvertToPolyObjPossible(FALSE) || mpDrawView->IsVectorizeAllowed() ) ) + rSet.DisableItem(SID_CHANGEPOLYGON); + + if( !( mpDrawView->IsConvertToPolyObjPossible(FALSE) || mpDrawView->IsConvertToContourPossible() ) ) + rSet.DisableItem(SID_CONVERT_TO_CONTOUR); + + if ( !mpDrawView->IsConvertTo3DObjPossible() ) + { + rSet.DisableItem(SID_CONVERT_TO_3D); + rSet.DisableItem(SID_CONVERT_TO_3D_LATHE); + rSet.DisableItem(SID_CONVERT_TO_3D_LATHE_FAST); + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MANAGE_LINKS ) ) + { + if ( GetDoc()->GetLinkCount() == 0 ) + { + rSet.DisableItem(SID_MANAGE_LINKS); + } + } + + if (mePageKind == PK_HANDOUT) + { + rSet.DisableItem(SID_PRESENTATION_LAYOUT); + rSet.DisableItem(SID_SELECT_BACKGROUND); + } + + if (mePageKind == PK_NOTES) + { + rSet.DisableItem(SID_INSERTPAGE); + rSet.DisableItem(SID_RENAMEPAGE); + rSet.DisableItem(SID_RENAMEPAGE_QUICK); + rSet.DisableItem(SID_DUPLICATE_PAGE); + rSet.ClearItem(SID_ANIMATION_OBJECTS); + rSet.DisableItem(SID_ANIMATION_OBJECTS); + rSet.DisableItem(SID_ANIMATION_EFFECTS); + + if (meEditMode == EM_MASTERPAGE) + rSet.DisableItem(SID_MODIFYPAGE); + + rSet.DisableItem(SID_SELECT_BACKGROUND); + rSet.DisableItem(SID_INSERTLAYER); + rSet.DisableItem(SID_LAYERMODE); + rSet.DisableItem(SID_INSERTFILE); + } + else if (mePageKind == PK_HANDOUT) + { + rSet.DisableItem(SID_INSERTPAGE); + rSet.DisableItem(SID_DUPLICATE_PAGE); + rSet.ClearItem(SID_ANIMATION_OBJECTS); + rSet.DisableItem(SID_ANIMATION_OBJECTS); + rSet.DisableItem(SID_ANIMATION_EFFECTS); + rSet.DisableItem(SID_RENAMEPAGE); + rSet.DisableItem(SID_RENAMEPAGE_QUICK); + rSet.DisableItem(SID_INSERTLAYER); + rSet.DisableItem(SID_MODIFYLAYER); + rSet.DisableItem(SID_RENAMELAYER); + rSet.DisableItem(SID_LAYERMODE); + rSet.DisableItem(SID_INSERTFILE); + rSet.DisableItem(SID_PAGEMODE); + rSet.DisableItem(SID_SELECT_BACKGROUND); + } + else + { + if (meEditMode == EM_MASTERPAGE) + { + rSet.DisableItem(SID_INSERTPAGE); + rSet.DisableItem(SID_DUPLICATE_PAGE); + rSet.DisableItem(SID_MODIFYPAGE); + rSet.ClearItem(SID_ANIMATION_OBJECTS); + rSet.DisableItem(SID_ANIMATION_OBJECTS); + } + + rSet.Put (SfxBoolItem (SID_LAYERMODE, IsLayerModeActive())); + } + + if ( ! IsLayerModeActive()) + { + rSet.DisableItem( SID_INSERTLAYER ); + rSet.DisableItem( SID_MODIFYLAYER ); + rSet.DisableItem( SID_DELETE_LAYER ); + rSet.DisableItem( SID_RENAMELAYER ); + } + + if (meEditMode == EM_PAGE) + { + /********************************************************************** + * Seiten-Modus + **********************************************************************/ + rSet.Put(SfxBoolItem(SID_PAGEMODE, TRUE)); + rSet.Put(SfxBoolItem(SID_MASTERPAGE, FALSE)); + rSet.Put(SfxBoolItem(SID_SLIDE_MASTERPAGE, FALSE)); + rSet.Put(SfxBoolItem(SID_NOTES_MASTERPAGE, FALSE)); + rSet.Put(SfxBoolItem(SID_HANDOUT_MASTERPAGE, FALSE)); + + if (mePageKind == PK_STANDARD && + rSet.GetItemState(SID_TITLE_MASTERPAGE) == SFX_ITEM_AVAILABLE) + { + // Gibt es eine Seite mit dem AutoLayout "Titel"? + BOOL bDisable = TRUE; + USHORT i = 0; + USHORT nCount = GetDoc()->GetSdPageCount(PK_STANDARD); + + while (i < nCount && bDisable) + { + SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD); + + if (pPage->GetAutoLayout() == AUTOLAYOUT_TITLE) + { + bDisable = FALSE; + } + + i++; + } + + if (bDisable) + { + rSet.DisableItem(SID_TITLE_MASTERPAGE); + } + else + { + rSet.Put(SfxBoolItem(SID_TITLE_MASTERPAGE, FALSE)); + } + } + else + { + rSet.DisableItem(SID_TITLE_MASTERPAGE); + } + + rSet.DisableItem (SID_INSERT_MASTER_PAGE); + rSet.DisableItem (SID_DELETE_MASTER_PAGE); + rSet.DisableItem (SID_RENAME_MASTER_PAGE); + rSet.DisableItem (SID_CLOSE_MASTER_VIEW); + } + else + { + rSet.Put(SfxBoolItem(SID_PAGEMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_MASTERPAGE, TRUE)); + + /********************************************************************** + * Hintergrundseiten-Modus + **********************************************************************/ + if (mePageKind == PK_STANDARD) + { + rSet.Put(SfxBoolItem(SID_SLIDE_MASTERPAGE, TRUE)); + rSet.Put(SfxBoolItem(SID_NOTES_MASTERPAGE, FALSE)); + rSet.Put(SfxBoolItem(SID_HANDOUT_MASTERPAGE, FALSE)); + + if (rSet.GetItemState(SID_TITLE_MASTERPAGE) == SFX_ITEM_AVAILABLE) + { + BOOL bCheck = FALSE; + BOOL bDisable = TRUE; + if( pPageView ) + { + SdPage* pMPage = dynamic_cast< SdPage* >( pPageView->GetPage() ); + + USHORT i = 0; + USHORT nCount = GetDoc()->GetSdPageCount(PK_STANDARD); + + // Referenziert eine Seite mit dem AutoLayout "Titel" die + // aktuelle MasterPage? + while (i < nCount && !bCheck && bDisable) + { + SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD); + + // Seite referenziert aktuelle MasterPage + if (pPage->GetAutoLayout() == AUTOLAYOUT_TITLE) + { + // Eine Seite hat das AutoLayout "Titel" + bDisable = FALSE; + + SdPage& rRefMPage = (SdPage&)(pPage->TRG_GetMasterPage()); + + if(&rRefMPage == pMPage) + { + // Eine Seite mit dem AutoLayout "Titel" + // referenziert die aktuelle MasterPage + bCheck = TRUE; + } + } + + i++; + } + } + + if (bCheck) + { + rSet.Put(SfxBoolItem(SID_SLIDE_MASTERPAGE, FALSE)); + } + + rSet.Put(SfxBoolItem(SID_TITLE_MASTERPAGE, bCheck)); + + if (bDisable) + { + rSet.ClearItem(SID_TITLE_MASTERPAGE); + rSet.DisableItem(SID_TITLE_MASTERPAGE); + } + } + } + else if (mePageKind == PK_NOTES) + { + rSet.Put(SfxBoolItem(SID_SLIDE_MASTERPAGE, FALSE)); + rSet.DisableItem(SID_TITLE_MASTERPAGE); + rSet.Put(SfxBoolItem(SID_NOTES_MASTERPAGE, TRUE)); + rSet.Put(SfxBoolItem(SID_HANDOUT_MASTERPAGE, FALSE)); + } + else if (mePageKind == PK_HANDOUT) + { + rSet.Put(SfxBoolItem(SID_SLIDE_MASTERPAGE, FALSE)); + rSet.DisableItem(SID_TITLE_MASTERPAGE); + rSet.Put(SfxBoolItem(SID_NOTES_MASTERPAGE, FALSE)); + rSet.Put(SfxBoolItem(SID_HANDOUT_MASTERPAGE, TRUE)); + } + } + + // Status der Lineale setzen + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_RULER ) ) + rSet.Put( SfxBoolItem( SID_RULER, HasRuler() ) ); + + // nicht die letzte Seite oder eine Masterpage loeschen + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DELETE_PAGE ) + || SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DELETE_MASTER_PAGE ) ) + { + if (maTabControl.GetPageCount() == 1 || + meEditMode == EM_MASTERPAGE || + mePageKind == PK_NOTES || + mePageKind == PK_HANDOUT || + (GetShellType()!=ST_DRAW&&IsLayerModeActive())) + { + if (rSet.GetItemState(SID_DELETE_PAGE) == SFX_ITEM_AVAILABLE) + rSet.DisableItem(SID_DELETE_PAGE); + if (rSet.GetItemState(SID_DELETE_MASTER_PAGE)==SFX_ITEM_AVAILABLE) + rSet.DisableItem(SID_DELETE_MASTER_PAGE); + } + } + + // darf der aktuelle Layer geloescht werden? + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DELETE_LAYER ) ) + { + USHORT nCurrentLayer = GetLayerTabControl()->GetCurPageId(); + const String& rName = GetLayerTabControl()->GetPageText(nCurrentLayer); + + BOOL bDisableIt = !IsLayerModeActive(); + bDisableIt |= (rName == String(SdResId(STR_LAYER_LAYOUT))); + bDisableIt |= (rName == String(SdResId(STR_LAYER_BCKGRND))); + bDisableIt |= (rName == String(SdResId(STR_LAYER_BCKGRNDOBJ))); + bDisableIt |= (rName == String(SdResId(STR_LAYER_CONTROLS))); + bDisableIt |= (rName == String(SdResId(STR_LAYER_MEASURELINES))); + + if (bDisableIt) + { + rSet.DisableItem(SID_DELETE_LAYER); + rSet.DisableItem(SID_RENAMELAYER); + } + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CUT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_COPY ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OUTLINE_BULLET )) + { + OutlinerView* pOlView = mpDrawView->GetTextEditOutlinerView(); + + // Sonderbehandlung für SID_OUTLINE_BULLET wenn Objekte + // mit unterschiedlichen arten von NumBullet Items markiert + // sind + BOOL bHasOutliner = FALSE; + BOOL bHasOther = FALSE; + for(ULONG nNum = 0; nNum < nMarkCount; nNum++) + { + SdrObject* pObj = rMarkList.GetMark(nNum)->GetMarkedSdrObj(); + if( pObj->GetObjInventor() == SdrInventor ) + { + if( pObj->GetObjIdentifier() == OBJ_OUTLINETEXT ) + { + bHasOutliner = TRUE; + if(bHasOther) + break; + } + else + { + bHasOther = TRUE; + if(bHasOutliner) + break; + } + } + } + + if( bHasOther && bHasOutliner ) + rSet.DisableItem( SID_OUTLINE_BULLET ); + + if (pOlView) + { + if ( pOlView->GetSelected().Len() == 0 ) + { + rSet.DisableItem( SID_CUT ); + rSet.DisableItem( SID_COPY ); + } + } + + } + + FuBullet::GetSlotState( rSet, this, GetViewFrame() ); + + if ( GetDocSh()->IsUIActive() ) + { + rSet.DisableItem( SID_INSERT_OBJECT ); + rSet.DisableItem( SID_INSERT_PLUGIN ); + rSet.DisableItem( SID_INSERT_SOUND ); + rSet.DisableItem( SID_INSERT_VIDEO ); + rSet.DisableItem( SID_INSERT_APPLET ); + rSet.DisableItem( SID_INSERT_FLOATINGFRAME ); +#ifdef STARIMAGE_AVAILABLE + rSet.DisableItem( SID_INSERT_IMAGE ); +#endif + rSet.DisableItem( SID_INSERT_MATH ); + rSet.DisableItem( SID_INSERT_DIAGRAM ); + rSet.DisableItem( SID_ATTR_TABLE ); + rSet.DisableItem( SID_SIZE_REAL ); + rSet.DisableItem( SID_SIZE_OPTIMAL ); + rSet.DisableItem( SID_SIZE_ALL ); + rSet.DisableItem( SID_SIZE_PAGE_WIDTH ); + rSet.DisableItem( SID_SIZE_PAGE ); +// rSet.DisableItem( SID_INSERTPAGE ); + rSet.DisableItem( SID_DUPLICATE_PAGE ); + rSet.DisableItem( SID_ZOOM_TOOLBOX ); + } + + // Zoom-Stati + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_IN ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_OUT )|| + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_PANNING ) ) + { + if( GetActiveWindow()->GetZoom() <= GetActiveWindow()->GetMinZoom() || GetDocSh()->IsUIActive() ) + { + rSet.DisableItem( SID_ZOOM_IN ); + rSet.DisableItem( SID_ZOOM_PANNING ); + } + if( GetActiveWindow()->GetZoom() >= GetActiveWindow()->GetMaxZoom() || GetDocSh()->IsUIActive() ) + rSet.DisableItem( SID_ZOOM_OUT ); + } + + if (!mpZoomList->IsNextPossible()) + { + rSet.DisableItem(SID_ZOOM_NEXT); + } + if (!mpZoomList->IsPreviousPossible()) + { + rSet.DisableItem(SID_ZOOM_PREV); + } + + // EditText aktiv + if (GetViewShellBase().GetViewShellManager()->GetShell(RID_DRAW_TEXT_TOOLBOX) != NULL) + { + USHORT nCurrentSId = SID_ATTR_CHAR; + + if(HasCurrentFunction()) + { + nCurrentSId = GetCurrentFunction()->GetSlotID(); + } + if( nCurrentSId != SID_TEXT_FITTOSIZE && + nCurrentSId != SID_TEXT_FITTOSIZE_VERTICAL && + nCurrentSId != SID_ATTR_CHAR_VERTICAL ) + nCurrentSId = SID_ATTR_CHAR; + + rSet.Put( SfxBoolItem( nCurrentSId, TRUE ) ); + + // Kurzform von UpdateToolboxImages() + rSet.Put( TbxImageItem( SID_DRAWTBX_TEXT, nCurrentSId ) ); + } + + if ( GetDocSh()->IsReadOnly() ) + { + rSet.DisableItem( SID_AUTOSPELL_CHECK ); + } + else + { + if (GetDoc()->GetOnlineSpell()) + { + rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, TRUE)); + } + else + { + rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, FALSE)); + } + } + + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + String aActiveLayer = mpDrawView->GetActiveLayer(); + + if ( ( aActiveLayer.Len() != 0 && pPV && ( pPV->IsLayerLocked(aActiveLayer) || + !pPV->IsLayerVisible(aActiveLayer) ) ) || + SD_MOD()->GetWaterCan() ) + { + rSet.DisableItem( SID_PASTE ); + rSet.DisableItem( SID_PASTE_SPECIAL ); + rSet.DisableItem( SID_CLIPBOARD_FORMAT_ITEMS ); + + rSet.DisableItem( SID_INSERT_FLD_DATE_FIX ); + rSet.DisableItem( SID_INSERT_FLD_DATE_VAR ); + rSet.DisableItem( SID_INSERT_FLD_TIME_FIX ); + rSet.DisableItem( SID_INSERT_FLD_TIME_VAR ); + rSet.DisableItem( SID_INSERT_FLD_AUTHOR ); + rSet.DisableItem( SID_INSERT_FLD_PAGE ); + rSet.DisableItem( SID_INSERT_FLD_PAGES ); + rSet.DisableItem( SID_INSERT_FLD_FILE ); + + rSet.DisableItem( SID_INSERT_GRAPHIC ); + rSet.DisableItem( SID_INSERT_AVMEDIA ); + rSet.DisableItem( SID_INSERT_DIAGRAM ); + rSet.DisableItem( SID_INSERT_OBJECT ); + rSet.DisableItem( SID_INSERT_PLUGIN ); + rSet.DisableItem( SID_INSERT_SOUND ); + rSet.DisableItem( SID_INSERT_VIDEO ); + rSet.DisableItem( SID_INSERT_APPLET ); + rSet.DisableItem( SID_INSERT_FLOATINGFRAME ); + +#ifdef STARIMAGE_AVAILABLE + rSet.DisableItem( SID_INSERT_IMAGE ); +#endif + rSet.DisableItem( SID_INSERT_MATH ); + rSet.DisableItem( SID_INSERT_FRAME ); + rSet.DisableItem( SID_INSERTFILE ); + rSet.DisableItem( SID_ATTR_TABLE ); + rSet.DisableItem( SID_COPYOBJECTS ); + + rSet.DisableItem( SID_SCAN ); + rSet.DisableItem( SID_TWAIN_SELECT ); + rSet.DisableItem( SID_TWAIN_TRANSFER ); + +// rSet.DisableItem( SID_BEZIER_EDIT ); + rSet.DisableItem( SID_GLUE_EDITMODE ); + rSet.DisableItem( SID_OBJECT_ROTATE ); + rSet.DisableItem( SID_OBJECT_SHEAR ); + rSet.DisableItem( SID_OBJECT_MIRROR ); + rSet.DisableItem( SID_OBJECT_CROP ); + rSet.DisableItem( SID_ATTR_GRAF_CROP ); + rSet.DisableItem( SID_OBJECT_TRANSPARENCE ); + rSet.DisableItem( SID_OBJECT_GRADIENT ); + rSet.DisableItem( SID_OBJECT_CROOK_ROTATE ); + rSet.DisableItem( SID_OBJECT_CROOK_SLANT ); + rSet.DisableItem( SID_OBJECT_CROOK_STRETCH ); + + // Alle objekterzeugenden Werkzeuge disablen + rSet.ClearItem( SID_ATTR_CHAR ); + rSet.DisableItem( SID_ATTR_CHAR ); + rSet.ClearItem( SID_ATTR_CHAR_VERTICAL ); + rSet.DisableItem( SID_ATTR_CHAR_VERTICAL ); + rSet.ClearItem(SID_DRAW_LINE); + rSet.DisableItem(SID_DRAW_LINE); + rSet.ClearItem(SID_DRAW_MEASURELINE); + rSet.DisableItem(SID_DRAW_MEASURELINE); + rSet.ClearItem(SID_DRAW_XLINE); + rSet.DisableItem(SID_DRAW_XLINE); + rSet.ClearItem( SID_LINE_ARROW_START ); + rSet.DisableItem( SID_LINE_ARROW_START ); + rSet.ClearItem( SID_LINE_ARROW_END ); + rSet.DisableItem( SID_LINE_ARROW_END ); + rSet.ClearItem( SID_LINE_ARROWS ); + rSet.DisableItem( SID_LINE_ARROWS ); + rSet.ClearItem( SID_LINE_ARROW_CIRCLE ); + rSet.DisableItem( SID_LINE_ARROW_CIRCLE ); + rSet.ClearItem( SID_LINE_CIRCLE_ARROW ); + rSet.DisableItem( SID_LINE_CIRCLE_ARROW ); + rSet.ClearItem( SID_LINE_ARROW_SQUARE ); + rSet.DisableItem( SID_LINE_ARROW_SQUARE ); + rSet.ClearItem( SID_LINE_SQUARE_ARROW ); + rSet.DisableItem( SID_LINE_SQUARE_ARROW ); + + rSet.ClearItem(SID_DRAW_RECT); + rSet.DisableItem(SID_DRAW_RECT); + rSet.ClearItem(SID_DRAW_RECT_NOFILL); + rSet.DisableItem(SID_DRAW_RECT_NOFILL); + rSet.ClearItem(SID_DRAW_RECT_ROUND); + rSet.DisableItem(SID_DRAW_RECT_ROUND); + rSet.ClearItem(SID_DRAW_RECT_ROUND_NOFILL); + rSet.DisableItem(SID_DRAW_RECT_ROUND_NOFILL); + rSet.ClearItem(SID_DRAW_SQUARE); + rSet.DisableItem(SID_DRAW_SQUARE); + rSet.ClearItem(SID_DRAW_SQUARE_NOFILL); + rSet.DisableItem(SID_DRAW_SQUARE_NOFILL); + rSet.ClearItem(SID_DRAW_SQUARE_ROUND); + rSet.DisableItem(SID_DRAW_SQUARE_ROUND); + rSet.ClearItem(SID_DRAW_SQUARE_ROUND_NOFILL); + rSet.DisableItem(SID_DRAW_SQUARE_ROUND_NOFILL); + rSet.ClearItem(SID_DRAW_ELLIPSE); + rSet.DisableItem(SID_DRAW_ELLIPSE); + rSet.ClearItem(SID_DRAW_ELLIPSE_NOFILL); + rSet.DisableItem(SID_DRAW_ELLIPSE_NOFILL); + rSet.ClearItem(SID_DRAW_CIRCLE); + rSet.DisableItem(SID_DRAW_CIRCLE); + rSet.ClearItem(SID_DRAW_CIRCLE_NOFILL); + rSet.DisableItem(SID_DRAW_CIRCLE_NOFILL); + rSet.ClearItem(SID_DRAW_CAPTION); + rSet.DisableItem(SID_DRAW_CAPTION); + rSet.ClearItem(SID_DRAW_FONTWORK); + rSet.DisableItem(SID_DRAW_FONTWORK); + rSet.ClearItem(SID_DRAW_FONTWORK_VERTICAL); + rSet.DisableItem(SID_DRAW_FONTWORK_VERTICAL); + rSet.ClearItem(SID_DRAW_CAPTION_VERTICAL); + rSet.DisableItem(SID_DRAW_CAPTION_VERTICAL); + rSet.ClearItem(SID_TEXT_FITTOSIZE); + rSet.DisableItem(SID_TEXT_FITTOSIZE); + rSet.ClearItem(SID_TEXT_FITTOSIZE_VERTICAL); + rSet.DisableItem(SID_TEXT_FITTOSIZE_VERTICAL); + rSet.ClearItem(SID_TOOL_CONNECTOR); + rSet.DisableItem(SID_TOOL_CONNECTOR); + rSet.ClearItem(SID_CONNECTOR_ARROW_START); + rSet.DisableItem(SID_CONNECTOR_ARROW_START); + rSet.ClearItem(SID_CONNECTOR_ARROW_END); + rSet.DisableItem(SID_CONNECTOR_ARROW_END); + rSet.ClearItem(SID_CONNECTOR_ARROWS); + rSet.DisableItem(SID_CONNECTOR_ARROWS); + rSet.ClearItem(SID_CONNECTOR_CIRCLE_START); + rSet.DisableItem(SID_CONNECTOR_CIRCLE_START); + rSet.ClearItem(SID_CONNECTOR_CIRCLE_END); + rSet.DisableItem(SID_CONNECTOR_CIRCLE_END); + rSet.ClearItem(SID_CONNECTOR_CIRCLES); + rSet.DisableItem(SID_CONNECTOR_CIRCLES); + rSet.ClearItem(SID_CONNECTOR_LINE); + rSet.DisableItem(SID_CONNECTOR_LINE); + rSet.ClearItem(SID_CONNECTOR_LINE_ARROW_START); + rSet.DisableItem(SID_CONNECTOR_LINE_ARROW_START); + rSet.ClearItem(SID_CONNECTOR_LINE_ARROW_END); + rSet.DisableItem(SID_CONNECTOR_LINE_ARROW_END); + rSet.ClearItem(SID_CONNECTOR_LINE_ARROWS); + rSet.DisableItem(SID_CONNECTOR_LINE_ARROWS); + rSet.ClearItem(SID_CONNECTOR_LINE_CIRCLE_START); + rSet.DisableItem(SID_CONNECTOR_LINE_CIRCLE_START); + rSet.ClearItem(SID_CONNECTOR_LINE_CIRCLE_END); + rSet.DisableItem(SID_CONNECTOR_LINE_CIRCLE_END); + rSet.ClearItem(SID_CONNECTOR_LINE_CIRCLES); + rSet.DisableItem(SID_CONNECTOR_LINE_CIRCLES); + rSet.ClearItem(SID_CONNECTOR_CURVE); + rSet.DisableItem(SID_CONNECTOR_CURVE); + rSet.ClearItem(SID_CONNECTOR_CURVE_ARROW_START); + rSet.DisableItem(SID_CONNECTOR_CURVE_ARROW_START); + rSet.ClearItem(SID_CONNECTOR_CURVE_ARROW_END); + rSet.DisableItem(SID_CONNECTOR_CURVE_ARROW_END); + rSet.ClearItem(SID_CONNECTOR_CURVE_ARROWS); + rSet.DisableItem(SID_CONNECTOR_CURVE_ARROWS); + rSet.ClearItem(SID_CONNECTOR_CURVE_CIRCLE_START); + rSet.DisableItem(SID_CONNECTOR_CURVE_CIRCLE_START); + rSet.ClearItem(SID_CONNECTOR_CURVE_CIRCLE_END); + rSet.DisableItem(SID_CONNECTOR_CURVE_CIRCLE_END); + rSet.ClearItem(SID_CONNECTOR_CURVE_CIRCLES); + rSet.DisableItem(SID_CONNECTOR_CURVE_CIRCLES); + rSet.ClearItem(SID_CONNECTOR_LINES); + rSet.DisableItem(SID_CONNECTOR_LINES); + rSet.ClearItem(SID_CONNECTOR_LINES_ARROW_START); + rSet.DisableItem(SID_CONNECTOR_LINES_ARROW_START); + rSet.ClearItem(SID_CONNECTOR_LINES_ARROW_END); + rSet.DisableItem(SID_CONNECTOR_LINES_ARROW_END); + rSet.ClearItem(SID_CONNECTOR_LINES_ARROWS); + rSet.DisableItem(SID_CONNECTOR_LINES_ARROWS); + rSet.ClearItem(SID_CONNECTOR_LINES_CIRCLE_START); + rSet.DisableItem(SID_CONNECTOR_LINES_CIRCLE_START); + rSet.ClearItem(SID_CONNECTOR_LINES_CIRCLE_END); + rSet.DisableItem(SID_CONNECTOR_LINES_CIRCLE_END); + rSet.ClearItem(SID_CONNECTOR_LINES_CIRCLES); + rSet.DisableItem(SID_CONNECTOR_LINES_CIRCLES); + rSet.ClearItem(SID_DRAW_ARC); + rSet.DisableItem(SID_DRAW_ARC); + rSet.ClearItem(SID_DRAW_CIRCLEARC); + rSet.DisableItem(SID_DRAW_CIRCLEARC); + rSet.ClearItem(SID_DRAW_PIE); + rSet.DisableItem(SID_DRAW_PIE); + rSet.ClearItem(SID_DRAW_PIE_NOFILL); + rSet.DisableItem(SID_DRAW_PIE_NOFILL); + rSet.ClearItem(SID_DRAW_CIRCLEPIE); + rSet.DisableItem(SID_DRAW_CIRCLEPIE); + rSet.ClearItem(SID_DRAW_CIRCLEPIE_NOFILL); + rSet.DisableItem(SID_DRAW_CIRCLEPIE_NOFILL); + rSet.ClearItem(SID_DRAW_ELLIPSECUT); + rSet.DisableItem(SID_DRAW_ELLIPSECUT); + rSet.ClearItem(SID_DRAW_ELLIPSECUT_NOFILL); + rSet.DisableItem(SID_DRAW_ELLIPSECUT_NOFILL); + rSet.ClearItem(SID_DRAW_CIRCLECUT); + rSet.DisableItem(SID_DRAW_CIRCLECUT); + rSet.ClearItem(SID_DRAW_CIRCLECUT_NOFILL); + rSet.DisableItem(SID_DRAW_CIRCLECUT_NOFILL); + rSet.ClearItem(SID_DRAW_POLYGON); + rSet.DisableItem(SID_DRAW_POLYGON); + rSet.ClearItem(SID_DRAW_POLYGON_NOFILL); + rSet.DisableItem(SID_DRAW_POLYGON_NOFILL); + rSet.ClearItem(SID_DRAW_FREELINE); + rSet.DisableItem(SID_DRAW_FREELINE); + rSet.ClearItem(SID_DRAW_FREELINE_NOFILL); + rSet.DisableItem(SID_DRAW_FREELINE_NOFILL); + rSet.ClearItem(SID_DRAW_XPOLYGON); + rSet.DisableItem(SID_DRAW_XPOLYGON); + rSet.ClearItem(SID_DRAW_XPOLYGON_NOFILL); + rSet.DisableItem(SID_DRAW_XPOLYGON_NOFILL); + rSet.ClearItem(SID_DRAW_BEZIER_FILL); + rSet.DisableItem(SID_DRAW_BEZIER_FILL); + rSet.ClearItem(SID_DRAW_BEZIER_NOFILL); + rSet.DisableItem(SID_DRAW_BEZIER_NOFILL); + rSet.ClearItem(SID_3D_CUBE); + rSet.DisableItem(SID_3D_CUBE); + rSet.ClearItem(SID_3D_SHELL); + rSet.DisableItem(SID_3D_SHELL); + rSet.ClearItem(SID_3D_SPHERE); + rSet.DisableItem(SID_3D_SPHERE); + rSet.ClearItem(SID_3D_HALF_SPHERE); + rSet.DisableItem(SID_3D_HALF_SPHERE); + rSet.ClearItem(SID_3D_CYLINDER); + rSet.DisableItem(SID_3D_CYLINDER); + rSet.ClearItem(SID_3D_CONE); + rSet.DisableItem(SID_3D_CONE); + rSet.ClearItem(SID_3D_TORUS); + rSet.DisableItem(SID_3D_TORUS); + rSet.ClearItem(SID_3D_PYRAMID); + rSet.DisableItem(SID_3D_PYRAMID); + } + + // Sind die Module verfuegbar? + + if (!SvtModuleOptions().IsCalc()) + { + // remove menu entry if module is not available + rSet.Put( SfxVisibilityItem( SID_ATTR_TABLE, sal_False ) ); + } + if (!SvtModuleOptions().IsChart()) + { + rSet.DisableItem( SID_INSERT_DIAGRAM ); + } +#ifdef STARIMAGE_AVAILABLE + if (!(pApp->HasFeature(SFX_FEATURE_SIMAGE))) + { + rSet.DisableItem( SID_INSERT_IMAGE ); + } +#endif + if (!SvtModuleOptions().IsMath()) + { + rSet.DisableItem( SID_INSERT_MATH ); + } + + rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if( (xSlideshow.is() && xSlideshow->isRunning() && (xSlideshow->getAnimationMode() != ANIMATIONMODE_PREVIEW) ) || GetDocSh()->IsPreview() ) + { + // Eigene Slots + rSet.DisableItem( SID_PRESENTATION ); + rSet.DisableItem( SID_ZOOM_IN ); + rSet.DisableItem( SID_ZOOM_OUT ); + rSet.DisableItem( SID_ZOOM_PANNING ); + rSet.DisableItem( SID_ZOOM_NEXT ); + rSet.DisableItem( SID_ZOOM_PREV ); + rSet.DisableItem( SID_SIZE_REAL ); + rSet.DisableItem( SID_SIZE_OPTIMAL ); + rSet.DisableItem( SID_SIZE_ALL ); + rSet.DisableItem( SID_SIZE_PAGE_WIDTH ); + rSet.DisableItem( SID_SIZE_PAGE ); + rSet.DisableItem( SID_INSERTPAGE ); + rSet.DisableItem( SID_DUPLICATE_PAGE ); + rSet.DisableItem( SID_MODIFYPAGE ); + rSet.DisableItem( SID_RENAMEPAGE ); + rSet.DisableItem( SID_RENAMEPAGE_QUICK ); + rSet.DisableItem( SID_DELETE_PAGE ); + rSet.DisableItem( SID_PAGESETUP ); + + if( xSlideshow.is() && xSlideshow->isRunning() ) + { + rSet.ClearItem(SID_OBJECT_ALIGN); + rSet.ClearItem(SID_ZOOM_TOOLBOX); + rSet.ClearItem(SID_OBJECT_CHOOSE_MODE); + rSet.ClearItem(SID_DRAWTBX_TEXT); + rSet.ClearItem(SID_DRAWTBX_RECTANGLES); + rSet.ClearItem(SID_DRAWTBX_ELLIPSES); + rSet.ClearItem(SID_DRAWTBX_LINES); + rSet.ClearItem(SID_DRAWTBX_ARROWS); + rSet.ClearItem(SID_DRAWTBX_3D_OBJECTS); + rSet.ClearItem(SID_DRAWTBX_CONNECTORS); + rSet.ClearItem(SID_OBJECT_CHOOSE_MODE ); + rSet.ClearItem(SID_DRAWTBX_INSERT); + rSet.ClearItem(SID_INSERTFILE); + rSet.ClearItem(SID_OBJECT_ROTATE); + rSet.ClearItem(SID_OBJECT_ALIGN); + rSet.ClearItem(SID_POSITION); + rSet.ClearItem(SID_FM_CONFIG); + rSet.ClearItem(SID_ANIMATION_EFFECTS); + rSet.ClearItem(SID_ANIMATION_OBJECTS); + rSet.ClearItem(SID_3D_WIN); + + rSet.DisableItem(SID_OBJECT_ALIGN); + rSet.DisableItem(SID_ZOOM_TOOLBOX); + rSet.DisableItem(SID_OBJECT_CHOOSE_MODE); + rSet.DisableItem(SID_DRAWTBX_TEXT); + rSet.DisableItem(SID_DRAWTBX_RECTANGLES); + rSet.DisableItem(SID_DRAWTBX_ELLIPSES); + rSet.DisableItem(SID_DRAWTBX_LINES); + rSet.DisableItem(SID_DRAWTBX_ARROWS); + rSet.DisableItem(SID_DRAWTBX_3D_OBJECTS); + rSet.DisableItem(SID_DRAWTBX_CONNECTORS); + rSet.DisableItem(SID_OBJECT_CHOOSE_MODE ); + rSet.DisableItem(SID_DRAWTBX_INSERT); + rSet.DisableItem(SID_INSERTFILE); + rSet.DisableItem(SID_OBJECT_ROTATE); + rSet.DisableItem(SID_OBJECT_ALIGN); + rSet.DisableItem(SID_POSITION); + rSet.DisableItem(SID_FM_CONFIG); + rSet.DisableItem(SID_ANIMATION_EFFECTS); + rSet.DisableItem(SID_ANIMATION_OBJECTS); + rSet.DisableItem(SID_3D_WIN); + } + } + + // #i102735# discussed with CL: removed for performance reasons + #if 0 + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_INSERT_SOUND ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_INSERT_VIDEO ) ) + { + /////////////////////////////////////////////////////////////////////// + // Menuoption : Insert->Object->Sound and Insert->Object->Video + // diable, if there isn't installed any appropriate plugin + // + if (!SvxPluginFileDlg::IsAvailable (SID_INSERT_SOUND)) + rSet.DisableItem (SID_INSERT_SOUND); + if (!SvxPluginFileDlg::IsAvailable (SID_INSERT_VIDEO)) + rSet.DisableItem (SID_INSERT_VIDEO); + } + #endif + + /////////////////////////////////////////////////////////////////////// + // Menuoption: Change->Convert->To Bitmap, Change->Convert->To Metafile + // disable, if there only Bitmap or Metafiles marked + // Menuoption: Format->Area, Format->Line + // disabled, if the marked objects not able to handle + // these attributes + // + + bool bSingleGraphicSelected = false; + + if (!mpDrawView->AreObjectsMarked()) + { + rSet.DisableItem (SID_CONVERT_TO_METAFILE); + rSet.DisableItem (SID_CONVERT_TO_BITMAP); + } + else + { + // get marklist + SdrMarkList aMarkList = mpDrawView->GetMarkedObjectList(); + + BOOL bFoundBitmap = FALSE; + BOOL bFoundMetafile = FALSE; + BOOL bFoundObjNoLine = FALSE; + BOOL bFoundObjNoArea = FALSE; + BOOL bFoundNoGraphicObj = FALSE; + BOOL bFoundAny = FALSE; + bool bFoundTable = false; + +// const int nMarkCount = (int) aMarkList.GetMarkCount(); + for (ULONG i=0; i < nMarkCount && !bFoundAny; i++) + { + SdrObject* pObj= aMarkList.GetMark(i)->GetMarkedSdrObj(); + UINT16 nId = pObj->GetObjIdentifier(); + UINT32 nInv = pObj->GetObjInventor(); + + if(nInv == SdrInventor) + { + // 2D objects + switch( nId ) + { + case OBJ_PATHLINE : + case OBJ_PLIN : + case OBJ_LINE: + case OBJ_FREELINE : + case OBJ_EDGE: + case OBJ_CARC : + bFoundObjNoArea = TRUE; + bFoundNoGraphicObj = TRUE; + break; + case OBJ_OLE2 : + bFoundObjNoLine = TRUE; + bFoundObjNoArea = TRUE; + bFoundNoGraphicObj = TRUE; + break; + case OBJ_GRAF : + bSingleGraphicSelected = nMarkCount == 1; + switch ( ((SdrGrafObj*)pObj)->GetGraphicType() ) + { + case GRAPHIC_BITMAP : + bFoundBitmap = TRUE; + break; + case GRAPHIC_GDIMETAFILE : + bFoundMetafile = TRUE; + break; + default: + break; + } + + // #i25616# bFoundObjNoLine = TRUE; + // #i25616# bFoundObjNoArea = TRUE; + break; + case OBJ_TABLE: + bFoundTable = true; + break; + default : + bFoundAny = TRUE; + } + } + else if(nInv == E3dInventor) + { + // 3D objects + bFoundAny = TRUE; + } + } + + if( bFoundTable ) + rSet.DisableItem( SID_ATTRIBUTES_LINE ); + + if (!bFoundAny) + { + // Disable menuitem for area-dialog + if( bFoundObjNoArea ) // #i25616# + rSet.DisableItem( SID_ATTRIBUTES_AREA ); + + // Disable menuitem for line-dialog + if( bFoundObjNoLine ) + rSet.DisableItem( SID_ATTRIBUTES_LINE ); + + if( bFoundBitmap && !bFoundMetafile && !bFoundNoGraphicObj ) // only Bitmaps marked + rSet.DisableItem( SID_CONVERT_TO_BITMAP ); + else if( !bFoundBitmap && bFoundMetafile && !bFoundNoGraphicObj ) // only Metafiles marked + rSet.DisableItem( SID_CONVERT_TO_METAFILE ); + else if( !bFoundBitmap && !bFoundMetafile && !bFoundNoGraphicObj ) // nothing to do + { + rSet.DisableItem( SID_CONVERT_TO_BITMAP ); + rSet.DisableItem( SID_CONVERT_TO_METAFILE ); + } + } + } + + if( !bSingleGraphicSelected ) + { + rSet.DisableItem (SID_OBJECT_CROP); + rSet.DisableItem (SID_ATTR_GRAF_CROP); + } + + // #96090# moved SID_UNDO to ViewShell::GetMenuState() + // #96090# moved SID_REDO to ViewShell::GetMenuState() + // #96090# moved SID_GETUNDOSTRINGS to ViewShell::GetMenuState() + // #96090# moved SID_GETREDOSTRINGS to ViewShell::GetMenuState() + + /////////////////////////////////////////////////////////////////////// + // Menuoption: Edit->Hyperlink + // Disable, if there is no hyperlink + // + sal_Bool bDisableEditHyperlink = sal_True; + if( mpDrawView->AreObjectsMarked() && ( mpDrawView->GetMarkedObjectList().GetMarkCount() == 1 ) ) + { + if( mpDrawView->IsTextEdit() ) + { + OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView(); + if (pOLV) + { + const SvxFieldItem* pFieldItem = pOLV->GetFieldAtSelection(); + if (pFieldItem) + { + ESelection aSel = pOLV->GetSelection(); + if ( abs( aSel.nEndPos - aSel.nStartPos ) == 1 ) + { + const SvxFieldData* pField = pFieldItem->GetField(); + if ( pField->ISA(SvxURLField) ) + bDisableEditHyperlink = sal_False; + } + } + } + } + else + { + SdrUnoObj* pUnoCtrl = PTR_CAST(SdrUnoObj, mpDrawView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj()); + + if ( pUnoCtrl && FmFormInventor == pUnoCtrl->GetObjInventor() ) + { + uno::Reference< awt::XControlModel > xControlModel( pUnoCtrl->GetUnoControlModel() ); + if( xControlModel.is() ) + { + uno::Reference< beans::XPropertySet > xPropSet( xControlModel, uno::UNO_QUERY ); + if( xPropSet.is() ) + { + uno::Reference< beans::XPropertySetInfo > xPropInfo( xPropSet->getPropertySetInfo() ); + if( xPropInfo.is() && xPropInfo->hasPropertyByName( + rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TargetURL")))) + { + bDisableEditHyperlink = sal_False; + } + } + } + } + } + } + + //highlight selected custom shape + { + USHORT nCurrentSId = 0; + if(HasCurrentFunction()) + nCurrentSId = GetCurrentFunction()->GetSlotID(); + + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DRAWTBX_CS_BASIC ) ) + rSet.Put(SfxBoolItem(SID_DRAWTBX_CS_BASIC, SID_DRAWTBX_CS_BASIC == nCurrentSId )); + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DRAWTBX_CS_SYMBOL ) ) + rSet.Put(SfxBoolItem(SID_DRAWTBX_CS_SYMBOL, SID_DRAWTBX_CS_SYMBOL == nCurrentSId )); + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DRAWTBX_CS_ARROW ) ) + rSet.Put(SfxBoolItem(SID_DRAWTBX_CS_ARROW, SID_DRAWTBX_CS_ARROW == nCurrentSId )); + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DRAWTBX_CS_FLOWCHART ) ) + rSet.Put(SfxBoolItem(SID_DRAWTBX_CS_FLOWCHART, SID_DRAWTBX_CS_FLOWCHART == nCurrentSId )); + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DRAWTBX_CS_CALLOUT ) ) + rSet.Put(SfxBoolItem(SID_DRAWTBX_CS_CALLOUT,SID_DRAWTBX_CS_CALLOUT == nCurrentSId )); + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DRAWTBX_CS_STAR ) ) + rSet.Put(SfxBoolItem(SID_DRAWTBX_CS_STAR, SID_DRAWTBX_CS_STAR == nCurrentSId )); + } + + if ( bDisableEditHyperlink || GetDocSh()->IsReadOnly() ) + rSet.DisableItem( SID_EDIT_HYPERLINK ); + + if ( bDisableEditHyperlink ) + rSet.DisableItem( SID_OPEN_HYPERLINK ); + +#if defined WIN || defined WNT || defined UNX + if( !mxScannerManager.is() ) + { + rSet.DisableItem( SID_TWAIN_SELECT ); + rSet.DisableItem( SID_TWAIN_TRANSFER ); + } +#endif + +// Fuer Win16 +#ifndef SOLAR_JAVA + rSet.DisableItem( SID_INSERT_APPLET ); +#endif + + // Set the state of two entries in the 'Slide' context sub-menu + // concerning the visibility of master page background and master page + // shapes. + if (rSet.GetItemState(SID_DISPLAY_MASTER_BACKGROUND) == SFX_ITEM_AVAILABLE + || rSet.GetItemState(SID_DISPLAY_MASTER_OBJECTS) == SFX_ITEM_AVAILABLE) + { + SdPage* pPage = GetActualPage(); + if (pPage != NULL + && GetDoc() != NULL) + { + SetOfByte aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers(); + SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin(); + BYTE aBackgroundId = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE); + BYTE aObjectId = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE); + rSet.Put(SfxBoolItem(SID_DISPLAY_MASTER_BACKGROUND, + aVisibleLayers.IsSet(aBackgroundId))); + rSet.Put(SfxBoolItem(SID_DISPLAY_MASTER_OBJECTS, + aVisibleLayers.IsSet(aObjectId))); + } + } + + GetModeSwitchingMenuState (rSet); +} + +void DrawViewShell::GetModeSwitchingMenuState (SfxItemSet &rSet) +{ + //draview + rSet.Put(SfxBoolItem(SID_DIAMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_OUTLINEMODE, FALSE)); + if (mePageKind == PK_NOTES) + { + rSet.Put(SfxBoolItem(SID_DRAWINGMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_NOTESMODE, TRUE)); + rSet.Put(SfxBoolItem(SID_HANDOUTMODE, FALSE)); + } + else if (mePageKind == PK_HANDOUT) + { + rSet.Put(SfxBoolItem(SID_DRAWINGMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_NOTESMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_HANDOUTMODE, TRUE)); + } + else + { + rSet.Put(SfxBoolItem(SID_DRAWINGMODE, TRUE)); + rSet.Put(SfxBoolItem(SID_NOTESMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_HANDOUTMODE, FALSE)); + } + + // #101976# Removed [GetDocSh()->GetCurrentFunction() ||] from the following + // clause because the current function of the docshell can only be + // search and replace or spell checking and in that case switching the + // view mode is allowed. + const bool bIsRunning = SlideShow::IsRunning(GetViewShellBase()); + + if (GetViewFrame()->GetFrame().IsInPlace() || bIsRunning) + { + if ( !GetViewFrame()->GetFrame().IsInPlace() ) + { + rSet.ClearItem( SID_DRAWINGMODE ); + rSet.DisableItem( SID_DRAWINGMODE ); + } + + rSet.ClearItem( SID_NOTESMODE ); + rSet.DisableItem( SID_NOTESMODE ); + + rSet.ClearItem( SID_HANDOUTMODE ); + rSet.DisableItem( SID_HANDOUTMODE ); + + rSet.ClearItem( SID_OUTLINEMODE ); + rSet.DisableItem( SID_OUTLINEMODE ); + + rSet.ClearItem( SID_DIAMODE ); + rSet.DisableItem( SID_DIAMODE ); + } + + if (GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED) + { + // Outplace-Edit: Kein Umschalten erlauben + rSet.ClearItem( SID_OUTLINEMODE ); + rSet.DisableItem( SID_OUTLINEMODE ); + + rSet.ClearItem( SID_DIAMODE ); + rSet.DisableItem( SID_DIAMODE ); + + rSet.ClearItem( SID_NOTESMODE ); + rSet.DisableItem( SID_NOTESMODE ); + + rSet.ClearItem( SID_HANDOUTMODE ); + rSet.DisableItem( SID_HANDOUTMODE ); + } + + svx::ExtrusionBar::getState( mpDrawView, rSet ); + svx::FontworkBar::getState( mpDrawView, rSet ); +} + + + +void DrawViewShell::GetState (SfxItemSet& rSet) +{ + // Iterate over all requested items in the set. + SfxWhichIter aIter( rSet ); + USHORT nWhich = aIter.FirstWhich(); + while (nWhich) + { + switch (nWhich) + { + case SID_SEARCH_ITEM: + case SID_SEARCH_OPTIONS: + // Forward this request to the the common (old) code of the + // document shell. + GetDocSh()->GetState (rSet); + break; + default: + OSL_TRACE ("DrawViewShell::GetState(): can not handle which id %d", nWhich); + break; + } + nWhich = aIter.NextWhich(); + } +} + + + + +void DrawViewShell::Execute (SfxRequest& rReq) +{ + if(SlideShow::IsRunning(GetViewShellBase())) + { + // Do not execute anything during a native slide show. + return; + } + + switch (rReq.GetSlot()) + { + case SID_SEARCH_ITEM: + // Forward this request to the the common (old) code of the + // document shell. + GetDocSh()->Execute (rReq); + break; + + case SID_SPELL_DIALOG: + { + SfxViewFrame* pViewFrame = GetViewFrame(); + if (rReq.GetArgs() != NULL) + pViewFrame->SetChildWindow (SID_SPELL_DIALOG, + ((const SfxBoolItem&) (rReq.GetArgs()-> + Get(SID_SPELL_DIALOG))).GetValue()); + else + pViewFrame->ToggleChildWindow(SID_SPELL_DIALOG); + + pViewFrame->GetBindings().Invalidate(SID_SPELL_DIALOG); + rReq.Ignore (); + } + break; + + default: + OSL_TRACE ("DrawViewShell::Execute(): can not handle slot %d", rReq.GetSlot()); + break; + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviews8.cxx b/sd/source/ui/view/drviews8.cxx new file mode 100755 index 000000000000..54cd0c792c94 --- /dev/null +++ b/sd/source/ui/view/drviews8.cxx @@ -0,0 +1,558 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" + +#include "ViewShellHint.hxx" + +#ifndef _TOOLKIT_HELPER_VCLUNOHELPER_HXX_ +#include <toolkit/unohlp.hxx> +#endif +#include <sfx2/dispatch.hxx> +#ifndef _SVXIDS_HXX +#include <svx/svxids.hrc> +#endif +#include <vcl/msgbox.hxx> +#include <svx/svddef.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/request.hxx> +#include <sfx2/viewfrm.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdpagv.hxx> + +#include "app.hrc" +#include "strings.hrc" + +#include "misc.hxx" +#include "fuzoom.hxx" +#include "fudspord.hxx" +#include "futransf.hxx" +#include "fuline.hxx" +#include "fuarea.hxx" +#include "fuchar.hxx" +#include "fuparagr.hxx" +#include "fubullet.hxx" +#include "futempl.hxx" +#include "fuinsert.hxx" +#include "fuprlout.hxx" +#include "fupage.hxx" +#ifndef SD_FU_OBJECT_ANIMATION_PARAMETERS_HXX +#include "fuoaprms.hxx" +#endif +#include "fucopy.hxx" +#ifndef SD_FU_LINE_END_HXX +#include "fulinend.hxx" +#endif +#include "fusnapln.hxx" +#include "fuolbull.hxx" +#include "fuinsfil.hxx" +#include "fulink.hxx" +#include "futhes.hxx" +#include "futxtatt.hxx" +#include "fumeasur.hxx" +#include "fuconnct.hxx" +#include "fumorph.hxx" +#include "fuvect.hxx" +#include "sdresid.hxx" +#include "Window.hxx" +#include "drawview.hxx" +#include "zoomlist.hxx" +#include <vos/mutex.hxx> +#include <vcl/salbtype.hxx> // FRound +#include <vcl/svapp.hxx> + +namespace sd { + +/************************************************************************* +|* +|* SfxRequests fuer temporaere Funktionen +|* +\************************************************************************/ + +void DrawViewShell::FuTemp01(SfxRequest& rReq) +{ + switch(rReq.GetSlot()) + { + case SID_ATTRIBUTES_LINE: // BASIC + { + SetCurrentFunction( FuLine::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_ATTRIBUTES_AREA: // BASIC + { + SetCurrentFunction( FuArea::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_ATTR_TRANSFORM: + { + SetCurrentFunction( FuTransform::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Invalidate(SID_RULER_OBJECT); + Cancel(); + } + break; + + case SID_CHAR_DLG: // BASIC + { + SetCurrentFunction( FuChar::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_PARA_DLG: + { + SetCurrentFunction( FuParagraph::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_OUTLINE_BULLET: + { + SetCurrentFunction( FuOutlineBullet::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case FN_INSERT_SOFT_HYPHEN: + case FN_INSERT_HARDHYPHEN: + case FN_INSERT_HARD_SPACE: + case SID_INSERT_RLM : + case SID_INSERT_LRM : + case SID_INSERT_ZWNBSP : + case SID_INSERT_ZWSP: + case SID_CHARMAP: + { + SetCurrentFunction( FuBullet::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_PRESENTATION_LAYOUT: + { + SetCurrentFunction( FuPresentationLayout::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) ); + Cancel(); + } + break; + + case SID_PASTE_SPECIAL: + { + SetCurrentFunction( FuInsertClipboard::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_INSERT_GRAPHIC: + { + SetCurrentFunction( FuInsertGraphic::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + rReq.Ignore (); + Invalidate(SID_DRAWTBX_INSERT); + } + break; + + case SID_INSERT_AVMEDIA: + { + SetCurrentFunction( FuInsertAVMedia::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + + Cancel(); + rReq.Ignore (); + + Invalidate(SID_DRAWTBX_INSERT); + } + break; + + case SID_INSERT_OBJECT: + case SID_INSERT_PLUGIN: + case SID_INSERT_SOUND: + case SID_INSERT_VIDEO: + case SID_INSERT_APPLET: + case SID_INSERT_FLOATINGFRAME: + case SID_INSERT_MATH: + case SID_INSERT_DIAGRAM: + case SID_ATTR_TABLE: + { + SetCurrentFunction( FuInsertOLE::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + + Cancel(); + rReq.Ignore (); + + Invalidate(SID_DRAWTBX_INSERT); + } + break; + + case SID_COPYOBJECTS: + { + if ( mpDrawView->IsPresObjSelected(FALSE, TRUE) ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + SetCurrentFunction( FuCopy::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + } + Cancel(); + rReq.Ignore (); + } + break; + + case SID_INSERTFILE: // BASIC + { + Broadcast (ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_START)); + SetCurrentFunction( FuInsertFile::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Broadcast (ViewShellHint(ViewShellHint::HINT_COMPLEX_MODEL_CHANGE_END)); + Cancel(); + rReq.Done (); + + Invalidate(SID_DRAWTBX_INSERT); + } + break; + + case SID_SELECT_BACKGROUND: + case SID_PAGESETUP: // BASIC ?? + { + SetCurrentFunction( FuPage::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + rReq.Ignore (); // es werden eigenstaendige macros generiert !! + } + break; + + case SID_ZOOM_OUT: + case SID_ZOOM_PANNING: + { + mbZoomOnPage = FALSE; + SetCurrentFunction( FuZoom::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) ); + // Beendet sich selbst, kein Cancel() notwendig! + Invalidate( SID_ZOOM_TOOLBOX ); + rReq.Ignore (); + } + break; + + case SID_BEFORE_OBJ: + case SID_BEHIND_OBJ: + { + SetCurrentFunction( FuDisplayOrder::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) ); + Invalidate( SID_POSITION ); + rReq.Ignore (); + // Beendet sich selbst, kein Cancel() notwendig! + } + break; + + case SID_REVERSE_ORDER: // BASIC + { + mpDrawView->ReverseOrderOfMarked(); + Invalidate( SID_POSITION ); + Cancel(); + rReq.Done (); + } + break; + + case SID_ANIMATION_EFFECTS: + { + SetCurrentFunction( FuObjectAnimationParameters::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) ); + Cancel(); + } + break; + + case SID_LINEEND_POLYGON: + { + SetCurrentFunction( FuLineEnd::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_CAPTUREPOINT: + // negative Werte um Aufruf aus Menue zu signalisieren + maMousePos = Point(-1,-1); + case SID_SET_SNAPITEM: + { + SetCurrentFunction( FuSnapLine::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) ); + Cancel(); + } + break; + + case SID_MANAGE_LINKS: + { + SetCurrentFunction( FuLink::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_THESAURUS: + { + SetCurrentFunction( FuThesaurus::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_TEXTATTR_DLG: + { + SetCurrentFunction( FuTextAttrDlg::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_MEASURE_DLG: + { + SetCurrentFunction( FuMeasureDlg::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_CONNECTION_DLG: + { + SetCurrentFunction( FuConnectionDlg::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + rReq.Done(); + } + break; + + case SID_CONNECTION_NEW_ROUTING: + { + SfxItemSet aDefAttr( GetPool(), SDRATTR_EDGELINE1DELTA, SDRATTR_EDGELINE3DELTA ); + GetView()->SetAttributes( aDefAttr, TRUE ); // (ReplaceAll) + + Cancel(); + rReq.Done(); + } + break; + + case SID_TWAIN_SELECT: + { + BOOL bDone = FALSE; + + if( mxScannerManager.is() ) + { + try + { + const ::com::sun::star::uno::Sequence< ::com::sun::star::scanner::ScannerContext > + aContexts( mxScannerManager->getAvailableScanners() ); + + if( aContexts.getLength() ) + { + ::com::sun::star::scanner::ScannerContext aContext( aContexts.getConstArray()[ 0 ] ); + bDone = mxScannerManager->configureScanner( aContext ); + } + } + catch(...) + { + } + } + + Cancel(); + rReq.Done(); + } + break; + + case SID_TWAIN_TRANSFER: + { + BOOL bDone = FALSE; + + if( mxScannerManager.is() ) + { + try + { + const ::com::sun::star::uno::Sequence< ::com::sun::star::scanner::ScannerContext > aContexts( mxScannerManager->getAvailableScanners() ); + + if( aContexts.getLength() ) + { + mxScannerManager->startScan( aContexts.getConstArray()[ 0 ], mxScannerListener ); + bDone = TRUE; + } + } + catch( ... ) + { + } + } + + if( !bDone ) + { +#ifndef UNX + const USHORT nId = STR_TWAIN_NO_SOURCE; +#else + const USHORT nId = STR_TWAIN_NO_SOURCE_UNX; +#endif + + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String( SdResId( nId ) ) ).Execute(); + } + else + { + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_TWAIN_SELECT ); + rBindings.Invalidate( SID_TWAIN_TRANSFER ); + } + + Cancel(); + rReq.Done(); + } + break; + + case SID_POLYGON_MORPHING: + { + SetCurrentFunction( FuMorph::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_VECTORIZE: + { + SetCurrentFunction( FuVectorize::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + default: + { + // switch Anweisung wegen CLOOKS aufgeteilt. Alle case-Anweisungen die + // eine Fu???? -Funktion aufrufen, sind in die Methode FuTemp01 (drviews8), + // FuTemp02 (drviewsb) gewandert. + FuTemp02(rReq); + } + break; + } +} + +/************************************************************************* +|* +|* Scanner-Event +|* +\************************************************************************/ + +void DrawViewShell::ScannerEvent( const ::com::sun::star::lang::EventObject& ) +{ + if( mxScannerManager.is() ) + { + const ::com::sun::star::scanner::ScannerContext aContext( mxScannerManager->getAvailableScanners().getConstArray()[ 0 ] ); + const ::com::sun::star::scanner::ScanError eError = mxScannerManager->getError( aContext ); + + if( ::com::sun::star::scanner::ScanError_ScanErrorNone == eError ) + { + const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XBitmap > xBitmap( mxScannerManager->getBitmap( aContext ) ); + + if( xBitmap.is() ) + { + const BitmapEx aScanBmp( VCLUnoHelper::GetBitmap( xBitmap ) ); + + if( !!aScanBmp ) + { + const ::vos::OGuard aGuard( Application::GetSolarMutex() ); + SdrPage* pPage = mpDrawView->GetSdrPageView()->GetPage(); + Size aBmpSize( aScanBmp.GetPrefSize() ), aPageSize( pPage->GetSize() ); + const MapMode aMap100( MAP_100TH_MM ); + + if( !aBmpSize.Width() || !aBmpSize.Height() ) + aBmpSize = aScanBmp.GetSizePixel(); + + if( aScanBmp.GetPrefMapMode().GetMapUnit() == MAP_PIXEL ) + aBmpSize = GetActiveWindow()->PixelToLogic( aBmpSize, aMap100 ); + else + aBmpSize = OutputDevice::LogicToLogic( aBmpSize, aScanBmp.GetPrefMapMode(), aMap100 ); + + aPageSize.Width() -= pPage->GetLftBorder() + pPage->GetRgtBorder(); + aPageSize.Height() -= pPage->GetUppBorder() + pPage->GetLwrBorder(); + + if( ( ( aBmpSize.Height() > aPageSize.Height() ) || ( aBmpSize.Width() > aPageSize.Width() ) ) && aBmpSize.Height() && aPageSize.Height() ) + { + double fGrfWH = (double) aBmpSize.Width() / aBmpSize.Height(); + double fWinWH = (double) aPageSize.Width() / aPageSize.Height(); + + if( fGrfWH < fWinWH ) + { + aBmpSize.Width() = FRound( aPageSize.Height() * fGrfWH ); + aBmpSize.Height()= aPageSize.Height(); + } + else if( fGrfWH > 0.F ) + { + aBmpSize.Width() = aPageSize.Width(); + aBmpSize.Height()= FRound( aPageSize.Width() / fGrfWH ); + } + } + + Point aPnt ( ( aPageSize.Width() - aBmpSize.Width() ) >> 1, ( aPageSize.Height() - aBmpSize.Height() ) >> 1 ); + aPnt += Point( pPage->GetLftBorder(), pPage->GetUppBorder() ); + Rectangle aRect( aPnt, aBmpSize ); + SdrGrafObj* pGrafObj = NULL; + BOOL bInsertNewObject = TRUE; + + if( GetView()->AreObjectsMarked() ) + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + + if( rMarkList.GetMarkCount() == 1 ) + { + SdrMark* pMark = rMarkList.GetMark(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + + if( pObj->ISA( SdrGrafObj ) ) + { + pGrafObj = static_cast< SdrGrafObj* >( pObj ); + + if( pGrafObj->IsEmptyPresObj() ) + { + bInsertNewObject = FALSE; + pGrafObj->SetEmptyPresObj(FALSE); + pGrafObj->SetOutlinerParaObject(NULL); + pGrafObj->SetGraphic( Graphic( aScanBmp ) ); + } + } + } + } + + if( bInsertNewObject ) + { + pGrafObj = new SdrGrafObj( Graphic( aScanBmp ), aRect ); + SdrPageView* pPV = GetView()->GetSdrPageView(); + GetView()->InsertObjectAtView( pGrafObj, *pPV, SDRINSERT_SETDEFLAYER ); + } + } + } + } + } + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_TWAIN_SELECT ); + rBindings.Invalidate( SID_TWAIN_TRANSFER ); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviews9.cxx b/sd/source/ui/view/drviews9.cxx new file mode 100644 index 000000000000..998d723aec45 --- /dev/null +++ b/sd/source/ui/view/drviews9.cxx @@ -0,0 +1,881 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include <vcl/wrkwin.hxx> +#include <svx/xgrad.hxx> +#include <svx/svdpagv.hxx> +#include <svx/xlnwtit.hxx> +#include <svx/xlndsit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xflgrit.hxx> +#include <svx/xlnclit.hxx> +#include <svx/xflclit.hxx> +#include <svx/xlnwtit.hxx> +#include <sfx2/bindings.hxx> + +#ifndef _SFX_DISPATCH_HXX //autogen +#include <sfx2/dispatch.hxx> +#endif +#include <svl/intitem.hxx> +#include <sfx2/app.hxx> +#include <sfx2/request.hxx> +#include <svl/stritem.hxx> +#ifndef _SVXIDS_HXX +#include <svx/svxids.hrc> +#endif +#include <svx/xtable.hxx> +#include <svx/gallery.hxx> +#include <vcl/graph.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdoole2.hxx> +#include <sot/storage.hxx> +#include <svl/whiter.hxx> +#include <basic/sbstar.hxx> + +#include <sfx2/viewfrm.hxx> + + +#include "app.hrc" +#include "strings.hrc" +#include "Window.hxx" +#include "drawdoc.hxx" +#include "drawview.hxx" +#include "DrawDocShell.hxx" +#include "sdresid.hxx" +#include "fupoor.hxx" + +namespace sd { + +#ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED +#define SO2_DECL_SVINPLACEOBJECT_DEFINED +SO2_DECL_REF(SvInPlaceObject) +#endif +#ifndef SO2_DECL_SVSTORAGE_DEFINED +#define SO2_DECL_SVSTORAGE_DEFINED +SO2_DECL_REF(SvStorage) +#endif + + +/************************************************************************* +|* +|* SfxRequests fuer Gallery bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecGallery(SfxRequest& rReq) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if(HasCurrentFunction(SID_PRESENTATION)) + return; + + const SfxItemSet* pArgs = rReq.GetArgs(); + + if ( pArgs ) + { + const UINT32 nFormats = ( (SfxUInt32Item&) pArgs->Get( SID_GALLERY_FORMATS ) ).GetValue(); + GalleryExplorer* pGal = SVX_GALLERY(); + + if ( pGal ) + { + GetDocSh()->SetWaitCursor( TRUE ); + + // Graphik einfuegen + if (nFormats & SGA_FORMAT_GRAPHIC) + { + Graphic aGraphic = pGal->GetGraphic(); + + // Ggf. Groesse reduzieren + Window aWindow (GetActiveWindow()); + aWindow.SetMapMode(aGraphic.GetPrefMapMode()); + Size aSizePix = aWindow.LogicToPixel(aGraphic.GetPrefSize()); + aWindow.SetMapMode( MapMode(MAP_100TH_MM) ); + Size aSize = aWindow.PixelToLogic(aSizePix); + + // Groesse ggf. auf Seitengroesse begrenzen + SdrPage* pPage = mpDrawView->GetSdrPageView()->GetPage(); + Size aPageSize = pPage->GetSize(); + aPageSize.Width() -= pPage->GetLftBorder() + pPage->GetRgtBorder(); + aPageSize.Height() -= pPage->GetUppBorder() + pPage->GetLwrBorder(); + + + // Falls Grafik zu gross, wird die Grafik + // in die Seite eingepasst + if ( ( ( aSize.Height() > aPageSize.Height() ) || ( aSize.Width() > aPageSize.Width() ) ) && + aSize.Height() && aPageSize.Height() ) + { + float fGrfWH = (float)aSize.Width() / + (float)aSize.Height(); + float fWinWH = (float)aPageSize.Width() / + (float)aPageSize.Height(); + + // Grafik an Pagesize anpassen (skaliert) + if ((fGrfWH != 0.F) && (fGrfWH < fWinWH)) + { + aSize.Width() = (long)(aPageSize.Height() * fGrfWH); + aSize.Height()= aPageSize.Height(); + } + else + { + aSize.Width() = aPageSize.Width(); + aSize.Height()= (long)(aPageSize.Width() / fGrfWH); + } + } + + + // Ausgaberechteck fuer Grafik setzen + Point aPnt ((aPageSize.Width() - aSize.Width()) / 2, + (aPageSize.Height() - aSize.Height()) / 2); + aPnt += Point(pPage->GetLftBorder(), pPage->GetUppBorder()); + Rectangle aRect (aPnt, aSize); + + SdrGrafObj* pGrafObj = NULL; + + BOOL bInsertNewObject = TRUE; + + if ( mpDrawView->AreObjectsMarked() ) + { + /****************************************************** + * Ist ein leeres Graphik-Objekt vorhanden? + ******************************************************/ + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + + if (rMarkList.GetMarkCount() == 1) + { + SdrMark* pMark = rMarkList.GetMark(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + + if (pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_GRAF) + { + pGrafObj = (SdrGrafObj*) pObj; + + if( pGrafObj->IsEmptyPresObj() ) + { + /****************************************** + * Das leere Graphik-Objekt bekommt eine neue + * Graphik + ******************************************/ + bInsertNewObject = FALSE; + + SdrGrafObj* pNewGrafObj = (SdrGrafObj*) pGrafObj->Clone(); + pNewGrafObj->SetEmptyPresObj(FALSE); + pNewGrafObj->SetOutlinerParaObject(NULL); + pNewGrafObj->SetGraphic(aGraphic); + + String aStr(mpDrawView->GetDescriptionOfMarkedObjects()); + aStr += sal_Unicode(' '); + aStr += String(SdResId(STR_UNDO_REPLACE)); + mpDrawView->BegUndo(aStr); + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + mpDrawView->ReplaceObjectAtView(pGrafObj, *pPV, pNewGrafObj); + mpDrawView->EndUndo(); + } + } + } + } + + + if( bInsertNewObject ) + { + pGrafObj = new SdrGrafObj(aGraphic, aRect); + SdrPageView* pPV = mpDrawView->GetSdrPageView(); + mpDrawView->InsertObjectAtView(pGrafObj, *pPV, SDRINSERT_SETDEFLAYER); + } + + // Soll nur ein Link benutzt werden? + if( pGrafObj && pGal->IsLinkage() ) + pGrafObj->SetGraphicLink( pGal->GetURL().GetMainURL( INetURLObject::NO_DECODE ), pGal->GetFilterName() ); + } + // insert sound + else if( nFormats & SGA_FORMAT_SOUND ) + { + const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, pGal->GetURL().GetMainURL( INetURLObject::NO_DECODE ) ); + GetViewFrame()->GetDispatcher()->Execute( SID_INSERT_AVMEDIA, SFX_CALLMODE_SYNCHRON, &aMediaURLItem, 0L ); + } + + GetDocSh()->SetWaitCursor( FALSE ); + } + } +} + + +/************************************************************************* +|* +|* Statuswerte fuer Gallery zurueckgeben +|* +\************************************************************************/ + +void DrawViewShell::GetGalleryState(SfxItemSet& ) +{ +} + +/************************************************************************* +|* +|* Makros fuer die Attributeinstellungen bearbeiten +|* +\************************************************************************/ + +// +// die vorgehensweise fuer die attributaenderung ist praktisch ueberall identisch +// 1. bisherige attribute auslesen +// 2. parameter aus dem basic-set auslesen +// 3. gewaehltes item aus dem attribut-set loeschen +// 4. neues attribut-item erzeugen +// 5. item in den set eintragen +// +void DrawViewShell::AttrExec (SfxRequest &rReq) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if(HasCurrentFunction(SID_PRESENTATION)) + return; + + CheckLineTo (rReq); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + SfxItemSet* pAttr = new SfxItemSet ( GetDoc()->GetPool() ); + + GetView()->GetAttributes( *pAttr ); + const SfxItemSet* pArgs = rReq.GetArgs(); + + switch (rReq.GetSlot ()) + { + // neuen fuellstil setzen + case SID_SETFILLSTYLE : + if (pArgs) + if (pArgs->Count () == 1) + { + SFX_REQUEST_ARG (rReq, pFillStyle, SfxUInt32Item, ID_VAL_STYLE, FALSE); + if (CHECK_RANGE (XFILL_NONE, (sal_Int32)pFillStyle->GetValue (), XFILL_BITMAP)) + { + pAttr->ClearItem (XATTR_FILLSTYLE); + pAttr->Put (XFillStyleItem ((XFillStyle) pFillStyle->GetValue ()), XATTR_FILLSTYLE); + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + } + else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + // linienstil neu bestimmen + case SID_SETLINESTYLE : + if (pArgs) + if (pArgs->Count () == 1) + { + SFX_REQUEST_ARG (rReq, pLineStyle, SfxUInt32Item, ID_VAL_STYLE, FALSE); + if (CHECK_RANGE (XLINE_NONE, (sal_Int32)pLineStyle->GetValue (), XLINE_DASH)) + { + pAttr->ClearItem (XATTR_LINESTYLE); + pAttr->Put (XLineStyleItem ((XLineStyle) pLineStyle->GetValue ()), XATTR_LINESTYLE); + rBindings.Invalidate (SID_ATTR_LINE_STYLE); + } + else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + // linienbreite setzen + case SID_SETLINEWIDTH : + if (pArgs) + if (pArgs->Count () == 1) + { + SFX_REQUEST_ARG (rReq, pLineWidth, SfxUInt32Item, ID_VAL_WIDTH, FALSE); + pAttr->ClearItem (XATTR_LINEWIDTH); + pAttr->Put (XLineWidthItem (pLineWidth->GetValue ()), XATTR_LINEWIDTH); + rBindings.Invalidate (SID_ATTR_LINE_WIDTH); + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + case SID_SETFILLCOLOR : + if (pArgs) + if (pArgs->Count () == 3) + { + SFX_REQUEST_ARG (rReq, pRed, SfxUInt32Item, ID_VAL_RED, FALSE); + SFX_REQUEST_ARG (rReq, pGreen, SfxUInt32Item, ID_VAL_GREEN, FALSE); + SFX_REQUEST_ARG (rReq, pBlue, SfxUInt32Item, ID_VAL_BLUE, FALSE); + + pAttr->ClearItem (XATTR_FILLCOLOR); + pAttr->ClearItem (XATTR_FILLSTYLE); + pAttr->Put (XFillColorItem (-1, Color ((BYTE) pRed->GetValue (), + (BYTE) pGreen->GetValue (), + (BYTE) pBlue->GetValue ())), + XATTR_FILLCOLOR); + pAttr->Put (XFillStyleItem (XFILL_SOLID), XATTR_FILLSTYLE); + rBindings.Invalidate (SID_ATTR_FILL_COLOR); + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + case SID_SETLINECOLOR : + if (pArgs) + if (pArgs->Count () == 3) + { + SFX_REQUEST_ARG (rReq, pRed, SfxUInt32Item, ID_VAL_RED, FALSE); + SFX_REQUEST_ARG (rReq, pGreen, SfxUInt32Item, ID_VAL_GREEN, FALSE); + SFX_REQUEST_ARG (rReq, pBlue, SfxUInt32Item, ID_VAL_BLUE, FALSE); + + pAttr->ClearItem (XATTR_LINECOLOR); + pAttr->Put (XLineColorItem (-1, Color ((BYTE) pRed->GetValue (), + (BYTE) pGreen->GetValue (), + (BYTE) pBlue->GetValue ())), + XATTR_LINECOLOR); + rBindings.Invalidate (SID_ATTR_LINE_COLOR); + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + case SID_SETGRADSTARTCOLOR : + case SID_SETGRADENDCOLOR : + if (pArgs) + if (pArgs->Count () == 4) + { + SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, FALSE); + SFX_REQUEST_ARG (rReq, pRed, SfxUInt32Item, ID_VAL_RED, FALSE); + SFX_REQUEST_ARG (rReq, pGreen, SfxUInt32Item, ID_VAL_GREEN, FALSE); + SFX_REQUEST_ARG (rReq, pBlue, SfxUInt32Item, ID_VAL_BLUE, FALSE); + + XGradientList *pGradientList = GetDoc()->GetGradientList (); + long nCounts = pGradientList->Count (); + Color aColor ((BYTE) pRed->GetValue (), + (BYTE) pGreen->GetValue (), + (BYTE) pBlue->GetValue ()); + long i; + + pAttr->ClearItem (XATTR_FILLGRADIENT); + pAttr->ClearItem (XATTR_FILLSTYLE); + + for ( i = 0; i < nCounts; i ++) + { + XGradientEntry *pEntry = pGradientList->GetGradient (i); + + if (pEntry->GetName () == pName->GetValue ()) + { + XGradient &rGradient = pEntry->GetGradient (); + + if (rReq.GetSlot () == SID_SETGRADSTARTCOLOR) rGradient.SetStartColor (aColor); + else rGradient.SetEndColor (aColor); + + pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE); + pAttr->Put (XFillGradientItem (pName->GetValue (), rGradient), XATTR_FILLGRADIENT); + break; + } + } + + if (i >= nCounts) + { + Color aBlack (0, 0, 0); + XGradient aGradient ((rReq.GetSlot () == SID_SETGRADSTARTCOLOR) + ? aColor + : aBlack, + (rReq.GetSlot () == SID_SETGRADENDCOLOR) + ? aColor + : aBlack); + + GetDoc()->GetGradientList ()->Insert (new XGradientEntry (aGradient, pName->GetValue ())); + + pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE); + pAttr->Put (XFillGradientItem (pName->GetValue (), aGradient), XATTR_FILLGRADIENT); + } + + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + rBindings.Invalidate (SID_ATTR_FILL_GRADIENT); + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + case SID_SETHATCHCOLOR : + if (pArgs) + if (pArgs->Count () == 4) + { + SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, FALSE); + SFX_REQUEST_ARG (rReq, pRed, SfxUInt32Item, ID_VAL_RED, FALSE); + SFX_REQUEST_ARG (rReq, pGreen, SfxUInt32Item, ID_VAL_GREEN, FALSE); + SFX_REQUEST_ARG (rReq, pBlue, SfxUInt32Item, ID_VAL_BLUE, FALSE); + + XHatchList *pHatchList = GetDoc()->GetHatchList (); + long nCounts = pHatchList->Count (); + Color aColor ((BYTE) pRed->GetValue (), + (BYTE) pGreen->GetValue (), + (BYTE) pBlue->GetValue ()); + long i; + + pAttr->ClearItem (XATTR_FILLHATCH); + pAttr->ClearItem (XATTR_FILLSTYLE); + + for ( i = 0; i < nCounts; i ++) + { + XHatchEntry *pEntry = pHatchList->GetHatch (i); + + if (pEntry->GetName () == pName->GetValue ()) + { + XHatch &rHatch = pEntry->GetHatch (); + + rHatch.SetColor (aColor); + + pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE); + pAttr->Put (XFillHatchItem (pName->GetValue (), rHatch), XATTR_FILLHATCH); + break; + } + } + + if (i >= nCounts) + { + XHatch aHatch (aColor); + + GetDoc()->GetHatchList ()->Insert (new XHatchEntry (aHatch, pName->GetValue ())); + + pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE); + pAttr->Put (XFillHatchItem (pName->GetValue (), aHatch), XATTR_FILLHATCH); + } + + rBindings.Invalidate (SID_ATTR_FILL_HATCH); + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + // einstellungen fuer liniendash + case SID_DASH : + if (pArgs) + if (pArgs->Count () == 7) + { + SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, FALSE); + SFX_REQUEST_ARG (rReq, pStyle, SfxUInt32Item, ID_VAL_STYLE, FALSE); + SFX_REQUEST_ARG (rReq, pDots, SfxUInt32Item, ID_VAL_DOTS, FALSE); + SFX_REQUEST_ARG (rReq, pDotLen, SfxUInt32Item, ID_VAL_DOTLEN, FALSE); + SFX_REQUEST_ARG (rReq, pDashes, SfxUInt32Item, ID_VAL_DASHES, FALSE); + SFX_REQUEST_ARG (rReq, pDashLen, SfxUInt32Item, ID_VAL_DASHLEN, FALSE); + SFX_REQUEST_ARG (rReq, pDistance, SfxUInt32Item, ID_VAL_DISTANCE, FALSE); + + if (CHECK_RANGE (XDASH_RECT, (sal_Int32)pStyle->GetValue (), XDASH_ROUNDRELATIVE)) + { + XDash aNewDash ((XDashStyle) pStyle->GetValue (), (short) pDots->GetValue (), pDotLen->GetValue (), + (short) pDashes->GetValue (), pDashLen->GetValue (), pDistance->GetValue ()); + + pAttr->ClearItem (XATTR_LINEDASH); + pAttr->ClearItem (XATTR_LINESTYLE); + + XDashList *pDashList = GetDoc()->GetDashList (); + long nCounts = pDashList->Count (); + XDashEntry *pEntry = new XDashEntry (aNewDash, pName->GetValue ()); + long i; + + for ( i = 0; i < nCounts; i++ ) + if (pDashList->GetDash (i)->GetName () == pName->GetValue ()) + break; + + if (i < nCounts) + pDashList->Replace (pEntry, i); + else + pDashList->Insert (pEntry); + + pAttr->Put (XLineDashItem (pName->GetValue (), aNewDash), XATTR_LINEDASH); + pAttr->Put (XLineStyleItem (XLINE_DASH), XATTR_LINESTYLE); + rBindings.Invalidate (SID_ATTR_LINE_DASH); + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + } + else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + // einstellungen fuer farbverlauf + case SID_GRADIENT : + if (pArgs) + if (pArgs->Count () == 8) + { + SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, FALSE); + SFX_REQUEST_ARG (rReq, pStyle, SfxUInt32Item, ID_VAL_STYLE, FALSE); + SFX_REQUEST_ARG (rReq, pAngle, SfxUInt32Item, ID_VAL_ANGLE, FALSE); + SFX_REQUEST_ARG (rReq, pBorder, SfxUInt32Item, ID_VAL_BORDER, FALSE); + SFX_REQUEST_ARG (rReq, pCenterX, SfxUInt32Item, ID_VAL_CENTER_X, FALSE); + SFX_REQUEST_ARG (rReq, pCenterY, SfxUInt32Item, ID_VAL_CENTER_Y, FALSE); + SFX_REQUEST_ARG (rReq, pStart, SfxUInt32Item, ID_VAL_STARTINTENS, FALSE); + SFX_REQUEST_ARG (rReq, pEnd, SfxUInt32Item, ID_VAL_ENDINTENS, FALSE); + + if (CHECK_RANGE (XGRAD_LINEAR, (sal_Int32)pStyle->GetValue (), XGRAD_RECT) && + CHECK_RANGE (0, (sal_Int32)pAngle->GetValue (), 360) && + CHECK_RANGE (0, (sal_Int32)pBorder->GetValue (), 100) && + CHECK_RANGE (0, (sal_Int32)pCenterX->GetValue (), 100) && + CHECK_RANGE (0, (sal_Int32)pCenterY->GetValue (), 100) && + CHECK_RANGE (0, (sal_Int32)pStart->GetValue (), 100) && + CHECK_RANGE (0, (sal_Int32)pEnd->GetValue (), 100)) + { + pAttr->ClearItem (XATTR_FILLGRADIENT); + pAttr->ClearItem (XATTR_FILLSTYLE); + + XGradientList *pGradientList = GetDoc()->GetGradientList (); + long nCounts = pGradientList->Count (); + long i; + + for ( i = 0; i < nCounts; i++ ) + { + XGradientEntry *pEntry = pGradientList->GetGradient (i); + + if (pEntry->GetName () == pName->GetValue ()) + { + XGradient &rGradient = pEntry->GetGradient (); + + rGradient.SetGradientStyle ((XGradientStyle) pStyle->GetValue ()); + rGradient.SetAngle (pAngle->GetValue () * 10); + rGradient.SetBorder ((short) pBorder->GetValue ()); + rGradient.SetXOffset ((short) pCenterX->GetValue ()); + rGradient.SetYOffset ((short) pCenterY->GetValue ()); + rGradient.SetStartIntens ((short) pStart->GetValue ()); + rGradient.SetEndIntens ((short) pEnd->GetValue ()); + + pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE); + pAttr->Put (XFillGradientItem (pName->GetValue (), rGradient), XATTR_FILLGRADIENT); + break; + } + } + + if (i >= nCounts) + { + Color aBlack (0, 0, 0); + XGradient aGradient (aBlack, aBlack, (XGradientStyle) pStyle->GetValue (), + pAngle->GetValue () * 10, (short) pCenterX->GetValue (), + (short) pCenterY->GetValue (), (short) pBorder->GetValue (), + (short) pStart->GetValue (), (short) pEnd->GetValue ()); + + pGradientList->Insert (new XGradientEntry (aGradient, pName->GetValue ())); + pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE); + pAttr->Put (XFillGradientItem (pName->GetValue (), aGradient), XATTR_FILLGRADIENT); + } + + rBindings.Invalidate (SID_ATTR_FILL_GRADIENT); + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + } + else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + // einstellungen fuer schraffur + case SID_HATCH : + if (pArgs) + if (pArgs->Count () == 4) + { + SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, FALSE); + SFX_REQUEST_ARG (rReq, pStyle, SfxUInt32Item, ID_VAL_STYLE, FALSE); + SFX_REQUEST_ARG (rReq, pDistance, SfxUInt32Item, ID_VAL_DISTANCE, FALSE); + SFX_REQUEST_ARG (rReq, pAngle, SfxUInt32Item, ID_VAL_ANGLE, FALSE); + + if (CHECK_RANGE (XHATCH_SINGLE, (sal_Int32)pStyle->GetValue (), XHATCH_TRIPLE) && + CHECK_RANGE (0, (sal_Int32)pAngle->GetValue (), 360)) + { + pAttr->ClearItem (XATTR_FILLHATCH); + pAttr->ClearItem (XATTR_FILLSTYLE); + + XHatchList *pHatchList = GetDoc()->GetHatchList (); + long nCounts = pHatchList->Count (); + long i; + + for ( i = 0; i < nCounts; i++ ) + { + XHatchEntry *pEntry = pHatchList->GetHatch (i); + + if (pEntry->GetName () == pName->GetValue ()) + { + XHatch &rHatch = pEntry->GetHatch (); + + rHatch.SetHatchStyle ((XHatchStyle) pStyle->GetValue ()); + rHatch.SetDistance (pDistance->GetValue ()); + rHatch.SetAngle (pAngle->GetValue () * 10); + + pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE); + pAttr->Put (XFillHatchItem (pName->GetValue (), rHatch), XATTR_FILLHATCH); + break; + } + } + + if (i >= nCounts) + { + Color aBlack (0, 0, 0); + XHatch aHatch (aBlack, (XHatchStyle) pStyle->GetValue (), pDistance->GetValue (), + pAngle->GetValue () * 10); + + pHatchList->Insert (new XHatchEntry (aHatch, pName->GetValue ())); + pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE); + pAttr->Put (XFillHatchItem (pName->GetValue (), aHatch), XATTR_FILLHATCH); + } + + rBindings.Invalidate (SID_ATTR_FILL_HATCH); + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + } + else StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + case SID_SELECTGRADIENT : + if (pArgs) + if (pArgs->Count () == 1) + { + SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, FALSE); + + XGradientList *pGradientList = GetDoc()->GetGradientList (); + long nCounts = pGradientList->Count (); + + for (long i = 0; + i < nCounts; + i ++) + { + XGradientEntry *pEntry = pGradientList->GetGradient (i); + + if (pEntry->GetName () == pName->GetValue ()) + { + pAttr->ClearItem (XATTR_FILLGRADIENT); + pAttr->ClearItem (XATTR_FILLSTYLE); + pAttr->Put (XFillStyleItem (XFILL_GRADIENT), XATTR_FILLSTYLE); + pAttr->Put (XFillGradientItem (pName->GetValue (), pEntry->GetGradient ()), XATTR_FILLGRADIENT); + + rBindings.Invalidate (SID_ATTR_FILL_GRADIENT); + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + break; + } + } + + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + case SID_SELECTHATCH : + if (pArgs) + if (pArgs->Count () == 1) + { + SFX_REQUEST_ARG (rReq, pName, SfxStringItem, ID_VAL_INDEX, FALSE); + + XHatchList *pHatchList = GetDoc()->GetHatchList (); + long nCounts = pHatchList->Count (); + + for (long i = 0; + i < nCounts; + i ++) + { + XHatchEntry *pEntry = pHatchList->GetHatch (i); + + if (pEntry->GetName () == pName->GetValue ()) + { + pAttr->ClearItem (XATTR_FILLHATCH); + pAttr->ClearItem (XATTR_FILLSTYLE); + pAttr->Put (XFillStyleItem (XFILL_HATCH), XATTR_FILLSTYLE); + pAttr->Put (XFillHatchItem (pName->GetValue (), pEntry->GetHatch ()), XATTR_FILLHATCH); + + rBindings.Invalidate (SID_ATTR_FILL_HATCH); + rBindings.Invalidate (SID_ATTR_FILL_STYLE); + break; + } + } + + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + + case SID_UNSELECT : + mpDrawView->UnmarkAll (); + break; + + case SID_GETRED : + if (pArgs) + if (pArgs->Count () == 1) + { + break; + } + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + break; + +/* case SID_SETFONTFAMILYNAME : + case SID_SETFONTSTYLENAME : + case SID_SETFONTFAMILY : + case SID_SETFONTPITCH : + case SID_SETFONTCHARSET : + case SID_SETFONTPOSTURE : + case SID_SETFONTWEIGHT : + case SID_SETFONTUNDERLINE : + case SID_SETFONTCROSSEDOUT : + case SID_SETFONTSHADOWED : + case SID_SETFONTCONTOUR : + case SID_SETFONTCOLOR : + case SID_SETFONTLANGUAGE : + case SID_SETFONTWORDLINE : + case SID_SETFONTCASEMAP : + case SID_SETFONTESCAPE : + case SID_SETFONTKERNING : + break;*/ + + default : + ; + } + + mpDrawView->SetAttributes (*(const SfxItemSet *) pAttr); + rReq.Ignore (); + delete pAttr; +} + +/************************************************************************* +|* +|* Makros fuer die Attributeinstellungen bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::AttrState (SfxItemSet& rSet) +{ + SfxWhichIter aIter (rSet); + USHORT nWhich = aIter.FirstWhich (); + SfxItemSet aAttr( GetDoc()->GetPool() ); + mpDrawView->GetAttributes( aAttr ); + + while (nWhich) + { + switch (nWhich) + { + case SID_GETFILLSTYLE : + { + const XFillStyleItem &rFillStyleItem = (const XFillStyleItem &) aAttr.Get (XATTR_FILLSTYLE); + + rSet.Put (SfxUInt32Item (nWhich, (long) rFillStyleItem.GetValue ())); + break; + } + + case SID_GETLINESTYLE : + { + const XLineStyleItem &rLineStyleItem = (const XLineStyleItem &) aAttr.Get (XATTR_LINESTYLE); + + rSet.Put (SfxUInt32Item (nWhich, (long) rLineStyleItem.GetValue ())); + break; + } + + case SID_GETLINEWIDTH : + { + const XLineWidthItem &rLineWidthItem = (const XLineWidthItem &) aAttr.Get (XATTR_LINEWIDTH); + + rSet.Put (SfxUInt32Item (nWhich, (long) rLineWidthItem.GetValue ())); + break; + } + + case SID_GETGREEN : + case SID_GETRED : + case SID_GETBLUE : + { + const SfxUInt32Item &rWhatKind = (const SfxUInt32Item &) rSet.Get (ID_VAL_WHATKIND); + Color aColor; + + switch (rWhatKind.GetValue ()) + { + case 1 : + { + const XLineColorItem &rLineColorItem = (const XLineColorItem &) aAttr.Get (XATTR_LINECOLOR); + + aColor = rLineColorItem.GetColorValue (); + break; + } + + case 2 : + { + const XFillColorItem &rFillColorItem = (const XFillColorItem &) aAttr.Get (XATTR_FILLCOLOR); + + aColor = rFillColorItem.GetColorValue (); + break; + } + + case 3 : + case 4 : + { + const XFillGradientItem &rFillGradientItem = (const XFillGradientItem &) aAttr.Get (XATTR_FILLGRADIENT); + const XGradient &rGradient = rFillGradientItem.GetGradientValue (); + + aColor = (rWhatKind.GetValue () == 3) + ? rGradient.GetStartColor () + : rGradient.GetEndColor (); + break; + } + + case 5: + { + const XFillHatchItem &rFillHatchItem = (const XFillHatchItem &) aAttr.Get (XATTR_FILLHATCH); + const XHatch &rHatch = rFillHatchItem.GetHatchValue (); + + aColor = rHatch.GetColor (); + break; + } + + default : + ; + } + + rSet.Put (SfxUInt32Item (nWhich, (long) ((nWhich == SID_GETRED) + ? aColor.GetRed () + : (nWhich == SID_GETGREEN) + ? aColor.GetGreen () + : aColor.GetBlue ()))); + break; + } + + default : + ; + } + + nWhich = aIter.NextWhich (); + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviewsa.cxx b/sd/source/ui/view/drviewsa.cxx new file mode 100755 index 000000000000..3628a11ac5a1 --- /dev/null +++ b/sd/source/ui/view/drviewsa.cxx @@ -0,0 +1,859 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include <cppuhelper/implbase1.hxx> +#include <comphelper/processfactory.hxx> +#ifndef _SVX_SIZEITEM +#include <editeng/sizeitem.hxx> +#endif +#include <svx/svdlayer.hxx> +#ifndef _SVX_ZOOMITEM +#include <svx/zoomitem.hxx> +#endif +#include <svx/svdpagv.hxx> +#include <svl/ptitem.hxx> +#include <svl/stritem.hxx> +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/svdopath.hxx> +#include <sfx2/docfile.hxx> +#include <svx/zoomslideritem.hxx> +#include <svl/eitem.hxx> + +#ifndef _SVX_DIALOGS_HRC +#include <svx/dialogs.hrc> +#endif +#include <svx/extrusionbar.hxx> +#include <svx/fontworkbar.hxx> +#include <svx/clipfmtitem.hxx> + + +#include <sfx2/viewfrm.hxx> +#include <svx/fmshell.hxx> +#include <sfx2/dispatch.hxx> +#include <svtools/cliplistener.hxx> +#include <svx/float3d.hxx> + +#include "view/viewoverlaymanager.hxx" +#include "app.hrc" +#include "helpids.h" +#include "strings.hrc" +#include "res_bmp.hrc" +#include "sdpage.hxx" +#include "FrameView.hxx" +#include "drawdoc.hxx" +#include "sdresid.hxx" +#include "DrawDocShell.hxx" +#include "Window.hxx" +#include "fupoor.hxx" +#include "fusel.hxx" +#include "drawview.hxx" +#include "SdUnoDrawView.hxx" +#include "ViewShellBase.hxx" +#include "SdUnoDrawView.hxx" +#include "slideshow.hxx" +#include "ToolBarManager.hxx" +#include "annotationmanager.hxx" + +using namespace ::rtl; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; + +namespace { +static const ::rtl::OUString MASTER_VIEW_TOOL_BAR_NAME( + ::rtl::OUString::createFromAscii("masterviewtoolbar")); +} + +namespace sd { + +BOOL DrawViewShell::mbPipette = FALSE; + +// ------------------------ +// - ScannerEventListener - +// ------------------------ + +class ScannerEventListener : public ::cppu::WeakImplHelper1< ::com::sun::star::lang::XEventListener > +{ +private: + + DrawViewShell* mpParent; + +public: + + ScannerEventListener( DrawViewShell* pParent ) : mpParent( pParent ) {}; + ~ScannerEventListener(); + + // XEventListener + virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& rEventObject ) throw (::com::sun::star::uno::RuntimeException); + + void ParentDestroyed() { mpParent = NULL; } +}; + +// ----------------------------------------------------------------------------- + +ScannerEventListener::~ScannerEventListener() +{ +} + +// ----------------------------------------------------------------------------- + +void SAL_CALL ScannerEventListener::disposing( const ::com::sun::star::lang::EventObject& rEventObject ) throw (::com::sun::star::uno::RuntimeException) +{ + if( mpParent ) + mpParent->ScannerEvent( rEventObject ); +} + +/************************************************************************* +|* +|* Standard-Konstruktor +|* +\************************************************************************/ + +DrawViewShell::DrawViewShell( SfxViewFrame* pFrame, ViewShellBase& rViewShellBase, ::Window* pParentWindow, PageKind ePageKind, FrameView* pFrameViewArgument ) +: ViewShell (pFrame, pParentWindow, rViewShellBase) +, maTabControl(this, pParentWindow) +, mbIsInSwitchPage(false) +{ + if (pFrameViewArgument != NULL) + mpFrameView = pFrameViewArgument; + else + mpFrameView = new FrameView(GetDoc()); + Construct(GetDocSh(), ePageKind); +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +DrawViewShell::~DrawViewShell() +{ + mpAnnotationManager.reset(); + mpViewOverlayManager.reset(); + + OSL_ASSERT (GetViewShell()!=NULL); + + if( mxScannerListener.is() ) + static_cast< ScannerEventListener* >( mxScannerListener.get() )->ParentDestroyed(); + + // #96642# Remove references to items within Svx3DWin + // (maybe do a listening sometime in Svx3DWin) + USHORT nId = Svx3DChildWindow::GetChildWindowId(); + SfxChildWindow* pWindow = GetViewFrame() ? GetViewFrame()->GetChildWindow(nId) : NULL; + if(pWindow) + { + Svx3DWin* p3DWin = static_cast< Svx3DWin* > (pWindow->GetWindow()); + if(p3DWin) + p3DWin->DocumentReload(); + } + + EndListening (*GetDoc()); + EndListening (*GetDocSh()); + + if( SlideShow::IsRunning(*this) ) + StopSlideShow(false); + + DisposeFunctions(); + + SdPage* pPage; + USHORT aPageCnt = GetDoc()->GetSdPageCount(mePageKind); + + for (USHORT i = 0; i < aPageCnt; i++) + { + pPage = GetDoc()->GetSdPage(i, mePageKind); + + if (pPage == mpActualPage) + { + GetDoc()->SetSelected(pPage, TRUE); + } + else + { + GetDoc()->SetSelected(pPage, FALSE); + } + } + + if ( mpClipEvtLstnr ) + { + mpClipEvtLstnr->AddRemoveListener( GetActiveWindow(), FALSE ); + mpClipEvtLstnr->ClearCallbackLink(); // #103849# prevent callback if another thread is waiting + mpClipEvtLstnr->release(); + } + + delete mpDrawView; + // Set mpView to NULL so that the destructor of the ViewShell base class + // does not access it. + mpView = mpDrawView = NULL; + + mpFrameView->Disconnect(); + delete [] mpSlotArray; +} + +/************************************************************************* +|* +|* gemeinsamer Initialisierungsanteil der beiden Konstruktoren +|* +\************************************************************************/ + +void DrawViewShell::Construct(DrawDocShell* pDocSh, PageKind eInitialPageKind) +{ + mpActualPage = 0; + mbMousePosFreezed = FALSE; + mbReadOnly = GetDocSh()->IsReadOnly(); + mpSlotArray = 0; + mpClipEvtLstnr = 0; + mbPastePossible = FALSE; + mbIsLayerModeActive = false; + + mpFrameView->Connect(); + + OSL_ASSERT (GetViewShell()!=NULL); + + // Array fuer Slot-/ImageMapping: + // Gerader Eintrag: Haupt-/ToolboxSlot + // Ungerader Eintrag: gemappter Slot + // Achtung: Anpassen von GetIdBySubId() !!! + // Reihenfolge (insbesondere Zoom) darf nicht geaendert werden !!! + mpSlotArray = new USHORT[ SLOTARRAY_COUNT ]; + mpSlotArray[ 0 ] = SID_OBJECT_CHOOSE_MODE; + mpSlotArray[ 1 ] = SID_OBJECT_ROTATE; + mpSlotArray[ 2 ] = SID_OBJECT_ALIGN; + mpSlotArray[ 3 ] = SID_OBJECT_ALIGN_LEFT; + mpSlotArray[ 4 ] = SID_ZOOM_TOOLBOX; + mpSlotArray[ 5 ] = SID_ZOOM_TOOLBOX; + mpSlotArray[ 6 ] = SID_DRAWTBX_TEXT; + mpSlotArray[ 7 ] = SID_ATTR_CHAR; + mpSlotArray[ 8 ] = SID_DRAWTBX_RECTANGLES; + mpSlotArray[ 9 ] = SID_DRAW_RECT; + mpSlotArray[ 10 ] = SID_DRAWTBX_ELLIPSES; + mpSlotArray[ 11 ] = SID_DRAW_ELLIPSE; + mpSlotArray[ 12 ] = SID_DRAWTBX_LINES; + mpSlotArray[ 13 ] = SID_DRAW_FREELINE_NOFILL; + mpSlotArray[ 14 ] = SID_DRAWTBX_3D_OBJECTS; + mpSlotArray[ 15 ] = SID_3D_CUBE; + mpSlotArray[ 16 ] = SID_DRAWTBX_INSERT; + mpSlotArray[ 17 ] = SID_INSERT_DIAGRAM; + mpSlotArray[ 18 ] = SID_POSITION; + mpSlotArray[ 19 ] = SID_FRAME_TO_TOP; + mpSlotArray[ 20 ] = SID_DRAWTBX_CONNECTORS; + mpSlotArray[ 21 ] = SID_TOOL_CONNECTOR; + mpSlotArray[ 22 ] = SID_DRAWTBX_ARROWS; + mpSlotArray[ 23 ] = SID_LINE_ARROW_END; + + SetPool( &GetDoc()->GetPool() ); + + GetDoc()->CreateFirstPages(); + + mpDrawView = new DrawView(pDocSh, GetActiveWindow(), this); + mpView = mpDrawView; // Pointer der Basisklasse ViewShell + mpDrawView->SetSwapAsynchron(TRUE); // Asynchrones Laden von Graphiken + + // We do not read the page kind from the frame view anymore so we have + // to set it in order to resync frame view and this view. + mpFrameView->SetPageKind(eInitialPageKind); + mePageKind = eInitialPageKind; + meEditMode = EM_PAGE; + DocumentType eDocType = GetDoc()->GetDocumentType(); // RTTI fasst hier noch nicht + switch (mePageKind) + { + case PK_STANDARD: + meShellType = ST_IMPRESS; + break; + + case PK_NOTES: + meShellType = ST_NOTES; + break; + + case PK_HANDOUT: + meShellType = ST_HANDOUT; + break; + } + + Size aPageSize( GetDoc()->GetSdPage(0, mePageKind)->GetSize() ); + Point aPageOrg( aPageSize.Width(), aPageSize.Height() / 2); + Size aSize(aPageSize.Width() * 3, aPageSize.Height() * 2); + InitWindows(aPageOrg, aSize, Point(-1, -1)); + + Point aVisAreaPos; + + if ( pDocSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ) + { + aVisAreaPos = pDocSh->GetVisArea(ASPECT_CONTENT).TopLeft(); + } + + mpDrawView->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aSize)); + + // Objekte koennen max. so gross wie die ViewSize werden + GetDoc()->SetMaxObjSize(aSize); + + // Split-Handler fuer TabControls + maTabControl.SetSplitHdl( LINK( this, DrawViewShell, TabSplitHdl ) ); + + // Damit der richtige EditMode von der FrameView komplett eingestellt + // werden kann, wird hier ein aktuell anderer gewaehlt (kleiner Trick) + if (mpFrameView->GetViewShEditMode(mePageKind) == EM_PAGE) + { + meEditMode = EM_MASTERPAGE; + } + else + { + meEditMode = EM_PAGE; + } + + // Einstellungen der FrameView uebernehmen + ReadFrameViewData(mpFrameView); + + if( eDocType == DOCUMENT_TYPE_DRAW ) + { + SetHelpId( SD_IF_SDGRAPHICVIEWSHELL ); + GetActiveWindow()->SetHelpId( SD_IF_SDGRAPHICVIEWSHELL ); + GetActiveWindow()->SetUniqueId( SD_IF_SDGRAPHICVIEWSHELL ); + } + else + { + if (mePageKind == PK_NOTES) + { + SetHelpId( SID_NOTESMODE ); + GetActiveWindow()->SetHelpId( SID_NOTESMODE ); + GetActiveWindow()->SetUniqueId( SID_NOTESMODE ); + + // AutoLayouts muessen erzeugt sein + GetDoc()->StopWorkStartupDelay(); + } + else if (mePageKind == PK_HANDOUT) + { + SetHelpId( SID_HANDOUTMODE ); + GetActiveWindow()->SetHelpId( SID_HANDOUTMODE ); + GetActiveWindow()->SetUniqueId( SID_HANDOUTMODE ); + + // AutoLayouts muessen erzeugt sein + GetDoc()->StopWorkStartupDelay(); + } + else + { + SetHelpId( SD_IF_SDDRAWVIEWSHELL ); + GetActiveWindow()->SetHelpId( SD_IF_SDDRAWVIEWSHELL ); + GetActiveWindow()->SetUniqueId( SD_IF_SDDRAWVIEWSHELL ); + } + } + + // Selektionsfunktion starten + SfxRequest aReq(SID_OBJECT_SELECT, 0, GetDoc()->GetItemPool()); + FuPermanent(aReq); + mpDrawView->SetFrameDragSingles(TRUE); + + if (pDocSh->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED) + { + mbZoomOnPage = FALSE; + } + else + { + mbZoomOnPage = TRUE; + } + + mbIsRulerDrag = FALSE; + + String aName( RTL_CONSTASCII_USTRINGPARAM("DrawViewShell")); + SetName (aName); + + mnLockCount = 0UL; + + ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() ); + + if( xMgr.is() ) + { + mxScannerManager = ::com::sun::star::uno::Reference< ::com::sun::star::scanner::XScannerManager >( + xMgr->createInstance( ::rtl::OUString::createFromAscii( "com.sun.star.scanner.ScannerManager" ) ), + ::com::sun::star::uno::UNO_QUERY ); + + if( mxScannerManager.is() ) + { + mxScannerListener = ::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener >( + static_cast< ::cppu::OWeakObject* >( new ScannerEventListener( this ) ), + ::com::sun::star::uno::UNO_QUERY ); + } + } + + mpAnnotationManager.reset( new AnnotationManager( GetViewShellBase() ) ); + mpViewOverlayManager.reset( new ViewOverlayManager( GetViewShellBase() ) ); +} + + + + +void DrawViewShell::Init (bool bIsMainViewShell) +{ + ViewShell::Init(bIsMainViewShell); + + StartListening (*GetDocSh()); +} + + + + +void DrawViewShell::Shutdown (void) +{ + ViewShell::Shutdown(); + + if(SlideShow::IsRunning( GetViewShellBase() ) ) + { + // Turn off effects. + GetDrawView()->SetAnimationMode(SDR_ANIMATION_DISABLE); + } +} + + + + +css::uno::Reference<css::drawing::XDrawSubController> DrawViewShell::CreateSubController (void) +{ + css::uno::Reference<css::drawing::XDrawSubController> xSubController; + + if (IsMainViewShell()) + { + // Create uno sub controller for the main view shell. + xSubController = css::uno::Reference<css::drawing::XDrawSubController>( + new SdUnoDrawView ( + GetViewShellBase().GetDrawController(), + *this, + *GetView())); + } + + return xSubController; +} + + + + +bool DrawViewShell::RelocateToParentWindow (::Window* pParentWindow) +{ + // DrawViewShells can not be relocated to a new parent window at the + // moment, so return <FALSE/> except when the given parent window is the + // parent window that is already in use. + return pParentWindow==GetParentWindow(); +} + + + + +/************************************************************************* +|* +|* pruefe ob linienzuege gezeichnet werden muessen +|* +\************************************************************************/ + +/* + linienzuege werden ueber makros als folge von + MoveTo (x, y) + LineTo (x, y) [oder BezierTo (x, y)] + LineTo (x, y) + : + dargestellt. einen endbefehl fuer die linienzuege + gibt es nicht, also muessen alle befehle in den + requests nach LineTo (BezierTo) abgetestet und die + punktparameter gesammelt werden. + der erste nicht-LineTo fuehrt dann dazu, dass aus + den gesammelten punkten der linienzug erzeugt wird +*/ + +void DrawViewShell::CheckLineTo(SfxRequest& rReq) +{ + (void)rReq; +#ifdef DBG_UTIL + if(rReq.IsAPI()) + { + if(SID_LINETO == rReq.GetSlot() || SID_BEZIERTO == rReq.GetSlot() || SID_MOVETO == rReq.GetSlot() ) + { + DBG_ERROR("DrawViewShell::CheckLineTo: slots SID_LINETO, SID_BEZIERTO, SID_MOVETO no longer supported."); + } + } +#endif + + rReq.Ignore (); +} + +/************************************************************************* +|* +|* veraendere die seitemparameter, wenn SID_PAGESIZE oder SID_PAGEMARGIN +|* +\************************************************************************/ + +void DrawViewShell::SetupPage (Size &rSize, + long nLeft, + long nRight, + long nUpper, + long nLower, + BOOL bSize, + BOOL bMargin, + BOOL bScaleAll) +{ + USHORT nPageCnt = GetDoc()->GetMasterSdPageCount(mePageKind); + USHORT i; + + for (i = 0; i < nPageCnt; i++) + { + /********************************************************************** + * Erst alle MasterPages bearbeiten + **********************************************************************/ + SdPage *pPage = GetDoc()->GetMasterSdPage(i, mePageKind); + + if( pPage ) + { + if( bSize ) + { + Rectangle aBorderRect(nLeft, nUpper, nRight, nLower); + pPage->ScaleObjects(rSize, aBorderRect, bScaleAll); + pPage->SetSize(rSize); + + } + if( bMargin ) + { + pPage->SetLftBorder(nLeft); + pPage->SetRgtBorder(nRight); + pPage->SetUppBorder(nUpper); + pPage->SetLwrBorder(nLower); + } + + if ( mePageKind == PK_STANDARD ) + { + GetDoc()->GetMasterSdPage(i, PK_NOTES)->CreateTitleAndLayout(); + } + + pPage->CreateTitleAndLayout(); + } + } + + nPageCnt = GetDoc()->GetSdPageCount(mePageKind); + + for (i = 0; i < nPageCnt; i++) + { + /********************************************************************** + * Danach alle Pages bearbeiten + **********************************************************************/ + SdPage *pPage = GetDoc()->GetSdPage(i, mePageKind); + + if( pPage ) + { + if( bSize ) + { + Rectangle aBorderRect(nLeft, nUpper, nRight, nLower); + pPage->ScaleObjects(rSize, aBorderRect, bScaleAll); + pPage->SetSize(rSize); + } + if( bMargin ) + { + pPage->SetLftBorder(nLeft); + pPage->SetRgtBorder(nRight); + pPage->SetUppBorder(nUpper); + pPage->SetLwrBorder(nLower); + } + + if ( mePageKind == PK_STANDARD ) + { + SdPage* pNotesPage = GetDoc()->GetSdPage(i, PK_NOTES); + pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() ); + } + + pPage->SetAutoLayout( pPage->GetAutoLayout() ); + } + } + + if ( mePageKind == PK_STANDARD ) + { + SdPage* pHandoutPage = GetDoc()->GetSdPage(0, PK_HANDOUT); + pHandoutPage->CreateTitleAndLayout(TRUE); + } + + long nWidth = mpActualPage->GetSize().Width(); + long nHeight = mpActualPage->GetSize().Height(); + + Point aPageOrg(nWidth, nHeight / 2); + Size aSize( nWidth * 3, nHeight * 2); + + InitWindows(aPageOrg, aSize, Point(-1, -1), TRUE); + + Point aVisAreaPos; + + if ( GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ) + { + aVisAreaPos = GetDocSh()->GetVisArea(ASPECT_CONTENT).TopLeft(); + } + + GetView()->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aSize)); + + UpdateScrollBars(); + + Point aNewOrigin(mpActualPage->GetLftBorder(), mpActualPage->GetUppBorder()); + GetView()->GetSdrPageView()->SetPageOrigin(aNewOrigin); + + GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET); + + // auf (neue) Seitengroesse zoomen + GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); +} + +/************************************************************************* +|* +|* Statuswerte der Statusbar zurueckgeben +|* +\************************************************************************/ + +void DrawViewShell::GetStatusBarState(SfxItemSet& rSet) +{ + // Zoom-Item + // Hier sollte der entsprechende Wert (Optimal ?, Seitenbreite oder + // Seite) mit Hilfe des ZoomItems weitergegeben werden !!! + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOM ) ) + { + if (GetDocSh()->IsUIActive() || (SlideShow::IsRunning(GetViewShellBase())) ) + { + rSet.DisableItem( SID_ATTR_ZOOM ); + } + else + { + SvxZoomItem* pZoomItem; + UINT16 nZoom = (UINT16) GetActiveWindow()->GetZoom(); + + if( mbZoomOnPage ) + pZoomItem = new SvxZoomItem( SVX_ZOOM_WHOLEPAGE, nZoom ); + else + pZoomItem = new SvxZoomItem( SVX_ZOOM_PERCENT, nZoom ); + + // Bereich einschraenken + USHORT nZoomValues = SVX_ZOOM_ENABLE_ALL; + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + + if( ( pPageView && pPageView->GetObjList()->GetObjCount() == 0 ) ) + // || ( mpDrawView->GetMarkedObjectList().GetMarkCount() == 0 ) ) + { + nZoomValues &= ~SVX_ZOOM_ENABLE_OPTIMAL; + } + + pZoomItem->SetValueSet( nZoomValues ); + rSet.Put( *pZoomItem ); + delete pZoomItem; + } + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOMSLIDER ) ) + { + rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetDoc() ) ); + if (GetDocSh()->IsUIActive() || (xSlideshow.is() && xSlideshow->isRunning()) || !GetActiveWindow() ) + { + rSet.DisableItem( SID_ATTR_ZOOMSLIDER ); + } + else + { + sd::Window * pActiveWindow = GetActiveWindow(); + SvxZoomSliderItem aZoomItem( (UINT16) pActiveWindow->GetZoom(), (USHORT)pActiveWindow->GetMinZoom(), (USHORT)pActiveWindow->GetMaxZoom() ) ; + + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + if( pPageView ) + { + Point aPagePos(0, 0); + Size aPageSize = pPageView->GetPage()->GetSize(); + + aPagePos.X() += aPageSize.Width() / 2; + aPageSize.Width() = (long) (aPageSize.Width() * 1.03); + + aPagePos.Y() += aPageSize.Height() / 2; + aPageSize.Height() = (long) (aPageSize.Height() * 1.03); + aPagePos.Y() -= aPageSize.Height() / 2; + + aPagePos.X() -= aPageSize.Width() / 2; + + Rectangle aFullPageZoomRect( aPagePos, aPageSize ); + aZoomItem.AddSnappingPoint( pActiveWindow->GetZoomForRect( aFullPageZoomRect ) ); + } + aZoomItem.AddSnappingPoint(100); + rSet.Put( aZoomItem ); + } + } + + Point aPos = GetActiveWindow()->PixelToLogic(maMousePos); + mpDrawView->GetSdrPageView()->LogicToPagePos(aPos); + Fraction aUIScale(GetDoc()->GetUIScale()); + aPos.X() = Fraction(aPos.X()) / aUIScale; + aPos.Y() = Fraction(aPos.Y()) / aUIScale; + + // Position- und Groesse-Items + if ( mpDrawView->IsAction() ) + { + Rectangle aRect; + mpDrawView->TakeActionRect( aRect ); + + if ( aRect.IsEmpty() ) + rSet.Put( SfxPointItem(SID_ATTR_POSITION, aPos) ); + else + { + mpDrawView->GetSdrPageView()->LogicToPagePos(aRect); + aPos = aRect.TopLeft(); + aPos.X() = Fraction(aPos.X()) / aUIScale; + aPos.Y() = Fraction(aPos.Y()) / aUIScale; + rSet.Put( SfxPointItem( SID_ATTR_POSITION, aPos) ); + Size aSize( aRect.Right() - aRect.Left(), aRect.Bottom() - aRect.Top() ); + aSize.Height() = Fraction(aSize.Height()) / aUIScale; + aSize.Width() = Fraction(aSize.Width()) / aUIScale; + rSet.Put( SvxSizeItem( SID_ATTR_SIZE, aSize) ); + } + } + else + { + if ( mpDrawView->AreObjectsMarked() ) + { + Rectangle aRect = mpDrawView->GetAllMarkedRect(); + mpDrawView->GetSdrPageView()->LogicToPagePos(aRect); + + // Show the position of the selected shape(s) + Point aShapePosition (aRect.TopLeft()); + aShapePosition.X() = Fraction(aShapePosition.X()) / aUIScale; + aShapePosition.Y() = Fraction(aShapePosition.Y()) / aUIScale; + rSet.Put (SfxPointItem(SID_ATTR_POSITION, aShapePosition)); + + Size aSize( aRect.Right() - aRect.Left(), aRect.Bottom() - aRect.Top() ); + aSize.Height() = Fraction(aSize.Height()) / aUIScale; + aSize.Width() = Fraction(aSize.Width()) / aUIScale; + rSet.Put( SvxSizeItem( SID_ATTR_SIZE, aSize) ); + } + else + { + rSet.Put( SfxPointItem(SID_ATTR_POSITION, aPos) ); + rSet.Put( SvxSizeItem( SID_ATTR_SIZE, Size( 0, 0 ) ) ); + } + } + + // Display of current page and layer. + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_PAGE ) ) + { + // Allways show the slide/page number. + String aString (SdResId( STR_SD_PAGE )); + aString += sal_Unicode(' '); + aString += UniString::CreateFromInt32( maTabControl.GetCurPageId() ); + aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " / " )); + aString += UniString::CreateFromInt32( GetDoc()->GetSdPageCount( mePageKind ) ); + + // If in layer mode additionally show the layer that contains all + // selected shapes of the page. If the shapes are distributed on + // more than one layer, no layer name is shown. + if (IsLayerModeActive()) + { + SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin(); + SdrLayerID nLayer = 0, nOldLayer = 0; + SdrLayer* pLayer = NULL; + SdrObject* pObj = NULL; + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + ULONG nMarkCount = rMarkList.GetMarkCount(); + FASTBOOL bOneLayer = TRUE; + + // Use the first ten selected shapes as a (hopefully + // representative) sample of all shapes of the current page. + // Detect whether they belong to the same layer. + for( ULONG j = 0; j < nMarkCount && bOneLayer && j < 10; j++ ) + { + pObj = rMarkList.GetMark( j )->GetMarkedSdrObj(); + if( pObj ) + { + nLayer = pObj->GetLayer(); + + if( j != 0 && nLayer != nOldLayer ) + bOneLayer = FALSE; + + nOldLayer = nLayer; + } + } + + // Append the layer name to the current page number. + if( bOneLayer && nMarkCount ) + { + pLayer = rLayerAdmin.GetLayerPerID( nLayer ); + if( pLayer ) + { + aString.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " (" )); + aString += pLayer->GetName(); + aString += sal_Unicode(')'); + } + } + } + + rSet.Put (SfxStringItem (SID_STATUS_PAGE, aString)); + } + // Layout + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_LAYOUT ) ) + { + String aString = mpActualPage->GetLayoutName(); + aString.Erase( aString.SearchAscii( SD_LT_SEPARATOR ) ); + rSet.Put( SfxStringItem( SID_STATUS_LAYOUT, aString ) ); + } +} + + + +void DrawViewShell::Notify (SfxBroadcaster&, const SfxHint& rHint) +{ + const SfxSimpleHint* pSimple = dynamic_cast< const SfxSimpleHint* >(&rHint); + if (pSimple!=NULL && pSimple->GetId()==SFX_HINT_MODECHANGED) + { + // Change to selection when turning on read-only mode. + if(GetDocSh()->IsReadOnly() && dynamic_cast< FuSelection* >( GetCurrentFunction().get() ) ) + { + SfxRequest aReq(SID_OBJECT_SELECT, 0, GetDoc()->GetItemPool()); + FuPermanent(aReq); + } + + // Turn on design mode when document is not read-only. + if (GetDocSh()->IsReadOnly() != mbReadOnly ) + { + mbReadOnly = GetDocSh()->IsReadOnly(); + + SfxBoolItem aItem( SID_FM_DESIGN_MODE, !mbReadOnly ); + GetViewFrame()->GetDispatcher()->Execute( SID_FM_DESIGN_MODE, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); + } + } + +} + +void DrawViewShell::ExecuteAnnotation (SfxRequest& rRequest) +{ + if( mpAnnotationManager.get() ) + mpAnnotationManager->ExecuteAnnotation( rRequest ); +} + +// -------------------------------------------------------------------- + +void DrawViewShell::GetAnnotationState (SfxItemSet& rItemSet ) +{ + if( mpAnnotationManager.get() ) + mpAnnotationManager->GetAnnotationState( rItemSet ); +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/drviewsb.cxx b/sd/source/ui/view/drviewsb.cxx new file mode 100644 index 000000000000..2574032e3d99 --- /dev/null +++ b/sd/source/ui/view/drviewsb.cxx @@ -0,0 +1,879 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" +#include <com/sun/star/ui/dialogs/XExecutableDialog.hpp> +#include <comphelper/processfactory.hxx> +#include <svx/svdlayer.hxx> +#ifndef _SVXIDS_HXX +#include <svx/svxids.hrc> +#endif + +#include <svx/hyprlink.hxx> +#include <sfx2/viewfrm.hxx> +#include <svx/hlnkitem.hxx> +#include <tools/urlobj.hxx> +#include <editeng/eeitem.hxx> +#ifndef _FLDITEM_HXX +#include <editeng/flditem.hxx> +#endif +#include <vcl/msgbox.hxx> +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/svdorect.hxx> +#include <sfx2/docfile.hxx> +#include <basic/sbstar.hxx> +#include <basic/sberrors.hxx> +#include <svx/fmshell.hxx> +#include <svx/svxdlg.hxx> +#include <svx/dialogs.hrc> +#include <unotools/useroptions.hxx> + +#include "app.hrc" +#include "strings.hrc" +#include "res_bmp.hrc" +#include "glob.hrc" +#include "Outliner.hxx" +#include "Window.hxx" +#include "app.hxx" +#include "sdattr.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "sdresid.hxx" +#include "sdpage.hxx" +#include "DrawViewShell.hxx" +#include "drawview.hxx" +#include "unmodpg.hxx" +#include "undolayer.hxx" +#include "ViewShellBase.hxx" +#include "FormShellManager.hxx" +#include "LayerTabBar.hxx" +#include "sdabstdlg.hxx" +#include "SlideSorterViewShell.hxx" +#include "SlideSorter.hxx" +#include "controller/SlideSorterController.hxx" + +#define RET_DELETE 100 + +namespace sd { + +/************************************************************************* +|* +|* SfxRequests fuer temporaere Funktionen +|* +\************************************************************************/ + +void DrawViewShell::FuTemp02(SfxRequest& rReq) +{ + USHORT nSId = rReq.GetSlot(); + switch( nSId ) + { + case SID_INSERTLAYER: + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin(); + USHORT nLayerCnt = rLayerAdmin.GetLayerCount(); + USHORT nLayer = nLayerCnt - 2 + 1; + String aLayerName ( SdResId(STR_LAYER) ), aLayerTitle, aLayerDesc; + aLayerName += String::CreateFromInt32( (sal_Int32)nLayer ); + BOOL bIsVisible = FALSE; + BOOL bIsLocked = FALSE; + BOOL bIsPrintable = FALSE; + + const SfxItemSet* pArgs = rReq.GetArgs(); + + if (! pArgs) + { + SfxItemSet aNewAttr( GetDoc()->GetPool(), ATTR_LAYER_START, ATTR_LAYER_END ); + + aNewAttr.Put( SdAttrLayerName( aLayerName ) ); + aNewAttr.Put( SdAttrLayerTitle() ); + aNewAttr.Put( SdAttrLayerDesc() ); + aNewAttr.Put( SdAttrLayerVisible() ); + aNewAttr.Put( SdAttrLayerPrintable() ); + aNewAttr.Put( SdAttrLayerLocked() ); + aNewAttr.Put( SdAttrLayerThisPage() ); + + SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); + AbstractSdInsertLayerDlg* pDlg = pFact ? pFact->CreateSdInsertLayerDlg(NULL, aNewAttr, true, String( SdResId( STR_INSERTLAYER ) ) ) : 0; + if( pDlg ) + { + pDlg->SetHelpId( SID_INSERTLAYER ); + + // Ueberpruefung auf schon vorhandene Namen + BOOL bLoop = TRUE; + while( bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetAttr( aNewAttr ); + aLayerName = ((SdAttrLayerName &) aNewAttr.Get (ATTR_LAYER_NAME)).GetValue (); + + if( rLayerAdmin.GetLayer( aLayerName, FALSE ) + || aLayerName.Len()==0 ) + { + // Name ist schon vorhanden + WarningBox aWarningBox ( + GetParentWindow(), + WinBits( WB_OK ), + String(SdResId( STR_WARN_NAME_DUPLICATE))); + aWarningBox.Execute(); + } + else + bLoop = FALSE; + } + if( bLoop ) // wurde abgebrochen + { + delete pDlg; + + Cancel(); + rReq.Ignore (); + break; + } + else + { + //pDlg->GetAttr( aNewAttr ); + //aLayerName = ((SdAttrLayerName &) aNewAttr.Get (ATTR_LAYER_NAME)).GetValue (); + aLayerTitle = ((SdAttrLayerTitle &) aNewAttr.Get (ATTR_LAYER_TITLE)).GetValue (); + aLayerDesc = ((SdAttrLayerDesc &) aNewAttr.Get (ATTR_LAYER_DESC)).GetValue (); + bIsVisible = ((SdAttrLayerVisible &) aNewAttr.Get (ATTR_LAYER_VISIBLE)).GetValue (); + bIsLocked = ((SdAttrLayerLocked &) aNewAttr.Get (ATTR_LAYER_LOCKED)).GetValue () ; + bIsPrintable = ((SdAttrLayerPrintable &) aNewAttr.Get (ATTR_LAYER_PRINTABLE)).GetValue () ; + + delete pDlg; + } + } + } + else if (pArgs->Count () != 4) + { + StarBASIC::FatalError (SbERR_WRONG_ARGS); + Cancel(); + rReq.Ignore (); + break; + } + else + { + SFX_REQUEST_ARG (rReq, pLayerName, SfxStringItem, ID_VAL_LAYERNAME, FALSE); + SFX_REQUEST_ARG (rReq, pIsVisible, SfxBoolItem, ID_VAL_ISVISIBLE, FALSE); + SFX_REQUEST_ARG (rReq, pIsLocked, SfxBoolItem, ID_VAL_ISLOCKED, FALSE); + SFX_REQUEST_ARG (rReq, pIsPrintable, SfxBoolItem, ID_VAL_ISPRINTABLE, FALSE); + + aLayerName = pLayerName->GetValue (); + bIsVisible = pIsVisible->GetValue (); + bIsLocked = pIsLocked->GetValue (); + bIsPrintable = pIsPrintable->GetValue (); + } + + String aPrevLayer = mpDrawView->GetActiveLayer(); + String aName; + SdrLayer* pLayer; + USHORT nPrevLayer = 0; + nLayerCnt = rLayerAdmin.GetLayerCount(); + + for ( nLayer = 0; nLayer < nLayerCnt; nLayer++ ) + { + pLayer = rLayerAdmin.GetLayer(nLayer); + aName = pLayer->GetName(); + + if ( aPrevLayer == aName ) + { +// nPrevLayer = nLayer; + nPrevLayer = Max(nLayer, (USHORT) 4); + } + } + + mpDrawView->InsertNewLayer(aLayerName, nPrevLayer + 1); + pLayer = rLayerAdmin.GetLayer(aLayerName, FALSE); + if( pLayer ) + { + pLayer->SetTitle( aLayerTitle ); + pLayer->SetDescription( aLayerDesc ); + } + + mpDrawView->SetLayerVisible( aLayerName, bIsVisible ); + mpDrawView->SetLayerLocked( aLayerName, bIsLocked); + mpDrawView->SetLayerPrintable(aLayerName, bIsPrintable); + + mpDrawView->SetActiveLayer(aLayerName); + + ResetActualLayer(); + + GetDoc()->SetChanged(TRUE); + + GetViewFrame()->GetDispatcher()->Execute(SID_SWITCHLAYER, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + + Cancel(); + rReq.Done (); + } + break; + + case SID_MODIFYLAYER: + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + SdrLayerAdmin& rLayerAdmin = GetDoc()->GetLayerAdmin(); + USHORT nCurPage = GetLayerTabControl()->GetCurPageId(); + String aLayerName( GetLayerTabControl()->GetPageText(nCurPage) ); + SdrLayer* pLayer = rLayerAdmin.GetLayer(aLayerName, FALSE); + + String aLayerTitle( pLayer->GetTitle() ); + String aLayerDesc( pLayer->GetDescription() ); + + String aOldLayerName( aLayerName ); + String aOldLayerTitle( aLayerTitle ); + String aOldLayerDesc( aLayerDesc ); + + BOOL bIsVisible, bIsLocked, bIsPrintable; + BOOL bOldIsVisible = bIsVisible = mpDrawView->IsLayerVisible(aLayerName); + BOOL bOldIsLocked = bIsLocked = mpDrawView->IsLayerLocked(aLayerName); + BOOL bOldIsPrintable = bIsPrintable = mpDrawView->IsLayerPrintable(aLayerName); + + + const SfxItemSet* pArgs = rReq.GetArgs(); + // darf der Layer geloescht werden ? + bool bDelete = true; + + String aLayoutLayer ( SdResId(STR_LAYER_LAYOUT) ); + String aControlsLayer ( SdResId(STR_LAYER_CONTROLS) ); + String aMeasureLinesLayer ( SdResId(STR_LAYER_MEASURELINES) ); + String aBackgroundLayer( SdResId(STR_LAYER_BCKGRND) ); + String aBackgroundObjLayer( SdResId(STR_LAYER_BCKGRNDOBJ) ); + + if( aLayerName == aLayoutLayer || aLayerName == aControlsLayer || + aLayerName == aMeasureLinesLayer || + aLayerName == aBackgroundLayer || aLayerName == aBackgroundObjLayer ) + { + bDelete = false; + } + + if (! pArgs) + { + SfxItemSet aNewAttr( GetDoc()->GetPool(), ATTR_LAYER_START, ATTR_LAYER_END ); + + aNewAttr.Put( SdAttrLayerName( aLayerName ) ); + aNewAttr.Put( SdAttrLayerTitle( aLayerTitle ) ); + aNewAttr.Put( SdAttrLayerDesc( aLayerDesc ) ); + aNewAttr.Put( SdAttrLayerVisible( bIsVisible ) ); + aNewAttr.Put( SdAttrLayerLocked( bIsLocked ) ); + aNewAttr.Put( SdAttrLayerPrintable( bIsPrintable ) ); + aNewAttr.Put( SdAttrLayerThisPage() ); + + SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); + AbstractSdInsertLayerDlg* pDlg = pFact ? pFact->CreateSdInsertLayerDlg(NULL, aNewAttr, bDelete, String( SdResId( STR_MODIFYLAYER ) ) ) : 0; + if( pDlg ) + { + pDlg->SetHelpId( SID_MODIFYLAYER ); + + // Ueberpruefung auf schon vorhandene Namen + BOOL bLoop = TRUE; + USHORT nRet = 0; + while( bLoop && ( (nRet = pDlg->Execute()) == RET_OK ) ) + { + pDlg->GetAttr( aNewAttr ); + aLayerName = ((SdAttrLayerName &) aNewAttr.Get (ATTR_LAYER_NAME)).GetValue (); + + if( (rLayerAdmin.GetLayer( aLayerName, FALSE ) && + aLayerName != aOldLayerName) || aLayerName.Len()==0 ) + { + // Name ist schon vorhanden + WarningBox aWarningBox ( + GetParentWindow(), + WinBits( WB_OK ), + String( SdResId( STR_WARN_NAME_DUPLICATE))); + aWarningBox.Execute(); + } + else + bLoop = FALSE; + } + switch (nRet) + { + case RET_OK : + aLayerTitle = ((SdAttrLayerTitle &) aNewAttr.Get (ATTR_LAYER_TITLE)).GetValue (); + aLayerDesc = ((SdAttrLayerDesc &) aNewAttr.Get (ATTR_LAYER_DESC)).GetValue (); + bIsVisible = ((const SdAttrLayerVisible &) aNewAttr.Get (ATTR_LAYER_VISIBLE)).GetValue (); + bIsLocked = ((const SdAttrLayerLocked &) aNewAttr.Get (ATTR_LAYER_LOCKED)).GetValue (); + bIsPrintable = ((const SdAttrLayerLocked &) aNewAttr.Get (ATTR_LAYER_PRINTABLE)).GetValue (); + + delete pDlg; + break; + + default : + delete pDlg; + rReq.Ignore (); + Cancel (); + return; + } + } + } + else if (pArgs->Count () == 4) + { + SFX_REQUEST_ARG (rReq, pLayerName, SfxStringItem, ID_VAL_LAYERNAME, FALSE); + SFX_REQUEST_ARG (rReq, pIsVisible, SfxBoolItem, ID_VAL_ISVISIBLE, FALSE); + SFX_REQUEST_ARG (rReq, pIsLocked, SfxBoolItem, ID_VAL_ISLOCKED, FALSE); + SFX_REQUEST_ARG (rReq, pIsPrintable, SfxBoolItem, ID_VAL_ISPRINTABLE, FALSE); + + aLayerName = pLayerName->GetValue (); + bIsVisible = pIsVisible->GetValue (); + bIsLocked = pIsLocked->GetValue (); + bIsPrintable = pIsPrintable->GetValue (); + } + else + { + StarBASIC::FatalError (SbERR_WRONG_ARGS); + Cancel (); + rReq.Ignore (); + break; + } + + SfxUndoManager* pManager = GetDoc()->GetDocSh()->GetUndoManager(); + SdLayerModifyUndoAction* pAction = new SdLayerModifyUndoAction( + GetDoc(), + pLayer, + // old values + aOldLayerName, + aOldLayerTitle, + aOldLayerDesc, + bOldIsVisible, + bOldIsLocked, + bOldIsPrintable, + // new values + aLayerName, + aLayerTitle, + aLayerDesc, + bIsVisible, + bIsLocked, + bIsPrintable + ); + pManager->AddUndoAction( pAction ); + + ModifyLayer( pLayer, aLayerName, aLayerTitle, aLayerDesc, bIsVisible, bIsLocked, bIsPrintable ); + + Cancel(); + rReq.Done (); + } + break; + + case SID_RENAMELAYER: + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + GetLayerTabControl()->StartEditMode( + GetLayerTabControl()->GetCurPageId() ); + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_EDIT_HYPERLINK : + { + GetViewFrame()->GetDispatcher()->Execute( SID_HYPERLINK_DIALOG ); + + Cancel(); + rReq.Done (); + } + break; + + case SID_OPEN_HYPERLINK: + { + OutlinerView* pOutView = mpDrawView->GetTextEditOutlinerView(); + if ( pOutView ) + { + const SvxFieldItem* pFieldItem = pOutView->GetFieldAtSelection(); + if ( pFieldItem ) + { + const SvxFieldData* pField = pFieldItem->GetField(); + if( pField && pField->ISA( SvxURLField ) ) + { + const SvxURLField* pURLField = static_cast< const SvxURLField* >( pField ); + + SfxStringItem aUrl( SID_FILE_NAME, pURLField->GetURL() ); + SfxStringItem aTarget( SID_TARGETNAME, pURLField->GetTargetFrame() ); + + String aReferName; + SfxViewFrame* pFrame = GetViewFrame(); + SfxMedium* pMed = pFrame->GetObjectShell()->GetMedium(); + if (pMed) + aReferName = pMed->GetName(); + + SfxFrameItem aFrm( SID_DOCFRAME, pFrame ); + SfxStringItem aReferer( SID_REFERER, aReferName ); + + SfxBoolItem aNewView( SID_OPEN_NEW_VIEW, FALSE ); + SfxBoolItem aBrowsing( SID_BROWSE, TRUE ); + + SfxViewFrame* pViewFrm = SfxViewFrame::Current(); + if (pViewFrm) + pViewFrm->GetDispatcher()->Execute( SID_OPENDOC, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, + &aUrl, &aTarget, + &aFrm, &aReferer, + &aNewView, &aBrowsing, + 0L ); + } + } + } + Cancel(); + rReq.Done (); + } + break; + + case SID_HYPERLINK_SETLINK: + { + const SfxItemSet* pReqArgs = rReq.GetArgs(); + + if (pReqArgs) + { + SvxHyperlinkItem* pHLItem = + (SvxHyperlinkItem*) &pReqArgs->Get(SID_HYPERLINK_SETLINK); + + if (pHLItem->GetInsertMode() == HLINK_FIELD) + { + InsertURLField(pHLItem->GetURL(), pHLItem->GetName(), + pHLItem->GetTargetFrame(), NULL); + } + else if (pHLItem->GetInsertMode() == HLINK_BUTTON) + { + InsertURLButton(pHLItem->GetURL(), pHLItem->GetName(), + pHLItem->GetTargetFrame(), NULL); + } + else if (pHLItem->GetInsertMode() == HLINK_DEFAULT) + { + OutlinerView* pOlView = mpDrawView->GetTextEditOutlinerView(); + + if (pOlView) + { + InsertURLField(pHLItem->GetURL(), pHLItem->GetName(), + pHLItem->GetTargetFrame(), NULL); + } + else + { + InsertURLButton(pHLItem->GetURL(), pHLItem->GetName(), + pHLItem->GetTargetFrame(), NULL); + } + } + } + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_INSERT_FLD_DATE_FIX: + case SID_INSERT_FLD_DATE_VAR: + case SID_INSERT_FLD_TIME_FIX: + case SID_INSERT_FLD_TIME_VAR: + case SID_INSERT_FLD_AUTHOR: + case SID_INSERT_FLD_PAGE: + case SID_INSERT_FLD_PAGES: + case SID_INSERT_FLD_FILE: + { + USHORT nMul = 1; + SvxFieldItem* pFieldItem = 0; + + switch( nSId ) + { + case SID_INSERT_FLD_DATE_FIX: + pFieldItem = new SvxFieldItem( + SvxDateField( Date(), SVXDATETYPE_FIX ), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_DATE_VAR: + pFieldItem = new SvxFieldItem( SvxDateField(), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_TIME_FIX: + pFieldItem = new SvxFieldItem( + SvxExtTimeField( Time(), SVXTIMETYPE_FIX ), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_TIME_VAR: + pFieldItem = new SvxFieldItem( SvxExtTimeField(), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_AUTHOR: + { + SvtUserOptions aUserOptions; + pFieldItem = new SvxFieldItem( + SvxAuthorField( + aUserOptions.GetFirstName(), aUserOptions.GetLastName(), aUserOptions.GetID() ), EE_FEATURE_FIELD ); + } + break; + + case SID_INSERT_FLD_PAGE: + { + pFieldItem = new SvxFieldItem( SvxPageField(), EE_FEATURE_FIELD ); + nMul = 3; + } + break; + + case SID_INSERT_FLD_PAGES: + { + pFieldItem = new SvxFieldItem( SvxPagesField(), EE_FEATURE_FIELD ); + nMul = 3; + } + break; + + case SID_INSERT_FLD_FILE: + { + String aName; + if( GetDocSh()->HasName() ) + aName = GetDocSh()->GetMedium()->GetName(); + //else + // aName = GetDocSh()->GetName(); + pFieldItem = new SvxFieldItem( SvxExtFileField( aName ), EE_FEATURE_FIELD ); + } + break; + } + + OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView(); + + if( pOLV ) + { + const SvxFieldItem* pOldFldItem = pOLV->GetFieldAtSelection(); + + if( pOldFldItem && ( pOldFldItem->GetField()->ISA( SvxURLField ) || + pOldFldItem->GetField()->ISA( SvxDateField ) || + pOldFldItem->GetField()->ISA( SvxTimeField ) || + pOldFldItem->GetField()->ISA( SvxExtTimeField ) || + pOldFldItem->GetField()->ISA( SvxExtFileField ) || + pOldFldItem->GetField()->ISA( SvxAuthorField ) || + pOldFldItem->GetField()->ISA( SvxPageField ) ) ) + { + // Feld selektieren, so dass es beim Insert geloescht wird + ESelection aSel = pOLV->GetSelection(); + if( aSel.nStartPos == aSel.nEndPos ) + aSel.nEndPos++; + pOLV->SetSelection( aSel ); + } + + if( pFieldItem ) + pOLV->InsertField( *pFieldItem ); + } + else + { + Outliner* pOutl = GetDoc()->GetInternalOutliner(); + pOutl->Init( OUTLINERMODE_TEXTOBJECT ); + USHORT nOutlMode = pOutl->GetMode(); + pOutl->SetStyleSheet( 0, NULL ); + pOutl->QuickInsertField( *pFieldItem, ESelection() ); + OutlinerParaObject* pOutlParaObject = pOutl->CreateParaObject(); + + SdrRectObj* pRectObj = new SdrRectObj( OBJ_TEXT ); + pRectObj->SetMergedItem(SdrTextAutoGrowWidthItem(TRUE)); + + pOutl->UpdateFields(); + pOutl->SetUpdateMode( TRUE ); + Size aSize( pOutl->CalcTextSize() ); + aSize.Width() *= nMul; + pOutl->SetUpdateMode( FALSE ); + + Point aPos; + Rectangle aRect( aPos, GetActiveWindow()->GetOutputSizePixel() ); + aPos = aRect.Center(); + aPos = GetActiveWindow()->PixelToLogic(aPos); + aPos.X() -= aSize.Width() / 2; + aPos.Y() -= aSize.Height() / 2; + + Rectangle aLogicRect(aPos, aSize); + pRectObj->SetLogicRect(aLogicRect); + pRectObj->SetOutlinerParaObject( pOutlParaObject ); + mpDrawView->InsertObjectAtView(pRectObj, *mpDrawView->GetSdrPageView()); + pOutl->Init( nOutlMode ); + } + + delete pFieldItem; + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_MODIFY_FIELD: + { + OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView(); + + if( pOLV ) + { + const SvxFieldItem* pFldItem = pOLV->GetFieldAtSelection(); + + if( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) || + pFldItem->GetField()->ISA( SvxAuthorField ) || + pFldItem->GetField()->ISA( SvxExtFileField ) || + pFldItem->GetField()->ISA( SvxExtTimeField ) ) ) + { + // Dialog... + SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); + AbstractSdModifyFieldDlg* pDlg = pFact ? pFact->CreateSdModifyFieldDlg(GetActiveWindow(), pFldItem->GetField(), pOLV->GetAttribs() ) : 0; + if( pDlg && pDlg->Execute() == RET_OK ) + { + // #108538# + // To make a correct SetAttribs() call at the utlinerView + // it is necessary to split the actions here + SvxFieldData* pField = pDlg->GetField(); + ESelection aSel = pOLV->GetSelection(); + sal_Bool bSelectionWasModified(sal_False); + + if( pField ) + { + SvxFieldItem aFieldItem( *pField, EE_FEATURE_FIELD ); + + if( aSel.nStartPos == aSel.nEndPos ) + { + bSelectionWasModified = sal_True; + aSel.nEndPos++; + pOLV->SetSelection( aSel ); + } + + pOLV->InsertField( aFieldItem ); + + // #108538# select again for eventual SetAttribs call + pOLV->SetSelection( aSel ); + } + + SfxItemSet aSet( pDlg->GetItemSet() ); + + if( aSet.Count() ) + { + pOLV->SetAttribs( aSet ); + + ::Outliner* pOutliner = pOLV->GetOutliner(); + if( pOutliner ) + pOutliner->UpdateFields(); + } + + if(pField) + { + // #108538# restore selection to original + if(bSelectionWasModified) + { + aSel.nEndPos--; + pOLV->SetSelection( aSel ); + } + + delete pField; + } + } + delete pDlg; + } + } + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_OPEN_XML_FILTERSETTINGS: + { + try + { + com::sun::star::uno::Reference < ::com::sun::star::ui::dialogs::XExecutableDialog > xDialog(::comphelper::getProcessServiceFactory()->createInstance(rtl::OUString::createFromAscii("com.sun.star.comp.ui.XSLTFilterDialog")), com::sun::star::uno::UNO_QUERY); + if( xDialog.is() ) + { + xDialog->execute(); + } + } + catch( ::com::sun::star::uno::RuntimeException& ) + { + } + + Cancel(); + rReq.Ignore (); + } + break; + + default: + { + // switch Anweisung wegen CLOOKS aufgeteilt. Alle case-Anweisungen die + // eine Fu???? -Funktion aufrufen, sind in die Methode FuTemp03 (drviewsb) + // gewandert. + FuTemp03(rReq); + } + break; + }; +}; + +bool DrawViewShell::RenameSlide( USHORT nPageId, const String & rName ) +{ + BOOL bOutDummy; + if( GetDoc()->GetPageByName( rName, bOutDummy ) != SDRPAGE_NOTFOUND ) + return false; + + SdPage* pPageToRename = NULL; + PageKind ePageKind = GetPageKind(); + + if( GetEditMode() == EM_PAGE ) + { + pPageToRename = GetDoc()->GetSdPage( nPageId - 1, ePageKind ); + + // Undo + SdPage* pUndoPage = pPageToRename; + SdrLayerAdmin & rLayerAdmin = GetDoc()->GetLayerAdmin(); + BYTE nBackground = rLayerAdmin.GetLayerID( String( SdResId( STR_LAYER_BCKGRND )), FALSE ); + BYTE nBgObj = rLayerAdmin.GetLayerID( String( SdResId( STR_LAYER_BCKGRNDOBJ )), FALSE ); + SetOfByte aVisibleLayers = mpActualPage->TRG_GetMasterPageVisibleLayers(); + + // (#67720#) + SfxUndoManager* pManager = GetDoc()->GetDocSh()->GetUndoManager(); + ModifyPageUndoAction* pAction = new ModifyPageUndoAction( + pManager, GetDoc(), pUndoPage, rName, pUndoPage->GetAutoLayout(), + aVisibleLayers.IsSet( nBackground ), + aVisibleLayers.IsSet( nBgObj )); + pManager->AddUndoAction( pAction ); + + // rename + pPageToRename->SetName( rName ); + + if( ePageKind == PK_STANDARD ) + { + // also rename notes-page + SdPage* pNotesPage = GetDoc()->GetSdPage( nPageId - 1, PK_NOTES ); + pNotesPage->SetName( rName ); + } + } + else + { + // rename MasterPage -> rename LayoutTemplate + pPageToRename = GetDoc()->GetMasterSdPage( nPageId - 1, ePageKind ); + GetDoc()->RenameLayoutTemplate( pPageToRename->GetLayoutName(), rName ); + } + + bool bSuccess = ( FALSE != rName.Equals( pPageToRename->GetName())); + + if( bSuccess ) + { + // user edited page names may be changed by the page so update control + maTabControl.SetPageText( nPageId, rName ); + + // set document to modified state + GetDoc()->SetChanged( TRUE ); + + // inform navigator about change + SfxBoolItem aItem( SID_NAVIGATOR_INIT, TRUE ); + GetViewFrame()->GetDispatcher()->Execute( + SID_NAVIGATOR_INIT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); + + // Tell the slide sorter about the name change (necessary for + // accessibility.) + slidesorter::SlideSorterViewShell* pSlideSorterViewShell + = slidesorter::SlideSorterViewShell::GetSlideSorter(GetViewShellBase()); + if (pSlideSorterViewShell != NULL) + { + pSlideSorterViewShell->GetSlideSorter().GetController().PageNameHasChanged( + nPageId-1, rName); + } + } + + return bSuccess; +} + + + + +IMPL_LINK( DrawViewShell, RenameSlideHdl, AbstractSvxNameDialog*, pDialog ) +{ + if( ! pDialog ) + return 0; + + String aNewName; + pDialog->GetName( aNewName ); + + SdPage* pCurrentPage = GetDoc()->GetSdPage( maTabControl.GetCurPageId() - 1, GetPageKind() ); + + return pCurrentPage && ( aNewName.Equals( pCurrentPage->GetName() ) || GetDocSh()->IsNewPageNameValid( aNewName ) ); +} + + + + +void DrawViewShell::ModifyLayer ( + SdrLayer* pLayer, + const String& rLayerName, + const String& rLayerTitle, + const String& rLayerDesc, + bool bIsVisible, + bool bIsLocked, + bool bIsPrintable) +{ + if( pLayer ) + { + const USHORT nPageCount = GetLayerTabControl()->GetPageCount(); + USHORT nCurPage = 0; + USHORT nPos; + for( nPos = 0; nPos < nPageCount; nPos++ ) + { + USHORT nId = GetLayerTabControl()->GetPageId( nPos ); + if( pLayer->GetName() == GetLayerTabControl()->GetPageText( nId ) ) + { + nCurPage = nId; + break; + } + } + + pLayer->SetName( rLayerName ); + pLayer->SetTitle( rLayerTitle ); + pLayer->SetDescription( rLayerDesc ); + mpDrawView->SetLayerVisible( rLayerName, bIsVisible ); + mpDrawView->SetLayerLocked( rLayerName, bIsLocked); + mpDrawView->SetLayerPrintable(rLayerName, bIsPrintable); + + GetDoc()->SetChanged(TRUE); + + GetLayerTabControl()->SetPageText(nCurPage, rLayerName); + + TabBarPageBits nBits = 0; + + if (!bIsVisible) + { + // Unsichtbare Layer werden anders dargestellt + nBits = TPB_SPECIAL; + } + + GetLayerTabControl()->SetPageBits(nCurPage, nBits); + + GetViewFrame()->GetDispatcher()->Execute( + SID_SWITCHLAYER, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + + // Call Invalidate at the form shell. + FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell(); + if (pFormShell != NULL) + pFormShell->Invalidate(); + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviewsc.cxx b/sd/source/ui/view/drviewsc.cxx new file mode 100644 index 000000000000..eefe0680d2d4 --- /dev/null +++ b/sd/source/ui/view/drviewsc.cxx @@ -0,0 +1,994 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include "ViewShellImplementation.hxx" +#include <vcl/waitobj.hxx> + +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <svx/dialogs.hrc> +#ifndef _IMAPDLG_HXX +#include <svx/imapdlg.hxx> +#endif +#include <vcl/msgbox.hxx> +#include <sfx2/request.hxx> +#include <svx/svdogrp.hxx> +#include <svx/svdoole2.hxx> +#include <svx/svdograf.hxx> +#include <svx/svxdlg.hxx> +#ifndef _BINDING_HXX //autogen +#include <sfx2/bindings.hxx> +#endif +#include <sfx2/dispatch.hxx> +#include <svx/svdoole2.hxx> +#include <svl/style.hxx> +#include <svx/svdpagv.hxx> +#include <svx/grafctrl.hxx> +#include "stlsheet.hxx" + +#include <sfx2/viewfrm.hxx> + +#include "app.hrc" +#include "strings.hrc" +#include "helpids.h" +#include "misc.hxx" +#include "Window.hxx" +#include "imapinfo.hxx" +#include "futempl.hxx" +#include "fusel.hxx" +#include "sdresid.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "drawview.hxx" +#include "sdabstdlg.hxx" +#include "brkdlg.hrc" +namespace sd { + +#define MIN_ACTIONS_FOR_DIALOG 5000 // bei mehr als 1600 Metaobjekten + // wird beim Aufbrechen ein Dialog + // angezeigt. +/************************************************************************* +|* +|* SfxRequests fuer temporaere Funktionen +|* +\************************************************************************/ + +void DrawViewShell::FuTemp03(SfxRequest& rReq) +{ + USHORT nSId = rReq.GetSlot(); + switch( nSId ) + { + case SID_GROUP: // BASIC + { + if ( mpDrawView->IsPresObjSelected( TRUE, TRUE, TRUE ) ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + mpDrawView->GroupMarked(); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_UNGROUP: // BASIC + { + mpDrawView->UnGroupMarked(); + Cancel(); + rReq.Done (); + } + break; + + case SID_NAME_GROUP: + { + // only allow for single object selection since the name of an object needs + // to be unique + if(1L == mpDrawView->GetMarkedObjectCount()) + { + // #i68101# + SdrObject* pSelected = mpDrawView->GetMarkedObjectByIndex(0L); + OSL_ENSURE(pSelected, "DrawViewShell::FuTemp03: nMarkCount, but no object (!)"); + String aName(pSelected->GetName()); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + OSL_ENSURE(pFact, "Dialogdiet fail!"); + AbstractSvxObjectNameDialog* pDlg = pFact->CreateSvxObjectNameDialog(NULL, aName); + OSL_ENSURE(pDlg, "Dialogdiet fail!"); + + pDlg->SetCheckNameHdl(LINK(this, DrawViewShell, NameObjectHdl)); + + if(RET_OK == pDlg->Execute()) + { + pDlg->GetName(aName); + pSelected->SetName(aName); + } + + delete pDlg; + } + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_NAVIGATOR_STATE, TRUE, FALSE ); + rBindings.Invalidate( SID_CONTEXT ); + + Cancel(); + rReq.Ignore(); + break; + } + + // #i68101# + case SID_OBJECT_TITLE_DESCRIPTION: + { + if(1L == mpDrawView->GetMarkedObjectCount()) + { + SdrObject* pSelected = mpDrawView->GetMarkedObjectByIndex(0L); + OSL_ENSURE(pSelected, "DrawViewShell::FuTemp03: nMarkCount, but no object (!)"); + String aTitle(pSelected->GetTitle()); + String aDescription(pSelected->GetDescription()); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + OSL_ENSURE(pFact, "Dialogdiet fail!"); + AbstractSvxObjectTitleDescDialog* pDlg = pFact->CreateSvxObjectTitleDescDialog(NULL, aTitle, aDescription); + OSL_ENSURE(pDlg, "Dialogdiet fail!"); + + if(RET_OK == pDlg->Execute()) + { + pDlg->GetTitle(aTitle); + pDlg->GetDescription(aDescription); + pSelected->SetTitle(aTitle); + pSelected->SetDescription(aDescription); + } + + delete pDlg; + } + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_NAVIGATOR_STATE, TRUE, FALSE ); + rBindings.Invalidate( SID_CONTEXT ); + + Cancel(); + rReq.Ignore(); + break; + } + + case SID_ENTER_GROUP: // BASIC + { + mpDrawView->EnterMarkedGroup(); + Cancel(); + rReq.Done (); + } + break; + + case SID_LEAVE_GROUP: // BASIC + { + mpDrawView->LeaveOneGroup(); + Cancel(); + rReq.Done (); + } + break; + + case SID_LEAVE_ALL_GROUPS: // BASIC + { + mpDrawView->LeaveAllGroup(); + Cancel(); + rReq.Done (); + } + break; + + case SID_COMBINE: // BASIC + { + // #88224# End text edit to avoid conflicts + if(mpDrawView->IsTextEdit()) + mpDrawView->SdrEndTextEdit(); + + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->CombineMarkedObjects(sal_False); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_DISTRIBUTE_DLG: + { + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + mpDrawView->DistributeMarkedObjects(); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_POLY_MERGE: + { + // #88224# End text edit to avoid conflicts + if(mpDrawView->IsTextEdit()) + mpDrawView->SdrEndTextEdit(); + + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->MergeMarkedObjects(SDR_MERGE_MERGE); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_POLY_SUBSTRACT: + { + // #88224# End text edit to avoid conflicts + if(mpDrawView->IsTextEdit()) + mpDrawView->SdrEndTextEdit(); + + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->MergeMarkedObjects(SDR_MERGE_SUBSTRACT); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_POLY_INTERSECT: + { + // #88224# End text edit to avoid conflicts + if(mpDrawView->IsTextEdit()) + mpDrawView->SdrEndTextEdit(); + + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->MergeMarkedObjects(SDR_MERGE_INTERSECT); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_DISMANTLE: // BASIC + { + if ( mpDrawView->IsDismantlePossible(FALSE) ) + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->DismantleMarkedObjects(FALSE); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_CONNECT: // BASIC + { + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->CombineMarkedObjects(sal_True); + } + Cancel(); + rReq.Done (); + } + break; + + case SID_BREAK: // BASIC + { + if ( mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + if ( mpDrawView->IsBreak3DObjPossible() ) + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->Break3DObj(); + } + else if ( mpDrawView->IsDismantlePossible(TRUE) ) + { + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->DismantleMarkedObjects(TRUE); + } + else if ( mpDrawView->IsImportMtfPossible() ) + { + + WaitObject aWait( (Window*)GetActiveWindow() ); + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + ULONG nAnz=rMarkList.GetMarkCount(); + + // Summe der Metaobjekte aller sel. Metafiles erm. + ULONG nCount = 0; + for(ULONG nm=0; nm<nAnz; nm++) + { + SdrMark* pM=rMarkList.GetMark(nm); + SdrObject* pObj=pM->GetMarkedSdrObj(); + SdrGrafObj* pGraf=PTR_CAST(SdrGrafObj,pObj); + SdrOle2Obj* pOle2=PTR_CAST(SdrOle2Obj,pObj); + if (pGraf!=NULL && pGraf->HasGDIMetaFile()) + nCount += pGraf->GetGraphic().GetGDIMetaFile().GetActionCount(); + if(pOle2!=NULL && pOle2->GetGraphic()) + nCount += pOle2->GetGraphic()->GetGDIMetaFile().GetActionCount(); + } + + // anhand der erm. Summe entscheiden ob mit + // oder ohne Dialog aufgebrochen wird. + if(nCount < MIN_ACTIONS_FOR_DIALOG) + { + // ohne Dialog aufbrechen + mpDrawView->DoImportMarkedMtf(); + } + else + { + SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); + if( pFact ) + { + VclAbstractDialog* pDlg = pFact->CreateBreakDlg(GetActiveWindow(), mpDrawView, GetDocSh(), nCount, nAnz ); + if( pDlg ) + { + pDlg->Execute(); + delete pDlg; + } + } + } + } + + Cancel(); + rReq.Done (); + } + break; + + case SID_CONVERT_TO_3D: + { + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + if (mpDrawView->IsConvertTo3DObjPossible()) + { + if (mpDrawView->IsTextEdit()) + { + mpDrawView->SdrEndTextEdit(); + } + + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->ConvertMarkedObjTo3D(TRUE); + } + } + + Cancel(); + rReq.Done(); + } + break; + + case SID_FRAME_TO_TOP: // BASIC + { + mpDrawView->PutMarkedToTop(); + Cancel(); + Invalidate( SID_POSITION ); + rReq.Done (); + } + break; + + case SID_MOREFRONT: // BASIC + { + mpDrawView->MovMarkedToTop(); + Cancel(); + Invalidate( SID_POSITION ); + rReq.Done (); + } + break; + + case SID_MOREBACK: // BASIC + { + mpDrawView->MovMarkedToBtm(); + Cancel(); + Invalidate( SID_POSITION ); + rReq.Done (); + } + break; + + case SID_FRAME_TO_BOTTOM: // BASIC + { + mpDrawView->PutMarkedToBtm(); + Cancel(); + Invalidate( SID_POSITION ); + rReq.Done (); + } + break; + + case SID_HORIZONTAL: // BASIC + { + mpDrawView->MirrorAllMarkedHorizontal(); + Cancel(); + rReq.Done (); + } + break; + + case SID_VERTICAL: // BASIC + { + mpDrawView->MirrorAllMarkedVertical(); + Cancel(); + rReq.Done (); + } + break; + + case SID_OBJECT_ALIGN_LEFT: // BASIC + { + mpDrawView->AlignMarkedObjects(SDRHALIGN_LEFT, SDRVALIGN_NONE); + Cancel(); + rReq.Done (); + } + break; + + case SID_OBJECT_ALIGN_CENTER: // BASIC + { + mpDrawView->AlignMarkedObjects(SDRHALIGN_CENTER, SDRVALIGN_NONE); + Cancel(); + rReq.Done (); + } + break; + + case SID_OBJECT_ALIGN_RIGHT: // BASIC + { + mpDrawView->AlignMarkedObjects(SDRHALIGN_RIGHT, SDRVALIGN_NONE); + Cancel(); + rReq.Done (); + } + break; + + case SID_OBJECT_ALIGN_UP: // BASIC + { + mpDrawView->AlignMarkedObjects(SDRHALIGN_NONE, SDRVALIGN_TOP); + Cancel(); + rReq.Done (); + } + break; + + case SID_OBJECT_ALIGN_MIDDLE: // BASIC + { + mpDrawView->AlignMarkedObjects(SDRHALIGN_NONE, SDRVALIGN_CENTER); + Cancel(); + rReq.Done (); + } + break; + + case SID_OBJECT_ALIGN_DOWN: // BASIC + { + mpDrawView->AlignMarkedObjects(SDRHALIGN_NONE, SDRVALIGN_BOTTOM); + Cancel(); + rReq.Done (); + } + break; + + case SID_SELECTALL: // BASIC + { + if( (dynamic_cast<FuSelection*>( GetOldFunction().get() ) != 0) && + !GetView()->IsFrameDragSingles() && GetView()->HasMarkablePoints()) + { + if ( !mpDrawView->IsAction() ) + mpDrawView->MarkAllPoints(); + } + else + mpDrawView->SelectAll(); + + Cancel(); + rReq.Done (); + } + break; + + case SID_STYLE_NEW: // BASIC ??? + case SID_STYLE_APPLY: + case SID_STYLE_EDIT: + case SID_STYLE_DELETE: + case SID_STYLE_FAMILY: + case SID_STYLE_WATERCAN: + case SID_STYLE_UPDATE_BY_EXAMPLE: + case SID_STYLE_NEW_BY_EXAMPLE: + { + if( rReq.GetSlot() == SID_STYLE_EDIT && !rReq.GetArgs() ) + { + SfxStyleSheet* pStyleSheet = mpDrawView->GetStyleSheet(); + if( pStyleSheet && pStyleSheet->GetFamily() == SD_STYLE_FAMILY_MASTERPAGE) + pStyleSheet = ((SdStyleSheet*)pStyleSheet)->GetPseudoStyleSheet(); + + if( (pStyleSheet == NULL) && GetView()->IsTextEdit() ) + { + GetView()->SdrEndTextEdit(); + + pStyleSheet = mpDrawView->GetStyleSheet(); + if(pStyleSheet && pStyleSheet->GetFamily() == SD_STYLE_FAMILY_MASTERPAGE) + pStyleSheet = ((SdStyleSheet*)pStyleSheet)->GetPseudoStyleSheet(); + } + + if( pStyleSheet == NULL ) + { + rReq.Ignore(); + break; + } + + SfxAllItemSet aSet(GetDoc()->GetPool()); + + SfxStringItem aStyleNameItem( SID_STYLE_EDIT, pStyleSheet->GetName() ); + aSet.Put(aStyleNameItem); + + SfxUInt16Item aStyleFamilyItem( SID_STYLE_FAMILY, (UINT16)pStyleSheet->GetFamily() ); + aSet.Put(aStyleFamilyItem); + + rReq.SetArgs(aSet); + } + + if( rReq.GetArgs() ) + { + SetCurrentFunction( FuTemplate::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + if( rReq.GetSlot() == SID_STYLE_APPLY ) + GetViewFrame()->GetBindings().Invalidate( SID_STYLE_APPLY ); + Cancel(); + } + else if( rReq.GetSlot() == SID_STYLE_APPLY ) + GetViewFrame()->GetDispatcher()->Execute( SID_STYLE_DESIGNER, SFX_CALLMODE_ASYNCHRON ); + rReq.Ignore (); + } + break; + + case SID_IMAP: + { + SvxIMapDlg* pDlg; + USHORT nId = SvxIMapDlgChildWindow::GetChildWindowId(); + + GetViewFrame()->ToggleChildWindow( nId ); + GetViewFrame()->GetBindings().Invalidate( SID_IMAP ); + + if ( GetViewFrame()->HasChildWindow( nId ) + && ( ( pDlg = ViewShell::Implementation::GetImageMapDialog() ) != NULL ) ) + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + + if ( rMarkList.GetMarkCount() == 1 ) + UpdateIMapDlg( rMarkList.GetMark( 0 )->GetMarkedSdrObj() ); + } + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_GRID_FRONT: + { + mpDrawView->SetGridFront( !mpDrawView->IsGridFront() ); + Cancel(); + rReq.Done (); + } + break; + + case SID_HELPLINES_FRONT: + { + mpDrawView->SetHlplFront( !mpDrawView->IsHlplFront() ); + Cancel(); + rReq.Done (); + } + break; + + default: + FuTemp04(rReq); + break; + }; +}; + +/************************************************************************* +|* +|* Liefert die globale/Haupt-ID zurueck, also die ID, ueber die die +|* Toolbox ausgeloest wird +|* +\************************************************************************/ + +USHORT DrawViewShell::GetIdBySubId( USHORT nSId ) +{ + USHORT nMappedSId = 0; + switch( nSId ) + { + case SID_OBJECT_ROTATE: + case SID_OBJECT_MIRROR: + case SID_OBJECT_TRANSPARENCE: + case SID_OBJECT_GRADIENT: + case SID_OBJECT_SHEAR: + case SID_OBJECT_CROOK_ROTATE: + case SID_OBJECT_CROOK_SLANT: + case SID_OBJECT_CROOK_STRETCH: + case SID_CONVERT_TO_3D_LATHE: + { + nMappedSId = SID_OBJECT_CHOOSE_MODE; + } + break; + + case SID_OBJECT_ALIGN_LEFT: + case SID_OBJECT_ALIGN_CENTER: + case SID_OBJECT_ALIGN_RIGHT: + case SID_OBJECT_ALIGN_UP: + case SID_OBJECT_ALIGN_MIDDLE: + case SID_OBJECT_ALIGN_DOWN: + { + nMappedSId = SID_OBJECT_ALIGN; + } + break; + + case SID_FRAME_TO_TOP: + case SID_MOREFRONT: + case SID_MOREBACK: + case SID_FRAME_TO_BOTTOM: + case SID_BEFORE_OBJ: + case SID_BEHIND_OBJ: + case SID_REVERSE_ORDER: + { + nMappedSId = SID_POSITION; + } + break; + + case SID_ZOOM_OUT: + case SID_ZOOM_IN: + case SID_SIZE_REAL: + case SID_ZOOM_PANNING: + case SID_SIZE_PAGE: + case SID_SIZE_PAGE_WIDTH: + case SID_SIZE_ALL: + case SID_SIZE_OPTIMAL: + case SID_ZOOM_NEXT: + case SID_ZOOM_PREV: + { + nMappedSId = SID_ZOOM_TOOLBOX; + } + break; + + case SID_ATTR_CHAR: + case SID_TEXT_FITTOSIZE: + case SID_DRAW_CAPTION: + case SID_DRAW_FONTWORK: + case SID_DRAW_FONTWORK_VERTICAL: + { + nMappedSId = SID_DRAWTBX_TEXT; + } + break; + + case SID_DRAW_RECT: + case SID_DRAW_SQUARE: + case SID_DRAW_RECT_ROUND: + case SID_DRAW_SQUARE_ROUND: + case SID_DRAW_RECT_NOFILL: + case SID_DRAW_SQUARE_NOFILL: + case SID_DRAW_RECT_ROUND_NOFILL: + case SID_DRAW_SQUARE_ROUND_NOFILL: + { + nMappedSId = SID_DRAWTBX_RECTANGLES; + } + break; + + case SID_DRAW_ELLIPSE: + case SID_DRAW_CIRCLE: + case SID_DRAW_PIE: + case SID_DRAW_CIRCLEPIE: + case SID_DRAW_ELLIPSECUT: + case SID_DRAW_CIRCLECUT: + case SID_DRAW_ARC: + case SID_DRAW_CIRCLEARC: + case SID_DRAW_ELLIPSE_NOFILL: + case SID_DRAW_CIRCLE_NOFILL: + case SID_DRAW_PIE_NOFILL: + case SID_DRAW_CIRCLEPIE_NOFILL: + case SID_DRAW_ELLIPSECUT_NOFILL: + case SID_DRAW_CIRCLECUT_NOFILL: + { + nMappedSId = SID_DRAWTBX_ELLIPSES; + } + break; + + case SID_DRAW_BEZIER_NOFILL: + case SID_DRAW_POLYGON_NOFILL: + case SID_DRAW_XPOLYGON_NOFILL: + case SID_DRAW_FREELINE_NOFILL: + case SID_DRAW_BEZIER_FILL: + case SID_DRAW_POLYGON: + case SID_DRAW_XPOLYGON: + case SID_DRAW_FREELINE: + { + nMappedSId = SID_DRAWTBX_LINES; + } + break; + + case SID_DRAW_LINE: + case SID_DRAW_XLINE: + case SID_DRAW_MEASURELINE: + case SID_LINE_ARROW_START: + case SID_LINE_ARROW_END: + case SID_LINE_ARROWS: + case SID_LINE_ARROW_CIRCLE: + case SID_LINE_CIRCLE_ARROW: + case SID_LINE_ARROW_SQUARE: + case SID_LINE_SQUARE_ARROW: + { + nMappedSId = SID_DRAWTBX_ARROWS; + } + break; + + case SID_3D_CUBE: + case SID_3D_TORUS: + case SID_3D_SPHERE: + case SID_3D_SHELL: + case SID_3D_HALF_SPHERE: + case SID_3D_CYLINDER: + case SID_3D_CONE: + case SID_3D_PYRAMID: + { + nMappedSId = SID_DRAWTBX_3D_OBJECTS; + } + break; + + case SID_INSERT_DIAGRAM: +#ifdef STARIMAGE_AVAILABLE + case SID_INSERT_IMAGE: +#endif + case SID_ATTR_TABLE: + case SID_INSERTFILE: + case SID_INSERT_GRAPHIC: + case SID_INSERT_AVMEDIA: + case SID_INSERTPAGE: + case SID_INSERT_MATH: + case SID_INSERT_FLOATINGFRAME: + case SID_INSERT_OBJECT: + case SID_INSERT_PLUGIN: + case SID_INSERT_SOUND: + case SID_INSERT_VIDEO: + case SID_INSERT_APPLET: + case SID_INSERT_TABLE: + { + nMappedSId = SID_DRAWTBX_INSERT; + } + break; + + case SID_TOOL_CONNECTOR: + case SID_CONNECTOR_ARROW_START: + case SID_CONNECTOR_ARROW_END: + case SID_CONNECTOR_ARROWS: + case SID_CONNECTOR_CIRCLE_START: + case SID_CONNECTOR_CIRCLE_END: + case SID_CONNECTOR_CIRCLES: + case SID_CONNECTOR_LINE: + case SID_CONNECTOR_LINE_ARROW_START: + case SID_CONNECTOR_LINE_ARROW_END: + case SID_CONNECTOR_LINE_ARROWS: + case SID_CONNECTOR_LINE_CIRCLE_START: + case SID_CONNECTOR_LINE_CIRCLE_END: + case SID_CONNECTOR_LINE_CIRCLES: + case SID_CONNECTOR_CURVE: + case SID_CONNECTOR_CURVE_ARROW_START: + case SID_CONNECTOR_CURVE_ARROW_END: + case SID_CONNECTOR_CURVE_ARROWS: + case SID_CONNECTOR_CURVE_CIRCLE_START: + case SID_CONNECTOR_CURVE_CIRCLE_END: + case SID_CONNECTOR_CURVE_CIRCLES: + case SID_CONNECTOR_LINES: + case SID_CONNECTOR_LINES_ARROW_START: + case SID_CONNECTOR_LINES_ARROW_END: + case SID_CONNECTOR_LINES_ARROWS: + case SID_CONNECTOR_LINES_CIRCLE_START: + case SID_CONNECTOR_LINES_CIRCLE_END: + case SID_CONNECTOR_LINES_CIRCLES: + { + nMappedSId = SID_DRAWTBX_CONNECTORS; + } + } + return( nMappedSId ); +} + +/************************************************************************* +|* +|* Fuellt das SlotArray, um das aktuelle Mapping des ToolboxSlots zu +|* bekommen +|* +\************************************************************************/ + +void DrawViewShell::MapSlot( USHORT nSId ) +{ + USHORT nMappedSId = GetIdBySubId( nSId ); + + if( nMappedSId > 0 ) + { + USHORT nID = GetArrayId( nMappedSId ) + 1; + mpSlotArray[ nID ] = nSId; + } +} + +/************************************************************************* +|* +|* Ermoeglicht ueber das SlotArray ein ImageMapping +|* +\************************************************************************/ + +void DrawViewShell::UpdateToolboxImages( SfxItemSet &rSet, BOOL bPermanent ) +{ + if( !bPermanent ) + { + USHORT nId = GetArrayId( SID_ZOOM_TOOLBOX ) + 1; + rSet.Put( TbxImageItem( SID_ZOOM_TOOLBOX, mpSlotArray[nId] ) ); + + nId = GetArrayId( SID_DRAWTBX_INSERT ) + 1; + rSet.Put( TbxImageItem( SID_DRAWTBX_INSERT, mpSlotArray[nId] ) ); + + nId = GetArrayId( SID_POSITION ) + 1; + rSet.Put( TbxImageItem( SID_POSITION, mpSlotArray[nId] ) ); + + nId = GetArrayId( SID_OBJECT_ALIGN ) + 1; + rSet.Put( TbxImageItem( SID_OBJECT_ALIGN, mpSlotArray[nId] ) ); + } + else + { + for( USHORT nId = 0; nId < SLOTARRAY_COUNT; nId += 2 ) + { + rSet.Put( TbxImageItem( mpSlotArray[nId], mpSlotArray[nId+1] ) ); + } + } +} + +/************************************************************************* +|* +|* Gibt den gemappten Slot zurueck +|* +\************************************************************************/ + +USHORT DrawViewShell::GetMappedSlot( USHORT nSId ) +{ + USHORT nSlot = 0; + USHORT nId = GetArrayId( nSId ); + if( nId != USHRT_MAX ) + nSlot = mpSlotArray[ nId+1 ]; + + // Wenn der Slot noch auf sich selbst gemapped ist, muss 0 zurueck- + // gegeben werden, da sonst der Slot immer wieder selbst executet + // wird. Im Array ist der Slot selbst initial vorhanden, damit das + // Image richtig angezeigt wird. + if( nSId == nSlot ) + return( 0 ); + + return( nSlot ); +} + +/************************************************************************* +|* +|* Gibt die Nummer des HauptSlots im SlotArray zurueck +|* +\************************************************************************/ + +USHORT DrawViewShell::GetArrayId( USHORT nSId ) +{ + for( USHORT i = 0; i < SLOTARRAY_COUNT; i += 2 ) + { + if( mpSlotArray[ i ] == nSId ) + return( i ); + } + DBG_ERROR( "Slot im Array nicht gefunden!" ); + return( USHRT_MAX ); +} + + +/************************************************************************* +|* +|* IMap-Dlg updaten +|* +\************************************************************************/ + +void DrawViewShell::UpdateIMapDlg( SdrObject* pObj ) +{ + if( ( pObj->ISA( SdrGrafObj ) || pObj->ISA( SdrOle2Obj ) ) && !mpDrawView->IsTextEdit() && + GetViewFrame()->HasChildWindow( SvxIMapDlgChildWindow::GetChildWindowId() ) ) + { + Graphic aGraphic; + ImageMap* pIMap = NULL; + TargetList* pTargetList = NULL; + SdIMapInfo* pIMapInfo = GetDoc()->GetIMapInfo( pObj ); + + // get graphic from shape + SdrGrafObj* pGrafObj = dynamic_cast< SdrGrafObj* >( pObj ); + if( pGrafObj ) + aGraphic = pGrafObj->GetGraphic(); + + if ( pIMapInfo ) + { + pIMap = (ImageMap*) &pIMapInfo->GetImageMap(); + pTargetList = new TargetList; + GetViewFrame()->GetTargetList( *pTargetList ); + } + + SvxIMapDlgChildWindow::UpdateIMapDlg( aGraphic, pIMap, pTargetList, pObj ); + + // TargetListe kann von uns wieder geloescht werden + if ( pTargetList ) + { + String* pEntry = pTargetList->First(); + while( pEntry ) + { + delete pEntry; + pEntry = pTargetList->Next(); + } + + delete pTargetList; + } + } +} + +// ----------------------------------------------------------------------------- + +IMPL_LINK( DrawViewShell, NameObjectHdl, AbstractSvxNameDialog*, pDialog ) +{ + String aName; + + if( pDialog ) + pDialog->GetName( aName ); + + return( ( !aName.Len() || ( GetDoc() && !GetDoc()->GetObj( aName ) ) ) ? 1 : 0 ); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviewsd.cxx b/sd/source/ui/view/drviewsd.cxx new file mode 100644 index 000000000000..7e0dff5eeede --- /dev/null +++ b/sd/source/ui/view/drviewsd.cxx @@ -0,0 +1,259 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" + +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <svl/aeitem.hxx> +#include <svl/stritem.hxx> +#include <sfx2/docfile.hxx> +#include <svl/intitem.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/request.hxx> + +#include <sfx2/viewfrm.hxx> + + +#include "app.hrc" + +#include "sdpage.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "slideshow.hxx" +#include "pgjump.hxx" +#include "NavigatorChildWindow.hxx" +#ifndef SD_NAVIGATION_HXX +#include "navigatr.hxx" +#endif +#include "drawview.hxx" +#include "slideshow.hxx" + +namespace sd { + +/************************************************************************* +|* +|* SfxRequests fuer Navigator bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecNavigatorWin( SfxRequest& rReq ) +{ + CheckLineTo (rReq); + + USHORT nSId = rReq.GetSlot(); + + switch( nSId ) + { + case SID_NAVIGATOR_INIT: + { + USHORT nId = SID_NAVIGATOR; + SfxChildWindow* pWindow = GetViewFrame()->GetChildWindow( nId ); + if( pWindow ) + { + SdNavigatorWin* pNavWin = (SdNavigatorWin*)( pWindow->GetContextWindow( SD_MOD() ) ); + if( pNavWin ) + pNavWin->InitTreeLB( GetDoc() ); + } + } + break; + + case SID_NAVIGATOR_PEN: + case SID_NAVIGATOR_PAGE: + case SID_NAVIGATOR_OBJECT: + { + rtl::Reference< SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if (xSlideshow.is() && xSlideshow->isRunning() ) + { + xSlideshow->receiveRequest( rReq ); + } + else if (nSId == SID_NAVIGATOR_PAGE) + { + if ( mpDrawView->IsTextEdit() ) + mpDrawView->SdrEndTextEdit(); + + const SfxItemSet* pArgs = rReq.GetArgs(); + PageJump eJump = (PageJump)((SfxAllEnumItem&) pArgs-> + Get(SID_NAVIGATOR_PAGE)).GetValue(); + + switch (eJump) + { + case PAGE_FIRST: + { + // Sprung zu erster Seite + SwitchPage(0); + } + break; + + case PAGE_LAST: + { + // Sprung zu letzter Seite + SwitchPage(GetDoc()->GetSdPageCount(mpActualPage->GetPageKind()) - 1); + } + break; + + case PAGE_NEXT: + { + // Sprung zu naechster Seite + USHORT nSdPage = (mpActualPage->GetPageNum() - 1) / 2; + + if (nSdPage < GetDoc()->GetSdPageCount(mpActualPage->GetPageKind()) - 1) + { + SwitchPage(nSdPage + 1); + } + } + break; + + case PAGE_PREVIOUS: + { + // Sprung zu vorheriger Seite + USHORT nSdPage = (mpActualPage->GetPageNum() - 1) / 2; + + if (nSdPage > 0) + { + SwitchPage(nSdPage - 1); + } + } + break; + + case PAGE_NONE: + break; + } + } + else if (nSId == SID_NAVIGATOR_OBJECT) + { + String aBookmarkStr; + aBookmarkStr += sal_Unicode( '#' ); + const SfxItemSet* pArgs = rReq.GetArgs(); + String aTarget = ((SfxStringItem&) pArgs-> + Get(SID_NAVIGATOR_OBJECT)).GetValue(); + aBookmarkStr += aTarget; + SfxStringItem aStrItem(SID_FILE_NAME, aBookmarkStr); + SfxStringItem aReferer(SID_REFERER, GetDocSh()->GetMedium()->GetName()); + SfxViewFrame* pFrame = GetViewFrame(); + SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame); + SfxBoolItem aBrowseItem(SID_BROWSE, TRUE); + pFrame->GetDispatcher()-> + Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, + &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L); + } + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_NAVIGATOR_STATE ); + rBindings.Invalidate( SID_NAVIGATOR_PAGENAME ); + } + break; + + default: + break; + } +} + +/************************************************************************* +|* +|* Statuswerte fuer Navigator zurueckgeben +|* +\************************************************************************/ + +void DrawViewShell::GetNavigatorWinState( SfxItemSet& rSet ) +{ + UINT32 nState = NAVSTATE_NONE; + USHORT nCurrentPage = 0; + USHORT nFirstPage = 0; + USHORT nLastPage; + BOOL bEndless = FALSE; + String aPageName; + + rtl::Reference< SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if( xSlideshow.is() && xSlideshow->isRunning() ) + { + // pen activated? + nState |= xSlideshow->isDrawingPossible() ? NAVBTN_PEN_CHECKED : NAVBTN_PEN_UNCHECKED; + + nCurrentPage = (USHORT)xSlideshow->getCurrentPageNumber(); + nFirstPage = (USHORT)xSlideshow->getFirstPageNumber(); + nLastPage = (USHORT)xSlideshow->getLastPageNumber(); + bEndless = xSlideshow->isEndless(); + + // Get the page for the current page number. + SdPage* pPage = 0; + if( nCurrentPage < GetDoc()->GetSdPageCount( PK_STANDARD ) ) + pPage = GetDoc()->GetSdPage (nCurrentPage, PK_STANDARD); + + if(pPage) + aPageName = pPage->GetName(); + } + else + { + nState |= NAVBTN_PEN_DISABLED | NAVTLB_UPDATE; + + if (mpActualPage != NULL) + { + nCurrentPage = ( mpActualPage->GetPageNum() - 1 ) / 2; + aPageName = mpActualPage->GetName(); + } + nLastPage = GetDoc()->GetSdPageCount( mePageKind ) - 1; + } + + // erste Seite / vorherige Seite + if( nCurrentPage == nFirstPage ) + { + nState |= NAVBTN_FIRST_DISABLED; + if( !bEndless ) + nState |= NAVBTN_PREV_DISABLED; + else + nState |= NAVBTN_PREV_ENABLED; + } + else + { + nState |= NAVBTN_FIRST_ENABLED | NAVBTN_PREV_ENABLED; + } + + // letzte Seite / naechste Seite + if( nCurrentPage == nLastPage ) + { + nState |= NAVBTN_LAST_DISABLED; + if( !bEndless ) + nState |= NAVBTN_NEXT_DISABLED; + else + nState |= NAVBTN_NEXT_ENABLED; + } + else + { + nState |= NAVBTN_LAST_ENABLED | NAVBTN_NEXT_ENABLED; + } + + rSet.Put( SfxUInt32Item( SID_NAVIGATOR_STATE, nState ) ); + rSet.Put( SfxStringItem( SID_NAVIGATOR_PAGENAME, aPageName ) ); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviewse.cxx b/sd/source/ui/view/drviewse.cxx new file mode 100755 index 000000000000..6f6f49fdc93c --- /dev/null +++ b/sd/source/ui/view/drviewse.cxx @@ -0,0 +1,1684 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include <com/sun/star/presentation/XPresentation2.hpp> +#include <com/sun/star/form/FormButtonType.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/i18n/TransliterationModules.hpp> +#include <com/sun/star/i18n/TransliterationModulesExtra.hpp> + +#include <comphelper/processfactory.hxx> + +#include "undo/undomanager.hxx" +#include <vcl/waitobj.hxx> +#include <svl/aeitem.hxx> +#include <editeng/editstat.hxx> +#include <vcl/msgbox.hxx> +#include <svl/urlbmk.hxx> +#include <svx/svdpagv.hxx> +#include <svx/fmshell.hxx> +#include <vcl/scrbar.hxx> +#include <svx/svdopath.hxx> +#include <svx/svdundo.hxx> +#include <svx/svdorect.hxx> +#include <svx/svdograf.hxx> +#include <svl/eitem.hxx> +#include <editeng/eeitem.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/request.hxx> +#include <svx/svxids.hrc> +#include <editeng/flditem.hxx> +#include <svx/ruler.hxx> +#include <svx/obj3d.hxx> +#include <svx/fmglob.hxx> +#include <svx/svdouno.hxx> +#include <svx/dataaccessdescriptor.hxx> +#include <tools/urlobj.hxx> +#include <svl/slstitm.hxx> +#include <sfx2/ipclient.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <avmedia/mediawindow.hxx> +#include <svl/urihelper.hxx> +#include <sfx2/docfile.hxx> + +#include "DrawViewShell.hxx" +#include "slideshow.hxx" +#include "ViewShellImplementation.hxx" +#include "ViewShellHint.hxx" +#include "framework/FrameworkHelper.hxx" +#include "app.hrc" +#include "glob.hrc" +#include "strings.hrc" +#include "res_bmp.hrc" +#include "drawdoc.hxx" +#include "fusel.hxx" +#include "futext.hxx" +#include "fuconrec.hxx" +#include "fuconcs.hxx" +#include "fuconuno.hxx" +#include "fuconbez.hxx" +#include "fuediglu.hxx" +#include "fuconarc.hxx" +#include "fucon3d.hxx" +#include "sdresid.hxx" +#include "slideshow.hxx" +#include "Outliner.hxx" +#include "PresentationViewShell.hxx" +#include "sdpage.hxx" +#include "FrameView.hxx" +#include "zoomlist.hxx" +#include "drawview.hxx" +#include "DrawDocShell.hxx" +#include "sdattr.hxx" +#include "ViewShellBase.hxx" +#include "ToolBarManager.hxx" +#include "anminfo.hxx" +#include "optsitem.hxx" +#include "Window.hxx" +#include "fuformatpaintbrush.hxx" + +using ::rtl::OUString; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::presentation; + +namespace sd { + +#ifdef _MSC_VER +#pragma optimize ( "", off ) +#endif + +/************************************************************************* +|* +|* Permanente Funktionen +|* +\************************************************************************/ + +void ImpAddPrintableCharactersToTextEdit(SfxRequest& rReq, ::sd::View* pView) +{ + // #98198# evtl. feed characters to activated textedit + const SfxItemSet* pSet = rReq.GetArgs(); + + if(pSet) + { + String aInputString; + + if(SFX_ITEM_SET == pSet->GetItemState(SID_ATTR_CHAR)) + aInputString = ((SfxStringItem&)pSet->Get(SID_ATTR_CHAR)).GetValue(); + + if(aInputString.Len()) + { + OutlinerView* pOLV = pView->GetTextEditOutlinerView(); + + if(pOLV) + { + for(sal_uInt16 a(0); a < aInputString.Len(); a++) + { + sal_Char aChar = (sal_Char)aInputString.GetChar(a); + KeyCode aKeyCode; + KeyEvent aKeyEvent(aChar, aKeyCode); + + // add actual character + pOLV->PostKeyEvent(aKeyEvent); + } + } + } + } +} + +void DrawViewShell::FuPermanent(SfxRequest& rReq) +{ + // Waehrend einer Native-Diashow wird nichts ausgefuehrt! + + if (SlideShow::IsRunning(GetViewShellBase())) + return; + + USHORT nSId = rReq.GetSlot(); + + if( HasCurrentFunction() && + ( nSId == SID_TEXTEDIT || nSId == SID_ATTR_CHAR || nSId == SID_TEXT_FITTOSIZE || + nSId == SID_ATTR_CHAR_VERTICAL || nSId == SID_TEXT_FITTOSIZE_VERTICAL ) ) + { + FunctionReference xFunc( GetCurrentFunction() ); + + FuText* pFuText = dynamic_cast< FuText* >( xFunc.get() ); + + if( pFuText ) + { + pFuText->SetPermanent(TRUE); + xFunc->ReceiveRequest( rReq ); + + MapSlot( nSId ); + + Invalidate(); + + Invalidate(); + + // #98198# evtl. feed characters to activated textedit + if(SID_ATTR_CHAR == nSId && GetView() && GetView()->IsTextEdit()) + ImpAddPrintableCharactersToTextEdit(rReq, GetView()); + + rReq.Done(); + return; + } + } + + CheckLineTo (rReq); + USHORT nOldSId = 0; + BOOL bPermanent = FALSE; + + if( !mpDrawView ) + return; + + if(HasCurrentFunction()) + { + if( (nSId == SID_FORMATPAINTBRUSH) && (GetCurrentFunction()->GetSlotID() == SID_TEXTEDIT) ) + { + // save text edit mode for format paintbrush! + SetOldFunction( GetCurrentFunction() ); + } + else + { + if(GetOldFunction() == GetCurrentFunction()) + { + SetOldFunction(0); + } + } + + if ( nSId != SID_TEXTEDIT && nSId != SID_ATTR_CHAR && nSId != SID_TEXT_FITTOSIZE && + nSId != SID_ATTR_CHAR_VERTICAL && nSId != SID_TEXT_FITTOSIZE_VERTICAL && + nSId != SID_FORMATPAINTBRUSH && + mpDrawView->IsTextEdit() ) + { + mpDrawView->SdrEndTextEdit(); + } + + if( HasCurrentFunction() ) + { + nOldSId = GetCurrentFunction()->GetSlotID(); + + if (nOldSId == nSId || + ((nOldSId == SID_TEXTEDIT || nOldSId == SID_ATTR_CHAR || nOldSId == SID_TEXT_FITTOSIZE || + nOldSId == SID_ATTR_CHAR_VERTICAL || nOldSId == SID_TEXT_FITTOSIZE_VERTICAL) && + (nSId == SID_TEXTEDIT || nSId == SID_ATTR_CHAR || nSId == SID_TEXT_FITTOSIZE || + nSId == SID_ATTR_CHAR_VERTICAL || nSId == SID_TEXT_FITTOSIZE_VERTICAL ))) + { + bPermanent = TRUE; + } + + GetCurrentFunction()->Deactivate(); + } + + SetCurrentFunction(0); + + SfxBindings& rBind = GetViewFrame()->GetBindings(); + rBind.Invalidate(nOldSId); + rBind.Update(nOldSId); + } + + // Slot wird gemapped (ToolboxImages/-Slots) + MapSlot( nSId ); + + switch ( nSId ) + { + case SID_TEXTEDIT: // BASIC ??? + case SID_ATTR_CHAR: + case SID_ATTR_CHAR_VERTICAL: + case SID_TEXT_FITTOSIZE: + case SID_TEXT_FITTOSIZE_VERTICAL: + { + SetCurrentFunction( FuText::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) ); + GetCurrentFunction()->DoExecute(rReq); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_ATTR_CHAR ); + rBindings.Invalidate( SID_ATTR_CHAR_VERTICAL ); + rBindings.Invalidate( SID_TEXT_FITTOSIZE ); + rBindings.Invalidate( SID_TEXT_FITTOSIZE_VERTICAL ); + + // #98198# evtl. feed characters to activated textedit + if(SID_ATTR_CHAR == nSId && GetView() && GetView()->IsTextEdit()) + ImpAddPrintableCharactersToTextEdit(rReq, GetView()); + + rReq.Done(); + } + break; + + case SID_FM_CREATE_CONTROL: + { + SetCurrentFunction( FuConstructUnoControl::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq, bPermanent ) ); + rReq.Done(); + } + break; + + // #98721# + case SID_FM_CREATE_FIELDCONTROL: + { + SFX_REQUEST_ARG( rReq, pDescriptorItem, SfxUnoAnyItem, SID_FM_DATACCESS_DESCRIPTOR, sal_False ); + DBG_ASSERT( pDescriptorItem, "DrawViewShell::FuPermanent(SID_FM_CREATE_FIELDCONTROL): invalid request args!" ); + + if(pDescriptorItem) + { + // get the form view + FmFormView* pFormView = PTR_CAST(FmFormView, mpDrawView); + SdrPageView* pPageView = pFormView ? pFormView->GetSdrPageView() : NULL; + + if(pPageView) + { + ::svx::ODataAccessDescriptor aDescriptor(pDescriptorItem->GetValue()); + SdrObject* pNewDBField = pFormView->CreateFieldControl(aDescriptor); + + if(pNewDBField) + { + Rectangle aVisArea = GetActiveWindow()->PixelToLogic(Rectangle(Point(0,0), GetActiveWindow()->GetOutputSizePixel())); + Point aObjPos(aVisArea.Center()); + Size aObjSize(pNewDBField->GetLogicRect().GetSize()); + aObjPos.X() -= aObjSize.Width() / 2; + aObjPos.Y() -= aObjSize.Height() / 2; + Rectangle aNewObjectRectangle(aObjPos, aObjSize); + + pNewDBField->SetLogicRect(aNewObjectRectangle); + + GetView()->InsertObjectAtView(pNewDBField, *pPageView); + } + } + } + rReq.Done(); + } + break; + + case SID_OBJECT_SELECT: + case SID_OBJECT_ROTATE: + case SID_OBJECT_MIRROR: + case SID_OBJECT_CROP: + case SID_OBJECT_TRANSPARENCE: + case SID_OBJECT_GRADIENT: + case SID_OBJECT_SHEAR: + case SID_OBJECT_CROOK_ROTATE: + case SID_OBJECT_CROOK_SLANT: + case SID_OBJECT_CROOK_STRETCH: + case SID_CONVERT_TO_3D_LATHE: + { + short nSlotId = rReq.GetSlot(); + + if (nSlotId == SID_OBJECT_CROOK_ROTATE || + nSlotId == SID_OBJECT_CROOK_SLANT || + nSlotId == SID_OBJECT_CROOK_STRETCH) + { + if ( mpDrawView->GetMarkedObjectList().GetMarkCount() > 0 && + !mpDrawView->IsCrookAllowed( mpDrawView->IsCrookNoContortion() ) ) + { + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else if ( QueryBox(GetActiveWindow(), WB_YES_NO, + String(SdResId(STR_ASK_FOR_CONVERT_TO_BEZIER) ) + ).Execute() == RET_YES ) + { + // Implizite Wandlung in Bezier + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->ConvertMarkedToPathObj(FALSE); + } + } + } + else if (nSlotId == SID_OBJECT_SHEAR) + { + ULONG i = 0; + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + ULONG nMarkCnt = rMarkList.GetMarkCount(); + BOOL b3DObjMarked = FALSE; + + while (i < nMarkCnt && !b3DObjMarked) + { + if (rMarkList.GetMark(i)->GetMarkedSdrObj()->ISA(E3dObject)) + { + b3DObjMarked = TRUE; + } + else + { + i++; + } + } + + if ( nMarkCnt > 0 && !b3DObjMarked && + (!mpDrawView->IsShearAllowed() || !mpDrawView->IsDistortAllowed()) ) + { + if ( mpDrawView->IsPresObjSelected() ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else if ( QueryBox(GetActiveWindow(), WB_YES_NO, + String(SdResId(STR_ASK_FOR_CONVERT_TO_BEZIER) ) + ).Execute() == RET_YES ) + { + // Implizite Wandlung in Bezier + WaitObject aWait( (Window*)GetActiveWindow() ); + mpDrawView->ConvertMarkedToPathObj(FALSE); + } + } + } + + SetCurrentFunction( FuSelection::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq) ); + rReq.Done(); + Invalidate( SID_OBJECT_SELECT ); + } + break; + + case SID_DRAW_LINE: + case SID_DRAW_XLINE: + case SID_DRAW_MEASURELINE: + case SID_LINE_ARROW_START: + case SID_LINE_ARROW_END: + case SID_LINE_ARROWS: + case SID_LINE_ARROW_CIRCLE: + case SID_LINE_CIRCLE_ARROW: + case SID_LINE_ARROW_SQUARE: + case SID_LINE_SQUARE_ARROW: + + case SID_DRAW_RECT: + case SID_DRAW_RECT_NOFILL: + case SID_DRAW_RECT_ROUND: + case SID_DRAW_RECT_ROUND_NOFILL: + case SID_DRAW_SQUARE: + case SID_DRAW_SQUARE_NOFILL: + case SID_DRAW_SQUARE_ROUND: + case SID_DRAW_SQUARE_ROUND_NOFILL: + case SID_DRAW_ELLIPSE: + case SID_DRAW_ELLIPSE_NOFILL: + case SID_DRAW_CIRCLE: + case SID_DRAW_CIRCLE_NOFILL: + case SID_DRAW_CAPTION: + case SID_DRAW_CAPTION_VERTICAL: + case SID_TOOL_CONNECTOR: + case SID_CONNECTOR_ARROW_START: + case SID_CONNECTOR_ARROW_END: + case SID_CONNECTOR_ARROWS: + case SID_CONNECTOR_CIRCLE_START: + case SID_CONNECTOR_CIRCLE_END: + case SID_CONNECTOR_CIRCLES: + case SID_CONNECTOR_LINE: + case SID_CONNECTOR_LINE_ARROW_START: + case SID_CONNECTOR_LINE_ARROW_END: + case SID_CONNECTOR_LINE_ARROWS: + case SID_CONNECTOR_LINE_CIRCLE_START: + case SID_CONNECTOR_LINE_CIRCLE_END: + case SID_CONNECTOR_LINE_CIRCLES: + case SID_CONNECTOR_CURVE: + case SID_CONNECTOR_CURVE_ARROW_START: + case SID_CONNECTOR_CURVE_ARROW_END: + case SID_CONNECTOR_CURVE_ARROWS: + case SID_CONNECTOR_CURVE_CIRCLE_START: + case SID_CONNECTOR_CURVE_CIRCLE_END: + case SID_CONNECTOR_CURVE_CIRCLES: + case SID_CONNECTOR_LINES: + case SID_CONNECTOR_LINES_ARROW_START: + case SID_CONNECTOR_LINES_ARROW_END: + case SID_CONNECTOR_LINES_ARROWS: + case SID_CONNECTOR_LINES_CIRCLE_START: + case SID_CONNECTOR_LINES_CIRCLE_END: + case SID_CONNECTOR_LINES_CIRCLES: + { + SetCurrentFunction( FuConstructRectangle::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq, bPermanent ) ); + rReq.Done(); + } + break; + case SID_DRAW_POLYGON: + case SID_DRAW_POLYGON_NOFILL: + case SID_DRAW_XPOLYGON: + case SID_DRAW_XPOLYGON_NOFILL: + case SID_DRAW_FREELINE: + case SID_DRAW_FREELINE_NOFILL: + case SID_DRAW_BEZIER_FILL: // BASIC + case SID_DRAW_BEZIER_NOFILL: // BASIC + { + SetCurrentFunction( FuConstructBezierPolygon::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq, bPermanent) ); + rReq.Done(); + } + break; + + case SID_GLUE_EDITMODE: + { + if (nOldSId != SID_GLUE_EDITMODE) + { + SetCurrentFunction( FuEditGluePoints::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq, bPermanent ) ); + } + else + { + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + } + + rReq.Done(); + } + break; + + case SID_DRAW_ARC: + case SID_DRAW_CIRCLEARC: + case SID_DRAW_PIE: + case SID_DRAW_PIE_NOFILL: + case SID_DRAW_CIRCLEPIE: + case SID_DRAW_CIRCLEPIE_NOFILL: + case SID_DRAW_ELLIPSECUT: + case SID_DRAW_ELLIPSECUT_NOFILL: + case SID_DRAW_CIRCLECUT: + case SID_DRAW_CIRCLECUT_NOFILL: + { + SetCurrentFunction( FuConstructArc::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq, bPermanent) ); + rReq.Done(); + } + break; + + case SID_3D_CUBE: + case SID_3D_SHELL: + case SID_3D_SPHERE: + case SID_3D_TORUS: + case SID_3D_HALF_SPHERE: + case SID_3D_CYLINDER: + case SID_3D_CONE: + case SID_3D_PYRAMID: + { + SetCurrentFunction( FuConstruct3dObject::Create(this, GetActiveWindow(), mpDrawView, GetDoc(), rReq, bPermanent ) ); + rReq.Done(); + } + break; + + case SID_DRAWTBX_CS_BASIC : + case SID_DRAWTBX_CS_SYMBOL : + case SID_DRAWTBX_CS_ARROW : + case SID_DRAWTBX_CS_FLOWCHART : + case SID_DRAWTBX_CS_CALLOUT : + case SID_DRAWTBX_CS_STAR : + case SID_DRAW_CS_ID : + { + SetCurrentFunction( FuConstructCustomShape::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq, bPermanent ) ); + rReq.Done(); + + if ( nSId != SID_DRAW_CS_ID ) + { + SfxBindings& rBind = GetViewFrame()->GetBindings(); + rBind.Invalidate( nSId ); + rBind.Update( nSId ); + } + } + break; + + case SID_FORMATPAINTBRUSH: + { + SetCurrentFunction( FuFormatPaintBrush::Create( this, GetActiveWindow(), mpDrawView, GetDoc(), rReq ) ); + rReq.Done(); + SfxBindings& rBind = GetViewFrame()->GetBindings(); + rBind.Invalidate( nSId ); + rBind.Update( nSId ); + break; + } + + default: + break; + } + + if(HasOldFunction()) + { + USHORT nSlotId = GetOldFunction()->GetSlotID(); + + GetOldFunction()->Deactivate(); + SetOldFunction(0); + + SfxBindings& rBind = GetViewFrame()->GetBindings(); + rBind.Invalidate( nSlotId ); + rBind.Update( nSlotId ); + } + + if(HasCurrentFunction()) + { + GetCurrentFunction()->Activate(); + SetOldFunction( GetCurrentFunction() ); + + SetHelpId( GetCurrentFunction()->GetSlotID() ); + } + + // Shell wird invalidiert, schneller als einzeln (laut MI) + // Jetzt explizit der letzte Slot incl. Update() + Invalidate(); + + // #97016# III CTRL-SID_OBJECT_SELECT -> select first draw object if none is selected yet + if(SID_OBJECT_SELECT == nSId && HasCurrentFunction() && (rReq.GetModifier() & KEY_MOD1)) + { + if(!GetView()->AreObjectsMarked()) + { + // select first object + GetView()->UnmarkAllObj(); + GetView()->MarkNextObj(TRUE); + + // ...and make it visible + if(GetView()->AreObjectsMarked()) + GetView()->MakeVisible(GetView()->GetAllMarkedRect(), *GetActiveWindow()); + } + } + + // #97016# with qualifier construct directly + if(HasCurrentFunction() && (rReq.GetModifier() & KEY_MOD1)) + { + // get SdOptions + SdOptions* pOptions = SD_MOD()->GetSdOptions(GetDoc()->GetDocumentType()); + sal_uInt32 nDefaultObjectSizeWidth(pOptions->GetDefaultObjectSizeWidth()); + sal_uInt32 nDefaultObjectSizeHeight(pOptions->GetDefaultObjectSizeHeight()); + + // calc position and size + Rectangle aVisArea = GetActiveWindow()->PixelToLogic(Rectangle(Point(0,0), GetActiveWindow()->GetOutputSizePixel())); + Point aPagePos = aVisArea.Center(); + aPagePos.X() -= nDefaultObjectSizeWidth / 2; + aPagePos.Y() -= nDefaultObjectSizeHeight / 2; + Rectangle aNewObjectRectangle(aPagePos, Size(nDefaultObjectSizeWidth, nDefaultObjectSizeHeight)); + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + + if(pPageView) + { + // create the default object + SdrObject* pObj = GetCurrentFunction()->CreateDefaultObject(nSId, aNewObjectRectangle); + + if(pObj) + { + // insert into page + GetView()->InsertObjectAtView(pObj, *pPageView); + + // Now that pFuActual has done what it was created for we + // can switch on the edit mode for callout objects. + switch (nSId) + { + case SID_DRAW_CAPTION: + case SID_DRAW_CAPTION_VERTICAL: + { + // Make FuText the current function. + SfxUInt16Item aItem (SID_TEXTEDIT, 1); + GetViewFrame()->GetDispatcher()-> + Execute(SID_TEXTEDIT, SFX_CALLMODE_SYNCHRON | + SFX_CALLMODE_RECORD, &aItem, 0L); + // Put text object into edit mode. + GetView()->SdrBeginTextEdit(static_cast<SdrTextObj*>(pObj), pPageView); + break; + } + } + } + } + } +} + +////////////////////////////////////////////////////////////////////////////// +// service routine for Undo/Redo implementation +extern SfxUndoManager* ImpGetUndoManagerFromViewShell(DrawViewShell& rDViewShell); + +/************************************************************************* +|* +|* SfxRequests fuer Support-Funktionen +|* +\************************************************************************/ + +void DrawViewShell::FuSupport(SfxRequest& rReq) +{ + if( rReq.GetSlot() == SID_STYLE_FAMILY && rReq.GetArgs()) + GetDocSh()->SetStyleFamily(((SfxUInt16Item&)rReq.GetArgs()->Get( SID_STYLE_FAMILY )).GetValue()); + + // Waehrend einer Native-Diashow wird nichts ausgefuehrt! + if(SlideShow::IsRunning(GetViewShellBase()) && + (rReq.GetSlot() != SID_PRESENTATION_END && + rReq.GetSlot() != SID_SIZE_PAGE)) + return; + + CheckLineTo (rReq); + + if( !mpDrawView ) + return; + + USHORT nSId = rReq.GetSlot(); + + // Slot wird evtl. gemapped (ToolboxImages/-Slots) + MapSlot( nSId ); + + switch ( nSId ) + { + case SID_CLEAR_UNDO_STACK: + { + GetDocSh()->ClearUndoBuffer(); + rReq.Ignore (); + } + break; + + // Slots der ToolboxController gemapped ausfuehren + case SID_OBJECT_CHOOSE_MODE: + case SID_POSITION: + case SID_OBJECT_ALIGN: + case SID_ZOOM_TOOLBOX: + case SID_DRAWTBX_TEXT: + case SID_DRAWTBX_RECTANGLES: + case SID_DRAWTBX_ELLIPSES: + case SID_DRAWTBX_LINES: + case SID_DRAWTBX_ARROWS: + case SID_DRAWTBX_3D_OBJECTS: + case SID_DRAWTBX_CONNECTORS: + case SID_DRAWTBX_INSERT: + { + USHORT nMappedSlot = GetMappedSlot( nSId ); + if( nMappedSlot > 0 ) + { + SfxRequest aReq( nMappedSlot, 0, GetDoc()->GetItemPool() ); + ExecuteSlot( aReq ); + } + } + break; + + case SID_PRESENTATION: + case SID_REHEARSE_TIMINGS: + { + Reference< XPresentation2 > xPresentation( GetDoc()->getPresentation() ); + if( xPresentation.is() ) + { + if( ( SID_REHEARSE_TIMINGS != rReq.GetSlot() ) ) + xPresentation->start(); + else + xPresentation->rehearseTimings(); + } + rReq.Ignore (); + } + break; + + case SID_PRESENTATION_END: + { + StopSlideShow(true); + + rReq.Ignore (); + } + break; + + case SID_BEZIER_EDIT: + { + mpDrawView->SetFrameDragSingles(!mpDrawView->IsFrameDragSingles()); + + /****************************************************************** + * ObjectBar einschalten + ******************************************************************/ + if( dynamic_cast< FuSelection* >( GetCurrentFunction().get() ) || dynamic_cast< FuConstructBezierPolygon* >( GetCurrentFunction().get() ) ) + { + // Tell the tool bar manager about the context change. + GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this,*mpDrawView); + } + + Invalidate(SID_BEZIER_EDIT); + rReq.Ignore(); + } + break; + + case SID_OBJECT_CLOSE: + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + if ( rMarkList.GetMark(0) && !mpDrawView->IsAction() ) + { + SdrPathObj* pPathObj = (SdrPathObj*) rMarkList.GetMark(0)->GetMarkedSdrObj(); + const bool bUndo = mpDrawView->IsUndoEnabled(); + if( bUndo ) + mpDrawView->BegUndo(String(SdResId(STR_UNDO_BEZCLOSE))); + + mpDrawView->UnmarkAllPoints(); + + if( bUndo ) + mpDrawView->AddUndo(new SdrUndoGeoObj(*pPathObj)); + + pPathObj->ToggleClosed(); + + if( bUndo ) + mpDrawView->EndUndo(); + } + rReq.Done(); + } + break; + + case SID_CUT: + { + if ( mpDrawView->IsPresObjSelected(FALSE, TRUE, FALSE, TRUE) ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + if(HasCurrentFunction()) + { + GetCurrentFunction()->DoCut(); + } + else if(mpDrawView) + { + mpDrawView->DoCut(); + } + } + rReq.Ignore (); + } + break; + + case SID_COPY: + { + if ( mpDrawView->IsPresObjSelected(FALSE, TRUE, FALSE, TRUE) ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + if(HasCurrentFunction()) + { + GetCurrentFunction()->DoCopy(); + } + else if( mpDrawView ) + { + mpDrawView->DoCopy(); + } + } + rReq.Ignore (); + } + break; + + case SID_PASTE: + { + WaitObject aWait( (Window*)GetActiveWindow() ); + + if(HasCurrentFunction()) + { + GetCurrentFunction()->DoPaste(); + } + else if(mpDrawView) + { + mpDrawView->DoPaste(); + } + + rReq.Ignore (); + } + break; + + case SID_CLIPBOARD_FORMAT_ITEMS: + { + WaitObject aWait( (Window*)GetActiveWindow() ); + TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( GetActiveWindow() ) ); + const SfxItemSet* pReqArgs = rReq.GetArgs(); + UINT32 nFormat = 0; + + if( pReqArgs ) + { + SFX_REQUEST_ARG( rReq, pIsActive, SfxUInt32Item, SID_CLIPBOARD_FORMAT_ITEMS, FALSE ); + nFormat = pIsActive->GetValue(); + } + + + if( nFormat && aDataHelper.GetTransferable().is() ) + { + sal_Int8 nAction = DND_ACTION_COPY; + + if( !mpDrawView->InsertData( aDataHelper, + GetActiveWindow()->PixelToLogic( Rectangle( Point(), GetActiveWindow()->GetOutputSizePixel() ).Center() ), + nAction, FALSE, nFormat ) ) + { + INetBookmark aINetBookmark( aEmptyStr, aEmptyStr ); + + if( ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, aINetBookmark ) ) || + ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR, aINetBookmark ) ) || + ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR, aINetBookmark ) ) ) + { + InsertURLField( aINetBookmark.GetURL(), aINetBookmark.GetDescription(), aEmptyStr, NULL ); + } + } + } + } + break; + + case SID_DELETE: + { + if ( mpDrawView->IsTextEdit() ) + { + OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView(); + + if (pOLV) + { + KeyCode aKCode(KEY_DELETE); + KeyEvent aKEvt( 0, aKCode); + pOLV->PostKeyEvent(aKEvt); + } + } + else if ( mpDrawView->IsPresObjSelected(FALSE, TRUE, FALSE, TRUE) ) + { + ::sd::Window* pWindow = GetActiveWindow(); + InfoBox(pWindow, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + } + else + { + KeyCode aKCode(KEY_DELETE); + KeyEvent aKEvt( 0, aKCode); + + bool bConsumed = mpDrawView && mpDrawView->getSmartTags().KeyInput( aKEvt ); + + if( !bConsumed && HasCurrentFunction() ) + bConsumed = GetCurrentFunction()->KeyInput(aKEvt); + + if( !bConsumed && mpDrawView ) + mpDrawView->DeleteMarked(); + } + rReq.Ignore (); + } + break; + + case SID_NOTESMODE: + case SID_HANDOUTMODE: + // AutoLayouts have to be ready. + GetDoc()->StopWorkStartupDelay(); + // Fall through to following case statements. + + case SID_DRAWINGMODE: + case SID_DIAMODE: + case SID_OUTLINEMODE: + // Let the sub-shell manager handle the slot handling. + framework::FrameworkHelper::Instance(GetViewShellBase())->HandleModeChangeSlot( + nSId, + rReq); + rReq.Ignore (); + break; + + case SID_MASTERPAGE: // BASIC + case SID_SLIDE_MASTERPAGE: // BASIC + case SID_TITLE_MASTERPAGE: // BASIC + case SID_NOTES_MASTERPAGE: // BASIC + case SID_HANDOUT_MASTERPAGE: // BASIC + { + // AutoLayouts muessen fertig sein + GetDoc()->StopWorkStartupDelay(); + + const SfxItemSet* pReqArgs = rReq.GetArgs(); + + if ( pReqArgs ) + { + SFX_REQUEST_ARG (rReq, pIsActive, SfxBoolItem, SID_MASTERPAGE, FALSE); + mbIsLayerModeActive = pIsActive->GetValue (); + } + + Broadcast ( + ViewShellHint(ViewShellHint::HINT_CHANGE_EDIT_MODE_START)); + + if (nSId == SID_MASTERPAGE || + (nSId == SID_SLIDE_MASTERPAGE && mePageKind == PK_STANDARD) || + (nSId == SID_TITLE_MASTERPAGE && mePageKind == PK_STANDARD) || + (nSId == SID_NOTES_MASTERPAGE && mePageKind == PK_NOTES) || + (nSId == SID_HANDOUT_MASTERPAGE && mePageKind == PK_HANDOUT)) + { + if (nSId == SID_TITLE_MASTERPAGE || + nSId == SID_SLIDE_MASTERPAGE) + { + // Gibt es eine Seite mit dem AutoLayout "Titel"? + BOOL bFound = FALSE; + USHORT i = 0; + USHORT nCount = GetDoc()->GetSdPageCount(PK_STANDARD); + + while (i < nCount && !bFound) + { + SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD); + + if (nSId == SID_TITLE_MASTERPAGE && pPage->GetAutoLayout() == AUTOLAYOUT_TITLE) + { + bFound = TRUE; + SwitchPage((pPage->GetPageNum() - 1) / 2); + } + else if (nSId == SID_SLIDE_MASTERPAGE && pPage->GetAutoLayout() != AUTOLAYOUT_TITLE) + { + bFound = TRUE; + SwitchPage((pPage->GetPageNum() - 1) / 2); + } + + i++; + } + } + + // Default-Layer der MasterPage einschalten + mpDrawView->SetActiveLayer( String( SdResId(STR_LAYER_BCKGRNDOBJ) ) ); + + ChangeEditMode(EM_MASTERPAGE, mbIsLayerModeActive); + + if(HasCurrentFunction(SID_BEZIER_EDIT)) + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + } + else + { + // Switch to requested ViewShell. + ::OUString sRequestedView; + PageKind ePageKind; + switch (nSId) + { + case SID_SLIDE_MASTERPAGE: + case SID_TITLE_MASTERPAGE: + default: + sRequestedView = framework::FrameworkHelper::msImpressViewURL; + ePageKind = PK_STANDARD; + break; + + case SID_NOTES_MASTERPAGE: + sRequestedView = framework::FrameworkHelper::msNotesViewURL; + ePageKind = PK_NOTES; + break; + + case SID_HANDOUT_MASTERPAGE: + sRequestedView = framework::FrameworkHelper::msHandoutViewURL; + ePageKind = PK_HANDOUT; + break; + } + + mpFrameView->SetViewShEditMode(EM_MASTERPAGE, ePageKind); + mpFrameView->SetLayerMode(mbIsLayerModeActive); + framework::FrameworkHelper::Instance(GetViewShellBase())->RequestView( + sRequestedView, + framework::FrameworkHelper::msCenterPaneURL); + } + Broadcast ( + ViewShellHint(ViewShellHint::HINT_CHANGE_EDIT_MODE_END)); + + InvalidateWindows(); + Invalidate(); + + rReq.Done(); + } + break; + + + case SID_CLOSE_MASTER_VIEW: + { + Broadcast ( + ViewShellHint(ViewShellHint::HINT_CHANGE_EDIT_MODE_START)); + + // Switch page back to the first one. Not doing so leads to a + // crash. This seems to be some bug in the edit mode switching + // and page switching methods. + SwitchPage (0); + ChangeEditMode(EM_PAGE, IsLayerModeActive()); + Broadcast ( + ViewShellHint(ViewShellHint::HINT_CHANGE_EDIT_MODE_END)); + + if(HasCurrentFunction(SID_BEZIER_EDIT)) + { + GetViewFrame()->GetDispatcher()->Execute( + SID_OBJECT_SELECT, + SFX_CALLMODE_ASYNCHRON); + } + + + rReq.Done(); + } + break; + + + case SID_RULER: + { + const SfxItemSet* pReqArgs = rReq.GetArgs(); + + // #97516# Remember old ruler state + BOOL bOldHasRuler(HasRuler()); + + if ( pReqArgs ) + { + SFX_REQUEST_ARG (rReq, pIsActive, SfxBoolItem, SID_RULER, FALSE); + SetRuler (pIsActive->GetValue ()); + } + else SetRuler (!HasRuler()); + + // #97516# Did ruler state change? Tell that to SdOptions, too. + BOOL bHasRuler(HasRuler()); + + if(bOldHasRuler != bHasRuler) + { + SdOptions* pOptions = SD_MOD()->GetSdOptions(GetDoc()->GetDocumentType()); + + if(pOptions && pOptions->IsRulerVisible() != bHasRuler) + { + pOptions->SetRulerVisible(bHasRuler); + } + } + + Invalidate (SID_RULER); + Resize(); + rReq.Done (); + } + break; + + case SID_SIZE_PAGE: + case SID_SIZE_PAGE_WIDTH: // BASIC + { + mbZoomOnPage = ( rReq.GetSlot() == SID_SIZE_PAGE ); + + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + + if ( pPageView ) + { + Point aPagePos(0, 0); // = pPageView->GetOffset(); + Size aPageSize = pPageView->GetPage()->GetSize(); + + aPagePos.X() += aPageSize.Width() / 2; + aPageSize.Width() = (long) (aPageSize.Width() * 1.03); + + if( rReq.GetSlot() == SID_SIZE_PAGE ) + { + aPagePos.Y() += aPageSize.Height() / 2; + aPageSize.Height() = (long) (aPageSize.Height() * 1.03); + aPagePos.Y() -= aPageSize.Height() / 2; + } + else + { + Point aPt = GetActiveWindow()->PixelToLogic( Point( 0, GetActiveWindow()->GetSizePixel().Height() / 2 ) ); + aPagePos.Y() += aPt.Y(); + aPageSize.Height() = 2; + } + + aPagePos.X() -= aPageSize.Width() / 2; + + SetZoomRect( Rectangle( aPagePos, aPageSize ) ); + + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), + GetActiveWindow()->GetOutputSizePixel()) ); + mpZoomList->InsertZoomRect(aVisAreaWin); + } + Invalidate( SID_ZOOM_IN ); + Invalidate( SID_ZOOM_OUT ); + Invalidate( SID_ZOOM_PANNING ); + Invalidate( SID_ZOOM_TOOLBOX ); + rReq.Done (); + } + break; + + case SID_SIZE_REAL: // BASIC + { + mbZoomOnPage = FALSE; + SetZoom( 100 ); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), + GetActiveWindow()->GetOutputSizePixel()) ); + mpZoomList->InsertZoomRect(aVisAreaWin); + Invalidate( SID_ZOOM_IN ); + Invalidate( SID_ZOOM_OUT ); + Invalidate( SID_ZOOM_PANNING ); + Invalidate( SID_ZOOM_TOOLBOX ); + rReq.Done (); + } + break; + + case SID_ZOOM_IN: // BASIC + { + mbZoomOnPage = FALSE; + SetZoom( Max( (long) ( GetActiveWindow()->GetZoom() / 2 ), (long) GetActiveWindow()->GetMinZoom() ) ); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), + GetActiveWindow()->GetOutputSizePixel()) ); + mpZoomList->InsertZoomRect(aVisAreaWin); + Invalidate( SID_ZOOM_IN ); + Invalidate( SID_ZOOM_OUT ); + Invalidate( SID_ZOOM_PANNING ); + Invalidate( SID_ZOOM_TOOLBOX ); + rReq.Done (); + } + break; + + case SID_SIZE_VISAREA: + { + Rectangle aVisArea = mpFrameView->GetVisArea(); + Size aVisAreaSize = aVisArea.GetSize(); + + if (aVisAreaSize.Height()!=0 && aVisAreaSize.Width()!=0) + { + mbZoomOnPage = FALSE; + SetZoomRect(aVisArea); + Invalidate( SID_ZOOM_IN ); + Invalidate( SID_ZOOM_OUT ); + Invalidate( SID_ZOOM_PANNING ); + Invalidate( SID_ZOOM_TOOLBOX ); + } + rReq.Done (); + } + break; + + // Namensverwirrung: SID_SIZE_OPTIMAL -> Zoom auf selektierte Objekte + // --> Wird als Objektzoom im Programm angeboten + case SID_SIZE_OPTIMAL: // BASIC + { + mbZoomOnPage = FALSE; + if ( mpDrawView->AreObjectsMarked() ) + { + maMarkRect = mpDrawView->GetAllMarkedRect(); + long nW = (long) (maMarkRect.GetWidth() * 1.03); + long nH = (long) (maMarkRect.GetHeight() * 1.03); + Point aPos = maMarkRect.Center(); + aPos.X() -= nW / 2; + aPos.Y() -= nH / 2; + if ( nW && nH ) + { + SetZoomRect(Rectangle(aPos, Size(nW, nH))); + + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), + GetActiveWindow()->GetOutputSizePixel()) ); + mpZoomList->InsertZoomRect(aVisAreaWin); + } + } + Invalidate( SID_ZOOM_IN ); + Invalidate( SID_ZOOM_OUT ); + Invalidate( SID_ZOOM_PANNING ); + Invalidate( SID_ZOOM_TOOLBOX ); + rReq.Done (); + } + break; + + // Namensverwirrung: SID_SIZE_ALL -> Zoom auf alle Objekte + // --> Wird als Optimal im Programm angeboten + case SID_SIZE_ALL: // BASIC + { + mbZoomOnPage = FALSE; + SdrPageView* pPageView = mpDrawView->GetSdrPageView(); + + if( pPageView ) + { + Rectangle aBoundRect( pPageView->GetObjList()->GetAllObjBoundRect() ); + + long nW = (long) (aBoundRect.GetWidth() * 1.03); + long nH = (long) (aBoundRect.GetHeight() * 1.03); + Point aPos = aBoundRect.Center(); + aPos.X() -= nW / 2; + aPos.Y() -= nH / 2; + if ( nW && nH ) + { + SetZoomRect( Rectangle( aPos, Size( nW, nH ) ) ); + + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), + GetActiveWindow()->GetOutputSizePixel()) ); + mpZoomList->InsertZoomRect(aVisAreaWin); + } + + Invalidate( SID_ZOOM_IN ); + Invalidate( SID_ZOOM_OUT ); + Invalidate( SID_ZOOM_PANNING ); + Invalidate( SID_ZOOM_TOOLBOX ); + } + rReq.Done (); + } + break; + + case SID_ZOOM_PREV: + { + if (mpDrawView->IsTextEdit()) + { + mpDrawView->SdrEndTextEdit(); + } + + if (mpZoomList->IsPreviousPossible()) + { + // Vorheriges ZoomRect einstellen + SetZoomRect(mpZoomList->GetPreviousZoomRect()); + } + rReq.Done (); + Invalidate( SID_ZOOM_TOOLBOX ); + } + break; + + case SID_ZOOM_NEXT: + { + if (mpDrawView->IsTextEdit()) + { + mpDrawView->SdrEndTextEdit(); + } + + if (mpZoomList->IsNextPossible()) + { + // Naechstes ZoomRect einstellen + SetZoomRect(mpZoomList->GetNextZoomRect()); + } + rReq.Done (); + Invalidate( SID_ZOOM_TOOLBOX ); + } + break; + + case SID_GLUE_INSERT_POINT: + case SID_GLUE_PERCENT: + case SID_GLUE_ESCDIR: + case SID_GLUE_ESCDIR_LEFT: + case SID_GLUE_ESCDIR_RIGHT: + case SID_GLUE_ESCDIR_TOP: + case SID_GLUE_ESCDIR_BOTTOM: + case SID_GLUE_HORZALIGN_CENTER: + case SID_GLUE_HORZALIGN_LEFT: + case SID_GLUE_HORZALIGN_RIGHT: + case SID_GLUE_VERTALIGN_CENTER: + case SID_GLUE_VERTALIGN_TOP: + case SID_GLUE_VERTALIGN_BOTTOM: + { + FunctionReference xFunc( GetCurrentFunction() ); + FuEditGluePoints* pFunc = dynamic_cast< FuEditGluePoints* >( xFunc.get() ); + + if(pFunc) + pFunc->ReceiveRequest(rReq); + + rReq.Done(); + } + break; + +#ifdef DBG_UTIL + case SID_SHOW_ITEMBROWSER: + { + mpDrawView->ShowItemBrowser( !mpDrawView->IsItemBrowserVisible() ); + rReq.Done (); + } + break; +#endif + + case SID_AUTOSPELL_CHECK: + { + BOOL bOnlineSpell = !GetDoc()->GetOnlineSpell(); + GetDoc()->SetOnlineSpell(bOnlineSpell); + + ::Outliner* pOL = mpDrawView->GetTextEditOutliner(); + + if (pOL) + { + ULONG nCntrl = pOL->GetControlWord(); + + if (bOnlineSpell) + nCntrl |= EE_CNTRL_ONLINESPELLING; + else + nCntrl &= ~EE_CNTRL_ONLINESPELLING; + + pOL->SetControlWord(nCntrl); + } + + GetActiveWindow()->Invalidate(); + rReq.Done (); + } + break; + + case SID_CONVERT_TO_1BIT_THRESHOLD: + case SID_CONVERT_TO_1BIT_MATRIX: + case SID_CONVERT_TO_4BIT_GRAYS: + case SID_CONVERT_TO_4BIT_COLORS: + case SID_CONVERT_TO_8BIT_GRAYS: + case SID_CONVERT_TO_8BIT_COLORS: + case SID_CONVERT_TO_24BIT: + { + BmpConversion eBmpConvert = BMP_CONVERSION_NONE; + + switch( nSId ) + { + case SID_CONVERT_TO_1BIT_THRESHOLD: + eBmpConvert = BMP_CONVERSION_1BIT_THRESHOLD; + break; + + case SID_CONVERT_TO_1BIT_MATRIX: + eBmpConvert = BMP_CONVERSION_1BIT_MATRIX; + break; + + case SID_CONVERT_TO_4BIT_GRAYS: + eBmpConvert = BMP_CONVERSION_4BIT_GREYS; + break; + + case SID_CONVERT_TO_4BIT_COLORS: + eBmpConvert = BMP_CONVERSION_4BIT_COLORS; + break; + + case SID_CONVERT_TO_8BIT_GRAYS: + eBmpConvert = BMP_CONVERSION_8BIT_GREYS; + break; + + case SID_CONVERT_TO_8BIT_COLORS: + eBmpConvert = BMP_CONVERSION_8BIT_COLORS; + break; + + case SID_CONVERT_TO_24BIT: + eBmpConvert = BMP_CONVERSION_24BIT; + break; + } + + mpDrawView->BegUndo(String(SdResId(STR_UNDO_COLORRESOLUTION))); + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + + for (ULONG i=0; i<rMarkList.GetMarkCount(); i++) + { + SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + + if (pObj->GetObjInventor() == SdrInventor) + { + if (pObj->GetObjIdentifier() == OBJ_GRAF && !((SdrGrafObj*) pObj)->IsLinkedGraphic()) + { + const Graphic& rGraphic = ((SdrGrafObj*) pObj)->GetGraphic(); + + if( rGraphic.GetType() == GRAPHIC_BITMAP ) + { + SdrGrafObj* pNewObj = (SdrGrafObj*) pObj->Clone(); + + if( rGraphic.IsAnimated() ) + { + Animation aAnim( rGraphic.GetAnimation() ); + aAnim.Convert( eBmpConvert ); + pNewObj->SetGraphic( aAnim ); + } + else + { + BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); + aBmpEx.Convert( eBmpConvert ); + pNewObj->SetGraphic( aBmpEx ); + } + + mpDrawView->ReplaceObjectAtView( pObj, *mpDrawView->GetSdrPageView(), pNewObj ); + } + } + } + } + + mpDrawView->EndUndo(); + rReq.Done (); + } + break; + + case SID_TRANSLITERATE_SENTENCE_CASE: + case SID_TRANSLITERATE_TITLE_CASE: + case SID_TRANSLITERATE_TOGGLE_CASE: + case SID_TRANSLITERATE_UPPER: + case SID_TRANSLITERATE_LOWER: + case SID_TRANSLITERATE_HALFWIDTH: + case SID_TRANSLITERATE_FULLWIDTH: + case SID_TRANSLITERATE_HIRAGANA: + case SID_TRANSLITERATE_KATAGANA: + { + OutlinerView* pOLV = GetView()->GetTextEditOutlinerView(); + if( pOLV ) + { + using namespace ::com::sun::star::i18n; + sal_Int32 nType = 0; + + switch( nSId ) + { + case SID_TRANSLITERATE_SENTENCE_CASE: + nType = TransliterationModulesExtra::SENTENCE_CASE; + break; + case SID_TRANSLITERATE_TITLE_CASE: + nType = TransliterationModulesExtra::TITLE_CASE; + break; + case SID_TRANSLITERATE_TOGGLE_CASE: + nType = TransliterationModulesExtra::TOGGLE_CASE; + break; + case SID_TRANSLITERATE_UPPER: + nType = TransliterationModules_LOWERCASE_UPPERCASE; + break; + case SID_TRANSLITERATE_LOWER: + nType = TransliterationModules_UPPERCASE_LOWERCASE; + break; + case SID_TRANSLITERATE_HALFWIDTH: + nType = TransliterationModules_FULLWIDTH_HALFWIDTH; + break; + case SID_TRANSLITERATE_FULLWIDTH: + nType = TransliterationModules_HALFWIDTH_FULLWIDTH; + break; + case SID_TRANSLITERATE_HIRAGANA: + nType = TransliterationModules_KATAKANA_HIRAGANA; + break; + case SID_TRANSLITERATE_KATAGANA: + nType = TransliterationModules_HIRAGANA_KATAKANA; + break; + } + + pOLV->TransliterateText( nType ); + } + + rReq.Done(); + } + break; + + // #UndoRedo# + case SID_UNDO : + { + // #96090# moved implementation to BaseClass + ImpSidUndo(TRUE, rReq); + } + break; + case SID_REDO : + { + // #96090# moved implementation to BaseClass + ImpSidRedo(TRUE, rReq); + } + break; + + default: + break; + } +} + +/************************************************************************* +|* +|* URL-Feld einfuegen +|* +\************************************************************************/ + +void DrawViewShell::InsertURLField(const String& rURL, const String& rText, + const String& rTarget, const Point* pPos) +{ + OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView(); + + if (pOLV) + { + ESelection aSel( pOLV->GetSelection() ); + SvxFieldItem aURLItem( SvxURLField( rURL, rText, SVXURLFORMAT_REPR ), EE_FEATURE_FIELD ); + pOLV->InsertField( aURLItem ); + if ( aSel.nStartPos <= aSel.nEndPos ) + aSel.nEndPos = aSel.nStartPos + 1; + else + aSel.nStartPos = aSel.nEndPos + 1; + pOLV->SetSelection( aSel ); + } + else + { + Outliner* pOutl = GetDoc()->GetInternalOutliner(); + pOutl->Init( OUTLINERMODE_TEXTOBJECT ); + USHORT nOutlMode = pOutl->GetMode(); + + SvxURLField aURLField(rURL, rText, SVXURLFORMAT_REPR); + aURLField.SetTargetFrame(rTarget); + SvxFieldItem aURLItem(aURLField, EE_FEATURE_FIELD); + pOutl->QuickInsertField( aURLItem, ESelection() ); + OutlinerParaObject* pOutlParaObject = pOutl->CreateParaObject(); + + SdrRectObj* pRectObj = new SdrRectObj(OBJ_TEXT); + + pOutl->UpdateFields(); + pOutl->SetUpdateMode( TRUE ); + Size aSize(pOutl->CalcTextSize()); + pOutl->SetUpdateMode( FALSE ); + + Point aPos; + + if (pPos) + { + aPos = *pPos; + } + else + { + Rectangle aRect(aPos, GetActiveWindow()->GetOutputSizePixel() ); + aPos = aRect.Center(); + aPos = GetActiveWindow()->PixelToLogic(aPos); + aPos.X() -= aSize.Width() / 2; + aPos.Y() -= aSize.Height() / 2; + } + + Rectangle aLogicRect(aPos, aSize); + pRectObj->SetLogicRect(aLogicRect); + pRectObj->SetOutlinerParaObject( pOutlParaObject ); + mpDrawView->InsertObjectAtView(pRectObj, *mpDrawView->GetSdrPageView()); + pOutl->Init( nOutlMode ); + } +} + +/************************************************************************* +|* +|* URL-Button einfuegen +|* +\************************************************************************/ + +void DrawViewShell::InsertURLButton(const String& rURL, const String& rText, + const String& rTarget, const Point* pPos) +{ + BOOL bNewObj = TRUE; + + const OUString sTargetURL( ::URIHelper::SmartRel2Abs( INetURLObject( GetDocSh()->GetMedium()->GetBaseURL() ), rURL, URIHelper::GetMaybeFileHdl(), true, false, + INetURLObject::WAS_ENCODED, + INetURLObject::DECODE_UNAMBIGUOUS ) ); + if (mpDrawView->GetMarkedObjectList().GetMarkCount() > 0) + { + SdrObject* pMarkedObj = mpDrawView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(); + if( pMarkedObj ) try + { + // change first marked object + if( (FmFormInventor == pMarkedObj->GetObjInventor() && pMarkedObj->GetObjIdentifier() == OBJ_FM_BUTTON) ) + { + bNewObj = FALSE; + + SdrUnoObj* pUnoCtrl = static_cast< SdrUnoObj* >( pMarkedObj ); + + Reference< awt::XControlModel > xControlModel( pUnoCtrl->GetUnoControlModel(), UNO_QUERY_THROW ); + Reference< beans::XPropertySet > xPropSet( xControlModel, UNO_QUERY_THROW ); + + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Label" )), Any( OUString( rText ) ) ); + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TargetURL" )), Any( sTargetURL ) ); + + if( rTarget.Len() ) + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TargetFrame" )), Any( OUString( rTarget ) ) ); + + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "ButtonType" )), Any( form::FormButtonType_URL ) ); + if ( ::avmedia::MediaWindow::isMediaURL( rURL ) ) + { + // #105638# OJ + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "DispatchURLInternal" )), Any( sal_True ) ); + } + } + else + { + // add url as interaction for first selected shape + bNewObj = FALSE; + + SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pMarkedObj, true); + pInfo->meClickAction = presentation::ClickAction_DOCUMENT; + pInfo->SetBookmark( sTargetURL ); + } + } + catch( uno::Exception& ) + { + } + } + + if (bNewObj) try + { + SdrUnoObj* pUnoCtrl = static_cast< SdrUnoObj* >( SdrObjFactory::MakeNewObject(FmFormInventor, OBJ_FM_BUTTON, + mpDrawView->GetSdrPageView()->GetPage(), GetDoc()) ); + + Reference< awt::XControlModel > xControlModel( pUnoCtrl->GetUnoControlModel(), uno::UNO_QUERY_THROW ); + Reference< beans::XPropertySet > xPropSet( xControlModel, uno::UNO_QUERY_THROW ); + + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Label" )), Any( OUString( rText ) ) ); + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TargetURL" )), Any( sTargetURL ) ); + + if( rTarget.Len() ) + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "TargetFrame" )), Any( OUString( rTarget ) ) ); + + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "ButtonType" )), Any( form::FormButtonType_URL ) ); + // #105638# OJ + if ( ::avmedia::MediaWindow::isMediaURL( rURL ) ) + xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "DispatchURLInternal" )), Any( sal_True ) ); + + Point aPos; + + if (pPos) + { + aPos = *pPos; + } + else + { + aPos = Rectangle(aPos, GetActiveWindow()->GetOutputSizePixel()).Center(); + aPos = GetActiveWindow()->PixelToLogic(aPos); + } + + Size aSize(4000, 1000); + aPos.X() -= aSize.Width() / 2; + aPos.Y() -= aSize.Height() / 2; + pUnoCtrl->SetLogicRect(Rectangle(aPos, aSize)); + + ULONG nOptions = SDRINSERT_SETDEFLAYER; + + OSL_ASSERT (GetViewShell()!=NULL); + SfxInPlaceClient* pIpClient = GetViewShell()->GetIPClient(); + if (pIpClient!=NULL && pIpClient->IsObjectInPlaceActive()) + { + nOptions |= SDRINSERT_DONTMARK; + } + + mpDrawView->InsertObjectAtView(pUnoCtrl, *mpDrawView->GetSdrPageView(), nOptions); + } + catch( Exception& ) + { + } +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void DrawViewShell::ShowUIControls (bool bVisible) +{ + ViewShell::ShowUIControls (bVisible); + + //AF: The LayerDialogChildWindow is not used anymore (I hope). + // GetViewFrame()->SetChildWindow( + // LayerDialogChildWindow::GetChildWindowId(), + // IsLayerModeActive() && bVisible); + maTabControl.Show (bVisible); +} + +void DrawViewShell::StopSlideShow (bool /*bCloseFrame*/) +{ + Reference< XPresentation2 > xPresentation( GetDoc()->getPresentation() ); + if(xPresentation.is() && xPresentation->isRunning()) + { + if( mpDrawView->IsTextEdit() ) + mpDrawView->SdrEndTextEdit(); + + xPresentation->end(); + } +} + +#ifdef _MSC_VER +#pragma optimize ( "", on ) +#endif + +} // end of namespace sd diff --git a/sd/source/ui/view/drviewsf.cxx b/sd/source/ui/view/drviewsf.cxx new file mode 100755 index 000000000000..ac6b46f3018b --- /dev/null +++ b/sd/source/ui/view/drviewsf.cxx @@ -0,0 +1,576 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include <com/sun/star/form/FormButtonType.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> + +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#ifndef _GLOBL3D_HXX +#include <svx/globl3d.hxx> +#endif +#include <svx/hlnkitem.hxx> +#include <editeng/eeitem.hxx> +#ifndef _FLDITEM_HXX +#include <editeng/flditem.hxx> +#endif +#include <sfx2/viewfrm.hxx> +#include <svl/whiter.hxx> +#include <svl/eitem.hxx> +#include <svl/itempool.hxx> +#include <sfx2/tplpitem.hxx> +#ifndef _BINDING_HXX //autogen +#include <sfx2/bindings.hxx> +#endif +#include <sfx2/app.hxx> +#include <sfx2/templdlg.hxx> +#include <svx/xdef.hxx> +#include <svx/svddef.hxx> +#include <svx/fmglob.hxx> +#include <svx/svdouno.hxx> +#include <tools/urlobj.hxx> +#include <svx/fmshell.hxx> +#include <svl/cjkoptions.hxx> + +#ifndef SD_FRAME_VIEW +#include "FrameView.hxx" +#endif +#include "Outliner.hxx" +#include "app.hrc" + +#include "app.hxx" +#include "stlsheet.hxx" +#include "drawview.hxx" +#include "drawdoc.hxx" +#include "Window.hxx" +#include "ViewShellBase.hxx" +#include "FormShellManager.hxx" +#include "cfgids.hxx" +#include "anminfo.hxx" + +using ::rtl::OUString; +using namespace ::com::sun::star; + +namespace sd { + +/************************************************************************* +|* +|* Status von Controller-SfxSlots setzen +|* +\************************************************************************/ + +void DrawViewShell::GetCtrlState(SfxItemSet &rSet) +{ + if (rSet.GetItemState(SID_RELOAD) != SFX_ITEM_UNKNOWN) + { + // "Letzte Version" vom SFx en/disablen lassen + GetViewFrame()->GetSlotState (SID_RELOAD, NULL, &rSet); + } + + if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_HYPERLINK_GETLINK)) + { + SvxHyperlinkItem aHLinkItem; + + OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView(); + + if (pOLV) + { + bool bField = false; + const SvxFieldItem* pFieldItem = pOLV->GetFieldAtSelection(); + if (pFieldItem) + { + ESelection aSel = pOLV->GetSelection(); + if ( abs( aSel.nEndPos - aSel.nStartPos ) == 1 ) + { + const SvxFieldData* pField = pFieldItem->GetField(); + if (pField->ISA(SvxURLField)) + { + aHLinkItem.SetName(((const SvxURLField*) pField)->GetRepresentation()); + aHLinkItem.SetURL(((const SvxURLField*) pField)->GetURL()); + aHLinkItem.SetTargetFrame(((const SvxURLField*) pField)->GetTargetFrame()); + bField = true; + } + } + } + if (!bField) + { + // use selected text as name for urls + String sReturn = pOLV->GetSelected(); + sReturn.Erase(255); + sReturn.EraseTrailingChars(); + aHLinkItem.SetName(sReturn); + } + } + else + { + if (mpDrawView->GetMarkedObjectList().GetMarkCount() > 0) + { + bool bFound = false; + + SdrObject* pMarkedObj = mpDrawView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj(); + if( pMarkedObj && (FmFormInventor == pMarkedObj->GetObjInventor()) ) + { + SdrUnoObj* pUnoCtrl = dynamic_cast< SdrUnoObj* >( pMarkedObj ); + + if(pUnoCtrl) try + { + uno::Reference< awt::XControlModel > xControlModel( pUnoCtrl->GetUnoControlModel(), uno::UNO_QUERY_THROW ); + uno::Reference< beans::XPropertySet > xPropSet( xControlModel, uno::UNO_QUERY_THROW ); + uno::Reference< beans::XPropertySetInfo > xPropInfo( xPropSet->getPropertySetInfo(), uno::UNO_QUERY_THROW ); + + form::FormButtonType eButtonType = form::FormButtonType_URL; + const OUString sButtonType( RTL_CONSTASCII_USTRINGPARAM( "ButtonType" ) ); + if(xPropInfo->hasPropertyByName( sButtonType ) && (xPropSet->getPropertyValue( sButtonType ) >>= eButtonType ) ) + { + OUString aString; + + // Label + const OUString sLabel( RTL_CONSTASCII_USTRINGPARAM( "Label" ) ); + if(xPropInfo->hasPropertyByName(sLabel)) + { + if( xPropSet->getPropertyValue(sLabel) >>= aString ) + aHLinkItem.SetName(String( aString )); + } + + // URL + const OUString sTargetURL(RTL_CONSTASCII_USTRINGPARAM( "TargetURL" )); + if(xPropInfo->hasPropertyByName(sTargetURL)) + { + if( xPropSet->getPropertyValue(sTargetURL) >>= aString ) + aHLinkItem.SetURL(String( aString )); + } + + // Target + const OUString sTargetFrame( RTL_CONSTASCII_USTRINGPARAM( "TargetFrame" ) ); + if(xPropInfo->hasPropertyByName(sTargetFrame) ) + { + if( xPropSet->getPropertyValue(sTargetFrame) >>= aString ) + aHLinkItem.SetTargetFrame(String( aString )); + } + + aHLinkItem.SetInsertMode(HLINK_BUTTON); + bFound = true; + } + } + catch( uno::Exception& ) + { + } + } + + // try interaction link + if( !bFound && pMarkedObj ) + { + SdAnimationInfo* pInfo = SdDrawDocument::GetShapeUserData(*pMarkedObj); + if( pInfo && (pInfo->meClickAction == presentation::ClickAction_DOCUMENT) ) + aHLinkItem.SetURL( pInfo->GetBookmark()); + aHLinkItem.SetInsertMode(HLINK_BUTTON); + } + } + } + + rSet.Put(aHLinkItem); + } + rSet.Put( SfxBoolItem( SID_READONLY_MODE, mbReadOnly ) ); + + // Ausgabequalitaet + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OUTPUT_QUALITY_COLOR ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OUTPUT_QUALITY_GRAYSCALE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OUTPUT_QUALITY_BLACKWHITE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OUTPUT_QUALITY_CONTRAST ) ) + { + const ULONG nMode = (sal_Int32)GetActiveWindow()->GetDrawMode(); + rSet.Put( SfxBoolItem( SID_OUTPUT_QUALITY_COLOR, (BOOL)((ULONG)OUTPUT_DRAWMODE_COLOR == nMode) ) ); + rSet.Put( SfxBoolItem( SID_OUTPUT_QUALITY_GRAYSCALE, (BOOL)((ULONG)OUTPUT_DRAWMODE_GRAYSCALE == nMode) ) ); + rSet.Put( SfxBoolItem( SID_OUTPUT_QUALITY_BLACKWHITE, (BOOL)((ULONG)OUTPUT_DRAWMODE_BLACKWHITE == nMode) ) ); + rSet.Put( SfxBoolItem( SID_OUTPUT_QUALITY_CONTRAST, (BOOL)((ULONG)OUTPUT_DRAWMODE_CONTRAST == nMode) ) ); + } + + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_MAIL_SCROLLBODY_PAGEDOWN) ) + { + rSet.Put( SfxBoolItem( SID_MAIL_SCROLLBODY_PAGEDOWN, TRUE ) ); + } + + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_ATTR_YEAR2000) ) + { + FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell(); + if (pFormShell != NULL) + { + UINT16 nState = 0; + if (pFormShell->GetY2KState(nState)) + rSet.Put( SfxUInt16Item( SID_ATTR_YEAR2000, nState ) ); + else + rSet.DisableItem( SID_ATTR_YEAR2000 ); + } + } + + if ( !GetView()->GetTextEditOutliner() ) + { + SvtCJKOptions aCJKOptions; + if( !aCJKOptions.IsChangeCaseMapEnabled() ) + { + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, sal_False ); + } + else + { + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, sal_True ); + } + + rSet.DisableItem( SID_TRANSLITERATE_SENTENCE_CASE ); + rSet.DisableItem( SID_TRANSLITERATE_TITLE_CASE ); + rSet.DisableItem( SID_TRANSLITERATE_TOGGLE_CASE ); + rSet.DisableItem( SID_TRANSLITERATE_UPPER ); + rSet.DisableItem( SID_TRANSLITERATE_LOWER ); + rSet.DisableItem( SID_TRANSLITERATE_HALFWIDTH ); + rSet.DisableItem( SID_TRANSLITERATE_FULLWIDTH ); + rSet.DisableItem( SID_TRANSLITERATE_HIRAGANA ); + rSet.DisableItem( SID_TRANSLITERATE_KATAGANA ); + } + else + { + SvtCJKOptions aCJKOptions; + if( !aCJKOptions.IsChangeCaseMapEnabled() ) + { + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, sal_False ); + rSet.DisableItem( SID_TRANSLITERATE_HALFWIDTH ); + rSet.DisableItem( SID_TRANSLITERATE_FULLWIDTH ); + rSet.DisableItem( SID_TRANSLITERATE_HIRAGANA ); + rSet.DisableItem( SID_TRANSLITERATE_KATAGANA ); + } + else + { + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, sal_True ); + } + } +} + + +/************************************************************************* +|* +|* Status der Attribut-Items +|* +\************************************************************************/ + +void DrawViewShell::GetAttrState( SfxItemSet& rSet ) +{ + SfxWhichIter aIter( rSet ); + USHORT nWhich = aIter.FirstWhich(); + + BOOL bAttr = FALSE; + SfxAllItemSet aAllSet( *rSet.GetPool() ); + + while ( nWhich ) + { + USHORT nSlotId = SfxItemPool::IsWhich(nWhich) + ? GetPool().GetSlotId(nWhich) + : nWhich; + switch ( nSlotId ) + { + case SID_ATTR_FILL_STYLE: + case SID_ATTR_FILL_COLOR: + case SID_ATTR_FILL_GRADIENT: + case SID_ATTR_FILL_HATCH: + case SID_ATTR_FILL_BITMAP: + case SID_ATTR_FILL_SHADOW: + case SID_ATTR_LINE_STYLE: + case SID_ATTR_LINE_DASH: + case SID_ATTR_LINE_WIDTH: + case SID_ATTR_LINE_COLOR: + case SID_ATTR_TEXT_FITTOSIZE: + { + bAttr = TRUE; + } + break; + + case SID_HYPHENATION: + { + SfxItemSet aAttrs( GetDoc()->GetPool() ); + mpDrawView->GetAttributes( aAttrs ); + if( aAttrs.GetItemState( EE_PARA_HYPHENATE ) >= SFX_ITEM_AVAILABLE ) + { + BOOL bValue = ( (const SfxBoolItem&) aAttrs.Get( EE_PARA_HYPHENATE ) ).GetValue(); + rSet.Put( SfxBoolItem( SID_HYPHENATION, bValue ) ); + } + } + break; + + case SID_STYLE_FAMILY2: + case SID_STYLE_FAMILY3: + case SID_STYLE_FAMILY5: + case SID_STYLE_APPLY: // StyleControl + { + SfxStyleSheet* pStyleSheet = mpDrawView->GetStyleSheet(); + if( pStyleSheet ) + { + if( nSlotId != SID_STYLE_APPLY && !mpDrawView->AreObjectsMarked() ) + { + SfxTemplateItem aTmpItem( nWhich, String() ); + aAllSet.Put( aTmpItem, aTmpItem.Which() ); + } + else + { + if (pStyleSheet->GetFamily() == SD_STYLE_FAMILY_MASTERPAGE) + pStyleSheet = ((SdStyleSheet*)pStyleSheet)->GetPseudoStyleSheet(); + + if( pStyleSheet ) + { + SfxStyleFamily eFamily = pStyleSheet->GetFamily(); + + if ((eFamily == SD_STYLE_FAMILY_GRAPHICS && nSlotId == SID_STYLE_FAMILY2) || + (eFamily == SD_STYLE_FAMILY_CELL && nSlotId == SID_STYLE_FAMILY3) || + (eFamily == SD_STYLE_FAMILY_PSEUDO && nSlotId == SID_STYLE_FAMILY5)) + { + SfxTemplateItem aTmpItem ( nWhich, pStyleSheet->GetName() ); + aAllSet.Put( aTmpItem, aTmpItem.Which() ); + } + else + { + SfxTemplateItem aTmpItem(nWhich, String()); + aAllSet.Put(aTmpItem,aTmpItem.Which() ); + } + } + } + } + else + { SfxTemplateItem aItem( nWhich, String() ); + aAllSet.Put( aItem, aItem.Which() ); + // rSet.DisableItem( nWhich ); + } + } + break; + + case SID_SET_DEFAULT: + { + if( !mpDrawView->GetMarkedObjectList().GetMarkCount() || + ( !mpDrawView->IsTextEdit() && !mpDrawView->GetStyleSheet() ) + ) + rSet.DisableItem( nWhich ); + } + break; + + case SID_STYLE_WATERCAN: + { + ISfxTemplateCommon* pTemplateCommon = SFX_APP()->GetCurrentTemplateCommon(GetViewFrame()->GetBindings()); + if (pTemplateCommon && pTemplateCommon->GetActualFamily() == SD_STYLE_FAMILY_PSEUDO) + rSet.Put(SfxBoolItem(nWhich,FALSE)); + else + { + SfxBoolItem aItem(nWhich, SD_MOD()->GetWaterCan()); + aAllSet.Put( aItem, aItem.Which()); + } + } + break; + + case SID_STYLE_NEW: + { + ISfxTemplateCommon* pTemplateCommon = SFX_APP()->GetCurrentTemplateCommon(GetViewFrame()->GetBindings()); + if (pTemplateCommon && pTemplateCommon->GetActualFamily() == SD_STYLE_FAMILY_PSEUDO) + rSet.DisableItem(nWhich); + } + break; + + case SID_STYLE_DRAGHIERARCHIE: + { + ISfxTemplateCommon* pTemplateCommon = SFX_APP()->GetCurrentTemplateCommon(GetViewFrame()->GetBindings()); + if (pTemplateCommon && pTemplateCommon->GetActualFamily() == SD_STYLE_FAMILY_PSEUDO) + rSet.DisableItem(nWhich); + } + break; + + case SID_STYLE_NEW_BY_EXAMPLE: + { + // PseudoStyleSheets koennen nicht 'by Example' erzeugt werden; + // normale StyleSheets brauchen dafuer ein selektiertes Objekt + ISfxTemplateCommon* pTemplCommon = SFX_APP()->GetCurrentTemplateCommon(GetViewFrame()->GetBindings()); + if (pTemplCommon) + { + if (pTemplCommon->GetActualFamily() == SD_STYLE_FAMILY_PSEUDO) + { + rSet.DisableItem(nWhich); + } + else if (pTemplCommon->GetActualFamily() == SD_STYLE_FAMILY_GRAPHICS) + { + if (!mpDrawView->AreObjectsMarked()) + { + rSet.DisableItem(nWhich); + } + } + } + // falls (noch) kein Gestalter da ist, muessen wir uns auf den + // View-Zustand zurueckziehen; eine aktuell eingestellte Familie + // kann nicht beruecksichtigt werden + else + { + if (!mpDrawView->AreObjectsMarked()) + { + rSet.DisableItem(nWhich); + } + } + + } + break; + + case SID_STYLE_UPDATE_BY_EXAMPLE: + { + if (!mpDrawView->AreObjectsMarked()) + { + rSet.DisableItem(nWhich); + } + } + break; + } + nWhich = aIter.NextWhich(); + } + + SfxItemSet* pSet = NULL; + + if( bAttr ) + { + pSet = new SfxItemSet( GetDoc()->GetPool() ); + mpDrawView->GetAttributes( *pSet ); + rSet.Put( *pSet, FALSE ); + } + + rSet.Put( aAllSet, FALSE ); + + // Flaechen und/oder Linienattribute wurden geaendert + if( bAttr && pSet ) + { + // Wenn die View selektierte Objekte besitzt, muessen entspr. Items + // von SFX_ITEM_DEFAULT (_ON) auf SFX_ITEM_DISABLED geaendert werden + if( mpDrawView->AreObjectsMarked() ) + { + SfxWhichIter aNewIter( *pSet, XATTR_LINE_FIRST, XATTR_FILL_LAST ); + nWhich = aNewIter.FirstWhich(); + while( nWhich ) + { + if( SFX_ITEM_DEFAULT == pSet->GetItemState( nWhich ) ) + { + rSet.ClearItem( nWhich ); + rSet.DisableItem( nWhich ); + } + nWhich = aNewIter.NextWhich(); + } + } + delete pSet; + } + +// const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); +// ULONG nMarkCount = rMarkList.GetMarkCount(); +// BOOL bDisabled = FALSE; +// +// for (ULONG i = 0; +// i < nMarkCount && !bDisabled && i < 50; i++) +// { +// SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); +// +// if (pObj->GetObjInventor() == E3dInventor) +// { +// bDisabled = TRUE; +// rSet.ClearItem(SDRATTR_SHADOW); +// rSet.DisableItem(SDRATTR_SHADOW); +// } +// } +} + + +/************************************************************************* +|* +|* Text der Selektion zurueckgeben +|* +\************************************************************************/ + +String DrawViewShell::GetSelectionText(BOOL bCompleteWords) +{ + String aStrSelection; + ::Outliner* pOl = mpDrawView->GetTextEditOutliner(); + OutlinerView* pOlView = mpDrawView->GetTextEditOutlinerView(); + + if (pOl && pOlView) + { + if (bCompleteWords) + { + ESelection aSel = pOlView->GetSelection(); + String aStrCurrentDelimiters = pOl->GetWordDelimiters(); + + pOl->SetWordDelimiters( String( RTL_CONSTASCII_USTRINGPARAM( " .,;\"'" ))); + aStrSelection = pOl->GetWord( aSel.nEndPara, aSel.nEndPos ); + pOl->SetWordDelimiters( aStrCurrentDelimiters ); + } + else + { + aStrSelection = pOlView->GetSelected(); + } + } + + return (aStrSelection); +} + +/************************************************************************* +|* +|* Ist etwas selektiert? +|* +\************************************************************************/ + +BOOL DrawViewShell::HasSelection(BOOL bText) const +{ + BOOL bReturn = FALSE; + + if (bText) + { + OutlinerView* pOlView = mpDrawView->GetTextEditOutlinerView(); + + if (pOlView && pOlView->GetSelected().Len() != 0) + { + bReturn = TRUE; + } + } + else if (mpDrawView->GetMarkedObjectList().GetMarkCount() != 0) + { + bReturn = TRUE; + } + + return bReturn; +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviewsg.cxx b/sd/source/ui/view/drviewsg.cxx new file mode 100644 index 000000000000..41b43864a3c0 --- /dev/null +++ b/sd/source/ui/view/drviewsg.cxx @@ -0,0 +1,296 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include "ViewShellImplementation.hxx" + +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#ifndef _IMAPDLG_HXX +#include <svx/imapdlg.hxx> +#endif +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/viewfrm.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdoole2.hxx> + + +#include "app.hrc" + +#include "drawdoc.hxx" +#include "slideshow.hxx" +#include "imapinfo.hxx" +#include "sdmod.hxx" +#include "optsitem.hxx" +#ifndef SD_FRAME_VIEW +#include "FrameView.hxx" +#endif +#include "drawview.hxx" + +#include "fupoor.hxx" + +namespace sd { + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void DrawViewShell::ExecIMap( SfxRequest& rReq ) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if(HasCurrentFunction(SID_PRESENTATION) ) + return; + + if ( rReq.GetSlot() == SID_IMAP_EXEC ) + { + SdrMark* pMark = mpDrawView->GetMarkedObjectList().GetMark(0); + + if ( pMark ) + { + SdrObject* pSdrObj = pMark->GetMarkedSdrObj(); + SvxIMapDlg* pDlg = ViewShell::Implementation::GetImageMapDialog(); + + if ( pDlg->GetEditingObject() == (void*) pSdrObj ) + { + const ImageMap& rImageMap = pDlg->GetImageMap(); + SdIMapInfo* pIMapInfo = GetDoc()->GetIMapInfo( pSdrObj ); + + if ( !pIMapInfo ) + pSdrObj->InsertUserData( new SdIMapInfo( rImageMap ) ); + else + pIMapInfo->SetImageMap( rImageMap ); + + GetDoc()->SetChanged( sal_True ); + } + } + } +} + + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +void DrawViewShell::GetIMapState( SfxItemSet& rSet ) +{ + BOOL bDisable = TRUE; + + if( GetViewFrame()->HasChildWindow( SvxIMapDlgChildWindow::GetChildWindowId() ) ) + { + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + const SdrObject* pObj = NULL; + ULONG nMarkCount = rMarkList.GetMarkCount(); + + if ( nMarkCount == 1 ) + { + pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + + SvxIMapDlg* pImageMapDialog = ViewShell::Implementation::GetImageMapDialog(); + if ( ( pObj->ISA( SdrGrafObj ) /*|| pObj->ISA( SdrOle2Obj )*/ ) + && pImageMapDialog!=NULL + && ( pImageMapDialog->GetEditingObject() == (void*) pObj ) ) + { + bDisable = FALSE; + } + } + } + + rSet.Put( SfxBoolItem( SID_IMAP_EXEC, bDisable ) ); +} + +/************************************************************************* +|* +|* Execute-Methode der Optionsleiste +|* +\************************************************************************/ + +void DrawViewShell::ExecOptionsBar( SfxRequest& rReq ) +{ + // waehrend einer Diashow wird nichts ausgefuehrt! + if(HasCurrentFunction(SID_PRESENTATION)) + return; + + BOOL bDefault = FALSE; + USHORT nSlot = rReq.GetSlot(); + + SdOptions* pOptions = SD_MOD()->GetSdOptions(GetDoc()->GetDocumentType()); + + switch( nSlot ) + { + case SID_HANDLES_DRAFT: + pOptions->SetSolidMarkHdl( !mpDrawView->IsSolidMarkHdl() ); + break; + + case SID_SOLID_CREATE: + pOptions->SetSolidDragging( !mpDrawView->IsSolidDragging() ); + break; + + + // Raster- / Hilfslinien-Optionen + case SID_GRID_VISIBLE: // noch nicht hier ! + { + pOptions->SetGridVisible( !mpDrawView->IsGridVisible() ); + } + break; + + case SID_GRID_USE: + { + pOptions->SetUseGridSnap( !mpDrawView->IsGridSnap() ); + } + break; + + case SID_HELPLINES_VISIBLE: // noch nicht hier ! + { + pOptions->SetHelplines( !mpDrawView->IsHlplVisible() ); + } + break; + + case SID_HELPLINES_USE: + { + pOptions->SetSnapHelplines( !mpDrawView->IsHlplSnap() ); + } + break; + + case SID_HELPLINES_MOVE: + { + pOptions->SetDragStripes( !mpDrawView->IsDragStripes() ); + } + break; + + + case SID_SNAP_BORDER: + { + pOptions->SetSnapBorder( !mpDrawView->IsBordSnap() ); + } + break; + + case SID_SNAP_FRAME: + { + pOptions->SetSnapFrame( !mpDrawView->IsOFrmSnap() ); + } + break; + + case SID_SNAP_POINTS: + { + pOptions->SetSnapPoints( !mpDrawView->IsOPntSnap() ); + } + break; + + + case SID_QUICKEDIT: + { + pOptions->SetQuickEdit( !mpDrawView->IsQuickTextEditMode() ); + } + break; + + case SID_PICK_THROUGH: + { + pOptions->SetPickThrough( + !mpDrawView->GetModel()->IsPickThroughTransparentTextFrames() ); + } + break; + + case SID_BIG_HANDLES: + { + pOptions->SetBigHandles( !mpFrameView->IsBigHandles() ); + } + break; + + case SID_DOUBLECLICK_TEXTEDIT: + { + pOptions->SetDoubleClickTextEdit( !mpFrameView->IsDoubleClickTextEdit() ); + } + break; + + case SID_CLICK_CHANGE_ROTATION: + { + pOptions->SetClickChangeRotation( !mpFrameView->IsClickChangeRotation() ); + } + break; + + default: + bDefault = TRUE; + break; + } + + if( !bDefault ) + { + pOptions->StoreConfig(); + + // Speichert die Konfiguration SOFORT + // SFX_APP()->SaveConfiguration(); + WriteFrameViewData(); + + mpFrameView->Update( pOptions ); + ReadFrameViewData( mpFrameView ); + + Invalidate( nSlot ); + rReq.Done(); + } + +} + + +/************************************************************************* +|* +|* State-Methode der Optionsleiste +|* +\************************************************************************/ + +void DrawViewShell::GetOptionsBarState( SfxItemSet& rSet ) +{ + rSet.Put( SfxBoolItem( SID_HANDLES_DRAFT, !mpDrawView->IsSolidMarkHdl() ) ); + rSet.Put( SfxBoolItem( SID_SOLID_CREATE, mpDrawView->IsSolidDragging() ) ); + rSet.Put( SfxBoolItem( SID_GRID_VISIBLE, mpDrawView->IsGridVisible() ) ); + rSet.Put( SfxBoolItem( SID_GRID_USE, mpDrawView->IsGridSnap() ) ); + rSet.Put( SfxBoolItem( SID_HELPLINES_VISIBLE, mpDrawView->IsHlplVisible() ) ); + rSet.Put( SfxBoolItem( SID_HELPLINES_USE, mpDrawView->IsHlplSnap() ) ); + rSet.Put( SfxBoolItem( SID_HELPLINES_MOVE, mpDrawView->IsDragStripes() ) ); + + rSet.Put( SfxBoolItem( SID_SNAP_BORDER, mpDrawView->IsBordSnap() ) ); + rSet.Put( SfxBoolItem( SID_SNAP_FRAME, mpDrawView->IsOFrmSnap() ) ); + rSet.Put( SfxBoolItem( SID_SNAP_POINTS, mpDrawView->IsOPntSnap() ) ); + + rSet.Put( SfxBoolItem( SID_QUICKEDIT, mpDrawView->IsQuickTextEditMode() ) ); + rSet.Put( SfxBoolItem( SID_PICK_THROUGH, (BOOL) + mpDrawView->GetModel()->IsPickThroughTransparentTextFrames() ) ); + + rSet.Put( SfxBoolItem( SID_BIG_HANDLES, mpFrameView->IsBigHandles() ) ); + rSet.Put( SfxBoolItem( SID_DOUBLECLICK_TEXTEDIT, mpFrameView->IsDoubleClickTextEdit() ) ); + rSet.Put( SfxBoolItem( SID_CLICK_CHANGE_ROTATION, mpFrameView->IsClickChangeRotation() ) ); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/drviewsh.cxx b/sd/source/ui/view/drviewsh.cxx new file mode 100644 index 000000000000..26d0a70ba9a6 --- /dev/null +++ b/sd/source/ui/view/drviewsh.cxx @@ -0,0 +1,193 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include <svl/aeitem.hxx> +#include <svl/itemset.hxx> +#include <sfx2/request.hxx> +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif + + +#include <svx/fmshell.hxx> +#include <sfx2/dispatch.hxx> + +#include "app.hrc" +#include "strings.hrc" +#include "sdpage.hxx" +#ifndef SD_FRAME_VIEW +#include "FrameView.hxx" +#endif +#include "sdresid.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "Window.hxx" +#include "GraphicViewShell.hxx" +#include "drawview.hxx" + +#include "slideshow.hxx" + +namespace sd { + +#define TABCONTROL_INITIAL_SIZE 500 + +/************************************************************************* +|* +|* Sprung zu Bookmark +|* +\************************************************************************/ + +BOOL DrawViewShell::GotoBookmark(const String& rBookmark) +{ + BOOL bRet = FALSE; + ::sd::DrawDocShell* pDocSh = GetDocSh(); + if( pDocSh ) + { + if( !pDocSh->GetViewShell() ) //#i26016# this case occurs if the jump-target-document was opened already with file open dialog before triggering the jump via hyperlink + pDocSh->Connect(this); + bRet = (pDocSh->GotoBookmark(rBookmark)); + } + return bRet; +} + +/************************************************************************* +|* +|* Bereich sichtbar machen (Bildausschnitt scrollen) +|* +\************************************************************************/ + +void DrawViewShell::MakeVisible(const Rectangle& rRect, ::Window& rWin) +{ + // #98568# In older versions, if in X or Y the size of the object was + // smaller than the visible area, the user-defined zoom was + // changed. This was decided to be a bug for 6.x, thus I developed a + // version which instead handles X/Y bigger/smaller and visibility + // questions seperately. The new behaviour is triggered with the + // bZoomAllowed parameter which for old behaviour should be set to + // sal_True. I looked at all uses of MakeVisible() in the application + // and found no valid reason for really changing the zoom factor, thus I + // decided to NOT expand (incompatible) this virtual method to get one + // more parameter. If this is wanted in later versions, feel free to add + // that bool to the parameter list. + sal_Bool bZoomAllowed(sal_False); + Size aLogicSize(rRect.GetSize()); + + // Sichtbarer Bereich + Size aVisSizePixel(rWin.GetOutputSizePixel()); + Rectangle aVisArea(rWin.PixelToLogic(Rectangle(Point(0,0), aVisSizePixel))); + Size aVisAreaSize(aVisArea.GetSize()); + + if(!aVisArea.IsInside(rRect) && !SlideShow::IsRunning( GetViewShellBase() ) ) + { + // Objekt liegt nicht komplett im sichtbaren Bereich + sal_Int32 nFreeSpaceX(aVisAreaSize.Width() - aLogicSize.Width()); + sal_Int32 nFreeSpaceY(aVisAreaSize.Height() - aLogicSize.Height()); + + if(bZoomAllowed && (nFreeSpaceX < 0 || nFreeSpaceY < 0)) + { + // Objekt passt nicht in sichtbaren Bereich -> auf Objektgroesse zoomen + SetZoomRect(rRect); + } + else + { + // #98568# allow a mode for move-only visibility without zooming. + const sal_Int32 nPercentBorder(30); + const Rectangle aInnerRectangle( + aVisArea.Left() + ((aVisAreaSize.Width() * nPercentBorder) / 200), + aVisArea.Top() + ((aVisAreaSize.Height() * nPercentBorder) / 200), + aVisArea.Right() - ((aVisAreaSize.Width() * nPercentBorder) / 200), + aVisArea.Bottom() - ((aVisAreaSize.Height() * nPercentBorder) / 200) + ); + Point aNewPos(aVisArea.TopLeft()); + + if(nFreeSpaceX < 0) + { + if(aInnerRectangle.Left() > rRect.Right()) + { + // object moves out to the left + aNewPos.X() -= aVisAreaSize.Width() / 2; + } + + if(aInnerRectangle.Right() < rRect.Left()) + { + // object moves out to the right + aNewPos.X() += aVisAreaSize.Width() / 2; + } + } + else + { + if(nFreeSpaceX > rRect.GetWidth()) + nFreeSpaceX = rRect.GetWidth(); + + while(rRect.Right() > aNewPos.X() + aVisAreaSize.Width()) + aNewPos.X() += nFreeSpaceX; + + while(rRect.Left() < aNewPos.X()) + aNewPos.X() -= nFreeSpaceX; + } + + if(nFreeSpaceY < 0) + { + if(aInnerRectangle.Top() > rRect.Bottom()) + { + // object moves out to the top + aNewPos.Y() -= aVisAreaSize.Height() / 2; + } + + if(aInnerRectangle.Bottom() < rRect.Top()) + { + // object moves out to the right + aNewPos.Y() += aVisAreaSize.Height() / 2; + } + } + else + { + if(nFreeSpaceY > rRect.GetHeight()) + nFreeSpaceY = rRect.GetHeight(); + + while(rRect.Bottom() > aNewPos.Y() + aVisAreaSize.Height()) + aNewPos.Y() += nFreeSpaceY; + + while(rRect.Top() < aNewPos.Y()) + aNewPos.Y() -= nFreeSpaceY; + } + + // did position change? Does it need to be set? + if(aNewPos != aVisArea.TopLeft()) + { + aVisArea.SetPos(aNewPos); + SetZoomRect(aVisArea); + } + } + } +} + +} diff --git a/sd/source/ui/view/drviewsi.cxx b/sd/source/ui/view/drviewsi.cxx new file mode 100644 index 000000000000..17ebe33ea540 --- /dev/null +++ b/sd/source/ui/view/drviewsi.cxx @@ -0,0 +1,207 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include <svx/xtable.hxx> +#include "sdattr.hxx" +#include <svl/aeitem.hxx> +#include <editeng/eeitem.hxx> +#include <sfx2/request.hxx> +#include <svx/svditer.hxx> +#include <editeng/colritem.hxx> +#include <sfx2/viewfrm.hxx> +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <svx/svdundo.hxx> +#include <svx/view3d.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/float3d.hxx> +#include <svx/f3dchild.hxx> +#ifndef _SVX_DIALOGS_HRC //autogen +#include <svx/dialogs.hrc> +#endif +#include <vcl/msgbox.hxx> + + +#include "app.hrc" +#include "strings.hrc" + +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "anminfo.hxx" +#include "unoaprms.hxx" // Undo-Action +#include "sdundogr.hxx" // Undo Gruppe +#include "drawview.hxx" +#include "Window.hxx" +#include "sdresid.hxx" + +using namespace ::com::sun::star; + +namespace sd { + +#define ATTR_MISSING 0 // Attribut nicht verfuegbar +#define ATTR_MIXED 1 // Attribut uneindeutig (bei Mehrfachselektion) +#define ATTR_SET 2 // Attribut eindeutig + +#define ITEMVALUE(ItemSet,Id,Cast) ((const Cast&)(ItemSet).Get(Id)).GetValue() + +/************************************************************************* +|* +|* SfxRequests fuer EffekteWindow bearbeiten +|* +\************************************************************************/ + +void DrawViewShell::ExecEffectWin( SfxRequest& rReq ) +{ + CheckLineTo (rReq); + + USHORT nSId = rReq.GetSlot(); + + switch( nSId ) + { + case SID_3D_INIT: + { + USHORT nId = Svx3DChildWindow::GetChildWindowId(); + SfxChildWindow* pWindow = GetViewFrame()->GetChildWindow( nId ); + if( pWindow ) + { + Svx3DWin* p3DWin = (Svx3DWin*)( pWindow->GetWindow() ); + if( p3DWin ) + p3DWin->InitColorLB( GetDoc() ); + } + } + break; + + case SID_3D_STATE: + { + Update3DWindow(); + } + break; + + case SID_3D_ASSIGN: + { + AssignFrom3DWindow(); + } + break; + + } +} + +/************************************************************************* +|* +|* 3D - Assign / Update +|* +\************************************************************************/ +void DrawViewShell::Update3DWindow() +{ + USHORT nId = Svx3DChildWindow::GetChildWindowId(); + SfxChildWindow* pWindow = GetViewFrame()->GetChildWindow( nId ); + if( pWindow ) + { + Svx3DWin* p3DWin = (Svx3DWin*) pWindow->GetWindow(); + if( p3DWin && p3DWin->IsUpdateMode() ) + { + SfxItemSet aTmpItemSet = GetView()->Get3DAttributes(); + p3DWin->Update( aTmpItemSet ); + } + } +} + +/*----------------------------------------------------------------------------*/ + +void DrawViewShell::AssignFrom3DWindow() +{ + USHORT nId = Svx3DChildWindow::GetChildWindowId(); + SfxChildWindow* pWin = GetViewFrame()->GetChildWindow( nId ); + if( pWin ) + { + Svx3DWin* p3DWin = (Svx3DWin*) pWin->GetWindow(); + if( p3DWin && GetView() ) + { + if(!GetView()->IsPresObjSelected()) + { + SfxItemSet aSet( GetDoc()->GetPool(), + SDRATTR_START, SDRATTR_END, + 0, 0); + p3DWin->GetAttr( aSet ); + + // Eigene UNDO-Klammerung auch um die Wandlung in 3D + GetView()->BegUndo(String(SdResId(STR_UNDO_APPLY_3D_FAVOURITE))); + + if(GetView()->IsConvertTo3DObjPossible()) + { + // Nur TextAttribute zuweisen + SfxItemSet aTextSet( GetDoc()->GetPool(), + EE_ITEMS_START, EE_ITEMS_END, 0 ); + aTextSet.Put( aSet, FALSE ); + GetView()->SetAttributes( aTextSet ); + + // Text in 3D umwandeln + USHORT nSId = SID_CONVERT_TO_3D; + SfxBoolItem aItem( nSId, TRUE ); + GetViewFrame()->GetDispatcher()->Execute( + nSId, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); + + // Feststellen, ob ein FILL_Attribut gesetzt ist. + // Falls nicht, Fuellattribut hart setzen + XFillStyle eFillStyle = ITEMVALUE( aSet, XATTR_FILLSTYLE, XFillStyleItem ); + if(eFillStyle == XFILL_NONE) + aSet.Put(XFillStyleItem (XFILL_SOLID)); + + // remove some 3DSCENE attributes since these were + // created by convert to 3D and may not be changed + // to the defaults again. + aSet.ClearItem(SDRATTR_3DSCENE_DISTANCE); + aSet.ClearItem(SDRATTR_3DSCENE_FOCAL_LENGTH); + aSet.ClearItem(SDRATTR_3DOBJ_DEPTH); + } + + // Attribute zuweisen + GetView()->Set3DAttributes( aSet ); + + // Ende UNDO + GetView()->EndUndo(); + } + else + { + InfoBox aInfoBox ( + GetActiveWindow(), + String(SdResId(STR_ACTION_NOTPOSSIBLE))); + aInfoBox.Execute(); + } + + // Focus zurueckholen + GetActiveWindow()->GrabFocus(); + } + } +} + +} diff --git a/sd/source/ui/view/drviewsj.cxx b/sd/source/ui/view/drviewsj.cxx new file mode 100644 index 000000000000..ca69aeac0e59 --- /dev/null +++ b/sd/source/ui/view/drviewsj.cxx @@ -0,0 +1,564 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include <com/sun/star/embed/EmbedMisc.hpp> +#include <svl/aeitem.hxx> +#ifndef _SVXIDS_HRC //autogen +#include <svx/svxids.hrc> +#endif +#ifndef _GLOBL3D_HXX //autogen +#include <svx/globl3d.hxx> +#endif +#include <editeng/eeitem.hxx> +#ifndef _FLDITEM_HXX +#include <editeng/flditem.hxx> +#endif +#include <svx/svdogrp.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdoole2.hxx> +#include <svx/sxelditm.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/request.hxx> +#include <svx/svdopath.hxx> +#include <svx/polysc3d.hxx> +#include <svx/obj3d.hxx> +#include <sfx2/event.hxx> +#include <sfx2/docfile.hxx> +#include <rtl/ustrbuf.hxx> + + +#include "app.hrc" + +#include "Outliner.hxx" +#include "sdpage.hxx" +#include "fupoor.hxx" +#include "fusel.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "drawview.hxx" +#include "optsitem.hxx" + +using namespace com::sun::star; + +namespace sd { + +/************************************************************************* +|* +|* Status (Enabled/Disabled) von Menue-SfxSlots setzen +|* +\************************************************************************/ + +void DrawViewShell::GetMenuStateSel( SfxItemSet &rSet ) +{ + // Status der Menueintraege, bzw. Buttons + // Einfachselektion + + const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList(); + ULONG nMarkCount = rMarkList.GetMarkCount(); + + if ( nMarkCount == 1 ) + { + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_BEZIER_EDIT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_UNGROUP ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ENTER_GROUP ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_NAME_GROUP ) || + + // #i68101# + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_TITLE_DESCRIPTION ) || + + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_FILL_STYLE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CHANGEBEZIER ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CHANGEPOLYGON ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_LINEEND_POLYGON ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( OBJ_TITLETEXT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( OBJ_OUTLINETEXT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MEASURE_DLG ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONNECTION_DLG ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONNECTION_NEW_ROUTING ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_3D_LATHE ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_3D_LATHE_FAST ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_SHEAR ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_1BIT_THRESHOLD ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_1BIT_MATRIX ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_4BIT_GRAYS ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_4BIT_COLORS ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_8BIT_GRAYS ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_8BIT_COLORS ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_24BIT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_LEFT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_CENTER ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_RIGHT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_UP ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_MIDDLE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_DOWN ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_FRAME_TO_TOP ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MOREFRONT ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MOREBACK ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_FRAME_TO_BOTTOM ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_BEFORE_OBJ ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_BEHIND_OBJ ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_REVERSE_ORDER ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ORIGINAL_SIZE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_SAVEGRAPHIC ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_TEXTATTR_DLG ) ) + { + const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + UINT32 nInv = pObj->GetObjInventor(); + UINT16 nId = pObj->GetObjIdentifier(); + SdrObjTransformInfoRec aInfoRec; + pObj->TakeObjInfo( aInfoRec ); + + + // #91929#; don't show original size entry if not possible + if ( pObj->ISA( SdrOle2Obj ) ) + { + SdrOle2Obj* pOleObj = PTR_CAST(SdrOle2Obj, pObj); + if (pOleObj->GetObjRef().is() && + ((pOleObj->GetObjRef()->getStatus( pOleObj->GetAspect() ) & embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE) ) ) + rSet.DisableItem(SID_ORIGINAL_SIZE); + } + + if ( !( pObj->ISA( SdrGrafObj ) ) ) + { + rSet.DisableItem(SID_SAVEGRAPHIC); + } + + // Wenn es sich um kein Gruppenobjekt oder 3D-Objekt handelt + // wird "Gruppe betreten" disabled + if( !( ( pObj->ISA( SdrObjGroup ) && nInv == SdrInventor ) || + (pObj->ISA (E3dPolyScene) || pObj->ISA (E3dScene) /*|| pObj->ISA (E3dCompoundObject) */) ) ) + { + rSet.DisableItem( SID_ENTER_GROUP ); + } + + // Wenn es sich um kein Gruppenobjekt handelt + // wird "Gruppierung aufheben" disabled + if (!(pObj->ISA(SdrObjGroup) && nInv == SdrInventor)) + { + rSet.DisableItem(SID_UNGROUP); + } +/* + if (!pObj->ISA(SdrObjGroup) && !pObj->ISA(SdrGrafObj) && !pObj->ISA(SdrOle2Obj)) + { + rSet.DisableItem( SID_NAME_GROUP ); + } +*/ + if (!pObj->ISA(SdrGrafObj) || + ((SdrGrafObj*) pObj)->GetGraphicType() != GRAPHIC_BITMAP || + ((SdrGrafObj*) pObj)->IsLinkedGraphic()) + { + rSet.DisableItem(SID_CONVERT_TO_1BIT_THRESHOLD); + rSet.DisableItem(SID_CONVERT_TO_1BIT_MATRIX); + rSet.DisableItem(SID_CONVERT_TO_4BIT_GRAYS); + rSet.DisableItem(SID_CONVERT_TO_4BIT_COLORS); + rSet.DisableItem(SID_CONVERT_TO_8BIT_GRAYS); + rSet.DisableItem(SID_CONVERT_TO_8BIT_COLORS); + rSet.DisableItem(SID_CONVERT_TO_24BIT); + } + + if( nInv == SdrInventor && + (nId == OBJ_LINE || + nId == OBJ_PLIN || + nId == OBJ_PATHLINE || + nId == OBJ_FREELINE )) + { + //rSet.DisableItem( SID_ATTRIBUTES_AREA ); // wieder raus! + rSet.DisableItem( SID_ATTR_FILL_STYLE ); + } + if( (!pObj->ISA( SdrPathObj ) && !aInfoRec.bCanConvToPath) || pObj->ISA( SdrObjGroup ) ) // Solange es JOE fehlerhaft behandelt! + { // JOE: Ein Gruppenobjekt kann eben u.U. in ein PathObj gewandelt werden + rSet.DisableItem( SID_LINEEND_POLYGON ); + } + if(nInv == SdrInventor && + (nId == OBJ_PATHFILL || nId == OBJ_PATHLINE || !aInfoRec.bCanConvToPath)) + rSet.DisableItem( SID_CHANGEBEZIER ); + + if( nInv == SdrInventor && + ( nId == OBJ_POLY || nId == OBJ_PLIN || !aInfoRec.bCanConvToPoly ) && + !GetView()->IsVectorizeAllowed() ) + { + rSet.DisableItem( SID_CHANGEPOLYGON ); + } + + if(nInv == SdrInventor && (nId == OBJ_TITLETEXT || nId == OBJ_OUTLINETEXT)) + rSet.DisableItem( SID_TEXTATTR_DLG ); + + if(nInv == SdrInventor && nId == OBJ_TABLE ) + { + rSet.DisableItem( SID_TEXTATTR_DLG ); + } + + if( nInv != SdrInventor || nId != OBJ_MEASURE ) + rSet.DisableItem( SID_MEASURE_DLG ); + + if( nInv != SdrInventor || nId != OBJ_EDGE ) + rSet.DisableItem( SID_CONNECTION_DLG ); + else + { + BOOL bDisable = TRUE; + SfxItemSet aAttrSet( GetDoc()->GetPool() ); + GetView()->GetAttributes( aAttrSet ); + + if( aAttrSet.GetItemState( SDRATTR_EDGELINE1DELTA ) >= SFX_ITEM_AVAILABLE && + aAttrSet.GetItemState( SDRATTR_EDGELINE2DELTA ) >= SFX_ITEM_AVAILABLE && + aAttrSet.GetItemState( SDRATTR_EDGELINE3DELTA ) >= SFX_ITEM_AVAILABLE ) + { + long nVal1 = ( ( const SdrEdgeLine1DeltaItem& ) aAttrSet.Get( SDRATTR_EDGELINE1DELTA ) ).GetValue(); + long nVal2 = ( ( const SdrEdgeLine2DeltaItem& ) aAttrSet.Get( SDRATTR_EDGELINE2DELTA ) ).GetValue(); + long nVal3 = ( ( const SdrEdgeLine3DeltaItem& ) aAttrSet.Get( SDRATTR_EDGELINE3DELTA ) ).GetValue(); + { + if( nVal1 != 0 || nVal2 != 0 || nVal3 != 0 ) + bDisable = FALSE; + } + } + if( bDisable ) + rSet.DisableItem( SID_CONNECTION_NEW_ROUTING ); + } + + if ( nInv == E3dInventor || + (!mpDrawView->IsConvertToPathObjPossible(FALSE) && + !mpDrawView->IsShearAllowed() && + !mpDrawView->IsDistortAllowed()) ) + { + rSet.DisableItem( SID_OBJECT_SHEAR ); + } + + if(pObj->ISA(E3dCompoundObject)) + { + rSet.DisableItem( SID_OBJECT_ALIGN_LEFT ); + rSet.DisableItem( SID_OBJECT_ALIGN_CENTER ); + rSet.DisableItem( SID_OBJECT_ALIGN_RIGHT ); + rSet.DisableItem( SID_OBJECT_ALIGN_UP ); + rSet.DisableItem( SID_OBJECT_ALIGN_MIDDLE ); + rSet.DisableItem( SID_OBJECT_ALIGN_DOWN ); + rSet.DisableItem( SID_FRAME_TO_TOP ); + rSet.DisableItem( SID_MOREFRONT ); + rSet.DisableItem( SID_MOREBACK ); + rSet.DisableItem( SID_FRAME_TO_BOTTOM ); + rSet.DisableItem( SID_BEFORE_OBJ ); + rSet.DisableItem( SID_BEHIND_OBJ ); + rSet.DisableItem( SID_REVERSE_ORDER ); + } + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_DISMANTLE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_BREAK ) ) + { + if ( !mpDrawView->IsDismantlePossible(FALSE) ) + { + rSet.DisableItem( SID_DISMANTLE ); + } + + if ( !mpDrawView->IsDismantlePossible(TRUE) && + !mpDrawView->IsImportMtfPossible() && + !mpDrawView->IsBreak3DObjPossible() ) + { + rSet.DisableItem( SID_BREAK ); + } + } + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MODIFY_FIELD ) ) + { + OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView(); + + if( pOLV ) + { + const SvxFieldItem* pFldItem = pOLV->GetFieldAtSelection(); + + if( !( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) || + pFldItem->GetField()->ISA( SvxAuthorField ) || + pFldItem->GetField()->ISA( SvxExtFileField ) || + pFldItem->GetField()->ISA( SvxExtTimeField ) ) ) ) + { + rSet.DisableItem( SID_MODIFY_FIELD ); + } + } + else + rSet.DisableItem( SID_MODIFY_FIELD ); + } + + rSet.DisableItem( SID_GROUP ); + rSet.DisableItem( SID_COMBINE ); + rSet.DisableItem(SID_DISTRIBUTE_DLG); + rSet.DisableItem(SID_POLY_MERGE); + rSet.DisableItem(SID_POLY_SUBSTRACT); + rSet.DisableItem(SID_POLY_INTERSECT); + rSet.DisableItem( SID_CONNECT ); + } + // Mehrfachselektion + else if( nMarkCount > 1 ) + { + // distribure dialog for 3+n objects + if(nMarkCount <= 2) + rSet.DisableItem(SID_DISTRIBUTE_DLG); + +// rSet.ClearItem( SID_BEZIER_EDIT ); +// rSet.DisableItem( SID_BEZIER_EDIT ); + rSet.DisableItem( SID_LINEEND_POLYGON ); + rSet.DisableItem( SID_ENTER_GROUP ); + // Jetzt (28.10.96) muessen Namen fuer Objekte eindeutig sein + rSet.DisableItem( SID_NAME_GROUP ); + // #i68101# + rSet.DisableItem( SID_OBJECT_TITLE_DESCRIPTION ); + rSet.DisableItem( SID_MODIFY_FIELD ); + + if( 1 ) +// if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_FILL_STYLE ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_UNGROUP ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MEASURE_DLG ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONNECTION_DLG ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_COMBINE ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_SHEAR ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_TEXTATTR_DLG ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_3D_LATHE ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_CONVERT_TO_3D_LATHE_FAST ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_LEFT ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_CENTER ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_RIGHT ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_UP ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_MIDDLE ) || +// SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_OBJECT_ALIGN_DOWN ) ) + { + BOOL bText = FALSE; + BOOL bLine = FALSE; + BOOL bGroup = FALSE; + BOOL bGraf = FALSE; + BOOL bDrawObj = FALSE; + BOOL b3dObj = FALSE; + BOOL bTitOutText = FALSE; + bool bTable = false; + BOOL bMeasureObj = FALSE; + BOOL bEdgeObj = FALSE; // Connector + BOOL bE3dCompoundObject = FALSE; + + for( ULONG i = 0; + i < nMarkCount && !bText && i < 50; + i++ ) + { + SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + UINT32 nInv = pObj->GetObjInventor(); + UINT16 nId = pObj->GetObjIdentifier(); + + if (nInv == SdrInventor) + { + switch (nId) + { + case OBJ_TEXT: bText = TRUE; break; + + case OBJ_LINE: bLine = TRUE; break; + + case OBJ_EDGE: bEdgeObj = TRUE; break; + + case OBJ_MEASURE: bMeasureObj = TRUE; break; + + case OBJ_RECT: + case OBJ_CIRC: + case OBJ_FREELINE: + case OBJ_FREEFILL: + case OBJ_PATHFILL: + case OBJ_PATHLINE: + case OBJ_SECT: + case OBJ_CARC: + case OBJ_CCUT: bDrawObj = TRUE; break; + + case OBJ_GRUP: bGroup = TRUE; break; + + case OBJ_GRAF: bGraf = TRUE; break; + + case OBJ_TITLETEXT: + case OBJ_OUTLINETEXT: bTitOutText = TRUE; break; + case OBJ_TABLE: bTable = true; break; + } + } + else if (nInv == E3dInventor) + { + if(pObj->ISA(E3dScene)) + b3dObj = TRUE; + else if(pObj->ISA(E3dCompoundObject)) + bE3dCompoundObject = TRUE; + } + } + /* Kann wohl raus, da jedes(?) Objekt Text enthalten kann + if( !bText ) + { + rSet.DisableItem( SID_CHAR_DLG ); + rSet.DisableItem( SID_PARA_DLG ); + rSet.DisableItem( SID_CHARMAP ); + } + */ + if( bLine && !bText && !bDrawObj &&!b3dObj) + { + //rSet.DisableItem( SID_ATTRIBUTES_AREA ); + rSet.DisableItem( SID_ATTR_FILL_STYLE ); + } + if( !bEdgeObj ) + rSet.DisableItem( SID_CONNECTION_DLG ); + + if (b3dObj) + { + rSet.DisableItem( SID_COMBINE ); + rSet.DisableItem(SID_POLY_MERGE); + rSet.DisableItem(SID_POLY_SUBSTRACT); + rSet.DisableItem(SID_POLY_INTERSECT); + } + + if (b3dObj || + (!mpDrawView->IsConvertToPathObjPossible(FALSE) && + !mpDrawView->IsShearAllowed() && + !mpDrawView->IsDistortAllowed()) ) + { + rSet.DisableItem( SID_OBJECT_SHEAR ); + } + + if( !bGroup ) + { + rSet.DisableItem( SID_UNGROUP ); + } + if( bTitOutText || bTable ) + rSet.DisableItem( SID_TEXTATTR_DLG ); + + if( !bMeasureObj ) + rSet.DisableItem( SID_MEASURE_DLG ); + + if (!bGraf) + { + rSet.DisableItem(SID_CONVERT_TO_1BIT_THRESHOLD); + rSet.DisableItem(SID_CONVERT_TO_1BIT_MATRIX); + rSet.DisableItem(SID_CONVERT_TO_4BIT_GRAYS); + rSet.DisableItem(SID_CONVERT_TO_4BIT_COLORS); + rSet.DisableItem(SID_CONVERT_TO_8BIT_GRAYS); + rSet.DisableItem(SID_CONVERT_TO_8BIT_COLORS); + rSet.DisableItem(SID_CONVERT_TO_24BIT); + } + + if(bE3dCompoundObject) + { + rSet.DisableItem( SID_OBJECT_ALIGN_LEFT ); + rSet.DisableItem( SID_OBJECT_ALIGN_CENTER ); + rSet.DisableItem( SID_OBJECT_ALIGN_RIGHT ); + rSet.DisableItem( SID_OBJECT_ALIGN_UP ); + rSet.DisableItem( SID_OBJECT_ALIGN_MIDDLE ); + rSet.DisableItem( SID_OBJECT_ALIGN_DOWN ); + rSet.DisableItem( SID_FRAME_TO_TOP ); + rSet.DisableItem( SID_MOREFRONT ); + rSet.DisableItem( SID_MOREBACK ); + rSet.DisableItem( SID_FRAME_TO_BOTTOM ); + rSet.DisableItem( SID_BEFORE_OBJ ); + rSet.DisableItem( SID_BEHIND_OBJ ); + rSet.DisableItem( SID_REVERSE_ORDER ); + } + } + + if ( !mpDrawView->IsDismantlePossible(FALSE) ) + { + rSet.DisableItem( SID_DISMANTLE ); + } + if ( !mpDrawView->IsDismantlePossible(TRUE) && + !mpDrawView->IsImportMtfPossible() && + !mpDrawView->IsBreak3DObjPossible() ) + { + rSet.DisableItem( SID_BREAK ); + } + if ( !mpDrawView->IsCombinePossible(FALSE) ) + { + rSet.DisableItem( SID_COMBINE ); + rSet.DisableItem(SID_POLY_MERGE); + rSet.DisableItem(SID_POLY_SUBSTRACT); + rSet.DisableItem(SID_POLY_INTERSECT); + } + if ( !mpDrawView->IsCombinePossible(TRUE) ) + { + rSet.DisableItem( SID_CONNECT ); + } + if ( !mpDrawView->IsGroupPossible() ) + { + rSet.DisableItem( SID_GROUP ); + } + if ( !mpDrawView->IsUnGroupPossible() ) + { + rSet.DisableItem( SID_UNGROUP ); + } + } + // kein Objekt selektiert + else + { +// rSet.ClearItem( SID_BEZIER_EDIT ); + + rSet.DisableItem( SID_ENTER_GROUP ); + rSet.DisableItem( SID_CUT ); + rSet.DisableItem( SID_COPY ); + rSet.DisableItem( SID_DELETE ); + rSet.DisableItem( SID_ATTR_TRANSFORM ); + + rSet.DisableItem( SID_OBJECT_ALIGN_LEFT ); + rSet.DisableItem( SID_OBJECT_ALIGN_CENTER ); + rSet.DisableItem( SID_OBJECT_ALIGN_RIGHT ); + rSet.DisableItem( SID_OBJECT_ALIGN_UP ); + rSet.DisableItem( SID_OBJECT_ALIGN_MIDDLE ); + rSet.DisableItem( SID_OBJECT_ALIGN_DOWN ); + + rSet.DisableItem( SID_FRAME_TO_TOP ); + rSet.DisableItem( SID_MOREFRONT ); + rSet.DisableItem( SID_MOREBACK ); + rSet.DisableItem( SID_FRAME_TO_BOTTOM ); + rSet.DisableItem( SID_BEFORE_OBJ ); + rSet.DisableItem( SID_BEHIND_OBJ ); + rSet.DisableItem( SID_CONVERT ); + +// rSet.DisableItem( SID_BEZIER_EDIT ); + rSet.DisableItem( SID_SIZE_OPTIMAL ); + rSet.DisableItem( SID_LINEEND_POLYGON ); + rSet.DisableItem( SID_COPYOBJECTS ); + rSet.DisableItem( SID_HORIZONTAL ); + rSet.DisableItem( SID_VERTICAL ); + rSet.DisableItem( SID_GROUP ); + rSet.DisableItem( SID_UNGROUP ); + rSet.DisableItem( SID_NAME_GROUP ); + + // #i68101# + rSet.DisableItem( SID_OBJECT_TITLE_DESCRIPTION ); + + rSet.DisableItem( SID_DISMANTLE ); + rSet.DisableItem( SID_BREAK ); + rSet.DisableItem( SID_COMBINE ); + rSet.DisableItem(SID_DISTRIBUTE_DLG); + rSet.DisableItem(SID_POLY_MERGE); + rSet.DisableItem(SID_POLY_SUBSTRACT); + rSet.DisableItem(SID_POLY_INTERSECT); + rSet.DisableItem( SID_CONNECT ); + rSet.DisableItem( SID_ANIMATION_EFFECTS ); + rSet.DisableItem( SID_MODIFY_FIELD ); + rSet.DisableItem (SID_OBJECT_SHEAR); + } + +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/drvwshrg.cxx b/sd/source/ui/view/drvwshrg.cxx new file mode 100755 index 000000000000..76590dd45003 --- /dev/null +++ b/sd/source/ui/view/drvwshrg.cxx @@ -0,0 +1,127 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "DrawViewShell.hxx" +#include <sfx2/templdlg.hxx> + +#include <svx/fontwork.hxx> +#include <svx/bmpmask.hxx> +#include <svx/galbrws.hxx> +#include <svx/imapdlg.hxx> +#include <svx/colrctrl.hxx> +#include <sfx2/objface.hxx> +#include <svx/f3dchild.hxx> +#include <svx/tbxcustomshapes.hxx> + +#include <svx/svxids.hrc> +#include <svx/hyprlink.hxx> +#include <svx/hyperdlg.hxx> +#include <avmedia/mediaplayer.hxx> + + +#include "app.hrc" +#include "strings.hrc" +#include "res_bmp.hrc" +#include "glob.hrc" +#include "SpellDialogChildWindow.hxx" +#include "sdresid.hxx" +#include "DrawDocShell.hxx" +#include "GraphicDocShell.hxx" +#include "GraphicViewShell.hxx" +#include "AnimationChildWindow.hxx" +#include "NavigatorChildWindow.hxx" +#include "LayerDialogChildWindow.hxx" + +using namespace sd; +#define DrawViewShell +#include "sdslots.hxx" +#define GraphicViewShell +#include "sdgslots.hxx" + +namespace sd { + +//AF:unused #define TABCONTROL_INITIAL_SIZE 500 + +/************************************************************************* +|* +|* SFX-Slotmap und Standardinterface deklarieren +|* +\************************************************************************/ + + +SFX_IMPL_INTERFACE(DrawViewShell, SfxShell, SdResId(STR_DRAWVIEWSHELL)) +{ + SFX_POPUPMENU_REGISTRATION( SdResId(RID_DRAW_TEXTOBJ_INSIDE_POPUP) ); + SFX_CHILDWINDOW_CONTEXT_REGISTRATION( SID_NAVIGATOR ); + SFX_CHILDWINDOW_REGISTRATION( SfxTemplateDialogWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxFontWorkChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxColorChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( AnimationChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( Svx3DChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxBmpMaskChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( GalleryChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxIMapDlgChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxHyperlinkDlgWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxHlinkDlgWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( ::sd::SpellDialogChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SID_SEARCH_DLG ); + SFX_CHILDWINDOW_REGISTRATION( ::avmedia::MediaPlayer::GetChildWindowId() ); +} + + +TYPEINIT1( DrawViewShell, ViewShell ); + + +// SdGraphicViewShell + + +SFX_IMPL_INTERFACE(GraphicViewShell, SfxShell, SdResId(STR_DRAWVIEWSHELL)) //SOH... +{ + SFX_POPUPMENU_REGISTRATION( SdResId(RID_DRAW_TEXTOBJ_INSIDE_POPUP) ); + SFX_CHILDWINDOW_CONTEXT_REGISTRATION( SID_NAVIGATOR ); + SFX_CHILDWINDOW_REGISTRATION( SID_TASKPANE ); + SFX_CHILDWINDOW_REGISTRATION( SfxTemplateDialogWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxFontWorkChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxColorChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( Svx3DChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxBmpMaskChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( GalleryChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxIMapDlgChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxHyperlinkDlgWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxHlinkDlgWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( ::sd::SpellDialogChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SID_SEARCH_DLG ); + SFX_CHILDWINDOW_REGISTRATION( ::avmedia::MediaPlayer::GetChildWindowId() ); +} + +TYPEINIT1( GraphicViewShell, DrawViewShell ); + + +} // end of namespace sd diff --git a/sd/source/ui/view/frmview.cxx b/sd/source/ui/view/frmview.cxx new file mode 100644 index 000000000000..aca0130624ce --- /dev/null +++ b/sd/source/ui/view/frmview.cxx @@ -0,0 +1,1214 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "FrameView.hxx" + +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <com/sun/star/awt/Rectangle.hpp> +#include <com/sun/star/drawing/framework/ResourceId.hpp> +#include <rtl/ustrbuf.hxx> +#include "unokywds.hxx" + +#include <vector> +#include "ViewShell.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "optsitem.hxx" +#include "ViewShellBase.hxx" +#include "DrawViewShell.hxx" +#include "OutlineViewShell.hxx" +#include "app.hxx" +#include "sdresid.hxx" +#include "pres.hxx" +#include "glob.hrc" +#include "sdiocmpt.hxx" +#include "framework/FrameworkHelper.hxx" +#include <comphelper/processfactory.hxx> +#include <sfx2/viewfrm.hxx> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::std; +using ::rtl::OUString; + +namespace sd { + +/************************************************************************* +|* +|* Ctor +|* +\************************************************************************/ + +FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK */) + : SdrView(pDrawDoc, (OutputDevice*) NULL), + mnRefCount(0), + mnPresViewShellId(SID_VIEWSHELL0), + mnSlotId(SID_OBJECT_SELECT), + mbIsNavigatorShowingAllShapes(false) +{ + EndListening(*pDrawDoc); + + EnableExtendedKeyInputDispatcher(FALSE); + EnableExtendedMouseEventDispatcher(FALSE); + EnableExtendedCommandEventDispatcher(FALSE); + + SetGridFront( FALSE ); + SetHlplFront( FALSE ); + SetOConSnap( FALSE ); + SetFrameDragSingles( TRUE ); + SetSlidesPerRow(4); + + if( NULL == pFrameView ) + { + DrawDocShell* pDocShell = pDrawDoc->GetDocSh(); + + if ( pDocShell ) + { + /********************************************************************** + * Das Dokument wurde geladen, ist eine FrameView vorhanden? + **********************************************************************/ + ULONG nSdViewShellCount = 0; + ViewShellBase* pBase = NULL; + SfxViewShell* pSfxViewSh = NULL; + SfxViewFrame* pSfxViewFrame = SfxViewFrame::GetFirst(pDocShell); + + while (pSfxViewFrame) + { + // Count the FrameViews and remember the type of the main + // view shell. + pSfxViewSh = pSfxViewFrame->GetViewShell(); + pBase = PTR_CAST(ViewShellBase, pSfxViewSh ); + + if (pBase != NULL) + { + nSdViewShellCount++; + + ::rtl::OUString sViewURL; + Reference<drawing::framework::XView> xView ( + framework::FrameworkHelper::Instance(*pBase)->GetView( + drawing::framework::ResourceId::create( + ::comphelper::getProcessComponentContext(), + framework::FrameworkHelper::msCenterPaneURL))); + if (xView.is()) + sViewURL = xView->getResourceId()->getResourceURL(); + + switch (framework::FrameworkHelper::GetViewId(sViewURL)) + { + default: +// case ViewShell::ST_IMPRESS: +// case ViewShell::ST_NOTES: +// case ViewShell::ST_HANDOUT: + mnPresViewShellId = SID_VIEWSHELL0; + break; + + case ViewShell::ST_SLIDE_SORTER: + mnPresViewShellId = SID_VIEWSHELL1; + break; + + case ViewShell::ST_OUTLINE: + mnPresViewShellId = SID_VIEWSHELL2; + break; + } + } + + pSfxViewFrame = SfxViewFrame::GetNext(*pSfxViewFrame, pDocShell); + } + + SdDrawDocument* pDoc = pDocShell->GetDoc(); + pFrameView = pDoc->GetFrameView(nSdViewShellCount); + } + } + + if (pFrameView) + { + /********************************************************************** + * FrameView mit der FrameView der DocShell initialisieren + **********************************************************************/ + SetRuler( pFrameView->HasRuler() ); + SetGridCoarse( pFrameView->GetGridCoarse() ); + SetGridFine( pFrameView->GetGridFine() ); + SetSnapGridWidth(pFrameView->GetSnapGridWidthX(), pFrameView->GetSnapGridWidthY()); + SetGridVisible( pFrameView->IsGridVisible() ); + SetGridFront( pFrameView->IsGridFront() ); + SetSnapAngle( pFrameView->GetSnapAngle() ); + SetGridSnap( pFrameView->IsGridSnap() ); + SetBordSnap( pFrameView->IsBordSnap() ); + SetHlplSnap( pFrameView->IsHlplSnap() ); + SetOFrmSnap( pFrameView->IsOFrmSnap() ); + SetOPntSnap( pFrameView->IsOPntSnap() ); + SetOConSnap( pFrameView->IsOConSnap() ); + SetHlplVisible( pFrameView->IsHlplVisible() ); + SetDragStripes( pFrameView->IsDragStripes() ); + SetPlusHandlesAlwaysVisible( pFrameView->IsPlusHandlesAlwaysVisible() ); + SetFrameDragSingles( pFrameView->IsFrameDragSingles() ); + SetSnapMagneticPixel( pFrameView->GetSnapMagneticPixel() ); + SetMarkedHitMovesAlways( pFrameView->IsMarkedHitMovesAlways() ); + SetMoveOnlyDragging( pFrameView->IsMoveOnlyDragging() ); + SetCrookNoContortion( pFrameView->IsCrookNoContortion() ); + SetSlantButShear( pFrameView->IsSlantButShear() ); + SetNoDragXorPolys( pFrameView->IsNoDragXorPolys() ); + SetAngleSnapEnabled( pFrameView->IsAngleSnapEnabled() ); + SetBigOrtho( pFrameView->IsBigOrtho() ); + SetOrtho( pFrameView->IsOrtho() ); + SetEliminatePolyPointLimitAngle( pFrameView->GetEliminatePolyPointLimitAngle() ); + SetEliminatePolyPoints( pFrameView->IsEliminatePolyPoints() ); +// #110094#-7 +// SetMasterPagePaintCaching( pFrameView->IsMasterPagePaintCaching() ); + SetDesignMode( pFrameView->IsDesignMode() ); + + SetSolidMarkHdl( pFrameView->IsSolidMarkHdl() ); + SetSolidDragging( pFrameView->IsSolidDragging() ); + + maVisibleLayers = pFrameView->GetVisibleLayers(); + maPrintableLayers = pFrameView->GetPrintableLayers(); + maLockedLayers = pFrameView->GetLockedLayers(); + maStandardHelpLines = pFrameView->GetStandardHelpLines(); + maNotesHelpLines = pFrameView->GetNotesHelpLines(); + maHandoutHelpLines = pFrameView->GetHandoutHelpLines(); + SetActiveLayer( pFrameView->GetActiveLayer() ); + mbNoColors = pFrameView->IsNoColors(); + mbNoAttribs = pFrameView->IsNoAttribs() ; + maVisArea = pFrameView->GetVisArea(); + mePageKind = pFrameView->GetPageKind(); + mePageKindOnLoad = pFrameView->GetPageKindOnLoad(); + mnSelectedPage = pFrameView->GetSelectedPage(); + mnSelectedPageOnLoad = pFrameView->GetSelectedPageOnLoad(); + meStandardEditMode = pFrameView->GetViewShEditMode(PK_STANDARD); + meNotesEditMode = pFrameView->GetViewShEditMode(PK_NOTES); + meHandoutEditMode = pFrameView->GetViewShEditMode(PK_HANDOUT); + SetViewShEditModeOnLoad(pFrameView->GetViewShEditModeOnLoad()); + mbLayerMode = pFrameView->IsLayerMode(); + mbQuickEdit = pFrameView->IsQuickEdit(); + + // #i26631# + SetMasterPagePaintCaching( pFrameView->IsMasterPagePaintCaching() ); + + SetDragWithCopy( pFrameView->IsDragWithCopy() ); + mbBigHandles = pFrameView->IsBigHandles(); + mbDoubleClickTextEdit = pFrameView->IsDoubleClickTextEdit(); + mbClickChangeRotation = pFrameView->IsClickChangeRotation(); + mnSlidesPerRow = pFrameView->GetSlidesPerRow(); + mnDrawMode = pFrameView->GetDrawMode(); + mnTabCtrlPercent = pFrameView->GetTabCtrlPercent(); + mbIsNavigatorShowingAllShapes = pFrameView->IsNavigatorShowingAllShapes(); + SetPreviousViewShellType (pFrameView->GetPreviousViewShellType()); + SetViewShellTypeOnLoad (pFrameView->GetViewShellTypeOnLoad()); + } + else + { + /********************************************************************** + * FrameView mit den Applikationsdaten initialisieren + **********************************************************************/ + maVisibleLayers.SetAll(); + maPrintableLayers.SetAll(); + SetGridCoarse( Size( 1000, 1000 ) ); + SetSnapGridWidth(Fraction(1000, 1), Fraction(1000, 1)); + SetActiveLayer( String( SdResId(STR_LAYER_LAYOUT) ) ); + mbNoColors = TRUE; + mbNoAttribs = FALSE; + maVisArea = Rectangle( Point(), Size(0, 0) ); + mePageKind = PK_STANDARD; + mePageKindOnLoad = PK_STANDARD; + mnSelectedPage = 0; + mnSelectedPageOnLoad = 0; + meStandardEditMode = EM_PAGE; + meNotesEditMode = EM_PAGE; + meHandoutEditMode = EM_MASTERPAGE; + SetViewShEditModeOnLoad(EM_PAGE); + mbLayerMode = FALSE; + SetEliminatePolyPoints(FALSE); + mbBigHandles = FALSE; + mbDoubleClickTextEdit = FALSE; + mbClickChangeRotation = FALSE; + mnSlidesPerRow = 4; + + { + bool bUseContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode(); + mnDrawMode = bUseContrast ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR; + } + mnTabCtrlPercent = 0.0; + mbIsNavigatorShowingAllShapes = false; + SetPreviousViewShellType (ViewShell::ST_NONE); + SetViewShellTypeOnLoad (ViewShell::ST_IMPRESS); + + // get default for design mode + sal_Bool bInitDesignMode = pDrawDoc->GetOpenInDesignMode(); + if( pDrawDoc->OpenInDesignModeIsDefaulted() ) + { + bInitDesignMode = sal_True; + } + + SfxObjectShell* pObjShell = pDrawDoc->GetObjectShell(); + if( pObjShell && pObjShell->IsReadOnly() ) + bInitDesignMode = sal_False; + SetDesignMode( bInitDesignMode ); + + Update( SD_MOD()->GetSdOptions(pDrawDoc->GetDocumentType()) ); + } + +} + +/************************************************************************* +|* +|* Dtor +|* +\************************************************************************/ + +FrameView::~FrameView() +{ +} + + +/************************************************************************* +|* +|* Verbindung herstellen +|* +\************************************************************************/ + +void FrameView::Connect() +{ + mnRefCount++; +} + + +/************************************************************************* +|* +|* Verbindung loesen +|* +\************************************************************************/ + +void FrameView::Disconnect() +{ + if (mnRefCount > 0) + { + mnRefCount--; + } + + if (mnRefCount == 0) + { + delete this; + } +} + +/************************************************************************* +|* +|* Update mit Daten der SdOptions +|* +\************************************************************************/ + +void FrameView::Update(SdOptions* pOptions) +{ + if (pOptions) + { + mbRuler = pOptions->IsRulerVisible(); + SetGridVisible( pOptions->IsGridVisible() ); + SetSnapAngle( pOptions->GetAngle() ); + SetGridSnap( pOptions->IsUseGridSnap() ); + SetBordSnap( pOptions->IsSnapBorder() ); + SetHlplSnap( pOptions->IsSnapHelplines() ); + SetOFrmSnap( pOptions->IsSnapFrame() ); + SetOPntSnap( pOptions->IsSnapPoints() ); + SetHlplVisible( pOptions->IsHelplines() ); + SetDragStripes( pOptions->IsDragStripes() ); + SetPlusHandlesAlwaysVisible( pOptions->IsHandlesBezier() ); + SetSnapMagneticPixel( pOptions->GetSnapArea() ); + SetMarkedHitMovesAlways( pOptions->IsMarkedHitMovesAlways() ); + SetMoveOnlyDragging( pOptions->IsMoveOnlyDragging() ); + SetSlantButShear( pOptions->IsMoveOnlyDragging() ); + SetNoDragXorPolys ( !pOptions->IsMoveOutline() ); + SetCrookNoContortion( pOptions->IsCrookNoContortion() ); + SetAngleSnapEnabled( pOptions->IsRotate() ); + SetBigOrtho( pOptions->IsBigOrtho() ); + SetOrtho( pOptions->IsOrtho() ); + SetEliminatePolyPointLimitAngle( pOptions->GetEliminatePolyPointLimitAngle() ); +// #110094#-7 +// SetMasterPagePaintCaching( pOptions->IsMasterPagePaintCaching() ); + GetModel()->SetPickThroughTransparentTextFrames( pOptions->IsPickThrough() ); + + SetSolidMarkHdl( pOptions->IsSolidMarkHdl() ); + SetSolidDragging( pOptions->IsSolidDragging() ); + + SetGridCoarse( Size( pOptions->GetFldDrawX(), pOptions->GetFldDrawY() ) ); + SetGridFine( Size( pOptions->GetFldDivisionX(), pOptions->GetFldDivisionY() ) ); + Fraction aFractX(pOptions->GetFldDrawX(), pOptions->GetFldDrawX() / ( pOptions->GetFldDivisionX() ? pOptions->GetFldDivisionX() : 1 )); + Fraction aFractY(pOptions->GetFldDrawY(), pOptions->GetFldDrawY() / ( pOptions->GetFldDivisionY() ? pOptions->GetFldDivisionY() : 1 )); + SetSnapGridWidth(aFractX, aFractY); + SetQuickEdit(pOptions->IsQuickEdit()); + + // #i26631# + SetMasterPagePaintCaching( pOptions->IsMasterPagePaintCaching() ); + + SetDragWithCopy(pOptions->IsDragWithCopy()); + SetBigHandles( pOptions->IsBigHandles() ); + SetDoubleClickTextEdit( pOptions->IsDoubleClickTextEdit() ); + SetClickChangeRotation( pOptions->IsClickChangeRotation() ); + } +} + + +/************************************************************************* +|* +|* EditMode (Page oder MasterPage) des Arbeitsmodus setzen +|* +\************************************************************************/ + +void FrameView::SetViewShEditMode(EditMode eMode, PageKind eKind) +{ + if (eKind == PK_STANDARD) + { + meStandardEditMode = eMode; + } + else if (eKind == PK_NOTES) + { + meNotesEditMode = eMode; + } + else if (eKind == PK_HANDOUT) + { + meHandoutEditMode = eMode; + } +} + + +/************************************************************************* +|* +|* EditMode (Page oder MasterPage) des Arbeitsmodus zurueckgeben +|* +\************************************************************************/ + +EditMode FrameView::GetViewShEditMode(PageKind eKind) +{ + EditMode eMode = EM_PAGE; + + if (eKind == PK_STANDARD) + { + eMode = meStandardEditMode; + } + else if (eKind == PK_NOTES) + { + eMode = meNotesEditMode; + } + else if (eKind == PK_HANDOUT) + { + eMode = meHandoutEditMode; + } + + return (eMode); +} + + + + +void FrameView::SetViewShEditModeOnLoad (EditMode eMode) +{ + meEditModeOnLoad = eMode; +} + + + + +EditMode FrameView::GetViewShEditModeOnLoad (void) const +{ + return meEditModeOnLoad; +} + + + + +static OUString createHelpLinesString( const SdrHelpLineList& rHelpLines ) +{ + ::rtl::OUStringBuffer aLines; + + const USHORT nCount = rHelpLines.GetCount(); + for( USHORT nHlpLine = 0; nHlpLine < nCount; nHlpLine++ ) + { + const SdrHelpLine& rHelpLine = rHelpLines[nHlpLine]; + const Point& rPos = rHelpLine.GetPos(); + + switch( rHelpLine.GetKind() ) + { + case SDRHELPLINE_POINT: + aLines.append( (sal_Unicode)'P' ); + aLines.append( (sal_Int32)rPos.X() ); + aLines.append( (sal_Unicode)',' ); + aLines.append( (sal_Int32)rPos.Y() ); + break; + case SDRHELPLINE_VERTICAL: + aLines.append( (sal_Unicode)'V' ); + aLines.append( (sal_Int32)rPos.X() ); + break; + case SDRHELPLINE_HORIZONTAL: + aLines.append( (sal_Unicode)'H' ); + aLines.append( (sal_Int32)rPos.Y() ); + break; + default: + DBG_ERROR( "Unsupported helpline Kind!" ); + } + } + + return aLines.makeStringAndClear(); +} + +#define addValue( n, v ) push_back( std::pair< OUString, Any >( OUString( RTL_CONSTASCII_USTRINGPARAM( n ) ), v ) ) +void FrameView::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rValues, sal_Bool ) +{ + std::vector< std::pair< OUString, Any > > aUserData; + + aUserData.addValue( sUNO_View_GridIsVisible, makeAny( (sal_Bool)IsGridVisible() ) ); + aUserData.addValue( sUNO_View_GridIsFront, makeAny( (sal_Bool)IsGridFront() ) ); + aUserData.addValue( sUNO_View_IsSnapToGrid, makeAny( (sal_Bool)IsGridSnap() ) ); + aUserData.addValue( sUNO_View_IsSnapToPageMargins, makeAny( (sal_Bool)IsBordSnap() ) ); + aUserData.addValue( sUNO_View_IsSnapToSnapLines, makeAny( (sal_Bool)IsHlplSnap() ) ); + aUserData.addValue( sUNO_View_IsSnapToObjectFrame, makeAny( (sal_Bool)IsOFrmSnap() ) ); + aUserData.addValue( sUNO_View_IsSnapToObjectPoints, makeAny( (sal_Bool)IsOPntSnap() ) ); + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsSnapLinesVisible ) ); +// pValue->Value <<= (sal_Bool)IsHlplVisible(); +// pValue++;nIndex++; + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsDragStripes ) ); +// pValue->Value <<= (sal_Bool)IsDragStripes(); +// pValue++;nIndex++; + + aUserData.addValue( sUNO_View_IsPlusHandlesAlwaysVisible, makeAny( (sal_Bool)IsPlusHandlesAlwaysVisible() ) ); + aUserData.addValue( sUNO_View_IsFrameDragSingles, makeAny( (sal_Bool)IsFrameDragSingles() ) ); + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsMarkedHitMovesAlways ) ); +// pValue->Value <<= (sal_Bool)IsMarkedHitMovesAlways(); +// pValue++;nIndex++; + + aUserData.addValue( sUNO_View_EliminatePolyPointLimitAngle, makeAny( (sal_Int32)GetEliminatePolyPointLimitAngle() ) ); + aUserData.addValue( sUNO_View_IsEliminatePolyPoints, makeAny( (sal_Bool)IsEliminatePolyPoints() ) ); + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsLineDraft ) ); +// pValue->Value <<= (sal_Bool)IsLineDraft(); +// pValue++;nIndex++; + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsFillDraft ) ); +// pValue->Value <<= (sal_Bool)IsFillDraft(); +// pValue++;nIndex++; + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsTextDraft ) ); +// pValue->Value <<= (sal_Bool)IsTextDraft(); +// pValue++;nIndex++; + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsGrafDraft ) ); +// pValue->Value <<= (sal_Bool)IsGrafDraft(); +// pValue++;nIndex++; + + Any aAny; + GetVisibleLayers().QueryValue( aAny ); + aUserData.addValue( sUNO_View_VisibleLayers, aAny ); + + GetPrintableLayers().QueryValue( aAny ); + aUserData.addValue( sUNO_View_PrintableLayers, aAny ); + + GetLockedLayers().QueryValue( aAny ); + aUserData.addValue( sUNO_View_LockedLayers, aAny ); + + aUserData.addValue( sUNO_View_NoAttribs, makeAny( (sal_Bool)IsNoAttribs() ) ); + aUserData.addValue( sUNO_View_NoColors, makeAny( (sal_Bool)IsNoColors() ) ); + + if( GetStandardHelpLines().GetCount() ) + aUserData.addValue( sUNO_View_SnapLinesDrawing, makeAny( createHelpLinesString( GetStandardHelpLines() ) ) ); + + if( GetNotesHelpLines().GetCount() ) + aUserData.addValue( sUNO_View_SnapLinesNotes, makeAny( createHelpLinesString( GetNotesHelpLines() ) ) ); + + if( GetHandoutHelpLines().GetCount() ) + aUserData.addValue( sUNO_View_SnapLinesHandout, makeAny( createHelpLinesString( GetHandoutHelpLines() ) ) ); + + aUserData.addValue( sUNO_View_RulerIsVisible, makeAny( (sal_Bool)HasRuler() ) ); + aUserData.addValue( sUNO_View_PageKind, makeAny( (sal_Int16)GetPageKind() ) ); + aUserData.addValue( sUNO_View_SelectedPage, makeAny( (sal_Int16)GetSelectedPage() ) ); + aUserData.addValue( sUNO_View_IsLayerMode, makeAny( (sal_Bool)IsLayerMode() ) ); + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsQuickEdit ) ); +// pValue->Value <<= (sal_Bool)IsQuickEdit(); +// pValue++;nIndex++; + + aUserData.addValue( sUNO_View_IsBigHandles, makeAny( (sal_Bool)IsBigHandles() ) ); + aUserData.addValue( sUNO_View_IsDoubleClickTextEdit, makeAny( (sal_Bool)IsDoubleClickTextEdit() ) ); + aUserData.addValue( sUNO_View_IsClickChangeRotation, makeAny( (sal_Bool)IsClickChangeRotation() ) ); + +// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsDragWithCopy ) ); +// pValue->Value <<= (sal_Bool)IsDragWithCopy(); +// pValue++;nIndex++; + + aUserData.addValue( sUNO_View_SlidesPerRow, makeAny( (sal_Int16)GetSlidesPerRow() ) ); +/* #107128# Product managment decided to not make this persistent + aUserData.addValue( sUNO_View_DrawMode, makeAny( (sal_Int32)GetDrawMode() ) ); + aUserData.addValue( sUNO_View_PreviewDrawMode, makeAny( (sal_Int32)GetPreviewDrawMode() ) ); +*/ + aUserData.addValue( sUNO_View_EditModeStandard, makeAny( (sal_Int32)GetViewShEditMode( PK_STANDARD ) ) ); + aUserData.addValue( sUNO_View_EditModeNotes, makeAny( (sal_Int32)GetViewShEditMode( PK_NOTES ) ) ); + aUserData.addValue( sUNO_View_EditModeHandout, makeAny( (sal_Int32)GetViewShEditMode( PK_HANDOUT ) ) ); + + { + const Rectangle aVisArea = GetVisArea(); + + aUserData.addValue( sUNO_View_VisibleAreaTop, makeAny( (sal_Int32)aVisArea.Top() ) ); + aUserData.addValue( sUNO_View_VisibleAreaLeft, makeAny( (sal_Int32)aVisArea.Left() ) ); + aUserData.addValue( sUNO_View_VisibleAreaWidth, makeAny( (sal_Int32)aVisArea.GetWidth() ) ); + aUserData.addValue( sUNO_View_VisibleAreaHeight, makeAny( (sal_Int32)aVisArea.GetHeight() ) ); + } + + aUserData.addValue( sUNO_View_GridCoarseWidth, makeAny( (sal_Int32)GetGridCoarse().Width() ) ); + aUserData.addValue( sUNO_View_GridCoarseHeight, makeAny( (sal_Int32)GetGridCoarse().Height() ) ); + aUserData.addValue( sUNO_View_GridFineWidth, makeAny( (sal_Int32)GetGridFine().Width() ) ); + aUserData.addValue( sUNO_View_GridFineHeight, makeAny( (sal_Int32)GetGridFine().Height() ) ); + aUserData.addValue( sUNO_View_GridSnapWidthXNumerator, makeAny( (sal_Int32)GetSnapGridWidthX().GetNumerator() ) ); + aUserData.addValue( sUNO_View_GridSnapWidthXDenominator, makeAny( (sal_Int32)GetSnapGridWidthX().GetDenominator() ) ); + aUserData.addValue( sUNO_View_GridSnapWidthYNumerator, makeAny( (sal_Int32)GetSnapGridWidthY().GetNumerator() ) ); + aUserData.addValue( sUNO_View_GridSnapWidthYDenominator, makeAny( (sal_Int32)GetSnapGridWidthY().GetDenominator() ) ); + aUserData.addValue( sUNO_View_IsAngleSnapEnabled, makeAny( (sal_Bool)IsAngleSnapEnabled() ) ); + aUserData.addValue( sUNO_View_SnapAngle, makeAny( (sal_Int32)GetSnapAngle() ) ); + + const sal_Int32 nOldLength = rValues.getLength(); + rValues.realloc( nOldLength + aUserData.size() ); + + PropertyValue* pValue = &(rValues.getArray()[nOldLength]); + + std::vector< std::pair< OUString, Any > >::iterator aIter( aUserData.begin() ); + for( ; aIter != aUserData.end(); aIter++, pValue++ ) + { + pValue->Name = (*aIter).first; + pValue->Value = (*aIter).second; + } +} +#undef addValue + +static void createHelpLinesFromString( const rtl::OUString& rLines, SdrHelpLineList& rHelpLines ) +{ + const sal_Unicode * pStr = rLines.getStr(); + SdrHelpLine aNewHelpLine; + rtl::OUStringBuffer sBuffer; + + while( *pStr ) + { + Point aPoint; + + switch( *pStr ) + { + case (sal_Unicode)'P': + aNewHelpLine.SetKind( SDRHELPLINE_POINT ); + break; + case (sal_Unicode)'V': + aNewHelpLine.SetKind( SDRHELPLINE_VERTICAL ); + break; + case (sal_Unicode)'H': + aNewHelpLine.SetKind( SDRHELPLINE_HORIZONTAL ); + break; + default: + DBG_ERROR( "syntax error in snap lines settings string" ); + return; + } + + pStr++; + + while( (*pStr >= sal_Unicode('0') && *pStr <= sal_Unicode('9')) || (*pStr == '+') || (*pStr == '-') ) + { + sBuffer.append( *pStr++ ); + } + + sal_Int32 nValue = sBuffer.makeStringAndClear().toInt32(); + + if( aNewHelpLine.GetKind() == SDRHELPLINE_HORIZONTAL ) + { + aPoint.Y() = nValue; + } + else + { + aPoint.X() = nValue; + + if( aNewHelpLine.GetKind() == SDRHELPLINE_POINT ) + { + if( *pStr++ != ',' ) + return; + + while( (*pStr >= sal_Unicode('0') && *pStr <= sal_Unicode('9')) || (*pStr == '+') || (*pStr == '-') ) + { + sBuffer.append( *pStr++ ); + } + + aPoint.Y() = sBuffer.makeStringAndClear().toInt32(); + + } + } + + aNewHelpLine.SetPos( aPoint ); + rHelpLines.Insert( aNewHelpLine ); + } +} + +void FrameView::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool ) +{ + const sal_Int32 nLength = rSequence.getLength(); + if (nLength) + { + const bool bImpress = dynamic_cast< SdDrawDocument* >(GetModel())->GetDocumentType() == DOCUMENT_TYPE_IMPRESS; + + sal_Bool bBool = sal_False; + sal_Int32 nInt32 = 0; + sal_Int16 nInt16 = 0; + rtl::OUString aString; + + sal_Int32 aSnapGridWidthXNum = GetSnapGridWidthX().GetNumerator(); + sal_Int32 aSnapGridWidthXDom = GetSnapGridWidthX().GetDenominator(); + + sal_Int32 aSnapGridWidthYNum = GetSnapGridWidthY().GetNumerator(); + sal_Int32 aSnapGridWidthYDom = GetSnapGridWidthY().GetDenominator(); + + EditMode eStandardEditMode; + EditMode eNotesEditMode; + EditMode eHandoutEditMode; + + const com::sun::star::beans::PropertyValue *pValue = rSequence.getConstArray(); + for (sal_Int16 i = 0 ; i < nLength; i++, pValue++ ) + { + if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_ViewId ) ) ) + { + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesDrawing ) ) ) + { + if( pValue->Value >>= aString ) + { + SdrHelpLineList aHelpLines; + createHelpLinesFromString( aString, aHelpLines ); + SetStandardHelpLines( aHelpLines ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesNotes ) ) ) + { + if( pValue->Value >>= aString ) + { + SdrHelpLineList aHelpLines; + createHelpLinesFromString( aString, aHelpLines ); + SetNotesHelpLines( aHelpLines ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesHandout ) ) ) + { + if( pValue->Value >>= aString ) + { + SdrHelpLineList aHelpLines; + createHelpLinesFromString( aString, aHelpLines ); + SetHandoutHelpLines( aHelpLines ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_RulerIsVisible ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetRuler( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PageKind ) ) ) + { + if( pValue->Value >>= nInt16 ) + { + SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() ); + if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) ) + SetPageKind( (PageKind)nInt16 ); + + SetPageKindOnLoad( (PageKind)nInt16 ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SelectedPage ) ) ) + { + if( pValue->Value >>= nInt16 ) + { + SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() ); + if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) ) + SetSelectedPage( (USHORT)nInt16 ); + + SetSelectedPageOnLoad( (USHORT)nInt16 ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsLayerMode ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetLayerMode( bBool ); + } + } +/* else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsQuickEdit ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetQuickEdit( bBool ); + } + } +*/ else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsBigHandles ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetBigHandles( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDoubleClickTextEdit ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetDoubleClickTextEdit( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsClickChangeRotation ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetClickChangeRotation( bBool ); + } + } +/* else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDragWithCopy ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetDragWithCopy( bBool ); + } + } +*/ else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SlidesPerRow ) ) ) + { + if( pValue->Value >>= nInt16 ) + { + SetSlidesPerRow( (USHORT)nInt16 ); + } + } +/* #107128# Product managment decided to not make this persistent + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_DrawMode ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + if( rStyleSettings.GetHighContrastMode() ) + continue; + SetDrawMode( (ULONG)nInt32 ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PreviewDrawMode ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + SvtAccessibilityOptions aAccOptions; + if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() ) + continue; + SetPreviewDrawMode( (ULONG)nInt32 ); + } + } +*/ + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeStandard ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() ); + if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) ) + SetViewShEditMode( (EditMode)nInt32, PK_STANDARD ); + eStandardEditMode = (EditMode)nInt32; + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeNotes ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() ); + if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) ) + SetViewShEditMode( (EditMode)nInt32, PK_NOTES ); + eNotesEditMode = (EditMode)nInt32; + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeHandout ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() ); + if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) ) + SetViewShEditMode( (EditMode)nInt32, PK_HANDOUT ); + eHandoutEditMode = (EditMode)nInt32; + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaTop ) ) ) + { + sal_Int32 nTop = 0; + if( pValue->Value >>= nTop ) + { + Rectangle aVisArea( GetVisArea() ); + aVisArea.nBottom += nTop - aVisArea.nTop; + aVisArea.nTop = nTop; + SetVisArea( aVisArea ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaLeft ) ) ) + { + sal_Int32 nLeft = 0; + if( pValue->Value >>= nLeft ) + { + Rectangle aVisArea( GetVisArea() ); + aVisArea.nRight += nLeft - aVisArea.nLeft; + aVisArea.nLeft = nLeft; + SetVisArea( aVisArea ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaWidth ) ) ) + { + sal_Int32 nWidth = 0; + if( pValue->Value >>= nWidth ) + { + Rectangle aVisArea( GetVisArea() ); + aVisArea.nRight = aVisArea.nLeft + nWidth - 1; + SetVisArea( aVisArea ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaHeight ) ) ) + { + sal_Int32 nHeight = 0; + if( pValue->Value >>= nHeight ) + { + Rectangle aVisArea( GetVisArea() ); + aVisArea.nBottom = nHeight + aVisArea.nTop - 1; + SetVisArea( aVisArea ); + } + } + + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridIsVisible ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetGridVisible( bBool ); + } + } + + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToGrid ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetGridSnap( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridIsFront ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetGridFront( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToPageMargins ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetBordSnap( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToSnapLines ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetHlplSnap( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToObjectFrame ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetOFrmSnap( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToObjectPoints ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetOPntSnap( bBool ); + } + } +/* else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapLinesVisible ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetHlplVisible( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDragStripes ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetDragStripes( bBool ); + } + } +*/ else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsPlusHandlesAlwaysVisible ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetPlusHandlesAlwaysVisible( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsFrameDragSingles ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetFrameDragSingles( bBool ); + } + } +/* else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsMarkedHitMovesAlways ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetMarkedHitMovesAlways( bBool ); + } + } +*/ else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EliminatePolyPointLimitAngle ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + SetEliminatePolyPointLimitAngle( nInt32 ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsEliminatePolyPoints ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetEliminatePolyPoints( bBool ); + } + } +/* + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsLineDraft ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetLineDraft( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsFillDraft ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetFillDraft( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsTextDraft ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetTextDraft( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsGrafDraft ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetGrafDraft( bBool ); + } + } +*/ + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_ActiveLayer ) ) ) + { + if( pValue->Value >>= aString ) + { + SetActiveLayer( aString ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_NoAttribs ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetNoAttribs( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_NoColors ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetNoColors( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridCoarseWidth ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + const Size aCoarse( nInt32, GetGridCoarse().Height() ); + SetGridCoarse( aCoarse ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridCoarseHeight ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + const Size aCoarse( GetGridCoarse().Width(), nInt32 ); + SetGridCoarse( aCoarse ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridFineWidth ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + const Size aCoarse( nInt32, GetGridFine().Height() ); + SetGridFine( aCoarse ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridFineHeight ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + const Size aCoarse( GetGridFine().Width(), nInt32 ); + SetGridFine( aCoarse ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsAngleSnapEnabled ) ) ) + { + if( pValue->Value >>= bBool ) + { + SetAngleSnapEnabled( bBool ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapAngle ) ) ) + { + if( pValue->Value >>= nInt32 ) + { + SetSnapAngle( nInt32 ); + } + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthXNumerator ) ) ) + { + pValue->Value >>= aSnapGridWidthXNum; + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthXDenominator ) ) ) + { + pValue->Value >>= aSnapGridWidthXDom; + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthYNumerator ) ) ) + { + pValue->Value >>= aSnapGridWidthYNum; + } + else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthYDenominator ) ) ) + { + pValue->Value >>= aSnapGridWidthYDom; + } + else if (!bImpress && pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleLayers ) ) ) + { + SetOfByte aSetOfBytes; + aSetOfBytes.PutValue( pValue->Value ); + SetVisibleLayers( aSetOfBytes ); + } + else if (!bImpress && pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PrintableLayers ) ) ) + { + SetOfByte aSetOfBytes; + aSetOfBytes.PutValue( pValue->Value ); + SetPrintableLayers( aSetOfBytes ); + } + else if (!bImpress && pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_LockedLayers ) ) ) + { + SetOfByte aSetOfBytes; + aSetOfBytes.PutValue( pValue->Value ); + SetLockedLayers( aSetOfBytes ); + } + } + + switch (GetPageKindOnLoad()) + { + case PK_STANDARD: SetViewShEditModeOnLoad(meStandardEditMode); break; + case PK_NOTES: SetViewShEditModeOnLoad(meNotesEditMode); break; + case PK_HANDOUT: SetViewShEditModeOnLoad(meHandoutEditMode); break; + default: SetViewShEditModeOnLoad(EM_PAGE); break; + } + + const Fraction aSnapGridWidthX( aSnapGridWidthXNum, aSnapGridWidthXDom ); + const Fraction aSnapGridWidthY( aSnapGridWidthYNum, aSnapGridWidthYDom ); + + SetSnapGridWidth( aSnapGridWidthX, aSnapGridWidthY ); + } +} + + + + +void FrameView::SetPreviousViewShellType (ViewShell::ShellType eType) +{ + mePreviousViewShellType = eType; +} + + + + +ViewShell::ShellType FrameView::GetPreviousViewShellType (void) const +{ + return mePreviousViewShellType; +} + + + + +void FrameView::SetViewShellTypeOnLoad (ViewShell::ShellType eType) +{ + meViewShellTypeOnLoad = eType; +} + + + + +ViewShell::ShellType FrameView::GetViewShellTypeOnLoad (void) const +{ + return meViewShellTypeOnLoad; +} + + + + +void FrameView::SetSelectedPage(USHORT nPage) +{ + mnSelectedPage = nPage; +} + + + + +USHORT FrameView::GetSelectedPage (void) const +{ + return mnSelectedPage; +} + + + + +void FrameView::SetIsNavigatorShowingAllShapes (const bool bIsNavigatorShowingAllShapes) +{ + mbIsNavigatorShowingAllShapes = bIsNavigatorShowingAllShapes; +} + + + + +bool FrameView::IsNavigatorShowingAllShapes (void) const +{ + return mbIsNavigatorShowingAllShapes; +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/grviewsh.cxx b/sd/source/ui/view/grviewsh.cxx new file mode 100755 index 000000000000..646a437c42bf --- /dev/null +++ b/sd/source/ui/view/grviewsh.cxx @@ -0,0 +1,156 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "GraphicViewShell.hxx" +#include "LayerTabBar.hxx" +#include "FrameView.hxx" +#include <sfx2/objsh.hxx> +#include <sfx2/viewfrm.hxx> +#include <vcl/scrbar.hxx> +#include <vcl/salbtype.hxx> // FRound + +namespace sd { + +static const int TABCONTROL_INITIAL_SIZE = 350; + +/************************************************************************* +|* +|* Standard-Konstruktor +|* +\************************************************************************/ + +GraphicViewShell::GraphicViewShell ( + SfxViewFrame* pFrame, + ViewShellBase& rViewShellBase, + ::Window* pParentWindow, + FrameView* pFrameView) + : DrawViewShell ( + pFrame, + rViewShellBase, + pParentWindow, + PK_STANDARD, + pFrameView) +{ + ConstructGraphicViewShell(); +} + +GraphicViewShell::~GraphicViewShell (void) +{ +} + + + + +void GraphicViewShell::ConstructGraphicViewShell(void) +{ + meShellType = ST_DRAW; + + mpLayerTabBar.reset (new LayerTabBar(this,GetParentWindow())); + mpLayerTabBar->SetSplitHdl(LINK(this,GraphicViewShell,TabBarSplitHandler)); + + // pb: #i67363# no layer tabbar on preview mode + if ( !GetObjectShell()->IsPreview() ) + mpLayerTabBar->Show(); +} + + + + +void GraphicViewShell::ChangeEditMode ( + EditMode eMode, + bool ) +{ + // There is no page tab that could be shown instead of the layer tab. + // Therefore we have it allways visible regardless of what the caller + // said. (We have to change the callers behaviour, of course.) + DrawViewShell::ChangeEditMode (eMode, true); +} + + + + +void GraphicViewShell::ArrangeGUIElements (void) +{ + if (mpLayerTabBar.get()!=NULL && mpLayerTabBar->IsVisible()) + { + Size aSize = mpLayerTabBar->GetSizePixel(); + const Size aFrameSize ( + GetViewFrame()->GetWindow().GetOutputSizePixel()); + + if (aSize.Width() == 0) + { + if (mpFrameView->GetTabCtrlPercent() == 0.0) + aSize.Width() = TABCONTROL_INITIAL_SIZE; + else + aSize.Width() = FRound(aFrameSize.Width() + * mpFrameView->GetTabCtrlPercent()); + } + aSize.Height() = GetParentWindow()->GetSettings().GetStyleSettings() + .GetScrollBarSize(); + + Point aPos (0, maViewSize.Height() - aSize.Height()); + + mpLayerTabBar->SetPosSizePixel (aPos, aSize); + + if (aFrameSize.Width() > 0) + mpFrameView->SetTabCtrlPercent ( + (double) maTabControl.GetSizePixel().Width() + / aFrameSize.Width()); + else + mpFrameView->SetTabCtrlPercent( 0.0 ); + } + + DrawViewShell::ArrangeGUIElements(); +} + + + + +IMPL_LINK(GraphicViewShell, TabBarSplitHandler, TabBar*, pTabBar) +{ + const long int nMax = maViewSize.Width() + - maScrBarWH.Width() + - pTabBar->GetPosPixel().X(); + + Size aTabSize = pTabBar->GetSizePixel(); + aTabSize.Width() = Min(pTabBar->GetSplitSize(), (long)(nMax-1)); + + pTabBar->SetSizePixel (aTabSize); + + Point aPos = pTabBar->GetPosPixel(); + aPos.X() += aTabSize.Width(); + + Size aScrSize (nMax - aTabSize.Width(), maScrBarWH.Height()); + mpHorizontalScrollBar->SetPosSizePixel(aPos, aScrSize); + + return 0; +} + +} // end of namespace sd diff --git a/sd/source/ui/view/makefile.mk b/sd/source/ui/view/makefile.mk new file mode 100644 index 000000000000..0ee8280d3fad --- /dev/null +++ b/sd/source/ui/view/makefile.mk @@ -0,0 +1,123 @@ +#************************************************************************* +# +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# 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. +# +#************************************************************************* + + +PRJ=..$/..$/.. + +PROJECTPCH=sd +PROJECTPCHSOURCE=$(PRJ)$/util$/sd +PRJNAME=sd +TARGET=view + +AUTOSEG=true +PRJINC=..$/slidesorter +ENABLE_EXCEPTIONS=TRUE + +# --- Settings ----------------------------------------------------- + +.INCLUDE : settings.mk +.INCLUDE : $(PRJ)$/util$/makefile.pmk + +# --- Files -------------------------------------------------------- + +SRS1NAME=$(TARGET) +SRC1FILES = \ + DocumentRenderer.src + +SLOFILES = \ + $(SLO)$/sdview.obj \ + $(SLO)$/sdview2.obj \ + $(SLO)$/sdview3.obj \ + $(SLO)$/sdview4.obj \ + $(SLO)$/sdview5.obj \ + $(SLO)$/viewshel.obj \ + $(SLO)$/viewshe2.obj \ + $(SLO)$/viewshe3.obj \ + $(SLO)$/sdwindow.obj \ + $(SLO)$/drviewsh.obj \ + $(SLO)$/drviews1.obj \ + $(SLO)$/drviews2.obj \ + $(SLO)$/drviews3.obj \ + $(SLO)$/drviews4.obj \ + $(SLO)$/drviews5.obj \ + $(SLO)$/drviews6.obj \ + $(SLO)$/drviews7.obj \ + $(SLO)$/drviews8.obj \ + $(SLO)$/drviews9.obj \ + $(SLO)$/drviewsa.obj \ + $(SLO)$/drviewsb.obj \ + $(SLO)$/drviewsc.obj \ + $(SLO)$/drviewsd.obj \ + $(SLO)$/drviewse.obj \ + $(SLO)$/drviewsf.obj \ + $(SLO)$/drviewsg.obj \ + $(SLO)$/drviewsi.obj \ + $(SLO)$/drviewsj.obj \ + $(SLO)$/drvwshrg.obj \ + $(SLO)$/drawview.obj \ + $(SLO)$/grviewsh.obj \ + $(SLO)$/outlnvsh.obj \ + $(SLO)$/outlnvs2.obj \ + $(SLO)$/presvish.obj \ + $(SLO)$/outlview.obj \ + $(SLO)$/tabcontr.obj \ + $(SLO)$/bmcache.obj \ + $(SLO)$/drbezob.obj \ + $(SLO)$/drtxtob.obj \ + $(SLO)$/drtxtob1.obj \ + $(SLO)$/sdruler.obj \ + $(SLO)$/frmview.obj \ + $(SLO)$/clview.obj \ + $(SLO)$/zoomlist.obj \ + $(SLO)$/unmodpg.obj \ + $(SLO)$/DocumentRenderer.obj \ + $(SLO)$/FormShellManager.obj \ + $(SLO)$/GraphicObjectBar.obj \ + $(SLO)$/GraphicViewShellBase.obj \ + $(SLO)$/ImpressViewShellBase.obj \ + $(SLO)$/MediaObjectBar.obj \ + $(SLO)$/Outliner.obj \ + $(SLO)$/OutlinerIterator.obj \ + $(SLO)$/OutlineViewShellBase.obj \ + $(SLO)$/SlideSorterViewShellBase.obj \ + $(SLO)$/PresentationViewShellBase.obj \ + $(SLO)$/ToolBarManager.obj \ + $(SLO)$/UpdateLockManager.obj \ + $(SLO)$/ViewClipboard.obj \ + $(SLO)$/ViewShellBase.obj \ + $(SLO)$/ViewShellImplementation.obj \ + $(SLO)$/ViewShellManager.obj \ + $(SLO)$/ViewShellHint.obj \ + $(SLO)$/ViewTabBar.obj \ + $(SLO)$/WindowUpdater.obj \ + $(SLO)$/viewoverlaymanager.obj + + +# --- Tagets ------------------------------------------------------- + +.INCLUDE : target.mk + diff --git a/sd/source/ui/view/outlnvs2.cxx b/sd/source/ui/view/outlnvs2.cxx new file mode 100755 index 000000000000..2acf143ff0b3 --- /dev/null +++ b/sd/source/ui/view/outlnvs2.cxx @@ -0,0 +1,648 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "OutlineViewShell.hxx" + +#include <com/sun/star/presentation/XPresentation2.hpp> + +#include "app.hrc" +#include <svx/hlnkitem.hxx> +#include <sfx2/docfile.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/request.hxx> +#include <svl/eitem.hxx> +#ifndef _ZOOMITEM_HXX //autogen +#include <svx/zoomitem.hxx> +#endif +#include <vcl/msgbox.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/flditem.hxx> +#include <editeng/editstat.hxx> +#include "optsitem.hxx" +#include <unotools/useroptions.hxx> + +#include <sfx2/viewfrm.hxx> +#include "Outliner.hxx" +#include "Window.hxx" +#include "OutlineViewShell.hxx" +#include "fubullet.hxx" +#include "fuolbull.hxx" +#include "FrameView.hxx" +#include "fuzoom.hxx" +#include "fuscale.hxx" +#include "fuchar.hxx" +#include "fuinsfil.hxx" +#include "fuprobjs.hxx" +#include "futhes.hxx" +#include "futempl.hxx" +#include "fusldlg.hxx" +#include "zoomlist.hxx" +#include "fuexpand.hxx" +#include "fusumry.hxx" +#include "fucushow.hxx" +#include "drawdoc.hxx" +#include "sdattr.hxx" +#include "ViewShellBase.hxx" +#include "sdabstdlg.hxx" +#include "framework/FrameworkHelper.hxx" +#include "DrawViewShell.hxx" + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::presentation; + +namespace sd { + + +/************************************************************************/ + +/************************************************************************* +|* +|* SfxRequests fuer temporaere Funktionen +|* +\************************************************************************/ + +void OutlineViewShell::FuTemporary(SfxRequest &rReq) +{ + DeactivateCurrentFunction(); + + OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() ); + USHORT nSId = rReq.GetSlot(); + + switch( nSId ) + { + case SID_ATTR_ZOOM: + { + const SfxItemSet* pArgs = rReq.GetArgs(); + + if ( pArgs ) + { + SvxZoomType eZT = ( ( const SvxZoomItem& ) pArgs-> + Get( SID_ATTR_ZOOM ) ).GetType(); + switch( eZT ) + { + case SVX_ZOOM_PERCENT: + SetZoom( (long) ( ( const SvxZoomItem& ) pArgs-> + Get( SID_ATTR_ZOOM ) ).GetValue() ); + Invalidate( SID_ATTR_ZOOM ); + Invalidate( SID_ATTR_ZOOMSLIDER ); + break; + default: + break; + } + rReq.Done(); + } + else + { + // hier den Zoom-Dialog oeffnen + SetCurrentFunction( FuScale::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + } + Cancel(); + } + break; + + case SID_ATTR_ZOOMSLIDER: + { + const SfxItemSet* pArgs = rReq.GetArgs(); + + if (pArgs && pArgs->Count () == 1 ) + { + SFX_REQUEST_ARG (rReq, pScale, SfxUInt16Item, SID_ATTR_ZOOMSLIDER, FALSE); + if (CHECK_RANGE (5, pScale->GetValue (), 3000)) + { + SetZoom (pScale->GetValue ()); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_ATTR_ZOOM ); + rBindings.Invalidate( SID_ZOOM_IN ); + rBindings.Invalidate( SID_ZOOM_OUT ); + rBindings.Invalidate( SID_ATTR_ZOOMSLIDER ); + + } + } + + Cancel(); + rReq.Done (); + break; + } + + case SID_ZOOM_OUT: + { + SetCurrentFunction( FuZoom::Create(this, GetActiveWindow(), pOlView, GetDoc(), rReq) ); + // Beendet sich selbst, kein Cancel() notwendig! + rReq.Done(); + } + break; + + case SID_SIZE_REAL: + { + SetZoom( 100 ); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), + GetActiveWindow()->GetOutputSizePixel()) ); + mpZoomList->InsertZoomRect(aVisAreaWin); + Invalidate( SID_ATTR_ZOOM ); + Invalidate( SID_ATTR_ZOOMSLIDER ); + Cancel(); + rReq.Done(); + } + break; + + case SID_ZOOM_IN: + { + SetZoom( Max( (long) ( GetActiveWindow()->GetZoom() / 2 ), (long) GetActiveWindow()->GetMinZoom() ) ); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), + GetActiveWindow()->GetOutputSizePixel()) ); + mpZoomList->InsertZoomRect(aVisAreaWin); + Invalidate( SID_ATTR_ZOOM ); + Invalidate( SID_ZOOM_OUT); + Invalidate( SID_ZOOM_IN ); + Invalidate( SID_ATTR_ZOOMSLIDER ); + Cancel(); + rReq.Done(); + } + break; + + case SID_OUTLINE_COLLAPSE_ALL: + { + pOutlinerView->CollapseAll(); + Cancel(); + rReq.Done(); + } + break; + + case SID_OUTLINE_COLLAPSE: + { + pOutlinerView->Collapse(); + Cancel(); + rReq.Done(); + } + break; + + case SID_OUTLINE_EXPAND_ALL: + { + pOutlinerView->ExpandAll(); + Cancel(); + rReq.Done(); + } + break; + + case SID_OUTLINE_EXPAND: + { + pOutlinerView->Expand(); + Cancel(); + rReq.Done(); + } + break; + + case SID_OUTLINE_FORMAT: + { + ::Outliner* pOutl = pOutlinerView->GetOutliner(); + pOutl->SetFlatMode( !pOutl->IsFlatMode() ); + Invalidate( SID_COLORVIEW ); + Cancel(); + rReq.Done(); + } + break; + + case SID_SELECTALL: + { + ::Outliner* pOutl = pOlView->GetOutliner(); + ULONG nParaCount = pOutl->GetParagraphCount(); + if (nParaCount > 0) + { + pOutlinerView->SelectRange( 0, (USHORT) nParaCount ); + } + Cancel(); + } + break; + + case SID_PRESENTATION: + case SID_REHEARSE_TIMINGS: + { + pOlView->PrepareClose(); + + Reference< XPresentation2 > xPresentation( GetDoc()->getPresentation() ); + if( xPresentation.is() ) + { + if( ( SID_REHEARSE_TIMINGS != rReq.GetSlot() ) ) + xPresentation->start(); + else + xPresentation->rehearseTimings(); + } + rReq.Done(); + } + break; + + case SID_COLORVIEW: + { + ::Outliner* pOutl = pOutlinerView->GetOutliner(); + ULONG nCntrl = pOutl->GetControlWord(); + + if ( !(nCntrl & EE_CNTRL_NOCOLORS) ) + { + // Farbansicht ist eingeschaltet: ausschalten + pOutl->SetControlWord(nCntrl | EE_CNTRL_NOCOLORS); + } + else + { + // Farbansicht ist ausgeschaltet: einschalten + pOutl->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS); + } + + InvalidateWindows(); + Invalidate( SID_COLORVIEW ); + Cancel(); + rReq.Done(); + } + break; + + case SID_STYLE_EDIT: + case SID_STYLE_UPDATE_BY_EXAMPLE: + { + if( rReq.GetArgs() ) + { + SetCurrentFunction( FuTemplate::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + Cancel(); + } + + rReq.Ignore (); + } + break; + + case SID_PRESENTATION_DLG: + { + SetCurrentFunction( FuSlideShowDlg::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_CUSTOMSHOW_DLG: + { + SetCurrentFunction( FuCustomShowDlg::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + Cancel(); + } + break; + } + + if(HasCurrentFunction()) + GetCurrentFunction()->Activate(); + + Invalidate( SID_OUTLINE_COLLAPSE_ALL ); + Invalidate( SID_OUTLINE_COLLAPSE ); + Invalidate( SID_OUTLINE_EXPAND_ALL ); + Invalidate( SID_OUTLINE_EXPAND ); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_OUTLINE_LEFT ); + rBindings.Invalidate( SID_OUTLINE_RIGHT ); + rBindings.Invalidate( SID_OUTLINE_UP ); + rBindings.Invalidate( SID_OUTLINE_DOWN ); + + Invalidate( SID_OUTLINE_FORMAT ); + Invalidate( SID_COLORVIEW ); + Invalidate(SID_CUT); + Invalidate(SID_COPY); + Invalidate(SID_PASTE); +} + +void OutlineViewShell::FuTemporaryModify(SfxRequest &rReq) +{ + OutlineViewModelChangeGuard aGuard( *pOlView ); + + DeactivateCurrentFunction(); + + OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() ); + USHORT nSId = rReq.GetSlot(); + + switch( nSId ) + { + case SID_HYPERLINK_SETLINK: + { + const SfxItemSet* pReqArgs = rReq.GetArgs(); + + if (pReqArgs) + { + SvxHyperlinkItem* pHLItem = + (SvxHyperlinkItem*) &pReqArgs->Get(SID_HYPERLINK_SETLINK); + + SvxFieldItem aURLItem(SvxURLField(pHLItem->GetURL(), + pHLItem->GetName(), + SVXURLFORMAT_REPR), EE_FEATURE_FIELD); + ESelection aSel( pOutlinerView->GetSelection() ); + pOutlinerView->InsertField(aURLItem); + if ( aSel.nStartPos <= aSel.nEndPos ) + aSel.nEndPos = aSel.nStartPos + 1; + else + aSel.nStartPos = aSel.nEndPos + 1; + pOutlinerView->SetSelection( aSel ); + } + + Cancel(); + rReq.Ignore (); + } + break; + + case FN_INSERT_SOFT_HYPHEN: + case FN_INSERT_HARDHYPHEN: + case FN_INSERT_HARD_SPACE: + case SID_INSERT_RLM : + case SID_INSERT_LRM : + case SID_INSERT_ZWNBSP : + case SID_INSERT_ZWSP: + case SID_CHARMAP: + { + SetCurrentFunction( FuBullet::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_OUTLINE_BULLET: + { + SetCurrentFunction( FuOutlineBullet::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_THESAURUS: + { + SetCurrentFunction( FuThesaurus::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + Cancel(); + rReq.Ignore (); + } + break; + + case SID_CHAR_DLG: + { + SetCurrentFunction( FuChar::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + Cancel(); + } + break; + + case SID_INSERTFILE: + { + SetCurrentFunction( FuInsertFile::Create(this, GetActiveWindow(), pOlView, GetDoc(), rReq) ); + Cancel(); + } + break; + + case SID_PRESENTATIONOBJECT: + { + SetCurrentFunction( FuPresentationObjects::Create(this, GetActiveWindow(), pOlView, GetDoc(), rReq) ); + Cancel(); + } + break; + + case SID_SET_DEFAULT: + { + // 1. Selektion merken (kriegt die eselige EditEngine nicht selbst + // auf die Reihe!) + // 2. Update auf False (sonst flackert's noch staerker + // an allen selektierten Absaetzen: + // a. deren Vorlage nochmal setzen, um absatzweite harte Attribute + // zu entfernen + // b. harte Zeichenattribute loeschen + // 3. Update auf True und Selektion wieder setzen + /* + ESelection aEsel= pOutlinerView->GetSelection(); + Outliner* pOutl = pOutlinerView->GetOutliner(); + pOutl->SetUpdateMode(FALSE); + List* pSelectedParas = pOutlinerView->CreateSelectionList(); + Paragraph* pPara = (Paragraph*)pSelectedParas->First(); + while (pPara) + { + ULONG nParaPos = pOutl->GetAbsPos(pPara); + String aName; + SfxStyleFamily aFamily; + pOutl->GetStyleSheet(nParaPos, aName, aFamily); + pOutl->SetStyleSheet(nParaPos, aName, aFamily); + pOutl->QuickRemoveCharAttribs(nParaPos); + pPara = (Paragraph*)pSelectedParas->Next(); + } + delete pSelectedParas; + pOutl->SetUpdateMode(TRUE); + pOutlinerView->SetSelection(aEsel); + */ + pOutlinerView->RemoveAttribs(TRUE); // TRUE = auch Absatzattribute + Cancel(); + rReq.Done(); + } + break; + + case SID_SUMMARY_PAGE: + { + pOlView->SetSelectedPages(); + SetCurrentFunction( FuSummaryPage::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + pOlView->GetOutliner()->Clear(); + pOlView->FillOutliner(); + pOlView->GetActualPage(); + Cancel(); + } + break; + + case SID_EXPAND_PAGE: + { + pOlView->SetSelectedPages(); + SetCurrentFunction( FuExpandPage::Create( this, GetActiveWindow(), pOlView, GetDoc(), rReq ) ); + pOlView->GetOutliner()->Clear(); + pOlView->FillOutliner(); + pOlView->GetActualPage(); + Cancel(); + } + break; + + case SID_INSERT_FLD_DATE_FIX: + case SID_INSERT_FLD_DATE_VAR: + case SID_INSERT_FLD_TIME_FIX: + case SID_INSERT_FLD_TIME_VAR: + case SID_INSERT_FLD_AUTHOR: + case SID_INSERT_FLD_PAGE: + case SID_INSERT_FLD_PAGES: + case SID_INSERT_FLD_FILE: + { + SvxFieldItem* pFieldItem = 0; + + switch( nSId ) + { + case SID_INSERT_FLD_DATE_FIX: + pFieldItem = new SvxFieldItem( + SvxDateField( Date(), SVXDATETYPE_FIX ), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_DATE_VAR: + pFieldItem = new SvxFieldItem( SvxDateField(), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_TIME_FIX: + pFieldItem = new SvxFieldItem( + SvxExtTimeField( Time(), SVXTIMETYPE_FIX ), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_TIME_VAR: + pFieldItem = new SvxFieldItem( SvxExtTimeField(), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_AUTHOR: + { + SvtUserOptions aUserOptions; + pFieldItem = new SvxFieldItem( + SvxAuthorField( + aUserOptions.GetFirstName(), aUserOptions.GetLastName(), aUserOptions.GetID() ) + , EE_FEATURE_FIELD ); + } + break; + + case SID_INSERT_FLD_PAGE: + pFieldItem = new SvxFieldItem( SvxPageField(), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_PAGES: + pFieldItem = new SvxFieldItem( SvxPagesField(), EE_FEATURE_FIELD ); + break; + + case SID_INSERT_FLD_FILE: + { + String aName; + if( GetDocSh()->HasName() ) + aName = GetDocSh()->GetMedium()->GetName(); + //else + // aName = GetDocSh()->GetName(); + pFieldItem = new SvxFieldItem( SvxExtFileField( aName ), EE_FEATURE_FIELD ); + } + break; + } + + const SvxFieldItem* pOldFldItem = pOutlinerView->GetFieldAtSelection(); + + if( pOldFldItem && ( pOldFldItem->GetField()->ISA( SvxURLField ) || + pOldFldItem->GetField()->ISA( SvxDateField ) || + pOldFldItem->GetField()->ISA( SvxTimeField ) || + pOldFldItem->GetField()->ISA( SvxExtTimeField ) || + pOldFldItem->GetField()->ISA( SvxExtFileField ) || + pOldFldItem->GetField()->ISA( SvxAuthorField ) || + pOldFldItem->GetField()->ISA( SvxPageField ) || + pOldFldItem->GetField()->ISA( SvxPagesField )) ) + { + // Feld selektieren, so dass es beim Insert geloescht wird + ESelection aSel = pOutlinerView->GetSelection(); + if( aSel.nStartPos == aSel.nEndPos ) + aSel.nEndPos++; + pOutlinerView->SetSelection( aSel ); + } + + if( pFieldItem ) + pOutlinerView->InsertField( *pFieldItem ); + + delete pFieldItem; + + Cancel(); + rReq.Ignore (); + } + break; + + case SID_MODIFY_FIELD: + { + const SvxFieldItem* pFldItem = pOutlinerView->GetFieldAtSelection(); + + if( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) || + pFldItem->GetField()->ISA( SvxAuthorField ) || + pFldItem->GetField()->ISA( SvxExtFileField ) || + pFldItem->GetField()->ISA( SvxExtTimeField ) ) ) + { + // Dialog... + SdAbstractDialogFactory* pFact = SdAbstractDialogFactory::Create(); + AbstractSdModifyFieldDlg* pDlg = pFact ? pFact->CreateSdModifyFieldDlg(GetActiveWindow(), pFldItem->GetField(), pOutlinerView->GetAttribs() ) : 0; + if( pDlg && (pDlg->Execute() == RET_OK) ) + { + SvxFieldData* pField = pDlg->GetField(); + if( pField ) + { + SvxFieldItem aFieldItem( *pField, EE_FEATURE_FIELD ); + //pOLV->DeleteSelected(); <-- fehlt leider ! + // Feld selektieren, so dass es beim Insert geloescht wird + ESelection aSel = pOutlinerView->GetSelection(); + BOOL bSel = TRUE; + if( aSel.nStartPos == aSel.nEndPos ) + { + bSel = FALSE; + aSel.nEndPos++; + } + pOutlinerView->SetSelection( aSel ); + + pOutlinerView->InsertField( aFieldItem ); + + // Selektion wird wieder in den Ursprungszustand gebracht + if( !bSel ) + aSel.nEndPos--; + pOutlinerView->SetSelection( aSel ); + + delete pField; + } + + SfxItemSet aSet( pDlg->GetItemSet() ); + if( aSet.Count() ) + { + pOutlinerView->SetAttribs( aSet ); + + ::Outliner* pOutliner = pOutlinerView->GetOutliner(); + if( pOutliner ) + pOutliner->UpdateFields(); + } + } + delete pDlg; + } + + Cancel(); + rReq.Ignore (); + } + break; + } + + if(HasCurrentFunction()) + GetCurrentFunction()->Activate(); + + Invalidate( SID_OUTLINE_COLLAPSE_ALL ); + Invalidate( SID_OUTLINE_COLLAPSE ); + Invalidate( SID_OUTLINE_EXPAND_ALL ); + Invalidate( SID_OUTLINE_EXPAND ); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_OUTLINE_LEFT ); + rBindings.Invalidate( SID_OUTLINE_RIGHT ); + rBindings.Invalidate( SID_OUTLINE_UP ); + rBindings.Invalidate( SID_OUTLINE_DOWN ); + + Invalidate( SID_OUTLINE_FORMAT ); + Invalidate( SID_COLORVIEW ); + Invalidate(SID_CUT); + Invalidate(SID_COPY); + Invalidate(SID_PASTE); +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/outlnvsh.cxx b/sd/source/ui/view/outlnvsh.cxx new file mode 100755 index 000000000000..955a9d167b49 --- /dev/null +++ b/sd/source/ui/view/outlnvsh.cxx @@ -0,0 +1,2245 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "OutlineViewShell.hxx" + +#include "ViewShellImplementation.hxx" +#include <memory> + +#include "app.hrc" +#include <svx/hyprlink.hxx> +#include <svx/hyperdlg.hxx> +#include <svx/zoomslideritem.hxx> + +#include <sfx2/objface.hxx> +#include <sot/exchange.hxx> +#include <svx/ruler.hxx> +#include <svx/zoomitem.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/flditem.hxx> +#include <sfx2/shell.hxx> +#include <sfx2/templdlg.hxx> +#include <sfx2/viewfac.hxx> +#include <sfx2/request.hxx> +#include <svx/hlnkitem.hxx> +#include <svx/svdotext.hxx> +#include <sfx2/dispatch.hxx> +#include <vcl/scrbar.hxx> +#include <svl/whiter.hxx> +#include <editeng/editstat.hxx> +#include <svl/itempool.hxx> +#include <sfx2/tplpitem.hxx> +#include <svx/svdorect.hxx> +#include <sot/formats.hxx> +#include <com/sun/star/linguistic2/XThesaurus.hpp> +#include <com/sun/star/i18n/TransliterationModules.hpp> +#include <com/sun/star/i18n/TransliterationModulesExtra.hpp> +#include <editeng/unolingu.hxx> +#include <comphelper/processfactory.hxx> +#include <editeng/outlobj.hxx> +#include <svl/cjkoptions.hxx> +#include <svtools/cliplistener.hxx> +#include <svl/srchitem.hxx> +#include <editeng/editobj.hxx> +#include "fubullet.hxx" +#include "optsitem.hxx" + +#include "strings.hrc" +#include "glob.hrc" +#include "res_bmp.hrc" +#include "Outliner.hxx" +#include "Window.hxx" +#include "TextObjectBar.hxx" +#include "drawdoc.hxx" +#include "sdresid.hxx" +#include "sdpage.hxx" +#include "fuoltext.hxx" +#include "FrameView.hxx" +#include "zoomlist.hxx" +#include "stlsheet.hxx" +#include "slideshow.hxx" +#include "SdUnoOutlineView.hxx" +#include "SpellDialogChildWindow.hxx" + +#include "AccessibleOutlineView.hxx" +#include "ViewShellBase.hxx" +#include "ViewShellManager.hxx" +#include "DrawController.hxx" +#include "framework/FrameworkHelper.hxx" + +using ::rtl::OUString; +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::linguistic2; + +using namespace sd; +#define OutlineViewShell +#include "sdslots.hxx" + +namespace sd { + +#define MIN_ZOOM 10 // Minimaler Zoomfaktor +#define MAX_ZOOM 1000 // Maximaler Zoomfaktor + +/************************************************************************/ + + +/************************************************************************* +|* +|* SFX-Slotmap und Standardinterface deklarieren +|* +\************************************************************************/ + + +SFX_IMPL_INTERFACE(OutlineViewShell, SfxShell, SdResId(STR_OUTLINEVIEWSHELL)) +{ + SFX_POPUPMENU_REGISTRATION( SdResId(RID_OUTLINE_POPUP) ); + SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_TOOLS | SFX_VISIBILITY_STANDARD | + SFX_VISIBILITY_FULLSCREEN | SFX_VISIBILITY_SERVER, + SdResId(RID_OUTLINE_TOOLBOX) ); + SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_APPLICATION | SFX_VISIBILITY_DESKTOP | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_CLIENT | SFX_VISIBILITY_VIEWER | SFX_VISIBILITY_READONLYDOC, + SdResId(RID_DRAW_VIEWER_TOOLBOX) ); + SFX_CHILDWINDOW_REGISTRATION( SfxTemplateDialogWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxHyperlinkDlgWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SvxHlinkDlgWrapper::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( ::sd::SpellDialogChildWindow::GetChildWindowId() ); + SFX_CHILDWINDOW_REGISTRATION( SID_SEARCH_DLG ); +} + + +TYPEINIT1( OutlineViewShell, ViewShell ); + + +/************************************************************************* +|* +|* gemeinsamer Initialiserungsanteil der beiden Konstruktoren +|* +\************************************************************************/ + +void OutlineViewShell::Construct(DrawDocShell* ) +{ + BOOL bModified = GetDoc()->IsChanged(); + + meShellType = ST_OUTLINE; + Size aSize(29700, 21000); + Point aWinPos (0, 0); + Point aViewOrigin(0, 0); + GetActiveWindow()->SetMinZoomAutoCalc(FALSE); + GetActiveWindow()->SetMinZoom( MIN_ZOOM ); + GetActiveWindow()->SetMaxZoom( MAX_ZOOM ); + InitWindows(aViewOrigin, aSize, aWinPos); + pOlView = new OutlineView(GetDocSh(), GetActiveWindow(), this); + mpView = pOlView; // Pointer der Basisklasse ViewShell + + SetPool( &GetDoc()->GetPool() ); + + SetZoom(69); + + // Einstellungen der FrameView uebernehmen + ReadFrameViewData(mpFrameView); + + ::Outliner* pOutl = pOlView->GetOutliner(); + pOutl->SetUpdateMode(TRUE); + + if (!bModified) + { + pOutl->ClearModifyFlag(); + } + + pLastPage = GetActualPage(); + + String aName( RTL_CONSTASCII_USTRINGPARAM( "OutlineViewShell" )); + SetName (aName); + + SetHelpId( SD_IF_SDOUTLINEVIEWSHELL ); + GetActiveWindow()->SetHelpId( SD_IF_SDOUTLINEVIEWSHELL ); + GetActiveWindow()->SetUniqueId( SD_IF_SDOUTLINEVIEWSHELL ); +} + + + + +Reference<drawing::XDrawSubController> OutlineViewShell::CreateSubController (void) +{ + Reference<drawing::XDrawSubController> xSubController; + + if (IsMainViewShell()) + { + // Create uno sub controller for the main view shell. + xSubController = Reference<drawing::XDrawSubController>( + new SdUnoOutlineView ( + GetViewShellBase().GetDrawController(), + *this, + *GetView())); + } + + return xSubController; +} + + + + +/************************************************************************* +|* +|* Standard-Konstruktor, Fenster duerfen nicht automatisch zentrieren +|* +\************************************************************************/ + +OutlineViewShell::OutlineViewShell ( + SfxViewFrame* pFrame, + ViewShellBase& rViewShellBase, + ::Window* pParentWindow, + FrameView* pFrameViewArgument) + : ViewShell(pFrame, pParentWindow, rViewShellBase), + pOlView(NULL), + pLastPage( NULL ), + pClipEvtLstnr(NULL), + bPastePossible(false), + mbInitialized(false) + +{ + if (pFrameViewArgument != NULL) + mpFrameView = pFrameViewArgument; + else + mpFrameView = new FrameView(GetDoc()); + + mpFrameView->Connect(); + + Construct(GetDocSh()); +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +OutlineViewShell::~OutlineViewShell() +{ + DisposeFunctions(); + + delete pOlView; + + mpFrameView->Disconnect(); + + if ( pClipEvtLstnr ) + { + pClipEvtLstnr->AddRemoveListener( GetActiveWindow(), FALSE ); + pClipEvtLstnr->ClearCallbackLink(); // #103849# prevent callback if another thread is waiting + pClipEvtLstnr->release(); + } +} + + + + +void OutlineViewShell::Shutdown (void) +{ + ViewShell::Shutdown(); + + PrepareClose(); +} + + + + +/************************************************************************* +|* +|* Paint-Methode: das Ereignis wird vom Fenster pWindow an +|* die Viewshell und die aktuelle Funktion weitergeleitet +|* +\************************************************************************/ + +void OutlineViewShell::Paint(const Rectangle& rRect, ::sd::Window* pWin) +{ + if (pOlView) + { + pOlView->Paint(rRect, pWin); + } + + if(HasCurrentFunction()) + { + GetCurrentFunction()->Paint(rRect, pWin); + } +} + +void OutlineViewShell::ArrangeGUIElements () +{ + // Retrieve the current size (thickness) of the scroll bars. That is + // the width of the vertical and the height of the horizontal scroll + // bar. + int nScrollBarSize = + GetParentWindow()->GetSettings().GetStyleSettings().GetScrollBarSize(); + maScrBarWH = Size (nScrollBarSize, nScrollBarSize); + + ViewShell::ArrangeGUIElements (); + + ::sd::Window* pWindow = mpContentWindow.get(); + if (pWindow != NULL) + { + pWindow->SetMinZoomAutoCalc(FALSE); + + // pWindow->SetPosSizePixel(rNewPos, Size(nSizeX, nSizeY)); + + // OutputArea der OutlinerView aendern + OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow); + + Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel()); +// aWin.nLeft = pOlView->GetPageNumberWidthPixel(); + + aWin = pWindow->PixelToLogic(aWin); + pOutlinerView->SetOutputArea(aWin); + + Rectangle aVis = pOutlinerView->GetVisArea(); + + Rectangle aText = Rectangle(Point(0,0), + Size(pOlView->GetPaperWidth(), + pOlView->GetOutliner()->GetTextHeight())); + aText.Bottom() += aWin.GetHeight(); + + if (!aWin.IsEmpty()) // nicht beim Oeffnen + { + InitWindows(Point(0,0), aText.GetSize(), Point(aVis.TopLeft())); + UpdateScrollBars(); + } + } +} + +/************************************************************************* +|* +|* SfxRequests fuer Controller bearbeiten +|* +\************************************************************************/ + +void OutlineViewShell::ExecCtrl(SfxRequest &rReq) +{ + USHORT nSlot = rReq.GetSlot(); + switch ( nSlot ) + { + case SID_MAIL_SCROLLBODY_PAGEDOWN: + { + ExecReq( rReq ); + break; + } + + case SID_OPT_LOCALE_CHANGED: + { + pOlView->GetOutliner()->UpdateFields(); + UpdatePreview( GetActualPage() ); + rReq.Done(); + break; + } + + default: + break; + } +} + + + + +void OutlineViewShell::AddWindow (::sd::Window* pWin) +{ + pOlView->AddWindowToPaintView(pWin); +} + + + + +void OutlineViewShell::RemoveWindow (::sd::Window* pWin) +{ + pOlView->DeleteWindowFromPaintView(pWin); +} + + + + +/************************************************************************* +|* +|* Activate(), beim ersten Aufruf erfolgt ein Update der Felder +|* +\************************************************************************/ +void OutlineViewShell::Activate( BOOL bIsMDIActivate ) +{ + if ( ! mbInitialized) + { + mbInitialized = true; + SfxRequest aRequest (SID_EDIT_OUTLINER, 0, GetDoc()->GetItemPool()); + FuPermanent (aRequest); + } + + ViewShell::Activate( bIsMDIActivate ); + pOlView->SetLinks(); + pOlView->ConnectToApplication(); + + if( bIsMDIActivate ) + { + OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() ); + ::Outliner* pOutl = pOutlinerView->GetOutliner(); + pOutl->UpdateFields(); + } +} + +/************************************************************************* +|* +|* Deactivate() +|* +\************************************************************************/ +void OutlineViewShell::Deactivate( BOOL bIsMDIActivate ) +{ + pOlView->DisconnectFromApplication(); + + // #96416# Links must be kept also on deactivated viewshell, to allow drag'n'drop + // to function properly + // pOlView->ResetLinks(); + + ViewShell::Deactivate( bIsMDIActivate ); +} + +/************************************************************************* +|* +|* Status von Controller-SfxSlots setzen +|* +\************************************************************************/ +void OutlineViewShell::GetCtrlState(SfxItemSet &rSet) +{ + if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_HYPERLINK_GETLINK)) + { + SvxHyperlinkItem aHLinkItem; + + OutlinerView* pOLV = pOlView->GetViewByWindow(GetActiveWindow()); + if (pOLV) + { + const SvxFieldItem* pFieldItem = pOLV->GetFieldAtSelection(); + if (pFieldItem) + { + ESelection aSel = pOLV->GetSelection(); + if ( abs( aSel.nEndPos - aSel.nStartPos ) == 1 ) + { + const SvxFieldData* pField = pFieldItem->GetField(); + if ( pField->ISA(SvxURLField) ) + { + aHLinkItem.SetName(((const SvxURLField*) pField)->GetRepresentation()); + aHLinkItem.SetURL(((const SvxURLField*) pField)->GetURL()); + aHLinkItem.SetTargetFrame(((const SvxURLField*) pField)->GetTargetFrame()); + } + } + } + } + rSet.Put(aHLinkItem); + } + rSet.Put( SfxBoolItem( SID_READONLY_MODE, GetDocSh()->IsReadOnly() ) ); + + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_MAIL_SCROLLBODY_PAGEDOWN) ) + rSet.Put( SfxBoolItem( SID_MAIL_SCROLLBODY_PAGEDOWN, TRUE ) ); + + if ( SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_TRANSLITERATE_HALFWIDTH) || + SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_TRANSLITERATE_FULLWIDTH) || + SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_TRANSLITERATE_HIRAGANA) || + SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_TRANSLITERATE_KATAGANA) ) + { + SvtCJKOptions aCJKOptions; + if( !aCJKOptions.IsChangeCaseMapEnabled() ) + { + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, sal_False ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, sal_False ); + rSet.DisableItem( SID_TRANSLITERATE_HALFWIDTH ); + rSet.DisableItem( SID_TRANSLITERATE_FULLWIDTH ); + rSet.DisableItem( SID_TRANSLITERATE_HIRAGANA ); + rSet.DisableItem( SID_TRANSLITERATE_KATAGANA ); + } + else + { + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, sal_True ); + GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, sal_True ); + } + } +} + +/************************************************************************* +|* +|* SfxRequests fuer Support-Funktionen +|* +\************************************************************************/ + +void OutlineViewShell::FuSupport(SfxRequest &rReq) +{ + if( rReq.GetSlot() == SID_STYLE_FAMILY && rReq.GetArgs()) + GetDocSh()->SetStyleFamily(((SfxUInt16Item&)rReq.GetArgs()->Get( SID_STYLE_FAMILY )).GetValue()); + + BOOL bPreviewState = FALSE; + ULONG nSlot = rReq.GetSlot(); + + std::auto_ptr< OutlineViewModelChangeGuard > aGuard; + if( pOlView && ( + (nSlot == SID_TRANSLITERATE_SENTENCE_CASE) || + (nSlot == SID_TRANSLITERATE_TITLE_CASE) || + (nSlot == SID_TRANSLITERATE_TOGGLE_CASE) || + (nSlot == SID_TRANSLITERATE_UPPER) || + (nSlot == SID_TRANSLITERATE_LOWER) || + (nSlot == SID_TRANSLITERATE_HALFWIDTH) || + (nSlot == SID_TRANSLITERATE_FULLWIDTH) || + (nSlot == SID_TRANSLITERATE_HIRAGANA) || + (nSlot == SID_TRANSLITERATE_KATAGANA) || + (nSlot == SID_CUT) || +// (nSlot == SID_COPY) || + (nSlot == SID_PASTE) || + (nSlot == SID_DELETE))) + { + aGuard.reset( new OutlineViewModelChangeGuard( *pOlView ) ); + } + + switch ( nSlot ) + { + case SID_CUT: + { + if(HasCurrentFunction()) + { + GetCurrentFunction()->DoCut(); + } + else if (pOlView) + { + pOlView->DoCut(); + } + rReq.Done(); + bPreviewState = TRUE; + } + break; + + case SID_COPY: + { + if(HasCurrentFunction()) + { + GetCurrentFunction()->DoCopy(); + } + else if (pOlView) + { + pOlView->DoCopy(); + } + rReq.Done(); + bPreviewState = TRUE; + } + break; + + case SID_PASTE: + { + OutlineViewPageChangesGuard aGuard2(pOlView); + + if(HasCurrentFunction()) + { + GetCurrentFunction()->DoPaste(); + } + else if (pOlView) + { + pOlView->DoPaste(); + } + rReq.Done(); + bPreviewState = TRUE; + } + break; + + case SID_DELETE: + { + if( pOlView ) + { + OutlinerView* pOutlView = pOlView->GetViewByWindow(GetActiveWindow()); + if (pOutlView) + { + OutlineViewPageChangesGuard aGuard2(pOlView); + + KeyCode aKCode(KEY_DELETE); + KeyEvent aKEvt( 0, aKCode ); + pOutlView->PostKeyEvent(aKEvt); + + FunctionReference xFunc( GetCurrentFunction() ); + FuOutlineText* pFuOutlineText = dynamic_cast< FuOutlineText* >( xFunc.get() ); + if( pFuOutlineText ) + pFuOutlineText->UpdateForKeyPress (aKEvt); + } + } + rReq.Done(); + bPreviewState = TRUE; + } + break; + + case SID_DRAWINGMODE: + case SID_NOTESMODE: + case SID_HANDOUTMODE: + case SID_DIAMODE: + case SID_OUTLINEMODE: + framework::FrameworkHelper::Instance(GetViewShellBase())->HandleModeChangeSlot( + nSlot, + rReq); + rReq.Done(); + break; + + case SID_RULER: + SetRuler( !HasRuler() ); + Invalidate( SID_RULER ); + rReq.Done(); + break; + + case SID_ZOOM_PREV: + { + if (mpZoomList->IsPreviousPossible()) + { + // Vorheriges ZoomRect einstellen + SetZoomRect(mpZoomList->GetPreviousZoomRect()); + } + rReq.Done (); + } + break; + + case SID_ZOOM_NEXT: + { + if (mpZoomList->IsNextPossible()) + { + // Naechstes ZoomRect einstellen + SetZoomRect(mpZoomList->GetNextZoomRect()); + } + rReq.Done (); + } + break; + + case SID_AUTOSPELL_CHECK: + { + GetDoc()->SetOnlineSpell(!GetDoc()->GetOnlineSpell()); + rReq.Done (); + } + break; + + case SID_TRANSLITERATE_SENTENCE_CASE: + case SID_TRANSLITERATE_TITLE_CASE: + case SID_TRANSLITERATE_TOGGLE_CASE: + case SID_TRANSLITERATE_UPPER: + case SID_TRANSLITERATE_LOWER: + case SID_TRANSLITERATE_HALFWIDTH: + case SID_TRANSLITERATE_FULLWIDTH: + case SID_TRANSLITERATE_HIRAGANA: + case SID_TRANSLITERATE_KATAGANA: + { + OutlinerView* pOLV = pOlView->GetViewByWindow( GetActiveWindow() ); + if( pOLV ) + { + using namespace ::com::sun::star::i18n; + sal_Int32 nType = 0; + + switch( nSlot ) + { + case SID_TRANSLITERATE_SENTENCE_CASE: + nType = TransliterationModulesExtra::SENTENCE_CASE; + break; + case SID_TRANSLITERATE_TITLE_CASE: + nType = TransliterationModulesExtra::TITLE_CASE; + break; + case SID_TRANSLITERATE_TOGGLE_CASE: + nType = TransliterationModulesExtra::TOGGLE_CASE; + break; + case SID_TRANSLITERATE_UPPER: + nType = TransliterationModules_LOWERCASE_UPPERCASE; + break; + case SID_TRANSLITERATE_LOWER: + nType = TransliterationModules_UPPERCASE_LOWERCASE; + break; + case SID_TRANSLITERATE_HALFWIDTH: + nType = TransliterationModules_FULLWIDTH_HALFWIDTH; + break; + case SID_TRANSLITERATE_FULLWIDTH: + nType = TransliterationModules_HALFWIDTH_FULLWIDTH; + break; + case SID_TRANSLITERATE_HIRAGANA: + nType = TransliterationModules_KATAKANA_HIRAGANA; + break; + case SID_TRANSLITERATE_KATAGANA: + nType = TransliterationModules_HIRAGANA_KATAKANA; + break; + } + + pOLV->TransliterateText( nType ); + } + + rReq.Done(); + bPreviewState = TRUE; + } + break; + + // #96090# added Undo/Redo handling + case SID_UNDO : + { + OutlineViewPageChangesGuard aGuard2(pOlView); + ImpSidUndo(FALSE, rReq); + } + break; + case SID_REDO : + { + OutlineViewPageChangesGuard aGuard2(pOlView); + ImpSidRedo(FALSE, rReq); + } + break; + + default: + break; + } + + if( bPreviewState ) + Invalidate( SID_PREVIEW_STATE ); + + Invalidate(SID_CUT); + Invalidate(SID_COPY); + Invalidate(SID_PASTE); +} + +/************************************************************************* +|* +|* SfxRequests fuer permanente Funktionen +|* +\************************************************************************/ + +void OutlineViewShell::FuPermanent(SfxRequest &rReq) +{ + if(HasCurrentFunction()) + { + DeactivateCurrentFunction(true); + } + + switch ( rReq.GetSlot() ) + { + case SID_EDIT_OUTLINER: + { + ::Outliner* pOutl = pOlView->GetOutliner(); + if( pOutl ) + { + pOutl->GetUndoManager().Clear(); + pOutl->UpdateFields(); + } + + SetCurrentFunction( FuOutlineText::Create(this,GetActiveWindow(),pOlView,GetDoc(),rReq) ); + + rReq.Done(); + } + break; + + default: + break; + } + + if(HasOldFunction()) + { + GetOldFunction()->Deactivate(); + SetOldFunction(0); + } + + if(HasCurrentFunction()) + { + GetCurrentFunction()->Activate(); + SetOldFunction(GetCurrentFunction()); + } +} + + +IMPL_LINK( OutlineViewShell, ClipboardChanged, TransferableDataHelper*, pDataHelper ) +{ + if ( pDataHelper ) + { + bPastePossible = ( pDataHelper->GetFormatCount() != 0 && + ( pDataHelper->HasFormat( FORMAT_STRING ) || + pDataHelper->HasFormat( FORMAT_RTF ) || + pDataHelper->HasFormat( SOT_FORMATSTR_ID_HTML ) ) ); + + SfxBindings& rBindings = GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_PASTE ); + rBindings.Invalidate( SID_PASTE_SPECIAL ); + rBindings.Invalidate( SID_CLIPBOARD_FORMAT_ITEMS ); + } + return 0; +} + +/************************************************************************* +|* +|* Status (Enabled/Disabled) von Menue-SfxSlots setzen +|* +\************************************************************************/ + +void OutlineViewShell::GetMenuState( SfxItemSet &rSet ) +{ + ViewShell::GetMenuState(rSet); + + // Vorlagenkatalog darf nicht aufgerufen werden + rSet.DisableItem( SID_STYLE_CATALOG ); + + rSet.Put(SfxBoolItem(SID_DIAMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_DRAWINGMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_OUTLINEMODE, TRUE)); + rSet.Put(SfxBoolItem(SID_NOTESMODE, FALSE)); + rSet.Put(SfxBoolItem(SID_HANDOUTMODE, FALSE)); + + if (!mpZoomList->IsNextPossible()) + { + rSet.DisableItem(SID_ZOOM_NEXT); + } + if (!mpZoomList->IsPreviousPossible()) + { + rSet.DisableItem(SID_ZOOM_PREV); + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_IN ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ZOOM_OUT ) ) + { + if( GetActiveWindow()->GetZoom() <= GetActiveWindow()->GetMinZoom() || GetDocSh()->IsUIActive() ) + rSet.DisableItem( SID_ZOOM_IN ); + if( GetActiveWindow()->GetZoom() >= GetActiveWindow()->GetMaxZoom() || GetDocSh()->IsUIActive() ) + rSet.DisableItem( SID_ZOOM_OUT ); + } + + ::Outliner* pOutl = pOlView->GetOutliner(); + DBG_ASSERT(pOutl, "OutlineViewShell::GetMenuState(), no outliner? Fatality!"); + if( !pOutl ) + return; + + // 'Alles auswaehlen' zulassen? + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_SELECTALL ) ) + { + ULONG nParaCount = pOutl->GetParagraphCount(); + BOOL bDisable = nParaCount == 0; + if (!bDisable && nParaCount == 1) + { + String aTest( pOutl->GetText( pOutl->GetParagraph( 0 ) ) ); + if (aTest.Len() == 0) + { + bDisable = TRUE; + } + } + if (bDisable) + rSet.DisableItem(SID_SELECTALL); + } + + // Status des Lineals setzen + rSet.Put( SfxBoolItem( SID_RULER, HasRuler() ) ); + + // Formatierung ein oder aus? + rSet.Put( SfxBoolItem( SID_OUTLINE_FORMAT, !pOutl->IsFlatMode() ) ); + + if( pOutl->IsFlatMode() ) + rSet.DisableItem( SID_COLORVIEW ); + else + { + // Farbansicht ein/aus + ULONG nCntrl = pOutl->GetControlWord(); + BOOL bNoColor = FALSE; + if (nCntrl & EE_CNTRL_NOCOLORS) + bNoColor = TRUE; + + rSet.Put( SfxBoolItem( SID_COLORVIEW, bNoColor ) ); + } + + // Buttons der Werkzeugleiste + // zunaechst selektionsabhaengige: COLLAPSE, EXPAND + BOOL bDisableCollapse = TRUE; + BOOL bDisableExpand = TRUE; + BOOL bUnique = TRUE; + OutlinerView* pOutlinerView = pOlView->GetViewByWindow(GetActiveWindow()); + List* pList = pOutlinerView->CreateSelectionList(); + Paragraph* pPara = (Paragraph*)pList->First(); + + sal_Int16 nDepth; + sal_Int16 nTmpDepth = pOutl->GetDepth( (USHORT) pOutl->GetAbsPos( pPara ) ); + bool bPage = pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE ); + while (pPara) + { + nDepth = pOutl->GetDepth( (USHORT) pOutl->GetAbsPos( pPara ) ); + + if( nDepth != nTmpDepth ) + bUnique = FALSE; + if( bPage != pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE ) ) + bUnique = FALSE; + if (!pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara)) + bDisableExpand = FALSE; + if (pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara)) + bDisableCollapse = FALSE; + + pPara = (Paragraph*)pList->Next(); + } + + delete pList; + + if (bDisableExpand) + rSet.DisableItem(SID_OUTLINE_EXPAND); + if (bDisableCollapse) + rSet.DisableItem(SID_OUTLINE_COLLAPSE); + + // ergibt die Selektion ein eindeutiges Praesentationslayout? + // wenn nicht, duerfen die Vorlagen nicht bearbeitet werden + SfxItemSet aSet(*rSet.GetPool(), SID_STATUS_LAYOUT, SID_STATUS_LAYOUT); + GetStatusBarState(aSet); + String aTest(((SfxStringItem&)aSet.Get(SID_STATUS_LAYOUT)).GetValue()); + if (aTest.Len() == 0) + { + bUnique = FALSE; + rSet.DisableItem(SID_PRESENTATION_TEMPLATES); + } + + if (!bUnique) + rSet.DisableItem( SID_PRESENTATIONOBJECT ); + + // jetzt die selektionsunabhaengigen: COLLAPSE_ALL, EXPAND_ALL + BOOL bDisableCollapseAll = TRUE; + BOOL bDisableExpandAll = TRUE; + + // wenn schon die Selektion etwas kollabierbares/expandierbares enthaelt + if (!bDisableCollapse) + bDisableCollapseAll = FALSE; + if (!bDisableExpand) + bDisableExpandAll = FALSE; + + // schade, so billig kommen wir nicht davon; alle Absaetze durchsuchen + if (bDisableCollapseAll || bDisableExpandAll) + { + ULONG nParaPos = 0; + pPara = pOutl->GetParagraph( nParaPos ); + while (pPara && (bDisableCollapseAll || bDisableExpandAll)) + { + if (!pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara)) + bDisableExpandAll = FALSE; + + if (pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara)) + bDisableCollapseAll = FALSE; + + pPara = pOutl->GetParagraph( ++nParaPos ); + } + } + + if (bDisableExpandAll) + rSet.DisableItem(SID_OUTLINE_EXPAND_ALL); + if (bDisableCollapseAll) + rSet.DisableItem(SID_OUTLINE_COLLAPSE_ALL); + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PASTE ) ) + { + if ( !pClipEvtLstnr ) + { + // create listener + pClipEvtLstnr = new TransferableClipboardListener( LINK( this, OutlineViewShell, ClipboardChanged ) ); + pClipEvtLstnr->acquire(); + pClipEvtLstnr->AddRemoveListener( GetActiveWindow(), TRUE ); + + // get initial state + TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( GetActiveWindow() ) ); + bPastePossible = ( aDataHelper.GetFormatCount() != 0 && + ( aDataHelper.HasFormat( FORMAT_STRING ) || + aDataHelper.HasFormat( FORMAT_RTF ) || + aDataHelper.HasFormat( SOT_FORMATSTR_ID_HTML ) ) ); + } + + if( !bPastePossible ) + { + rSet.DisableItem( SID_PASTE ); + } + } + + if (!pOlView->GetViewByWindow(GetActiveWindow())->HasSelection()) + { + rSet.DisableItem(SID_CUT); + rSet.DisableItem(SID_COPY); + } + + if (pOlView->GetOutliner()->IsModified()) + { + GetDoc()->SetChanged(TRUE); + } + + // Da �berladen, muss hier der Status gesetzt werden + if( !GetDocSh()->IsModified() ) + { + rSet.DisableItem( SID_SAVEDOC ); + } + + if ( GetDocSh()->IsReadOnly() ) + { + rSet.DisableItem( SID_AUTOSPELL_CHECK ); + } + else + { + if (GetDoc()->GetOnlineSpell()) + { + rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, TRUE)); + } + else + { + rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, FALSE)); + } + } + + // Feldbefehle + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_MODIFY_FIELD ) ) + { + const SvxFieldItem* pFldItem = pOutlinerView->GetFieldAtSelection(); + + if( !( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) || + pFldItem->GetField()->ISA( SvxAuthorField ) || + pFldItem->GetField()->ISA( SvxExtFileField ) || + pFldItem->GetField()->ISA( SvxExtTimeField ) ) ) ) + { + rSet.DisableItem( SID_MODIFY_FIELD ); + } + } + + if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_EXPAND_PAGE)) + { + BOOL bDisable = TRUE; + USHORT i = 0; + USHORT nCount = GetDoc()->GetSdPageCount(PK_STANDARD); + pOlView->SetSelectedPages(); + + while (i < nCount && bDisable) + { + SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD); + + if (pPage->IsSelected()) + { + SdrObject* pObj = pPage->GetPresObj(PRESOBJ_OUTLINE); + + if (pObj && !pObj->IsEmptyPresObj()) + { + bDisable = FALSE; + } + } + + i++; + } + + if (bDisable) + { + rSet.DisableItem(SID_EXPAND_PAGE); + } + } + + if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_SUMMARY_PAGE)) + { + BOOL bDisable = TRUE; + USHORT i = 0; + USHORT nCount = GetDoc()->GetSdPageCount(PK_STANDARD); + pOlView->SetSelectedPages(); + + while (i < nCount && bDisable) + { + SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD); + + if (pPage->IsSelected()) + { + SdrObject* pObj = pPage->GetPresObj(PRESOBJ_TITLE); + + if (pObj && !pObj->IsEmptyPresObj()) + { + bDisable = FALSE; + } + } + + i++; + } + + if (bDisable) + { + rSet.DisableItem(SID_SUMMARY_PAGE); + } + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_THESAURUS ) ) + { + if ( !pOlView->IsTextEdit() ) + { + rSet.DisableItem( SID_THESAURUS ); + } + else + { + LanguageType eLang = GetDoc()->GetLanguage( EE_CHAR_LANGUAGE ); + Reference< XThesaurus > xThesaurus( LinguMgr::GetThesaurus() ); + Locale aLocale; + + SvxLanguageToLocale( aLocale, eLang ); + + if (!xThesaurus.is() || eLang == LANGUAGE_NONE || !xThesaurus->hasLocale(aLocale)) + rSet.DisableItem( SID_THESAURUS ); + } + } + + // Starten der Praesentation moeglich? + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_PRESENTATION ) ) + { + BOOL bDisable = TRUE; + USHORT nCount = GetDoc()->GetSdPageCount( PK_STANDARD ); + + for( USHORT i = 0; i < nCount && bDisable; i++ ) + { + SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD); + + if( !pPage->IsExcluded() ) + bDisable = FALSE; + } + if( bDisable || GetDocSh()->IsPreview()) + { + rSet.DisableItem( SID_PRESENTATION ); + } + } + + FuBullet::GetSlotState( rSet, this, GetViewFrame() ); + + //rSet.DisableItem( SID_PRINTDOC ); + //rSet.DisableItem( SID_PRINTDOCDIRECT ); + //rSet.DisableItem( SID_SETUPPRINTER ); +} + +/************************************************************************* +|* +|* wird gerufen, wenn ScrollBar benutzt wird +|* +\************************************************************************/ + +long OutlineViewShell::VirtHScrollHdl(ScrollBar* pHScroll) +{ + long nThumb = pHScroll->GetThumbPos(); + long nRange = pHScroll->GetRange().Len(); + double fX = (double) nThumb / nRange; + + Window* pWin = mpContentWindow.get(); + OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWin); + long nViewWidth = pWin->PixelToLogic( + pWin->GetSizePixel()).Width(); + long nTextWidth = pOlView->GetPaperWidth(); + nViewWidth = Max(nViewWidth, nTextWidth); + long nCurrentPos = pOutlinerView->GetVisArea().Left(); + long nTargetPos = (long)(fX * nViewWidth); + long nDelta = nTargetPos - nCurrentPos; + + pOutlinerView->HideCursor(); + pOutlinerView->Scroll(-nDelta, 0); + pOutlinerView->ShowCursor(FALSE); + + pOlView->InvalidateSlideNumberArea(); + return 0; +} + +/************************************************************************* +|* +|* wird gerufen, wenn ScrollBar benutzt wird +|* +\************************************************************************/ + +long OutlineViewShell::VirtVScrollHdl(ScrollBar* pVScroll) +{ + long nThumb = pVScroll->GetThumbPos(); + long nRange = pVScroll->GetRange().Len(); + double fY = (double) nThumb / nRange; + + Window* pWin = mpContentWindow.get(); + OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWin); + long nViewHeight = pWin->PixelToLogic( + pWin->GetSizePixel()).Height(); + long nTextHeight = pOlView->GetOutliner()->GetTextHeight(); + nViewHeight += nTextHeight; + long nCurrentPos = pOutlinerView->GetVisArea().Top(); + long nTargetPos = (long)(fY * nViewHeight); + long nDelta = nTargetPos - nCurrentPos; + + pOutlinerView->HideCursor(); + pOutlinerView->Scroll(0, -nDelta); + pOutlinerView->ShowCursor(FALSE); + + pOlView->InvalidateSlideNumberArea(); + + return 0; +} + +/************************************************************************* +|* +|* PrepareClose, wird gerufen, wenn die Shell zestoert werden soll, +|* leitet den Aufruf an die View weiter +|* +\************************************************************************/ + +USHORT OutlineViewShell::PrepareClose( BOOL bUI, BOOL bForBrowsing ) +{ + if( ViewShell::PrepareClose(bUI, bForBrowsing) != TRUE ) + return FALSE; + + return pOlView == NULL || pOlView->PrepareClose(bUI); +} + + +/************************************************************************* +|* +|* Zoomen mit Zoomfaktor, OutlinerView informieren +|* +\************************************************************************/ + +void OutlineViewShell::SetZoom(long nZoom) +{ + ViewShell::SetZoom(nZoom); + + ::sd::Window* pWindow = mpContentWindow.get(); + if (pWindow) + { + // OutputArea der OutlinerView aendern + OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow); + Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel()); + aWin = pWindow->PixelToLogic(aWin); + pOutlinerView->SetOutputArea(aWin); + } + + // #106268# + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM ); + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER ); +} + +/************************************************************************* +|* +|* Zoomen mit Zoomrechteck, OutlinerView informieren +|* +\************************************************************************/ + +void OutlineViewShell::SetZoomRect(const Rectangle& rZoomRect) +{ + ViewShell::SetZoomRect(rZoomRect); + + ::sd::Window* pWindow = mpContentWindow.get(); + if (pWindow) + { + // OutputArea der OutlinerView aendern + OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow); + Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel()); + aWin = pWindow->PixelToLogic(aWin); + pOutlinerView->SetOutputArea(aWin); + } + + // #106268# + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM ); + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER ); +} + +/************************************************************************* +|* +|* Vorm Speichern das Model der Drawing Engine aktualisieren, dann den +|* Call weiterleiten an die ObjectShell. +|* +\************************************************************************/ + +void OutlineViewShell::Execute(SfxRequest& rReq) +{ + bool bForwardCall = true; + + switch(rReq.GetSlot()) + { + case SID_SAVEDOC: + case SID_SAVEASDOC: + PrepareClose(); + break; + + case SID_SEARCH_ITEM: + // Forward this request to the the common (old) code of the + // document shell. + GetDocSh()->Execute (rReq); + bForwardCall = false; + break; + + case SID_SPELL_DIALOG: + { + SfxViewFrame* pViewFrame = GetViewFrame(); + if (rReq.GetArgs() != NULL) + pViewFrame->SetChildWindow (SID_SPELL_DIALOG, + ((const SfxBoolItem&) (rReq.GetArgs()-> + Get(SID_SPELL_DIALOG))).GetValue()); + else + pViewFrame->ToggleChildWindow(SID_SPELL_DIALOG); + + pViewFrame->GetBindings().Invalidate(SID_SPELL_DIALOG); + rReq.Done (); + + bForwardCall = false; + } + break; + + default: + OSL_TRACE ("OutlineViewShell::Execute(): can not handle slot %d", rReq.GetSlot()); + break; + + } + + if (bForwardCall) + ((DrawDocShell*)GetViewFrame()->GetObjectShell())->ExecuteSlot( rReq ); +} + +/************************************************************************* +|* +|* Read FrameViews data and set actual views data +|* +\************************************************************************/ + +void OutlineViewShell::ReadFrameViewData(FrameView* pView) +{ + ::Outliner* pOutl = pOlView->GetOutliner(); + + if ( pView->IsNoAttribs() ) + pOutl->SetFlatMode( TRUE ); // Attribut-Darstellung ausschalten + else + pOutl->SetFlatMode( FALSE ); // Attribut-Darstellung einschalten + + ULONG nCntrl = pOutl->GetControlWord(); + + if ( pView->IsNoColors() ) + pOutl->SetControlWord(nCntrl | EE_CNTRL_NOCOLORS); // Farbansicht ausschalten + else + pOutl->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS); // Farbansicht einschalten + + USHORT nPage = mpFrameView->GetSelectedPage(); + pLastPage = GetDoc()->GetSdPage( nPage, PK_STANDARD ); + pOlView->SetActualPage(pLastPage); +} + + + +/************************************************************************* +|* +|* Write actual views data to FrameView +|* +\************************************************************************/ + +void OutlineViewShell::WriteFrameViewData() +{ + ::Outliner* pOutl = pOlView->GetOutliner(); + + ULONG nCntrl = pOutl->GetControlWord(); + BOOL bNoColor = FALSE; + if (nCntrl & EE_CNTRL_NOCOLORS) + bNoColor = TRUE; + mpFrameView->SetNoColors(bNoColor); + mpFrameView->SetNoAttribs( pOutl->IsFlatMode() ); + SdPage* pActualPage = pOlView->GetActualPage(); + DBG_ASSERT(pActualPage, "No current page"); + if( pActualPage ) + mpFrameView->SetSelectedPage((pActualPage->GetPageNum() - 1) / 2); +} + + +/************************************************************************* +|* +|* SfxRequests fuer StatusBar bearbeiten +|* +\************************************************************************/ + +void OutlineViewShell::ExecStatusBar(SfxRequest&) +{ +} + +/************************************************************************* +|* +|* Statuswerte der Statusbar zurueckgeben +|* +\************************************************************************/ + +void OutlineViewShell::GetStatusBarState(SfxItemSet& rSet) +{ + // Zoom-Item + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOM ) ) + { + SvxZoomItem* pZoomItem; + UINT16 nZoom = (UINT16) GetActiveWindow()->GetZoom(); + + pZoomItem = new SvxZoomItem( SVX_ZOOM_PERCENT, nZoom ); + + // Bereich einschraenken + USHORT nZoomValues = SVX_ZOOM_ENABLE_ALL; + nZoomValues &= ~SVX_ZOOM_ENABLE_OPTIMAL; + nZoomValues &= ~SVX_ZOOM_ENABLE_WHOLEPAGE; + nZoomValues &= ~SVX_ZOOM_ENABLE_PAGEWIDTH; + + pZoomItem->SetValueSet( nZoomValues ); + rSet.Put( *pZoomItem ); + delete pZoomItem; + } + + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_ATTR_ZOOMSLIDER ) ) + { + if (GetDocSh()->IsUIActive() || !GetActiveWindow() ) + { + rSet.DisableItem( SID_ATTR_ZOOMSLIDER ); + } + else + { + sd::Window * pActiveWindow = GetActiveWindow(); + SvxZoomSliderItem aZoomItem( (UINT16) pActiveWindow->GetZoom(), (USHORT)pActiveWindow->GetMinZoom(), (USHORT)pActiveWindow->GetMaxZoom() ) ; + aZoomItem.AddSnappingPoint(100); + rSet.Put( aZoomItem ); + } + } + + + // Seitenanzeige und Layout + /* + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_PAGE ) || + SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STATUS_LAYOUT ) ) + */ + USHORT nPageCount = GetDoc()->GetSdPageCount( PK_STANDARD ); + String aPageStr, aLayoutStr; + + ::sd::Window* pWin = GetActiveWindow(); + OutlinerView* pActiveView = pOlView->GetViewByWindow( pWin ); + ::Outliner* pOutliner = pOlView->GetOutliner(); + List* pSelList = (List*)pActiveView->CreateSelectionList(); + Paragraph* pFirstPara = (Paragraph*)pSelList->First(); + Paragraph* pLastPara = (Paragraph*)pSelList->Last(); + + if( !pOutliner->HasParaFlag(pFirstPara,PARAFLAG_ISPAGE) ) + pFirstPara = pOlView->GetPrevTitle( pFirstPara ); + + if( !pOutliner->HasParaFlag(pLastPara, PARAFLAG_ISPAGE) ) + pLastPara = pOlView->GetPrevTitle( pLastPara ); + + delete pSelList; // die wurde extra fuer uns erzeugt + + // nur eine Seite selektiert? + if( pFirstPara == pLastPara ) + { + // wieviele Seiten sind vor der selektierten Seite? + ULONG nPos = 0L; + while( pFirstPara ) + { + pFirstPara = pOlView->GetPrevTitle( pFirstPara ); + if( pFirstPara ) + nPos++; + } + + if( nPos >= GetDoc()->GetSdPageCount( PK_STANDARD ) ) + nPos = 0; + + SdrPage* pPage = GetDoc()->GetSdPage( (USHORT) nPos, PK_STANDARD ); + + aPageStr = String(SdResId( STR_SD_PAGE )); + aPageStr += sal_Unicode(' '); + aPageStr += String::CreateFromInt32( (sal_Int32)(nPos + 1) ); // ULONG -> sal_Int32 + aPageStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " / " )); + aPageStr += String::CreateFromInt32( nPageCount ); + + aLayoutStr = pPage->GetLayoutName(); + aLayoutStr.Erase( aLayoutStr.SearchAscii( SD_LT_SEPARATOR ) ); + } + rSet.Put( SfxStringItem( SID_STATUS_PAGE, aPageStr ) ); + rSet.Put( SfxStringItem( SID_STATUS_LAYOUT, aLayoutStr ) ); +} + +/************************************************************************* +|* +|* Command event +|* +\************************************************************************/ + +void OutlineViewShell::Command( const CommandEvent& rCEvt, ::sd::Window* pWin ) +{ + if ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU ) + { + GetActiveWindow()->ReleaseMouse(); + + OutlinerView* pOLV = pOlView->GetViewByWindow(GetActiveWindow()); + Point aPos(rCEvt.GetMousePosPixel()); + + if (pOLV && pOLV->IsWrongSpelledWordAtPos(aPos)) + { + // #91457# Popup for Online-Spelling now handled by DrawDocShell + // Link aLink = LINK(GetDoc(), SdDrawDocument, OnlineSpellCallback); + Link aLink = LINK(GetDocSh(), DrawDocShell, OnlineSpellCallback); + + pOLV->ExecuteSpellPopup(aPos, &aLink); + } + else + { + GetViewFrame()->GetDispatcher()->ExecutePopup(SdResId(RID_OUTLINE_POPUP)); + } + } + else + { + ViewShell::Command( rCEvt, pWin ); + + // ggfs. Preview den neuen Kontext mitteilen + Invalidate( SID_PREVIEW_STATE ); + + } +} + + +/************************************************************************* +|* +|* Keyboard event +|* +\************************************************************************/ + +BOOL OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin) +{ + BOOL bReturn = FALSE; + OutlineViewPageChangesGuard aGuard(pOlView); + + if (pWin == NULL && HasCurrentFunction()) + { + bReturn = GetCurrentFunction()->KeyInput(rKEvt); + } + + // nein, weiterleiten an Basisklasse + else + { + bReturn = ViewShell::KeyInput(rKEvt, pWin); + } + + Invalidate(SID_STYLE_EDIT); + Invalidate(SID_STYLE_NEW); + Invalidate(SID_STYLE_DELETE); + Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE); + Invalidate(SID_STYLE_NEW_BY_EXAMPLE); + Invalidate(SID_STYLE_WATERCAN); + Invalidate(SID_STYLE_FAMILY5); + + // Pruefen und Unterscheiden von CursorBewegungs- oder Eingabe-Keys + KeyCode aKeyGroup( rKEvt.GetKeyCode().GetGroup() ); + if( (aKeyGroup != KEYGROUP_CURSOR && aKeyGroup != KEYGROUP_FKEYS) || + (GetActualPage() != pLastPage) ) + { + Invalidate( SID_PREVIEW_STATE ); + } + + return(bReturn); +} + + +/************************************************************************* +|* +|* Optimale Groesse zurueckgeben +|* +\************************************************************************/ + +Size OutlineViewShell::GetOptimalSizePixel() const +{ + Size aResult(200, 200); + if (pOlView) + { + ::Outliner* pOutliner = pOlView->GetOutliner(); + if (pOutliner) + { + Size aTemp = pOutliner->CalcTextSize(); + aTemp = GetActiveWindow()->LogicToPixel(aTemp); + aResult.Width() = Max(aResult.Width(), aTemp.Width()); + aResult.Height() = Max(aResult.Height(), aTemp.Height()); + if (4 * aResult.Height() > 3 * aResult.Width()) + { + aResult.Height() = 3 * aResult.Width() / 4; + } + } + } + + // und jetzt jetzt das Standardgelumpe draufaddieren + aResult.Width() += mpVerticalScrollBar->GetSizePixel().Width(); + aResult.Height() += mpHorizontalScrollBar->GetSizePixel().Height(); + //!!! + System::GetMenuBarHeightPixel(); // statt Titlebar + return aResult; +} + + +/************************************************************************* +|* +|* Text der Selektion zurueckgeben +|* +\************************************************************************/ + +String OutlineViewShell::GetSelectionText(BOOL bCompleteWords) +{ + String aStrSelection; + ::Outliner* pOl = pOlView->GetOutliner(); + OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() ); + + if (pOl && pOlView) + { + if (bCompleteWords) + { + ESelection aSel = pOutlinerView->GetSelection(); + String aStrCurrentDelimiters = pOl->GetWordDelimiters(); + + pOl->SetWordDelimiters( String( RTL_CONSTASCII_USTRINGPARAM( " .,;\"'" ))); + aStrSelection = pOl->GetWord( aSel.nEndPara, aSel.nEndPos ); + pOl->SetWordDelimiters( aStrCurrentDelimiters ); + } + else + { + aStrSelection = pOutlinerView->GetSelected(); + } + } + + return (aStrSelection); +} + + +/************************************************************************* +|* +|* Ist etwas selektiert? +|* +\************************************************************************/ + +BOOL OutlineViewShell::HasSelection(BOOL bText) const +{ + BOOL bReturn = FALSE; + + if (bText) + { + OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() ); + + if (pOutlinerView && pOutlinerView->GetSelected().Len() != 0) + { + bReturn = TRUE; + } + } + + return bReturn; +} + + +/************************************************************************* +|* +|* Status der Attribut-Items +|* +\************************************************************************/ + +void OutlineViewShell::GetAttrState( SfxItemSet& rSet ) +{ + SfxWhichIter aIter( rSet ); + USHORT nWhich = aIter.FirstWhich(); + SfxAllItemSet aAllSet( *rSet.GetPool() ); + + while ( nWhich ) + { + USHORT nSlotId = SfxItemPool::IsWhich(nWhich) + ? GetPool().GetSlotId(nWhich) + : nWhich; + + switch ( nSlotId ) + { + case SID_STYLE_FAMILY2: + case SID_STYLE_FAMILY3: + { + rSet.DisableItem( nWhich ); + } + break; + + case SID_STYLE_FAMILY5: + { + SfxStyleSheet* pStyleSheet = pOlView->GetViewByWindow(GetActiveWindow())->GetStyleSheet(); + + if( pStyleSheet ) + { + pStyleSheet = ((SdStyleSheet*)pStyleSheet)->GetPseudoStyleSheet(); + + if (pStyleSheet) + { + SfxTemplateItem aItem( nWhich, pStyleSheet->GetName() ); + aAllSet.Put( aItem, aItem.Which() ); + } + } + + if( !pStyleSheet ) + { + SfxTemplateItem aItem( nWhich, String() ); + aAllSet.Put( aItem, aItem.Which() ); + // rSet.DisableItem( nWhich ); + } + } + break; + + case SID_STYLE_EDIT: + { + ISfxTemplateCommon* pTmplCommon = SFX_APP()->GetCurrentTemplateCommon(GetViewFrame()->GetBindings()); + + if (pTmplCommon && pTmplCommon->GetActualFamily() == SD_STYLE_FAMILY_PSEUDO) + { + SfxItemSet aSet(*rSet.GetPool(), SID_STATUS_LAYOUT, SID_STATUS_LAYOUT); + GetStatusBarState(aSet); + String aRealStyle(((SfxStringItem&) aSet.Get(SID_STATUS_LAYOUT)).GetValue()); + + if (!aRealStyle.Len()) + { + // Kein eindeutiger Layoutname gefunden + rSet.DisableItem(nWhich); + } + } + } + break; + + case SID_STYLE_UPDATE_BY_EXAMPLE: + { + ::sd::Window* pActWin = GetActiveWindow(); + OutlinerView* pOV = pOlView->GetViewByWindow(pActWin); + ESelection aESel(pOV->GetSelection()); + + if (aESel.nStartPara != aESel.nEndPara || + aESel.nStartPos != aESel.nEndPos) + // aufgespannte Selektion, also StyleSheet und/oder + // Attributierung nicht zwingend eindeutig + rSet.DisableItem(nWhich); + } + break; + + case SID_STYLE_NEW: + case SID_STYLE_DELETE: + case SID_STYLE_NEW_BY_EXAMPLE: + case SID_STYLE_WATERCAN: + { + rSet.DisableItem(nWhich); + } + break; + } + + nWhich = aIter.NextWhich(); + } + + rSet.Put( aAllSet, FALSE ); +} + + + +/************************************************************************* +|* +|* MouseButtonUp event +|* +\************************************************************************/ + +void OutlineViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin) +{ + // Zuerst die Basisklasse + ViewShell::MouseButtonUp(rMEvt, pWin); + + Invalidate(SID_STYLE_EDIT); + Invalidate(SID_STYLE_NEW); + Invalidate(SID_STYLE_DELETE); + Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE); + Invalidate(SID_STYLE_NEW_BY_EXAMPLE); + Invalidate(SID_STYLE_WATERCAN); + Invalidate(SID_STYLE_FAMILY5); + + // ggfs. Preview den neuen Kontext mitteilen + if( GetActualPage() != pLastPage ) + Invalidate( SID_PREVIEW_STATE ); +} + + + +SdPage* OutlineViewShell::getCurrentPage() const +{ + // since there are no master pages in outline view, we can + // for now use the GetActualPage method + return const_cast<OutlineViewShell*>(this)->GetActualPage(); +} + +/************************************************************************* +|* +|* Liefert die erste selektierte Seite zurueck. +|* Wenn nichts selektiert ist, wird die erste Seite zurueckgeliefert. +|* +\************************************************************************/ +SdPage* OutlineViewShell::GetActualPage() +{ + return pOlView->GetActualPage(); +} + + +/************************************************************************* +|* +|* Retrieve range of marked pages +|* +\************************************************************************/ + +String OutlineViewShell::GetPageRangeString() +{ + ::sd::Window* pWin = GetActiveWindow(); + OutlinerView* pActiveView = pOlView->GetViewByWindow(pWin); + ::Outliner* pOutl = pActiveView->GetOutliner(); + List* pSelList = (List*)pActiveView->CreateSelectionList(); + Paragraph* pPara = (Paragraph*)pSelList->First(); + + String aStrPageRange; + BOOL bFirstPageNo = TRUE; + BOOL bOpenRange = FALSE; + USHORT nLastPage = 0; + USHORT nLastUsedPage = (USHORT)-1; + + USHORT nPageCount = 0; + for( USHORT n = 0; n< GetDoc()->GetPageCount(); n++ ) + if( ( (SdPage*)GetDoc()->GetPage( n ) )->GetPageKind() == PK_STANDARD ) + nPageCount++; + + while ( pPara ) + { + if ( !pOutl->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) + { + pPara = pOlView->GetPrevTitle(pPara); + } + USHORT nPageToSelect = 0; + while(pPara) + { + pPara = pOlView->GetPrevTitle(pPara); + if (pPara) + nPageToSelect++; + } + + if( bFirstPageNo ) + { + bFirstPageNo = FALSE; + aStrPageRange = String::CreateFromInt32( sal_Int32( nPageToSelect+1 ) ); + nLastUsedPage = nPageToSelect; + nPageCount--; + } + else + { + if( nPageToSelect != nLastPage ) + { + if( nPageToSelect == nLastPage+1 ) + { + bOpenRange = TRUE; + nPageCount--; + } + else + { + if( bOpenRange ) + { + if( nLastPage == nLastUsedPage+1 ) + aStrPageRange.Append( sal_Unicode(',') ); + else + aStrPageRange.Append( sal_Unicode('-') ); + + aStrPageRange.Append( String::CreateFromInt32( sal_Int32( nLastPage+1 ) ) ); + } + aStrPageRange.Append( sal_Unicode(',') ); + aStrPageRange.Append( String::CreateFromInt32( sal_Int32( nPageToSelect+1 ) ) ); + nLastUsedPage = nPageToSelect; + bOpenRange = FALSE; + nPageCount--; + } + } + } + + nLastPage = nPageToSelect; + pPara = (Paragraph*)pSelList->Next(); + } + + if( bOpenRange ) + { + if( nLastPage == nLastUsedPage+1 ) + aStrPageRange.Append( sal_Unicode(',') ); + else + aStrPageRange.Append( sal_Unicode('-') ); + + aStrPageRange.Append( String::CreateFromInt32( sal_Int32( nLastPage+1 ) ) ); + } + + if( nPageCount == 0 ) + aStrPageRange.Erase(); + + delete pSelList; // die wurde extra fuer uns erzeugt + + return aStrPageRange; +} + +void OutlineViewShell::UpdatePreview( SdPage* pPage, BOOL ) +{ + const bool bNewPage = pPage != pLastPage; + pLastPage = pPage; + if (bNewPage) + { + OutlineViewPageChangesGuard aGuard(pOlView); + SetCurrentPage(pPage); + } +} + +/************************************************************************* +|* +|* Update Title +|* +\************************************************************************/ + +bool OutlineViewShell::UpdateTitleObject( SdPage* pPage, Paragraph* pPara ) +{ + DBG_ASSERT( pPage, "sd::OutlineViewShell::UpdateTitleObject(), pPage == 0?" ); + DBG_ASSERT( pPara, "sd::OutlineViewShell::UpdateTitleObject(), pPara == 0?" ); + + if( !pPage || !pPara ) + return false; + + ::Outliner* pOutliner = pOlView->GetOutliner(); + SdrTextObj* pTO = pOlView->GetTitleTextObject( pPage ); + OutlinerParaObject* pOPO = NULL; + + String aTest( pOutliner->GetText( pPara ) ); + bool bText = aTest.Len() > 0; + bool bNewObject = false; + + if( bText ) + { + // create a title object if we don't have one but have text + if( !pTO ) + { + DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" ); + pTO = pOlView->CreateTitleTextObject(pPage); + bNewObject = TRUE; + } + + // if we have a title object and a text, set the text + if( pTO ) + { + pOPO = pOutliner->CreateParaObject( (USHORT) pOutliner->GetAbsPos( pPara ), 1 ); + pOPO->SetOutlinerMode( OUTLINERMODE_TITLEOBJECT ); + pOPO->SetVertical( pTO->IsVerticalWriting() ); + if( pTO->GetOutlinerParaObject() && (pOPO->GetTextObject() == pTO->GetOutlinerParaObject()->GetTextObject()) ) + { + // do nothing, same text already set + delete pOPO; + } + else + { + DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" ); + if( !bNewObject && pOlView->isRecordingUndo() ) + pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0)); + + pTO->SetOutlinerParaObject( pOPO ); + pTO->SetEmptyPresObj( FALSE ); + pTO->ActionChanged(); + } + } + } + else if( pTO ) + { + // no text but object available? + // outline object available, but we have no text + if(pPage->IsPresObj(pTO)) + { + // if it is not already empty + if( !pTO->IsEmptyPresObj() ) + { + DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" ); + + // make it empty + if( pOlView->isRecordingUndo() ) + pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0)); + pPage->RestoreDefaultText( pTO ); + pTO->SetEmptyPresObj(TRUE); + pTO->ActionChanged(); + } + } + else + { + DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" ); + // outline object is not part of the layout, delete it + if( pOlView->isRecordingUndo() ) + pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoRemoveObject(*pTO)); + pPage->RemoveObject(pTO->GetOrdNum()); + } + } + + return bNewObject; +} + +/************************************************************************* +|* +|* Update LayoutObject +|* +\************************************************************************/ + +bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara ) +{ + DBG_ASSERT( pPage, "sd::OutlineViewShell::UpdateOutlineObject(), pPage == 0?" ); + DBG_ASSERT( pPara, "sd::OutlineViewShell::UpdateOutlineObject(), pPara == 0?" ); + + if( !pPage || !pPara ) + return false; + + ::Outliner* pOutliner = pOlView->GetOutliner(); + OutlinerParaObject* pOPO = NULL; + SdrTextObj* pTO = NULL; + + BOOL bNewObject = FALSE; + + sal_uInt16 eOutlinerMode = OUTLINERMODE_TITLEOBJECT; + pTO = (SdrTextObj*)pPage->GetPresObj( PRESOBJ_TEXT ); + if( !pTO ) + { + eOutlinerMode = OUTLINERMODE_OUTLINEOBJECT; + pTO = pOlView->GetOutlineTextObject( pPage ); + } + + // wieviele Absaetze in der Gliederung? + ULONG nTitlePara = pOutliner->GetAbsPos( pPara ); + ULONG nPara = nTitlePara + 1; + ULONG nParasInLayout = 0L; + pPara = pOutliner->GetParagraph( nPara ); + while( pPara && !pOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) + { + nParasInLayout++; + pPara = pOutliner->GetParagraph( ++nPara ); + } + if( nParasInLayout ) + { + // ein OutlinerParaObject erzeugen + pPara = pOutliner->GetParagraph( nTitlePara + 1 ); + pOPO = pOutliner->CreateParaObject( (USHORT) nTitlePara + 1, (USHORT) nParasInLayout ); + } + + if( pOPO ) + { + DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" ); + + // do we need an outline text object? + if( !pTO ) + { + pTO = pOlView->CreateOutlineTextObject( pPage ); + bNewObject = TRUE; + } + + // Seitenobjekt, Gliederungstext im Outliner: + // Text uebernehmen + if( pTO ) + { + pOPO->SetVertical( pTO->IsVerticalWriting() ); + pOPO->SetOutlinerMode( eOutlinerMode ); + if( pTO->GetOutlinerParaObject() && (pOPO->GetTextObject() == pTO->GetOutlinerParaObject()->GetTextObject()) ) + { + // do nothing, same text already set + delete pOPO; + } + else + { + if( !bNewObject && pOlView->isRecordingUndo() ) + pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0)); + + pTO->SetOutlinerParaObject( pOPO ); + pTO->SetEmptyPresObj( FALSE ); + pTO->ActionChanged(); + } + } + } + else if( pTO ) + { + // Seitenobjekt, aber kein Gliederungstext: + // wenn Objekt in Praesentationsliste der Seite ist -> Defaulttext, + // sonst Objekt loeschen + if( pPage->IsPresObj(pTO) ) + { + if( !pTO->IsEmptyPresObj() ) + { + DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" ); + + // loescht auch altes OutlinerParaObject + if( pOlView->isRecordingUndo() ) + pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0)); + pPage->RestoreDefaultText( pTO ); + pTO->SetEmptyPresObj(TRUE); + pTO->ActionChanged(); + } + } + else + { + DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" ); + if( pOlView->isRecordingUndo() ) + pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoRemoveObject(*pTO)); + pPage->RemoveObject(pTO->GetOrdNum()); + } + } + + return bNewObject; +} + + +/************************************************************************* +|* +|* Outliner aus Stream fuellen +|* +\************************************************************************/ + +ULONG OutlineViewShell::Read(SvStream& rInput, const String& rBaseURL, USHORT eFormat) +{ + ULONG bRet = 0; + + ::Outliner* pOutl = pOlView->GetOutliner(); + + { + OutlineViewPageChangesGuard aGuard( pOlView ); + OutlineViewModelChangeGuard aGuard2( *pOlView ); + + bRet = pOutl->Read( rInput, rBaseURL, eFormat, GetDocSh()->GetHeaderAttributes() ); + + SdPage* pPage = GetDoc()->GetSdPage( GetDoc()->GetSdPageCount(PK_STANDARD) - 1, PK_STANDARD );; + SfxStyleSheet* pTitleSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_TITLE ); + SfxStyleSheet* pOutlSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_OUTLINE ); + + USHORT nParaCount = (USHORT)pOutl->GetParagraphCount(); + if ( nParaCount > 0 ) + { + for ( USHORT nPara = 0; nPara < nParaCount; nPara++ ) + { + pOlView->UpdateParagraph( nPara ); + + sal_Int16 nDepth = pOutl->GetDepth( nPara ); + + if( (nDepth == 0) || !nPara ) + { + Paragraph* pPara = pOutl->GetParagraph( nPara ); + pOutl->SetDepth(pPara, -1); + pOutl->SetParaFlag(pPara, PARAFLAG_ISPAGE); + + pOutl->SetStyleSheet( nPara, pTitleSheet ); + + if( nPara ) // first slide already exists + pOlView->InsertSlideForParagraph( pPara ); + } + else + { + pOutl->SetDepth( pOutl->GetParagraph( nPara ), nDepth - 1 ); + String aStyleSheetName( pOutlSheet->GetName() ); + aStyleSheetName.Erase( aStyleSheetName.Len() - 1, 1 ); + aStyleSheetName += String::CreateFromInt32( nDepth ); + SfxStyleSheetBasePool* pStylePool = GetDoc()->GetStyleSheetPool(); + SfxStyleSheet* pStyle = (SfxStyleSheet*) pStylePool->Find( aStyleSheetName, pOutlSheet->GetFamily() ); + DBG_ASSERT( pStyle, "AutoStyleSheetName - Style not found!" ); + if ( pStyle ) + pOutl->SetStyleSheet( nPara, pStyle ); + } + } + } + } + + pOutl->GetUndoManager().Clear(); + + return( bRet ); +} + +void OutlineViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse ) +{ + WriteFrameViewData(); + + ViewShell::WriteUserDataSequence( rSequence, bBrowse ); +} + +void OutlineViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse ) +{ + WriteFrameViewData(); + + ViewShell::ReadUserDataSequence( rSequence, bBrowse ); + + ReadFrameViewData( mpFrameView ); +} + +void OutlineViewShell::VisAreaChanged(const Rectangle& rRect) +{ + ViewShell::VisAreaChanged( rRect ); + + GetViewShellBase().GetDrawController().FireVisAreaChanged(rRect); +} + +/** If there is a valid controller then create a new instance of + <type>AccessibleDrawDocumentView</type>. Otherwise delegate this call + to the base class to return a default object (probably an empty + reference). +*/ +::com::sun::star::uno::Reference< + ::com::sun::star::accessibility::XAccessible> + OutlineViewShell::CreateAccessibleDocumentView (::sd::Window* pWindow) +{ + OSL_ASSERT (GetViewShell()!=NULL); + if (GetViewShell()->GetController() != NULL) + { + ::accessibility::AccessibleOutlineView* pDocumentView = + new ::accessibility::AccessibleOutlineView ( + pWindow, + this, + GetViewShell()->GetController(), + pWindow->GetAccessibleParentWindow()->GetAccessible()); + pDocumentView->Init(); + return ::com::sun::star::uno::Reference< + ::com::sun::star::accessibility::XAccessible> + (static_cast< ::com::sun::star::uno::XWeak*>(pDocumentView), + ::com::sun::star::uno::UNO_QUERY); + } + else + { + OSL_TRACE ("OutlineViewShell::CreateAccessibleDocumentView: no controller"); + return ViewShell::CreateAccessibleDocumentView (pWindow); + } +} + + + + +void OutlineViewShell::GetState (SfxItemSet& rSet) +{ + // Iterate over all requested items in the set. + SfxWhichIter aIter( rSet ); + USHORT nWhich = aIter.FirstWhich(); + while (nWhich) + { + switch (nWhich) + { + case SID_SEARCH_ITEM: + case SID_SEARCH_OPTIONS: + // Call common (old) implementation in the document shell. + GetDocSh()->GetState (rSet); + break; + default: + OSL_TRACE ("OutlineViewShell::GetState(): can not handle which id %d", nWhich); + break; + } + nWhich = aIter.NextWhich(); + } +} + + + + +void OutlineViewShell::SetCurrentPage (SdPage* pPage) +{ + // Adapt the selection of the model. + for (USHORT i=0; i<GetDoc()->GetSdPageCount(PK_STANDARD); i++) + GetDoc()->SetSelected( + GetDoc()->GetSdPage(i, PK_STANDARD), + FALSE); + GetDoc()->SetSelected (pPage, TRUE); + + DrawController& rController(GetViewShellBase().GetDrawController()); + rController.FireSelectionChangeListener(); + rController.FireSwitchCurrentPage (pPage); + + pOlView->SetActualPage(pPage); +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/outlview.cxx b/sd/source/ui/view/outlview.cxx new file mode 100755 index 000000000000..dfad4b34c6f2 --- /dev/null +++ b/sd/source/ui/view/outlview.cxx @@ -0,0 +1,2177 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "OutlineView.hxx" +#include <memory> +#include <editeng/forbiddencharacterstable.hxx> +#include <sfx2/progress.hxx> +#include <vcl/wrkwin.hxx> +#include <svx/svxids.hrc> +#include "eetext.hxx" +#include <editeng/eeitem.hxx> +#include <editeng/editstat.hxx> +#include <editeng/lrspitem.hxx> +#include <svx/svdotext.hxx> +#include <sfx2/printer.hxx> +#include <sfx2/imagemgr.hxx> +#include <sfx2/app.hxx> +#include <sfx2/bindings.hxx> +#include <svl/itempool.hxx> +#include <svl/style.hxx> +#include <svx/svdorect.hxx> +#include <svx/svdundo.hxx> +#include <svl/brdcst.hxx> +#include <vcl/msgbox.hxx> +#include <editeng/adjitem.hxx> +#include <editeng/tstpitem.hxx> +#include <editeng/lspcitem.hxx> +#include <editeng/numitem.hxx> +#include <editeng/outlobj.hxx> +#include <editeng/numitem.hxx> +#include <editeng/editeng.hxx> + +// #97766# +#include <editeng/editobj.hxx> +#include <editeng/editund2.hxx> + +#include <editeng/editview.hxx> +#include <editeng/svxfont.hxx> +#include <editeng/fhgtitem.hxx> + +#include "DrawDocShell.hxx" +#include "drawdoc.hxx" +#include "Window.hxx" +#include "sdpage.hxx" +#include "pres.hxx" +#include "OutlineViewShell.hxx" +#include "app.hrc" +#include "glob.hrc" +#include "sdresid.hxx" +#include "Outliner.hxx" +#include "strings.hrc" +#include "EventMultiplexer.hxx" +#include "ViewShellBase.hxx" +#include "undo/undoobjects.hxx" +#include "undo/undomanager.hxx" +#include "stlsheet.hxx" + +using ::rtl::OUString; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::frame; + +namespace sd { + +// Breite: DIN A 4, zwei Raender zu je 1 cm +#define OUTLINE_PAPERWIDTH 19000 + +// beim Seitenmanipulation Fortschrittsanzeige, wenn mehr Seiten betroffen +// sind als: +#define PROCESS_WITH_PROGRESS_THRESHOLD 5 + +struct SdParaAndPos +{ + Paragraph* pPara; + USHORT nPos; +}; + +TYPEINIT1( OutlineView, ::sd::View ); + +/************************************************************************* +|* +|* Konstruktor +|* +\************************************************************************/ + +OutlineView::OutlineView( DrawDocShell* pDocSh, ::Window* pWindow, OutlineViewShell* pOutlineViewSh) +: ::sd::View(pDocSh->GetDoc(), pWindow, pOutlineViewSh) +, mpOutlineViewShell(pOutlineViewSh) +, mpOutliner( mpDoc->GetOutliner(TRUE) ) +, mpOldParaOrder(NULL) +, mpSelectedParas(NULL) +, mnPagesToProcess(0) +, mnPagesProcessed(0) +, mbFirstPaint(TRUE) +, mpProgress(NULL) +, mbHighContrastMode( false ) +, maDocColor( COL_WHITE ) +, mnPageNumberWidthPixel( 0 ) +, maLRSpaceItem( 0, 0, 2000, 0, EE_PARA_OUTLLRSPACE ) +{ + BOOL bInitOutliner = FALSE; + + if (mpOutliner->GetViewCount() == 0) + { + // Outliner initialisieren: Referenz-Device setzen + bInitOutliner = TRUE; + mpOutliner->Init( OUTLINERMODE_OUTLINEVIEW ); +/* + SfxStyleSheet* pTitleSheet = mpDoc->GetSdPage( 0, PK_STANDARD )->GetStyleSheetForPresObj( PRESOBJ_TITLE ); + + if ( pTitleSheet ) + { + // set title symbol (level 0) + SvxNumBulletItem aNumBulletItem( (const SvxNumBulletItem&) pTitleSheet->GetItemSet().Get(EE_PARA_NUMBULLET) ); + SvxNumRule aNumRule(* aNumBulletItem.GetNumRule()); + SvxNumberFormat aFormat( aNumRule.GetLevel(0)); + Font aBulletFont; + const Font* pFont = aFormat.GetBulletFont(); + if ( pFont ) // if available take font size and color from style + aBulletFont = *pFont; + else + { + aBulletFont.SetColor( COL_AUTO ); + aBulletFont.SetHeight( 1552 ); + } + aBulletFont.SetCharSet(RTL_TEXTENCODING_MS_1252); // and replacing other values by standard + aBulletFont.SetName( String( RTL_CONSTASCII_USTRINGPARAM( "StarSymbol" )) ); + aBulletFont.SetWeight(WEIGHT_NORMAL); + aBulletFont.SetUnderline(UNDERLINE_NONE); + aBulletFont.SetStrikeout(STRIKEOUT_NONE); + aBulletFont.SetItalic(ITALIC_NONE); + aBulletFont.SetOutline(FALSE); + aBulletFont.SetShadow(FALSE); + aFormat.SetBulletFont( &aBulletFont ); + aFormat.SetBulletChar( 0xE011 ); // StarBats: 0xF000 + 114 + mpOutliner->OverwriteLevel0Bullet( aFormat ); + } +*/ + mpOutliner->SetRefDevice( SD_MOD()->GetRefDevice( *pDocSh ) ); + ULONG nWidth = OUTLINE_PAPERWIDTH; + mpOutliner->SetPaperSize(Size(nWidth, 400000000)); + } + + // View in Outliner einfuegen + for (USHORT nView = 0; nView < MAX_OUTLINERVIEWS; nView++) + { + mpOutlinerView[nView] = NULL; + } + + mpOutlinerView[0] = new OutlinerView(mpOutliner, pWindow); + Rectangle aNullRect; + mpOutlinerView[0]->SetOutputArea(aNullRect); + mpOutliner->SetUpdateMode(FALSE); + mpOutliner->InsertView(mpOutlinerView[0], LIST_APPEND); + + onUpdateStyleSettings( true ); + + if (bInitOutliner) + { + // Outliner mit Inhalt fuellen + FillOutliner(); + } + + Link aLink( LINK(this,OutlineView,EventMultiplexerListener) ); + mpOutlineViewShell->GetViewShellBase().GetEventMultiplexer()->AddEventListener( + aLink, + tools::EventMultiplexerEvent::EID_CURRENT_PAGE + | tools::EventMultiplexerEvent::EID_PAGE_ORDER); + + LanguageType eLang = mpOutliner->GetDefaultLanguage(); + maPageNumberFont = OutputDevice::GetDefaultFont( DEFAULTFONT_SANS_UNICODE, eLang, 0 ); + maPageNumberFont.SetHeight( 500 ); + + maBulletFont.SetColor( COL_AUTO ); + maBulletFont.SetHeight( 1000 ); + maBulletFont.SetCharSet(RTL_TEXTENCODING_MS_1252); // and replacing other values by standard + maBulletFont.SetName( String( RTL_CONSTASCII_USTRINGPARAM( "StarSymbol" )) ); + maBulletFont.SetWeight(WEIGHT_NORMAL); + maBulletFont.SetUnderline(UNDERLINE_NONE); + maBulletFont.SetStrikeout(STRIKEOUT_NONE); + maBulletFont.SetItalic(ITALIC_NONE); + maBulletFont.SetOutline(FALSE); + maBulletFont.SetShadow(FALSE); + + + Reference<XFrame> xFrame (mpOutlineViewShell->GetViewShellBase().GetFrame()->GetTopFrame().GetFrameInterface(), UNO_QUERY); + + const OUString aSlotURL( RTL_CONSTASCII_USTRINGPARAM( ".uno:ShowSlide" )); + maSlideImage = GetImage( xFrame, aSlotURL, true, false /* todo, hc mode */ ); + + // Tell undo manager of the document about the undo manager of the + // outliner, so that the former can synchronize with the later. + sd::UndoManager* pDocUndoMgr = dynamic_cast<sd::UndoManager*>(mpDocSh->GetUndoManager()); + if (pDocUndoMgr != NULL) + pDocUndoMgr->SetLinkedUndoManager(&mpOutliner->GetUndoManager()); +} + +/************************************************************************* +|* +|* Destruktor, Links restaurieren, Outliner leeren +|* +\************************************************************************/ + +OutlineView::~OutlineView() +{ + DBG_ASSERT(maDragAndDropModelGuard.get() == 0, "sd::OutlineView::~OutlineView(), prior drag operation not finished correctly!" ); + + Link aLink( LINK(this,OutlineView,EventMultiplexerListener) ); + mpOutlineViewShell->GetViewShellBase().GetEventMultiplexer()->RemoveEventListener( aLink ); + DisconnectFromApplication(); + + if( mpProgress ) + delete mpProgress; + + // OutlinerViews abmelden und zerstoeren + for (USHORT nView = 0; nView < MAX_OUTLINERVIEWS; nView++) + { + if (mpOutlinerView[nView] != NULL) + { + mpOutliner->RemoveView( mpOutlinerView[nView] ); + delete mpOutlinerView[nView]; + mpOutlinerView[nView] = NULL; + } + } + + if (mpOutliner->GetViewCount() == 0) + { + // Outliner deinitialisieren: Farbdarstellung einschalten + ResetLinks(); + ULONG nCntrl = mpOutliner->GetControlWord(); + mpOutliner->SetUpdateMode(FALSE); // sonst wird bei SetControlWord gezeichnet + mpOutliner->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS); + SvtAccessibilityOptions aOptions; + mpOutliner->ForceAutoColor( aOptions.GetIsAutomaticFontColor() ); + mpOutliner->Clear(); + } + + DBG_ASSERT(!mpSelectedParas, "Absatzliste nicht geloescht"); + DBG_ASSERT(!mpOldParaOrder, "Absatzliste nicht geloescht"); +} + + + + +void OutlineView::ConnectToApplication (void) +{ + mpOutlineViewShell->GetActiveWindow()->GrabFocus(); + Application::AddEventListener(LINK(this, OutlineView, AppEventListenerHdl)); +} + + + + +void OutlineView::DisconnectFromApplication (void) +{ + Application::RemoveEventListener(LINK(this, OutlineView, AppEventListenerHdl)); +} + + + + +/************************************************************************* +|* +|* Paint-Methode +|* +\************************************************************************/ + +void OutlineView::Paint(const Rectangle& rRect, ::sd::Window* pWin) +{ + OutlinerView* pOlView = GetViewByWindow(pWin); + + if (pOlView) + { + pOlView->HideCursor(); + pOlView->Paint(rRect); + + pOlView->ShowCursor(mbFirstPaint); + +/* + if( mnPageNumberWidthPixel == 0 ) + GetPageNumberWidthPixel(); + + const ULONG nParaCount = pOlView->GetOutliner()->GetParagraphCount(); + EditView& rEditView = pOlView->GetEditView(); + + Font aOldFont( pWin->GetFont() ); + + const String aBulletStr( sal_Unicode( 0xE011 ) ); + pWin->SetFont( maBulletFont); + sal_Int32 nBulletWidth = pWin->GetTextWidth(aBulletStr); + + sal_Int32 nPage = 1; + for( ULONG nPara = 0; nPara < nParaCount; nPara++ ) + { + Paragraph* pPara = pOlView->GetOutliner()->GetParagraph( nPara ); + if( pPara->HasFlag( PARAFLAG_ISPAGE ) ) + { + pWin->SetFont( maPageNumberFont ); + const String aStr( String::CreateFromInt32( nPage++ ) ); + Point aPos( rEditView.GetWindowPosTopLeft( (USHORT)nPara ) ); + + sal_Int32 nNumberOffset = pWin->PixelToLogic( Point(mnPageNumberWidthPixel, 0) ).X() - nBulletWidth; + sal_Int32 nLineHeight = pOlView->GetOutliner()->GetLineHeight( nPara, 0 ); + + aPos.X() = nNumberOffset; + + Point aPoint( aPos.X() - pWin->GetTextWidth( aStr ), aPos.Y() + ( nLineHeight - maPageNumberFont.GetHeight()) / 2 ); + pWin->DrawText( aPoint, aStr ); + + aPoint.X() = aPos.X(); + aPoint.Y() = aPos.Y() +( nLineHeight - maBulletFont.GetHeight()) / 2; + pWin->SetFont( maBulletFont ); + pWin->DrawText( aPoint, aBulletStr ); + } + } + + pWin->SetFont( aOldFont ); +*/ + mbFirstPaint = FALSE; + } +} + +void OutlineView::InvalidateSlideNumberArea() +{ +/* + for( sal_Int16 nView = 0; nView < MAX_OUTLINERVIEWS; ++nView ) + { + if (mpOutlinerView[nView] != NULL) + { + ::Window* pWindow = mpOutlinerView[nView]->GetWindow(); + if( pWindow ) + { + Rectangle aRect( Point(0,0), pWindow->GetOutputSize() ); + aRect.nRight = aRect.nLeft + pWindow->PixelToLogic( Point( mnPageNumberWidthPixel, 0 ) ).X() * 2; + + pWindow->Invalidate(aRect); + } + } + } +*/ +} + +/************************************************************************* +|* +|* Fenster-Groesse hat sich geaendert +|* +\************************************************************************/ + +void OutlineView::AdjustPosSizePixel(const Point &,const Size &,::sd::Window*) +{ +} + +/************************************************************************* +|* +|* ein Fenster hinzufuegen +|* +\************************************************************************/ + +void OutlineView::AddWindowToPaintView(OutputDevice* pWin) +{ + BOOL bAdded = FALSE; + BOOL bValidArea = FALSE; + Rectangle aOutputArea; + const Color aWhiteColor( COL_WHITE ); + USHORT nView = 0; + + while (nView < MAX_OUTLINERVIEWS && !bAdded) + { + if (mpOutlinerView[nView] == NULL) + { + mpOutlinerView[nView] = new OutlinerView(mpOutliner, dynamic_cast< ::sd::Window* >(pWin)); + mpOutlinerView[nView]->SetBackgroundColor( aWhiteColor ); + mpOutliner->InsertView(mpOutlinerView[nView], LIST_APPEND); + bAdded = TRUE; + + if (bValidArea) + { + mpOutlinerView[nView]->SetOutputArea(aOutputArea); + } + } + else if (!bValidArea) + { + aOutputArea = mpOutlinerView[nView]->GetOutputArea(); + bValidArea = TRUE; + } + + nView++; + } + + // weisser Hintergrund im Outliner + pWin->SetBackground( Wallpaper( aWhiteColor ) ); + + ::sd::View::AddWindowToPaintView(pWin); +} + +/************************************************************************* +|* +|* ein Fenster entfernen +|* +\************************************************************************/ + +void OutlineView::DeleteWindowFromPaintView(OutputDevice* pWin) +{ + BOOL bRemoved = FALSE; + USHORT nView = 0; + ::Window* pWindow; + + while (nView < MAX_OUTLINERVIEWS && !bRemoved) + { + if (mpOutlinerView[nView] != NULL) + { + pWindow = mpOutlinerView[nView]->GetWindow(); + + if (pWindow == pWin) + { + mpOutliner->RemoveView( mpOutlinerView[nView] ); + delete mpOutlinerView[nView]; + mpOutlinerView[nView] = NULL; + bRemoved = TRUE; + } + } + + nView++; + } + + ::sd::View::DeleteWindowFromPaintView(pWin); +} + +/************************************************************************* +|* +|* Zeiger der dem Fenster entsprechenden OutlinerView zurueckgeben. +|* +\************************************************************************/ + +OutlinerView* OutlineView::GetViewByWindow (::Window* pWin) const +{ + OutlinerView* pOlView = NULL; + for (USHORT nView = 0; nView < MAX_OUTLINERVIEWS; nView++) + { + if (mpOutlinerView[nView] != NULL) + { + if ( pWin == mpOutlinerView[nView]->GetWindow() ) + { + pOlView = mpOutlinerView[nView]; + } + } + } + return (pOlView); +} + + +/************************************************************************* +|* +|* Ermittelt den Titel vor einem beliebigen Absatz. +|* +\************************************************************************/ + +Paragraph* OutlineView::GetPrevTitle(const Paragraph* pPara) +{ + sal_Int32 nPos = mpOutliner->GetAbsPos(const_cast<Paragraph*>(pPara)); + + if (nPos > 0) + { + while(nPos) + { + pPara = mpOutliner->GetParagraph(--nPos); + if( mpOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) + { + return const_cast< Paragraph* >( pPara ); + } + } + + } + return NULL; +} + +/************************************************************************* +|* +|* Ermittelt den Titel nach einem beliebigen Absatz. +|* +\************************************************************************/ + +Paragraph* OutlineView::GetNextTitle(const Paragraph* pPara) +{ + Paragraph* pResult = const_cast< Paragraph* >( pPara ); + + sal_Int32 nPos = mpOutliner->GetAbsPos(pResult); + + do + { + pResult = mpOutliner->GetParagraph(++nPos); + if( pResult && mpOutliner->HasParaFlag(pResult, PARAFLAG_ISPAGE) ) + return pResult; + } + while( pResult ); + + return NULL; +} + +/************************************************************************* +|* +|* Handler fuer das Einfuegen von Seiten (Absaetzen) +|* +\************************************************************************/ + +IMPL_LINK( OutlineView, ParagraphInsertedHdl, ::Outliner *, pOutliner ) +{ +// DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::ParagraphInsertedHdl(), model change without undo?!" ); + + // we get calls to this handler during binary insert of drag and drop contents but + // we ignore it here and handle it later in OnEndPasteOrDrop() + if( maDragAndDropModelGuard.get() == 0 ) + { + OutlineViewPageChangesGuard aGuard(this); + + Paragraph* pPara = pOutliner->GetHdlParagraph(); + + USHORT nAbsPos = (USHORT)mpOutliner->GetAbsPos( pPara ); + + UpdateParagraph( nAbsPos ); + + if( (nAbsPos == 0) || mpOutliner->HasParaFlag(pPara,PARAFLAG_ISPAGE) || mpOutliner->HasParaFlag(mpOutliner->GetParagraph( nAbsPos-1 ), PARAFLAG_ISPAGE) ) + { + InsertSlideForParagraph( pPara ); + InvalidateSlideNumberArea(); + } + } + + return 0; +} + +/** creates and inserts an empty slide for the given paragraph */ +SdPage* OutlineView::InsertSlideForParagraph( Paragraph* pPara ) +{ + DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::InsertSlideForParagraph(), model change without undo?!" ); + + OutlineViewPageChangesGuard aGuard(this); + + mpOutliner->SetParaFlag( pPara, PARAFLAG_ISPAGE ); + // wieviele Titel sind vor dem neuen Titelabsatz? + ULONG nExample = 0L; // Position der "Vorbild"seite + ULONG nTarget = 0L; // Einfuegeposition + while(pPara) + { + pPara = GetPrevTitle(pPara); + if (pPara) + nTarget++; + } + + + // was der Outliner nicht kann, muss hier wieder wettgemacht werden: + // wenn VOR dem ersten Absatz ein neuer Absatz mit RETURN erzeugt wird, + // meldet der Outliner den bereits bestehenden (jetzt nach unten + // gerutschten) Absatz als neuen Absatz; nicht darauf reinfallen! + if (nTarget == 1) + { + String aTest(mpOutliner->GetText( mpOutliner->GetParagraph( 0 ) )); + if (aTest.Len() == 0) + { + nTarget = 0; + } + } + + + // "Vorbild"seite ist - wenn vorhanden - die Vorgaengerseite + if (nTarget > 0) + { + nExample = nTarget - 1; + + USHORT nPageCount = mpDoc->GetSdPageCount( PK_STANDARD ); + if( nExample >= nPageCount ) + nExample = nPageCount - 1; + } + + /********************************************************************** + * Es wird stets zuerst eine Standardseite und dann eine + * Notizseite erzeugt. Es ist sichergestellt, dass auf eine + * Standardseite stets die zugehoerige Notizseite folgt. + * Vorangestellt ist genau eine Handzettelseite + **********************************************************************/ + + // diese Seite hat Vorbildfunktion + SdPage* pExample = (SdPage*)mpDoc->GetSdPage((USHORT)nExample, PK_STANDARD); + SdPage* pPage = (SdPage*)mpDoc->AllocPage(FALSE); + + pPage->SetLayoutName(pExample->GetLayoutName()); + + // einfuegen (Seite) + mpDoc->InsertPage(pPage, (USHORT)(nTarget) * 2 + 1); + if( isRecordingUndo() ) + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoNewPage(*pPage)); + + // der Standardseite eine Masterpage zuweisen + pPage->TRG_SetMasterPage(pExample->TRG_GetMasterPage()); + + // Seitengroesse setzen + pPage->SetSize(pExample->GetSize()); + pPage->SetBorder( pExample->GetLftBorder(), + pExample->GetUppBorder(), + pExample->GetRgtBorder(), + pExample->GetLwrBorder() ); + + // neue Praesentationsobjekte anlegen (auf <Titel> oder + // <Titel mit Untertitel> folgt <Titel mit Gliederung>, ansonsten + // wird das Layout von der Vorgaengerseite uebernommen) + AutoLayout eAutoLayout = pExample->GetAutoLayout(); + if (eAutoLayout == AUTOLAYOUT_TITLE || + eAutoLayout == AUTOLAYOUT_ONLY_TITLE) + { + pPage->SetAutoLayout(AUTOLAYOUT_ENUM, TRUE); + } + else + { + pPage->SetAutoLayout(pExample->GetAutoLayout(), TRUE); + } + + /********************************************************************** + |* jetzt die Notizseite + \*********************************************************************/ + pExample = (SdPage*)mpDoc->GetSdPage((USHORT)nExample, PK_NOTES); + SdPage* pNotesPage = (SdPage*)mpDoc->AllocPage(FALSE); + + pNotesPage->SetLayoutName(pExample->GetLayoutName()); + + pNotesPage->SetPageKind(PK_NOTES); + + // einfuegen (Notizseite) + mpDoc->InsertPage(pNotesPage, (USHORT)(nTarget) * 2 + 2); + if( isRecordingUndo() ) + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoNewPage(*pNotesPage)); + + // der Notizseite eine Masterpage zuweisen + pNotesPage->TRG_SetMasterPage(pExample->TRG_GetMasterPage()); + + // Seitengroesse setzen, es muss bereits eine Seite vorhanden sein + pNotesPage->SetSize(pExample->GetSize()); + pNotesPage->SetBorder( pExample->GetLftBorder(), + pExample->GetUppBorder(), + pExample->GetRgtBorder(), + pExample->GetLwrBorder() ); + + // neue Praesentationsobjekte anlegen + pNotesPage->SetAutoLayout(pExample->GetAutoLayout(), TRUE); + + mpOutliner->UpdateFields(); + + return pPage; +} + +/************************************************************************* +|* +|* Handler fuer das Loeschen von Seiten (Absaetzen) +|* +\************************************************************************/ + +IMPL_LINK( OutlineView, ParagraphRemovingHdl, ::Outliner *, pOutliner ) +{ + DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::ParagraphRemovingHdl(), model change without undo?!" ); + + OutlineViewPageChangesGuard aGuard(this); + + Paragraph* pPara = pOutliner->GetHdlParagraph(); + if( pOutliner->HasParaFlag( pPara, PARAFLAG_ISPAGE ) ) + { + // wieviele Titel sind vor dem fraglichen Titelabsatz? + ULONG nPos = 0L; + while(pPara) + { + pPara = GetPrevTitle(pPara); + if (pPara) nPos++; + } + + // Seite und Notizseite loeschen + USHORT nAbsPos = (USHORT)nPos * 2 + 1; + SdrPage* pPage = mpDoc->GetPage(nAbsPos); + if( isRecordingUndo() ) + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoDeletePage(*pPage)); + mpDoc->RemovePage(nAbsPos); + + nAbsPos = (USHORT)nPos * 2 + 1; + pPage = mpDoc->GetPage(nAbsPos); + if( isRecordingUndo() ) + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoDeletePage(*pPage)); + mpDoc->RemovePage(nAbsPos); + + // ggfs. Fortschrittsanzeige + if (mnPagesToProcess) + { + mnPagesProcessed++; + + if(mpProgress) + mpProgress->SetState(mnPagesProcessed); + + if (mnPagesProcessed == mnPagesToProcess) + { + if(mpProgress) + { + delete mpProgress; + mpProgress = NULL; + } + mnPagesToProcess = 0; + mnPagesProcessed = 0; + } + } + pOutliner->UpdateFields(); + } + + InvalidateSlideNumberArea(); + + return 0; +} + +/************************************************************************* +|* +|* Handler fuer das Aendern der Einruecktiefe von Absaetzen (macht ggfs. +|* das Einfuegen oder Loeschen von Seiten notwendig) +|* +\************************************************************************/ + +IMPL_LINK( OutlineView, DepthChangedHdl, ::Outliner *, pOutliner ) +{ + DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::DepthChangedHdl(), no undo for model change?!" ); + + OutlineViewPageChangesGuard aGuard(this); + + Paragraph* pPara = pOutliner->GetHdlParagraph(); + if( pOutliner->HasParaFlag( pPara, PARAFLAG_ISPAGE ) && ((pOutliner->GetPrevFlags() & PARAFLAG_ISPAGE) == 0) ) + { + // the current paragraph is transformed into a slide + + mpOutliner->SetDepth( pPara, -1 ); + + // werden da etwa mehrere Level-1-Absaetze auf Level 0 gebracht und + // wir sollten eine Fortschrittsanzeige oder Eieruhr aufsetzen und + // haben es noch nicht getan? + if (mnPagesToProcess == 0) + { + Window* pActWin = mpOutlineViewShell->GetActiveWindow(); + OutlinerView* pOlView = GetViewByWindow(pActWin); + List* pList = pOlView->CreateSelectionList(); + + Paragraph* pParagraph = (Paragraph*)pList->First(); + while (pParagraph) + { + if( !pOutliner->HasParaFlag( pParagraph, PARAFLAG_ISPAGE ) && (pOutliner->GetDepth( (USHORT) pOutliner->GetAbsPos( pParagraph ) ) <= 0) ) + mnPagesToProcess++; + pParagraph = (Paragraph*)pList->Next(); + } + + mnPagesToProcess++; // der Absatz, der jetzt schon auf Level 0 + // steht, gehoert auch dazu + mnPagesProcessed = 0; + + if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD) + { + if( mpProgress ) + delete mpProgress; + + const String aStr(SdResId(STR_CREATE_PAGES)); + mpProgress = new SfxProgress( GetDocSh(), aStr, mnPagesToProcess ); + } + else + { + mpDocSh->SetWaitCursor( TRUE ); + } + delete pList; + } + + ParagraphInsertedHdl(pOutliner); + + mnPagesProcessed++; + + // muss eine Fortschrittsanzeige gepflegt werden? + if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD) + { + if (mpProgress) + mpProgress->SetState(mnPagesProcessed); + } + + // war das die letzte Seite? + if (mnPagesProcessed == mnPagesToProcess) + { + if (mnPagesToProcess > PROCESS_WITH_PROGRESS_THRESHOLD && mpProgress) + { + delete mpProgress; + mpProgress = NULL; + } + else + mpDocSh->SetWaitCursor( FALSE ); + + mnPagesToProcess = 0; + mnPagesProcessed = 0; + } + pOutliner->UpdateFields(); + } + else if( !pOutliner->HasParaFlag( pPara, PARAFLAG_ISPAGE ) && ((pOutliner->GetPrevFlags() & PARAFLAG_ISPAGE) != 0) ) + { + // the paragraph was a page but now becomes a normal paragraph + + // how many titles are before the title paragraph in question? + ULONG nPos = 0L; + Paragraph* pParagraph = pPara; + while(pParagraph) + { + pParagraph = GetPrevTitle(pParagraph); + if (pParagraph) + nPos++; + } + // Seite und Notizseite loeschen + + USHORT nAbsPos = (USHORT)nPos * 2 + 1; + SdrPage* pPage = mpDoc->GetPage(nAbsPos); + if( isRecordingUndo() ) + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoDeletePage(*pPage)); + mpDoc->RemovePage(nAbsPos); + + nAbsPos = (USHORT)nPos * 2 + 1; + pPage = mpDoc->GetPage(nAbsPos); + if( isRecordingUndo() ) + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoDeletePage(*pPage)); + mpDoc->RemovePage(nAbsPos); + + pPage = GetPageForParagraph( pPara ); + + mpOutliner->SetDepth( pPara, (pPage && (static_cast<SdPage*>(pPage)->GetAutoLayout() == AUTOLAYOUT_TITLE)) ? -1 : 0 ); + + // ggfs. Fortschrittsanzeige + if (mnPagesToProcess) + { + mnPagesProcessed++; + if (mpProgress) + mpProgress->SetState(mnPagesProcessed); + + if (mnPagesProcessed == mnPagesToProcess) + { + if(mpProgress) + { + delete mpProgress; + mpProgress = NULL; + } + mnPagesToProcess = 0; + mnPagesProcessed = 0; + } + } + pOutliner->UpdateFields(); + } + else if ( (pOutliner->GetPrevDepth() == 1) && ( pOutliner->GetDepth( (USHORT) pOutliner->GetAbsPos( pPara ) ) == 2 ) ) + { + // wieviele Titel sind vor dem fraglichen Titelabsatz? + sal_Int32 nPos = -1L; + + Paragraph* pParagraph = pPara; + while(pParagraph) + { + pParagraph = GetPrevTitle(pParagraph); + if (pParagraph) + nPos++; + } + + if(nPos >= 0) + { + SdPage*pPage = (SdPage*)mpDoc->GetSdPage( (USHORT) nPos, PK_STANDARD); + + if(pPage && pPage->GetPresObj(PRESOBJ_TEXT)) + pOutliner->SetDepth( pPara, 0 ); + } + + } + // wieviele Titel sind vor dem fraglichen Titelabsatz? + sal_Int32 nPos = -1L; + + Paragraph* pTempPara = pPara; + while(pTempPara) + { + pTempPara = GetPrevTitle(pTempPara); + if (pTempPara) + nPos++; + } + + if( nPos >= 0 ) + { + SdPage* pPage = (SdPage*) mpDoc->GetSdPage( (USHORT) nPos, PK_STANDARD ); + + if( pPage ) + { + SfxStyleSheet* pStyleSheet = NULL; + ULONG nPara = pOutliner->GetAbsPos( pPara ); + sal_Int16 nDepth = pOutliner->GetDepth( (USHORT) nPara ); + bool bSubTitle = pPage->GetPresObj(PRESOBJ_TEXT) != NULL; + + if( pOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) + { + pStyleSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_TITLE ); + } + else if( bSubTitle ) + { + pStyleSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_TEXT ); + } + else + { + pStyleSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_OUTLINE ); + + if( nDepth > 0 ) + { + String aNewStyleSheetName( pStyleSheet->GetName() ); + aNewStyleSheetName.Erase( aNewStyleSheetName.Len()-1, 1 ); + aNewStyleSheetName += String::CreateFromInt32( nDepth+1 ); + SfxStyleSheetBasePool* pStylePool = mpDoc->GetStyleSheetPool(); + pStyleSheet = (SfxStyleSheet*) pStylePool->Find( aNewStyleSheetName, pStyleSheet->GetFamily() ); + } + } + + // before we set the style sheet we need to preserve the bullet item + // since all items will be deleted while setting a new style sheet + SfxItemSet aOldAttrs( pOutliner->GetParaAttribs( (USHORT)nPara ) ); + + pOutliner->SetStyleSheet( nPara, pStyleSheet ); + + // restore the old bullet item but not if the style changed + if ( pOutliner->GetPrevDepth() != -1 && nDepth != -1 && + aOldAttrs.GetItemState( EE_PARA_NUMBULLET ) == SFX_ITEM_ON ) + { + SfxItemSet aAttrs( pOutliner->GetParaAttribs( (USHORT)nPara ) ); + aAttrs.Put( *aOldAttrs.GetItem( EE_PARA_NUMBULLET ) ); + pOutliner->SetParaAttribs( (USHORT)nPara, aAttrs ); + } + } + } + + InvalidateSlideNumberArea(); + + return 0; +} + +/************************************************************************* +|* +|* Handler fuer StatusEvents +|* +\************************************************************************/ + +IMPL_LINK( OutlineView, StatusEventHdl, EditStatus *, EMPTYARG ) +{ + ::sd::Window* pWin = mpOutlineViewShell->GetActiveWindow(); + OutlinerView* pOutlinerView = GetViewByWindow(pWin); + Rectangle aVis = pOutlinerView->GetVisArea(); + +// ULONG nWidth = ((SdPage*)mpDoc->GetSdPage(0, PK_STANDARD))->GetSize().Width(); + ULONG nWidth = OUTLINE_PAPERWIDTH; + Rectangle aText = Rectangle(Point(0,0), + Size(nWidth, + mpOutliner->GetTextHeight())); + Rectangle aWin(Point(0,0), pWin->GetOutputSizePixel()); + aWin = pWin->PixelToLogic(aWin); + + if (!aVis.IsEmpty()) // nicht beim Oeffnen + { + aText.Bottom() += aWin.GetHeight(); + + mpOutlineViewShell->InitWindows(Point(0,0), aText.GetSize(), + Point(aVis.TopLeft())); + mpOutlineViewShell->UpdateScrollBars(); + } + + InvalidateSlideNumberArea(); + return 0; +} + +IMPL_LINK( OutlineView, BeginDropHdl, void *, EMPTYARG ) +{ + DBG_ASSERT(maDragAndDropModelGuard.get() == 0, "sd::OutlineView::BeginDropHdl(), prior drag operation not finished correctly!" ); + + maDragAndDropModelGuard.reset( new OutlineViewModelChangeGuard( *this ) ); + return 0; +} + +IMPL_LINK( OutlineView, EndDropHdl, void *, EMPTYARG ) +{ + maDragAndDropModelGuard.reset(0); + InvalidateSlideNumberArea(); + return 0; +} + +/************************************************************************* +|* +|* Handler fuer den Beginn einer Absatzverschiebung +|* +\************************************************************************/ + +IMPL_LINK( OutlineView, BeginMovingHdl, ::Outliner *, pOutliner ) +{ + DBG_ASSERT(!mpSelectedParas, "Absatzliste nicht geloescht"); + DBG_ASSERT(!mpOldParaOrder, "Absatzliste nicht geloescht"); + + OutlineViewPageChangesGuard aGuard(this); + + mpOldParaOrder = new List; + + // Liste der selektierten Titelabsaetze + mpSelectedParas = mpOutlinerView[0]->CreateSelectionList(); + Paragraph* pPara = static_cast<Paragraph*>(mpSelectedParas->First()); + while (pPara) + { + if( !pOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) + { + mpSelectedParas->Remove(); + pPara = static_cast<Paragraph*>(mpSelectedParas->GetCurObject()); + } + else + { + pPara = static_cast<Paragraph*>(mpSelectedParas->Next()); + } + } + + // Die zu den selektierten Absaetzen auf Ebene 0 gehoerenden Seiten + // selektieren + USHORT nPos = 0; + ULONG nParaPos = 0; + pPara = pOutliner->GetParagraph( 0 ); + + while(pPara) + { + if( pOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) // eine Seite? + { + mpOldParaOrder->Insert(pPara, LIST_APPEND); + SdPage* pPage = mpDoc->GetSdPage(nPos, PK_STANDARD); + pPage->SetSelected(FALSE); + if (mpSelectedParas->Seek(pPara)) // selektiert? + { + pPage->SetSelected(TRUE); + } + nPos++; + } + pPara = pOutliner->GetParagraph( ++nParaPos ); + } + + return 0; +} + +/************************************************************************* +|* +|* Handler fuer das Ende einer Absatzverschiebung +|* +\************************************************************************/ + +IMPL_LINK( OutlineView, EndMovingHdl, ::Outliner *, pOutliner ) +{ + OutlineViewPageChangesGuard aGuard(this); + + DBG_ASSERT(mpSelectedParas, "keine Absatzliste"); + DBG_ASSERT(mpOldParaOrder, "keine Absatzliste"); + DBG_ASSERT( isRecordingUndo(), "sd::OutlineView::EndMovingHdl(), model change without undo?!" ); + + // Einfuegeposition anhand des ersten Absatzes suchen + Paragraph* pSearchIt = (Paragraph*)mpSelectedParas->First(); + + // den ersten der selektierten Paragraphen in der neuen Ordnung suchen + USHORT nPosNewOrder = 0; + ULONG nParaPos = 0; + Paragraph* pPara = pOutliner->GetParagraph( 0 ); + Paragraph* pPrev = NULL; + while (pPara && pPara != pSearchIt) + { + if( pOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) + { + nPosNewOrder++; + pPrev = pPara; + } + pPara = pOutliner->GetParagraph( ++nParaPos ); + } + + USHORT nPos = nPosNewOrder; // nPosNewOrder nicht veraendern + if (nPos == 0) + { + nPos = (USHORT)-1; // vor der ersten Seite einfuegen + } + else + { + // den Vorgaenger in der alten Ordnung suchen + nPos = (USHORT)mpOldParaOrder->GetPos(pPrev); + DBG_ASSERT(nPos != 0xffff, "Absatz nicht gefunden"); + } + + mpDoc->MovePages(nPos); + + // die Seiten wieder deselektieren + USHORT nPageCount = (USHORT)mpSelectedParas->Count(); + while (nPageCount) + { + SdPage* pPage = mpDoc->GetSdPage(nPosNewOrder, PK_STANDARD); + pPage->SetSelected(FALSE); + nPosNewOrder++; + nPageCount--; + } + + pOutliner->UpdateFields(); + + delete mpSelectedParas; + mpSelectedParas = NULL; + delete mpOldParaOrder; + mpOldParaOrder = NULL; + + InvalidateSlideNumberArea(); + + return 0; +} + +/************************************************************************* +|* +|* Eine Seite des Models nach dem Titeltextobjekt durchsuchen +|* +\************************************************************************/ + +SdrTextObj* OutlineView::GetTitleTextObject(SdrPage* pPage) +{ + ULONG nObjectCount = pPage->GetObjCount(); + SdrObject* pObject = NULL; + SdrTextObj* pResult = NULL; + + for (ULONG nObject = 0; nObject < nObjectCount; nObject++) + { + pObject = pPage->GetObj(nObject); + if (pObject->GetObjInventor() == SdrInventor && + pObject->GetObjIdentifier() == OBJ_TITLETEXT) + { + pResult = (SdrTextObj*)pObject; + break; + } + } + return pResult; +} + + +/************************************************************************* +|* +|* Eine Seite des Models nach dem Gliederungstextobjekt durchsuchen +|* +\************************************************************************/ + +SdrTextObj* OutlineView::GetOutlineTextObject(SdrPage* pPage) +{ + ULONG nObjectCount = pPage->GetObjCount(); + SdrObject* pObject = NULL; + SdrTextObj* pResult = NULL; + + for (ULONG nObject = 0; nObject < nObjectCount; nObject++) + { + pObject = pPage->GetObj(nObject); + if (pObject->GetObjInventor() == SdrInventor && + pObject->GetObjIdentifier() == OBJ_OUTLINETEXT) + { + pResult = (SdrTextObj*)pObject; + break; + } + } + return pResult; +} + +SdrTextObj* OutlineView::CreateTitleTextObject(SdPage* pPage) +{ + DBG_ASSERT( GetTitleTextObject(pPage) == 0, "sd::OutlineView::CreateTitleTextObject(), there is already a title text object!" ); + + if( pPage->GetAutoLayout() == AUTOLAYOUT_NONE ) + { + // simple case + pPage->SetAutoLayout( AUTOLAYOUT_ONLY_TITLE, true ); + } + else + { + // we already have a layout with a title but the title + // object was deleted, create a new one + pPage->InsertAutoLayoutShape( 0, PRESOBJ_TITLE, false, pPage->GetTitleRect(), true ); + } + + return GetTitleTextObject(pPage); +} + +SdrTextObj* OutlineView::CreateOutlineTextObject(SdPage* pPage) +{ + DBG_ASSERT( GetOutlineTextObject(pPage) == 0, "sd::OutlineView::CreateOutlineTextObject(), there is already a layout text object!" ); + + AutoLayout eNewLayout = pPage->GetAutoLayout(); + switch( eNewLayout ) + { + case AUTOLAYOUT_NONE: + case AUTOLAYOUT_ONLY_TITLE: + case AUTOLAYOUT_TITLE: eNewLayout = AUTOLAYOUT_ENUM; break; + + case AUTOLAYOUT_CHART: eNewLayout = AUTOLAYOUT_CHARTTEXT; break; + + case AUTOLAYOUT_ORG: + case AUTOLAYOUT_TAB: + case AUTOLAYOUT_OBJ: eNewLayout = AUTOLAYOUT_OBJTEXT; break; + default: + break; + } + + if( eNewLayout != pPage->GetAutoLayout() ) + { + pPage->SetAutoLayout( eNewLayout, true ); + } + else + { + // we already have a layout with a text but the text + // object was deleted, create a new one + pPage->InsertAutoLayoutShape( 0, + (eNewLayout == AUTOLAYOUT_TITLE) ? PRESOBJ_TEXT : PRESOBJ_OUTLINE, + false, pPage->GetLayoutRect(), true ); + } + + return GetOutlineTextObject(pPage); +} + +/** updates draw model with all changes from outliner model */ +BOOL OutlineView::PrepareClose(BOOL) +{ + ::sd::UndoManager* pDocUndoMgr = dynamic_cast<sd::UndoManager*>(mpDocSh->GetUndoManager()); + if (pDocUndoMgr != NULL) + pDocUndoMgr->SetLinkedUndoManager(NULL); + + mpOutliner->GetUndoManager().Clear(); + + const String aUndoStr(SdResId(STR_UNDO_CHANGE_TITLE_AND_LAYOUT)); + BegUndo(aUndoStr); + UpdateDocument(); + EndUndo(); + mpDoc->SetSelected(GetActualPage(), TRUE); + return TRUE; +} + + +/************************************************************************* +|* +|* Attribute des selektierten Textes setzen +|* +\************************************************************************/ + +BOOL OutlineView::SetAttributes(const SfxItemSet& rSet, BOOL ) +{ + BOOL bOk = FALSE; + + OutlinerView* pOlView = GetViewByWindow(mpOutlineViewShell->GetActiveWindow()); + + if (pOlView) + { + pOlView->SetAttribs(rSet); + bOk = TRUE; + } + + mpOutlineViewShell->Invalidate (SID_PREVIEW_STATE); + + return (bOk); +} + +/************************************************************************* +|* +|* Attribute des selektierten Textes erfragen +|* +\************************************************************************/ + +BOOL OutlineView::GetAttributes( SfxItemSet& rTargetSet, BOOL ) const +{ + OutlinerView* pOlView = GetViewByWindow( + mpOutlineViewShell->GetActiveWindow()); + DBG_ASSERT(pOlView, "keine OutlinerView gefunden"); + + rTargetSet.Put( pOlView->GetAttribs(), FALSE ); + return TRUE; +} + +/** creates outliner model from draw model */ +void OutlineView::FillOutliner() +{ + mpOutliner->GetUndoManager().Clear(); + mpOutliner->EnableUndo(FALSE); + ResetLinks(); + mpOutliner->SetUpdateMode(false); + + Paragraph* pTitleToSelect = NULL; + ULONG nPageCount = mpDoc->GetSdPageCount(PK_STANDARD); + + // fill outliner with paragraphs from slides title & (outlines|subtitles) + for (USHORT nPage = 0; nPage < nPageCount; nPage++) + { + SdPage* pPage = (SdPage*)mpDoc->GetSdPage(nPage, PK_STANDARD); + Paragraph * pPara = NULL; + + // take text from title shape + SdrTextObj* pTO = GetTitleTextObject(pPage); + if(pTO && !(pTO->IsEmptyPresObj())) + { + OutlinerParaObject* pOPO = pTO->GetOutlinerParaObject(); + if (pOPO) + { + BOOL bVertical = pOPO->IsVertical(); + pOPO->SetVertical( FALSE ); + mpOutliner->AddText(*pOPO); + pOPO->SetVertical( bVertical ); + pPara = mpOutliner->GetParagraph( mpOutliner->GetParagraphCount()-1 ); + } + } + + if( pPara == 0 ) // no title, insert an empty paragraph + { + pPara = mpOutliner->Insert(String()); + mpOutliner->SetDepth(pPara, -1); + + // Keine harten Attribute vom vorherigen Absatz uebernehmen + mpOutliner->SetParaAttribs( (USHORT)mpOutliner->GetAbsPos(pPara), + mpOutliner->GetEmptyItemSet() ); + + mpOutliner->SetStyleSheet( mpOutliner->GetAbsPos( pPara ), pPage->GetStyleSheetForPresObj( PRESOBJ_TITLE ) ); + } + + mpOutliner->SetParaFlag( pPara, PARAFLAG_ISPAGE ); + + ULONG nPara = mpOutliner->GetAbsPos( pPara ); + + UpdateParagraph( (USHORT)nPara ); + + // remember paragraph of currently selected page + if (pPage->IsSelected()) + pTitleToSelect = pPara; + + // take text from subtitle or outline + pTO = static_cast<SdrTextObj*>(pPage->GetPresObj(PRESOBJ_TEXT)); + const bool bSubTitle = pTO != 0; + + if (!pTO) // if no subtile found, try outline + pTO = GetOutlineTextObject(pPage); + + if(pTO && !(pTO->IsEmptyPresObj())) // found some text + { + OutlinerParaObject* pOPO = pTO->GetOutlinerParaObject(); + if (pOPO) + { + USHORT nParaCount1 = (USHORT)mpOutliner->GetParagraphCount(); + BOOL bVertical = pOPO->IsVertical(); + pOPO->SetVertical( FALSE ); + mpOutliner->AddText(*pOPO); + pOPO->SetVertical( bVertical ); + + USHORT nParaCount2 = (USHORT)mpOutliner->GetParagraphCount(); + for (USHORT n = nParaCount1; n < nParaCount2; n++) + { + if( bSubTitle ) + { + Paragraph* p = mpOutliner->GetParagraph(n); + if(p && mpOutliner->GetDepth( n ) > 0 ) + mpOutliner->SetDepth(p, 0); + } + + UpdateParagraph( n ); + } + } + } + } + + // place cursor at the start + Paragraph* pFirstPara = mpOutliner->GetParagraph( 0 ); + mpOutlinerView[0]->Select( pFirstPara, TRUE, FALSE ); + mpOutlinerView[0]->Select( pFirstPara, FALSE, FALSE ); + + // select title of slide that was selected + if (pTitleToSelect) + mpOutlinerView[0]->Select(pTitleToSelect, TRUE, FALSE); + + SetLinks(); + + mpOutliner->EnableUndo(TRUE); + + mpOutliner->SetUpdateMode(true); +} + +/************************************************************************* +|* +|* Handler fuer das Loeschen von Level-0-Absaetzen (Seiten): Warnung +|* +\************************************************************************/ + +IMPL_LINK( OutlineView, RemovingPagesHdl, OutlinerView *, EMPTYARG ) +{ + USHORT nNumOfPages = mpOutliner->GetSelPageCount(); + + if (nNumOfPages > PROCESS_WITH_PROGRESS_THRESHOLD) + { + mnPagesToProcess = nNumOfPages; + mnPagesProcessed = 0; + } + + if (mnPagesToProcess) + { + if( mpProgress ) + delete mpProgress; + + String aStr(SdResId(STR_DELETE_PAGES)); + mpProgress = new SfxProgress( GetDocSh(), aStr, mnPagesToProcess ); + } + mpOutliner->UpdateFields(); + + InvalidateSlideNumberArea(); + + return 1; +} + +/************************************************************************* +|* +|* Handler fuer das Einruecken von Level-0-Absaetzen (Seiten): Warnung +|* +\************************************************************************/ + +IMPL_LINK_INLINE_START( OutlineView, IndentingPagesHdl, OutlinerView *, pOutlinerView ) +{ + return RemovingPagesHdl(pOutlinerView); +} +IMPL_LINK_INLINE_END( OutlineView, IndentingPagesHdl, OutlinerView *, pOutlinerView ) + + +/** returns the first slide that is selected in the outliner or where + the cursor is located */ +SdPage* OutlineView::GetActualPage() +{ + ::sd::Window* pWin = mpOutlineViewShell->GetActiveWindow(); + OutlinerView* pActiveView = GetViewByWindow(pWin); + std::auto_ptr<List> pSelList( static_cast< List* >(pActiveView->CreateSelectionList()) ); + + SdPage* pCurrent = GetPageForParagraph(static_cast<Paragraph*>(pSelList->First()) ); + DBG_ASSERT( pCurrent || + (mpDocSh->GetUndoManager() && static_cast< sd::UndoManager *>(mpDocSh->GetUndoManager())->isInUndo()) || + maDragAndDropModelGuard.get(), + "sd::OutlineView::GetActualPage(), no current page?" ); + if( pCurrent ) + return pCurrent; + else + return mpDoc->GetSdPage( 0, PK_STANDARD ); +} + +SdPage* OutlineView::GetPageForParagraph( Paragraph* pPara ) +{ + if( !mpOutliner->HasParaFlag(pPara,PARAFLAG_ISPAGE) ) + pPara = GetPrevTitle(pPara); + + sal_uInt32 nPageToSelect = 0; + while(pPara) + { + pPara = GetPrevTitle(pPara); + if(pPara) + nPageToSelect++; + } + + if( nPageToSelect < (sal_uInt32)mpDoc->GetSdPageCount( PK_STANDARD ) ) + return static_cast< SdPage* >( mpDoc->GetSdPage( (USHORT)nPageToSelect, PK_STANDARD) ); + else + return 0; +} + +Paragraph* OutlineView::GetParagraphForPage( ::Outliner* pOutl, SdPage* pPage ) +{ + // get the number of paragraphs with ident 0 we need to skip before + // we finde the actual page + sal_uInt32 nPagesToSkip = (pPage->GetPageNum() - 1) >> 1; + + sal_uInt32 nParaPos = 0; + Paragraph* pPara = pOutl->GetParagraph( 0 ); + while( pPara ) + { + // if this paragraph is a page ... + if( mpOutliner->HasParaFlag(pPara,PARAFLAG_ISPAGE) ) + { + // see if we already skiped enough pages + if( 0 == nPagesToSkip ) + break; // and if so, end the loop + + // we skiped another page + nPagesToSkip--; + } + + // get next paragraph + pPara = mpOutliner->GetParagraph( ++nParaPos ); + } + + return pPara; +} + +/** selects the paragraph for the given page at the outliner view*/ +void OutlineView::SetActualPage( SdPage* pActual ) +{ + if( pActual && mpOutliner && dynamic_cast<Outliner*> ( mpOutliner )->GetIgnoreCurrentPageChangesLevel()==0 && !mbFirstPaint) + { + // if we found a paragraph, select its text at the outliner view + Paragraph* pPara = GetParagraphForPage( mpOutliner, pActual ); + if( pPara ) + mpOutlinerView[0]->Select( pPara, TRUE, FALSE ); + } +} + +/************************************************************************* +|* +|* StyleSheet aus der Selektion besorgen +|* +\************************************************************************/ + +SfxStyleSheet* OutlineView::GetStyleSheet() const +{ + ::sd::Window* pActWin = mpOutlineViewShell->GetActiveWindow(); + OutlinerView* pOlView = GetViewByWindow(pActWin); + SfxStyleSheet* pResult = pOlView->GetStyleSheet(); + return pResult; +} + + + +/************************************************************************* +|* +|* Seiten als selektiert / nicht selektiert setzen +|* +\************************************************************************/ + +void OutlineView::SetSelectedPages() +{ + // Liste der selektierten Titelabsaetze + List* pSelParas = mpOutlinerView[0]->CreateSelectionList(); + Paragraph* pPara = (Paragraph*) pSelParas->First(); + + while(pPara) + { + if( !mpOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) + { + pSelParas->Remove(); + pPara = (Paragraph*) pSelParas->GetCurObject(); + } + else + { + pPara = (Paragraph*) pSelParas->Next(); + } + } + + // Die zu den selektierten Absaetzen auf Ebene 0 gehoerenden Seiten + // selektieren + USHORT nPos = 0; + ULONG nParaPos = 0; + pPara = mpOutliner->GetParagraph( 0 ); + + while(pPara) + { + if( mpOutliner->HasParaFlag(pPara, PARAFLAG_ISPAGE) ) // eine Seite? + { + SdPage* pPage = mpDoc->GetSdPage(nPos, PK_STANDARD); + DBG_ASSERT(pPage!=NULL, + "Trying to select non-existing page OutlineView::SetSelectedPages()"); + if (pPage != NULL) + { + pPage->SetSelected(FALSE); + + if (pSelParas->Seek(pPara)) // selektiert? + pPage->SetSelected(TRUE); + } + + nPos++; + } + + pPara = mpOutliner->GetParagraph( ++nParaPos ); + } +} + + +/************************************************************************* +|* +|* Neue Links setzen +|* +\************************************************************************/ + +void OutlineView::SetLinks() +{ + // Benachrichtigungs-Links setzen + mpOutliner->SetParaInsertedHdl(LINK(this, OutlineView, ParagraphInsertedHdl)); + mpOutliner->SetParaRemovingHdl(LINK(this, OutlineView, ParagraphRemovingHdl)); + mpOutliner->SetDepthChangedHdl(LINK(this, OutlineView, DepthChangedHdl)); + mpOutliner->SetBeginMovingHdl(LINK(this, OutlineView, BeginMovingHdl)); + mpOutliner->SetEndMovingHdl(LINK(this, OutlineView, EndMovingHdl)); + mpOutliner->SetRemovingPagesHdl(LINK(this, OutlineView, RemovingPagesHdl)); + mpOutliner->SetIndentingPagesHdl(LINK(this, OutlineView, IndentingPagesHdl)); + mpOutliner->SetStatusEventHdl(LINK(this, OutlineView, StatusEventHdl)); + mpOutliner->SetBeginDropHdl(LINK(this,OutlineView, BeginDropHdl)); + mpOutliner->SetEndDropHdl(LINK(this,OutlineView, EndDropHdl)); + mpOutliner->SetPaintFirstLineHdl(LINK(this,OutlineView,PaintingFirstLineHdl)); + mpOutliner->SetBeginPasteOrDropHdl(LINK(this,OutlineView, BeginPasteOrDropHdl)); + mpOutliner->SetEndPasteOrDropHdl(LINK(this,OutlineView, EndPasteOrDropHdl)); +} + + + +/************************************************************************* +|* +|* Alte Links restaurieren +|* +\************************************************************************/ + +void OutlineView::ResetLinks() const +{ + // alte Links restaurieren + Link aEmptyLink; + mpOutliner->SetParaInsertedHdl(aEmptyLink); + mpOutliner->SetParaRemovingHdl(aEmptyLink); + mpOutliner->SetDepthChangedHdl(aEmptyLink); + mpOutliner->SetBeginMovingHdl(aEmptyLink); + mpOutliner->SetEndMovingHdl(aEmptyLink); + mpOutliner->SetStatusEventHdl(aEmptyLink); + mpOutliner->SetRemovingPagesHdl(aEmptyLink); + mpOutliner->SetIndentingPagesHdl(aEmptyLink); + mpOutliner->SetDrawPortionHdl(aEmptyLink); + mpOutliner->SetBeginPasteOrDropHdl(aEmptyLink); + mpOutliner->SetEndPasteOrDropHdl(aEmptyLink); +} + +/************************************************************************* +|* +|* AcceptDrop +|* +\************************************************************************/ + +sal_Int8 OutlineView::AcceptDrop( const AcceptDropEvent&, DropTargetHelper&, ::sd::Window*, USHORT, USHORT) +{ + return DND_ACTION_NONE; +} + +/************************************************************************* +|* +|* ExecuteDrop +|* +\************************************************************************/ + +sal_Int8 OutlineView::ExecuteDrop( const ExecuteDropEvent&, DropTargetHelper&, ::sd::Window*, USHORT, USHORT) +{ + return DND_ACTION_NONE; +} + +// #97766# Re-implement GetScriptType for this view to get correct results +sal_uInt16 OutlineView::GetScriptType() const +{ + sal_uInt16 nScriptType = ::sd::View::GetScriptType(); + + if(mpOutliner) + { + OutlinerParaObject* pTempOPObj = mpOutliner->CreateParaObject(); + + if(pTempOPObj) + { + nScriptType = pTempOPObj->GetTextObject().GetScriptType(); + delete pTempOPObj; + } + } + + return nScriptType; +} + +void OutlineView::onUpdateStyleSettings( bool bForceUpdate /* = false */ ) +{ + const bool bHighContrastMode = Application::GetSettings().GetStyleSettings().GetHighContrastMode() != 0; + if( bForceUpdate || (mbHighContrastMode != bHighContrastMode) ) + { + if( mpOutliner ) + { + mpOutliner->ForceAutoColor( bHighContrastMode ); + } + mbHighContrastMode = bHighContrastMode; + + } + + svtools::ColorConfig aColorConfig; + const Color aDocColor( aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor ); + if( bForceUpdate || (maDocColor != aDocColor) ) + { + sal_uInt16 nView; + for( nView = 0; nView < MAX_OUTLINERVIEWS; nView++ ) + { + if (mpOutlinerView[nView] != NULL) + { + mpOutlinerView[nView]->SetBackgroundColor( aDocColor ); + + ::Window* pWindow = mpOutlinerView[nView]->GetWindow(); + + if( pWindow ) + pWindow->SetBackground( Wallpaper( aDocColor ) ); + + } + } + + if( mpOutliner ) + mpOutliner->SetBackgroundColor( aDocColor ); + + maDocColor = aDocColor; + } +} + +IMPL_LINK( OutlineView, AppEventListenerHdl, void *, EMPTYARG ) +{ + onUpdateStyleSettings(); + return 0; +} + + + + +IMPL_LINK(OutlineView, EventMultiplexerListener, ::sd::tools::EventMultiplexerEvent*, pEvent) +{ + if (pEvent != NULL) + { + switch (pEvent->meEventId) + { + case tools::EventMultiplexerEvent::EID_CURRENT_PAGE: + SetActualPage(mpOutlineViewShell->GetActualPage()); + InvalidateSlideNumberArea(); + break; + + case tools::EventMultiplexerEvent::EID_PAGE_ORDER: + if (mpOutliner != NULL && mpDoc!=NULL && mpOutliner != NULL && dynamic_cast<Outliner*> ( mpOutliner )->GetIgnoreCurrentPageChangesLevel()==0) + { + if (((mpDoc->GetPageCount()-1)%2) == 0) + { + mpOutliner->Clear(); + FillOutliner(); + ::sd::Window* pWindow = mpOutlineViewShell->GetActiveWindow(); + if (pWindow != NULL) + pWindow->Invalidate(); + } + } + break; + } + } + return 0; +} + +void OutlineView::IgnoreCurrentPageChanges (bool bIgnoreChanges) +{ + if ( mpOutliner ) + { + if (bIgnoreChanges) + dynamic_cast<Outliner*> ( mpOutliner )->IncreIgnoreCurrentPageChangesLevel(); + else + dynamic_cast<Outliner*> ( mpOutliner )->DecreIgnoreCurrentPageChangesLevel(); + } +} + +/** call this method before you do anything that can modify the outliner + and or the drawing document model. It will create needed undo actions */ +void OutlineView::BeginModelChange() +{ + const String aEmpty; + mpOutliner->GetUndoManager().EnterListAction(aEmpty,aEmpty); + const String aUndoStr(SdResId(STR_UNDO_CHANGE_TITLE_AND_LAYOUT)); + BegUndo(aUndoStr); +} + +/** call this method after BeginModelChange(), when all possible model + changes are done. */ +void OutlineView::EndModelChange() +{ + UpdateDocument(); + + SfxUndoManager* pDocUndoMgr = mpDocSh->GetUndoManager(); + + bool bHasUndoActions = pDocUndoMgr->GetUndoActionCount() != 0; + + EndUndo(); + + DBG_ASSERT( bHasUndoActions == (mpOutliner->GetUndoManager().GetUndoActionCount() != 0), "sd::OutlineView::EndModelChange(), undo actions not in sync!" ); + + if( bHasUndoActions ) + { + SfxLinkUndoAction* pLink = new SfxLinkUndoAction(pDocUndoMgr); + mpOutliner->GetUndoManager().AddUndoAction(pLink); + } + + mpOutliner->GetUndoManager().LeaveListAction(); + + if( bHasUndoActions && mpOutliner->GetEditEngine().HasTriedMergeOnLastAddUndo() ) + TryToMergeUndoActions(); +} + +/** updates all changes in the outliner model to the draw model */ +void OutlineView::UpdateDocument() +{ + const sal_uInt32 nPageCount = mpDoc->GetSdPageCount(PK_STANDARD); + Paragraph* pPara = mpOutliner->GetParagraph( 0 ); + sal_uInt32 nPage; + for (nPage = 0; nPage < nPageCount; nPage++) + { + SdPage* pPage = mpDoc->GetSdPage( (USHORT)nPage, PK_STANDARD); + mpDoc->SetSelected(pPage, FALSE); + + mpOutlineViewShell->UpdateTitleObject( pPage, pPara ); + mpOutlineViewShell->UpdateOutlineObject( pPage, pPara ); + + if( pPara ) + pPara = GetNextTitle(pPara); + } + + DBG_ASSERT( pPara == 0, "sd::OutlineView::UpdateDocument(), slides are out of sync, creating missing ones" ); + while( pPara ) + { + SdPage* pPage = InsertSlideForParagraph( pPara ); + mpDoc->SetSelected(pPage, FALSE); + + mpOutlineViewShell->UpdateTitleObject( pPage, pPara ); + mpOutlineViewShell->UpdateOutlineObject( pPage, pPara ); + + if( pPara ) + pPara = GetNextTitle(pPara); + } +} + +/** merge edit engine undo actions if possible */ +void OutlineView::TryToMergeUndoActions() +{ + SfxUndoManager& rOutlineUndo = mpOutliner->GetUndoManager(); + if( rOutlineUndo.GetUndoActionCount() > 1 ) + { + SfxListUndoAction* pListAction = dynamic_cast< SfxListUndoAction* >( rOutlineUndo.GetUndoAction(0) ); + SfxListUndoAction* pPrevListAction = dynamic_cast< SfxListUndoAction* >( rOutlineUndo.GetUndoAction(1) ); + if( pListAction && pPrevListAction ) + { + // find the top EditUndo action in the top undo action list + USHORT nAction = pListAction->aUndoActions.Count(); + EditUndo* pEditUndo = 0; + while( !pEditUndo && nAction ) + { + pEditUndo = dynamic_cast< EditUndo* >(pListAction->aUndoActions[--nAction]); + } + + USHORT nEditPos = nAction; // we need this later to remove the merged undo actions + + // make sure it is the only EditUndo action in the top undo list + while( pEditUndo && nAction ) + { + if( dynamic_cast< EditUndo* >(pListAction->aUndoActions[--nAction]) ) + pEditUndo = 0; + } + + // do we have one and only one EditUndo action in the top undo list? + if( pEditUndo ) + { + // yes, see if we can merge it with the prev undo list + + nAction = pPrevListAction->aUndoActions.Count(); + EditUndo* pPrevEditUndo = 0; + while( !pPrevEditUndo && nAction ) + pPrevEditUndo = dynamic_cast< EditUndo* >(pPrevListAction->aUndoActions[--nAction]); + + if( pPrevEditUndo && pPrevEditUndo->Merge( pEditUndo ) ) + { + // ok we merged the only EditUndo of the top undo list with + // the top EditUndo of the previous undo list + + // first remove the merged undo action + DBG_ASSERT( pListAction->aUndoActions[nEditPos] == pEditUndo, "sd::OutlineView::TryToMergeUndoActions(), wrong edit pos!" ); + pListAction->aUndoActions.Remove(nEditPos); + delete pEditUndo; + + // now check if we also can merge the draw undo actions + SfxUndoManager* pDocUndoManager = mpDocSh->GetUndoManager(); + if( pDocUndoManager && ( pListAction->aUndoActions.Count() == 1 )) + { + SfxLinkUndoAction* pLinkAction = dynamic_cast< SfxLinkUndoAction* >( pListAction->aUndoActions[0] ); + SfxLinkUndoAction* pPrevLinkAction = 0; + + if( pLinkAction ) + { + nAction = pPrevListAction->aUndoActions.Count(); + while( !pPrevLinkAction && nAction ) + pPrevLinkAction = dynamic_cast< SfxLinkUndoAction* >(pPrevListAction->aUndoActions[--nAction]); + } + + if( pLinkAction && pPrevLinkAction && + ( pLinkAction->GetAction() == pDocUndoManager->GetUndoAction(0) ) && + ( pPrevLinkAction->GetAction() == pDocUndoManager->GetUndoAction(1) ) ) + { + SfxListUndoAction* pSourceList = dynamic_cast< SfxListUndoAction* >(pLinkAction->GetAction()); + SfxListUndoAction* pDestinationList = dynamic_cast< SfxListUndoAction* >(pPrevLinkAction->GetAction()); + + if( pSourceList && pDestinationList ) + { + USHORT nCount = pSourceList->aUndoActions.Count(); + USHORT nDestAction = pDestinationList->aUndoActions.Count(); + while( nCount-- ) + { + const SfxUndoAction* pTemp = pSourceList->aUndoActions.GetObject(0); + pSourceList->aUndoActions.Remove(0); + pDestinationList->aUndoActions.Insert( pTemp, nDestAction++ ); + } + pDestinationList->nCurUndoAction = pDestinationList->aUndoActions.Count(); + + pListAction->aUndoActions.Remove(0); + delete pLinkAction; + + pDocUndoManager->RemoveLastUndoAction(); + } + } + } + + if( pListAction->aUndoActions.Count() ) + { + // now we have to move all remaining doc undo actions from the top undo + // list to the previous undo list and remove the top undo list + + USHORT nCount = pListAction->aUndoActions.Count(); + USHORT nDestAction = pPrevListAction->aUndoActions.Count(); + while( nCount-- ) + { + const SfxUndoAction* pTemp = pListAction->aUndoActions.GetObject(0); + pListAction->aUndoActions.Remove(0); + if( pTemp ) + pPrevListAction->aUndoActions.Insert( pTemp, nDestAction++ ); + } + pPrevListAction->nCurUndoAction = pPrevListAction->aUndoActions.Count(); + } + + rOutlineUndo.RemoveLastUndoAction(); + } + } + } + } +} + +IMPL_LINK(OutlineView, PaintingFirstLineHdl, PaintFirstLineInfo*, pInfo) +{ + if( pInfo && mpOutliner ) + { + Paragraph* pPara = mpOutliner->GetParagraph( pInfo->mnPara ); + EditEngine& rEditEngine = const_cast< EditEngine& >( mpOutliner->GetEditEngine() ); + + Size aImageSize( pInfo->mpOutDev->PixelToLogic( maSlideImage.GetSizePixel() ) ); + Size aOffset( 100, 100 ); + + // paint slide number + if( pPara && mpOutliner->HasParaFlag(pPara,PARAFLAG_ISPAGE) ) + { + long nPage = 0; // todo, printing?? + for ( USHORT n = 0; n <= pInfo->mnPara; n++ ) + { + Paragraph* p = mpOutliner->GetParagraph( n ); + if ( mpOutliner->HasParaFlag(p,PARAFLAG_ISPAGE) ) + nPage++; + } + + long nBulletHeight = (long)mpOutliner->GetLineHeight( pInfo->mnPara ); + long nFontHeight = 0; + if ( !rEditEngine.IsFlatMode() ) + { +// const SvxFontHeightItem& rFH = (const SvxFontHeightItem&)rEditEngine.GetParaAttrib( pInfo->mnPara, EE_CHAR_FONTHEIGHT ); +// nBulletHeight = rFH.GetHeight(); + nFontHeight = nBulletHeight / 5; + } + else + { +// const SvxFontHeightItem& rFH = (const SvxFontHeightItem&)rEditEngine.GetEmptyItemSet().Get( EE_CHAR_FONTHEIGHT ); + // nBulletHeight = rFH.GetHeight(); + nFontHeight = (nBulletHeight * 10) / 25; + } + + Size aFontSz( 0, nFontHeight ); + + Size aOutSize( 2000, nBulletHeight ); + + const float fImageHeight = ((float)aOutSize.Height() * (float)4) / (float)7; + const float fImageRatio = (float)aImageSize.Height() / (float)aImageSize.Width(); + aImageSize.Width() = (long)( fImageRatio * fImageHeight ); + aImageSize.Height() = (long)( fImageHeight ); + + Point aImagePos( pInfo->mrStartPos ); + aImagePos.X() += aOutSize.Width() - aImageSize.Width() - aOffset.Width() ; + aImagePos.Y() += (aOutSize.Height() - aImageSize.Height()) / 2; + + pInfo->mpOutDev->DrawImage( aImagePos, aImageSize, maSlideImage ); + + const bool bVertical = mpOutliner->IsVertical(); + const bool bRightToLeftPara = rEditEngine.IsRightToLeft( pInfo->mnPara ); + + LanguageType eLang = rEditEngine.GetDefaultLanguage(); + + Point aTextPos( aImagePos.X() - aOffset.Width(), pInfo->mrStartPos.Y() ); + Font aNewFont( OutputDevice::GetDefaultFont( DEFAULTFONT_SANS_UNICODE, eLang, 0 ) ); + aNewFont.SetSize( aFontSz ); +// aNewFont.SetAlign( aBulletFont.GetAlign() ); + aNewFont.SetVertical( bVertical ); + aNewFont.SetOrientation( bVertical ? 2700 : 0 ); + aNewFont.SetColor( COL_AUTO ); + pInfo->mpOutDev->SetFont( aNewFont ); + String aPageText = String::CreateFromInt32( nPage ); + Size aTextSz; + aTextSz.Width() = pInfo->mpOutDev->GetTextWidth( aPageText ); + aTextSz.Height() = pInfo->mpOutDev->GetTextHeight(); +// long nBulletHeight = !bVertical ? aBulletArea.GetHeight() : aBulletArea.GetWidth(); + if ( !bVertical ) + { + aTextPos.Y() += (aOutSize.Height() - aTextSz.Height()) / 2; + if ( !bRightToLeftPara ) + { + aTextPos.X() -= aTextSz.Width(); + } + else + { + aTextPos.X() += aTextSz.Width(); + } + } + else + { + aTextPos.Y() -= aTextSz.Width(); + aTextPos.X() += nBulletHeight / 2; + } + pInfo->mpOutDev->DrawText( aTextPos, aPageText ); + } + } + + return 0; +} + +#if 0 +sal_Int32 OutlineView::GetPageNumberWidthPixel() +{ + Window* pActWin = mpOutlineViewShell->GetActiveWindow(); + if( pActWin ) + { + Font aOldFont( pActWin->GetFont() ); + pActWin->SetFont( maPageNumberFont ); + Size aSize( pActWin->GetTextWidth( String( RTL_CONSTASCII_USTRINGPARAM("X" ) ) ), 0 ); + sal_Int32 nWidth = pActWin->LogicToPixel( aSize ).Width() * 5; + + const String aBulletStr( sal_Unicode( 0xE011 ) ); + pActWin->SetFont( maBulletFont); + + aSize.Width() = pActWin->GetTextWidth(aBulletStr); + nWidth += pActWin->LogicToPixel( aSize ).Width(); + + pActWin->SetFont( aOldFont ); + + mnPageNumberWidthPixel = nWidth; + } + return mnPageNumberWidthPixel; +} +#endif + +// -------------------------------------------------------------------- + +void OutlineView::UpdateParagraph( USHORT nPara ) +{ + if( mpOutliner ) + { + SfxItemSet aNewAttrs2( mpOutliner->GetParaAttribs( nPara ) ); + aNewAttrs2.Put( maLRSpaceItem ); + mpOutliner->SetParaAttribs( nPara, aNewAttrs2 ); + } +} + +// -------------------------------------------------------------------- + +void OutlineView::OnBeginPasteOrDrop( PasteOrDropInfos* /*pInfos*/ ) +{ +} + +/** this is called after a paste or drop operation, make sure that the newly inserted paragraphs + get the correct style sheet and new slides are inserted. */ +void OutlineView::OnEndPasteOrDrop( PasteOrDropInfos* pInfos ) +{ + SdPage* pPage = 0; + SfxStyleSheetBasePool* pStylePool = GetDoc()->GetStyleSheetPool(); + + for( sal_uInt16 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ ) + { + Paragraph* pPara = mpOutliner->GetParagraph( nPara ); + + bool bPage = mpOutliner->HasParaFlag( pPara, PARAFLAG_ISPAGE ); + + if( !bPage ) + { + SdStyleSheet* pStyleSheet = dynamic_cast< SdStyleSheet* >( mpOutliner->GetStyleSheet( nPara ) ); + if( pStyleSheet ) + { + const OUString aName( pStyleSheet->GetApiName() ); + if( aName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("title" ) ) ) + bPage = true; + } + } + + if( !pPara ) + continue; // fatality!? + + if( bPage && (nPara != pInfos->nStartPara) ) + { + // insert new slide for this paragraph + pPage = InsertSlideForParagraph( pPara ); + } + else + { + // newly inserted non page paragraphs get the outline style + if( !pPage ) + pPage = GetPageForParagraph( pPara ); + + if( pPage ) + { + SfxStyleSheet* pStyle = pPage->GetStyleSheetForPresObj( bPage ? PRESOBJ_TITLE : PRESOBJ_OUTLINE ); + + if( !bPage ) + { + const sal_Int16 nDepth = mpOutliner->GetDepth( nPara ); + if( nDepth > 0 ) + { + String aStyleSheetName( pStyle->GetName() ); + aStyleSheetName.Erase( aStyleSheetName.Len() - 1, 1 ); + aStyleSheetName += String::CreateFromInt32( nDepth ); + pStyle = static_cast<SfxStyleSheet*>( pStylePool->Find( aStyleSheetName, pStyle->GetFamily() ) ); + DBG_ASSERT( pStyle, "sd::OutlineView::OnEndPasteOrDrop(), Style not found!" ); + } + } + + mpOutliner->SetStyleSheet( nPara, pStyle ); + } + + UpdateParagraph( nPara ); + } + } +} + +// ==================================================================== + + +OutlineViewModelChangeGuard::OutlineViewModelChangeGuard( OutlineView& rView ) +: mrView( rView ) +{ + mrView.BeginModelChange(); +} + +OutlineViewModelChangeGuard::~OutlineViewModelChangeGuard() +{ + mrView.EndModelChange(); +} + +OutlineViewPageChangesGuard::OutlineViewPageChangesGuard( OutlineView* pView ) +: mpView( pView ) +{ + if( mpView ) + mpView->IgnoreCurrentPageChanges( true ); +} + +OutlineViewPageChangesGuard::~OutlineViewPageChangesGuard() +{ + if( mpView ) + mpView->IgnoreCurrentPageChanges( false ); +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/presvish.cxx b/sd/source/ui/view/presvish.cxx new file mode 100644 index 000000000000..11f20c7a83d4 --- /dev/null +++ b/sd/source/ui/view/presvish.cxx @@ -0,0 +1,188 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include <com/sun/star/presentation/XSlideShowController.hpp> + +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <comphelper/processfactory.hxx> + +#include "PresentationViewShell.hxx" +#include "optsitem.hxx" +#include "sddll.hxx" +#include <sfx2/request.hxx> +#ifndef _SFX_DISPATCH_HXX +#include <sfx2/dispatch.hxx> +#endif + +#include <sfx2/objface.hxx> + +#include <svx/svxids.hrc> +#ifndef SD_FRAME_VIEW +#include "FrameView.hxx" +#endif +#include "sdresid.hxx" +#include "DrawDocShell.hxx" +#include "slideshow.hxx" +#include "sdattr.hxx" +#include "sdpage.hxx" +#include "drawdoc.hxx" +#include "drawview.hxx" +#include "app.hrc" +#include "strings.hrc" +#include "glob.hrc" +#include "ViewShellBase.hxx" +#include "FactoryIds.hxx" + +// #110496# +#include "slideshow.hxx" +#include "fupoor.hxx" +#include "Window.hxx" + +#define PresentationViewShell +using namespace sd; +#include "sdslots.hxx" + +using ::rtl::OUString; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::presentation; + +namespace sd { + +// ------------------- +// - PresentationViewShell - +// ------------------- + +SFX_IMPL_INTERFACE( PresentationViewShell, DrawViewShell, SdResId( STR_PRESVIEWSHELL ) ) +{ + SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_TOOLS | SFX_VISIBILITY_STANDARD | + SFX_VISIBILITY_FULLSCREEN | SFX_VISIBILITY_SERVER, + SdResId(RID_DRAW_TOOLBOX)); + SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_APPLICATION | SFX_VISIBILITY_DESKTOP | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_CLIENT | SFX_VISIBILITY_VIEWER | SFX_VISIBILITY_READONLYDOC, + SdResId(RID_DRAW_VIEWER_TOOLBOX) ); + SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_OPTIONS | SFX_VISIBILITY_STANDARD | + SFX_VISIBILITY_SERVER, + SdResId(RID_DRAW_OPTIONS_TOOLBOX)); + SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_COMMONTASK | SFX_VISIBILITY_STANDARD | + SFX_VISIBILITY_SERVER, + SdResId(RID_DRAW_COMMONTASK_TOOLBOX)); +} + + +TYPEINIT1( PresentationViewShell, DrawViewShell ); + +PresentationViewShell::PresentationViewShell( SfxViewFrame* pFrame, ViewShellBase& rViewShellBase, ::Window* pParentWindow, FrameView* pFrameView) +: DrawViewShell( pFrame, rViewShellBase, pParentWindow, PK_STANDARD, pFrameView) +{ + if( GetDocSh() && GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ) + maOldVisArea = GetDocSh()->GetVisArea( ASPECT_CONTENT ); + meShellType = ST_PRESENTATION; +} + +PresentationViewShell::~PresentationViewShell (void) +{ + if( GetDocSh() && GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED && !maOldVisArea.IsEmpty() ) + GetDocSh()->SetVisArea( maOldVisArea ); +} + +void PresentationViewShell::FinishInitialization( FrameView* pFrameView ) +{ + DrawViewShell::Init(true); + + // Use the frame view that comes form the view shell that initiated our + // creation. + if (pFrameView != NULL) + { + GetFrameView()->Disconnect(); + SetFrameView (pFrameView); + pFrameView->Connect(); + } + SetRuler(false); +// SwitchPage (nPageNumber); + WriteFrameViewData(); + + GetActiveWindow()->GrabFocus(); +} + + +SvxRuler* PresentationViewShell::CreateHRuler(::sd::Window*, BOOL) +{ + return NULL; +} + +SvxRuler* PresentationViewShell::CreateVRuler(::sd::Window*) +{ + return NULL; +} + + +void PresentationViewShell::Activate( BOOL bIsMDIActivate ) +{ + DrawViewShell::Activate( bIsMDIActivate ); + + if( bIsMDIActivate ) + { + //HMH::sd::View* pView = GetView(); + SfxBoolItem aItem( SID_NAVIGATOR_INIT, TRUE ); + + GetViewFrame()->GetDispatcher()->Execute( SID_NAVIGATOR_INIT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); + + rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if( xSlideShow.is() ) + xSlideShow->activate(GetViewShellBase()); + + if( HasCurrentFunction() ) + GetCurrentFunction()->Activate(); + } + + if( bIsMDIActivate ) + ReadFrameViewData( mpFrameView ); + GetDocSh()->Connect( this ); +} + +void PresentationViewShell::Paint( const Rectangle& rRect, ::sd::Window* ) +{ + rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if( xSlideShow.is() ) + xSlideShow->paint(rRect); +} + +void PresentationViewShell::Resize (void) +{ + ViewShell::Resize(); // do not call DrawViewShell here! + + rtl::Reference< sd::SlideShow > xSlideshow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if( xSlideshow.is() ) + xSlideshow->resize(maViewSize); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/sdruler.cxx b/sd/source/ui/view/sdruler.cxx new file mode 100644 index 000000000000..679c28bb3a93 --- /dev/null +++ b/sd/source/ui/view/sdruler.cxx @@ -0,0 +1,226 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "Ruler.hxx" +#include <svl/ptitem.hxx> +#include <svx/ruler.hxx> +#ifndef _SVXIDS_HXX //autogen +#include <svx/svxids.hrc> +#endif +#include <sfx2/ctrlitem.hxx> +#include <sfx2/bindings.hxx> + + +#include "View.hxx" +#include "DrawViewShell.hxx" +#include "Window.hxx" + +#include "helpids.h" + +namespace sd { + +/************************************************************************* +|* +|* Controller-Item fuer Ruler +|* +\************************************************************************/ + +class RulerCtrlItem : public SfxControllerItem +{ + Ruler &rRuler; + + protected: + virtual void StateChanged( USHORT nSId, SfxItemState eState, + const SfxPoolItem* pItem ); + + public: + RulerCtrlItem(USHORT nId, Ruler& rRlr, SfxBindings& rBind); +}; + +/************************************************************************* +|* +\************************************************************************/ + +RulerCtrlItem::RulerCtrlItem(USHORT _nId, Ruler& rRlr, SfxBindings& rBind) +: SfxControllerItem(_nId, rBind) +, rRuler(rRlr) +{ +} + + +/************************************************************************* +|* +\************************************************************************/ + +void RulerCtrlItem::StateChanged( USHORT nSId, SfxItemState, const SfxPoolItem* pState ) +{ + switch( nSId ) + { + case SID_RULER_NULL_OFFSET: + { + const SfxPointItem* pItem = dynamic_cast< const SfxPointItem* >(pState); + DBG_ASSERT(pState ? pItem != NULL : TRUE, "SfxPointItem erwartet"); + if ( pItem ) + rRuler.SetNullOffset(pItem->GetValue()); + } + break; + } +} + + +/************************************************************************* +|* +|* Konstruktor +|* +\************************************************************************/ + +Ruler::Ruler( DrawViewShell& rViewSh, ::Window* pParent, ::sd::Window* pWin, USHORT nRulerFlags, SfxBindings& rBindings, WinBits nWinStyle) +: SvxRuler(pParent, pWin, nRulerFlags, rBindings, nWinStyle) +, pSdWin(pWin) +, pDrViewShell(&rViewSh) +{ + rBindings.EnterRegistrations(); + pCtrlItem = new RulerCtrlItem(SID_RULER_NULL_OFFSET, *this, rBindings); + rBindings.LeaveRegistrations(); + + if ( nWinStyle & WB_HSCROLL ) + { + bHorz = TRUE; + SetHelpId( HID_SD_RULER_HORIZONTAL ); + } + else + { + bHorz = FALSE; + SetHelpId( HID_SD_RULER_VERTICAL ); + } +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +Ruler::~Ruler() +{ + SfxBindings& rBindings = pCtrlItem->GetBindings(); + rBindings.EnterRegistrations(); + delete pCtrlItem; + rBindings.LeaveRegistrations(); +} + +/************************************************************************* +|* +|* MouseButtonDown-Handler +|* +\************************************************************************/ + +void Ruler::MouseButtonDown(const MouseEvent& rMEvt) +{ + Point aMPos = rMEvt.GetPosPixel(); + RulerType eType = GetType(aMPos); + + if ( !pDrViewShell->GetView()->IsTextEdit() && + rMEvt.IsLeft() && rMEvt.GetClicks() == 1 && + (eType == RULER_TYPE_DONTKNOW || eType == RULER_TYPE_OUTSIDE) ) + { + pDrViewShell->StartRulerDrag(*this, rMEvt); + } + else + SvxRuler::MouseButtonDown(rMEvt); +} + +/************************************************************************* +|* +|* MouseMove-Handler +|* +\************************************************************************/ + +void Ruler::MouseMove(const MouseEvent& rMEvt) +{ + SvxRuler::MouseMove(rMEvt); +} + +/************************************************************************* +|* +|* MouseButtonUp-Handler +|* +\************************************************************************/ + +void Ruler::MouseButtonUp(const MouseEvent& rMEvt) +{ + SvxRuler::MouseButtonUp(rMEvt); +} + +/************************************************************************* +|* +|* NullOffset setzen +|* +\************************************************************************/ + +void Ruler::SetNullOffset(const Point& rOffset) +{ + long nOffset; + + if ( bHorz ) nOffset = rOffset.X(); + else nOffset = rOffset.Y(); + + SetNullOffsetLogic(nOffset); +} + +/************************************************************************* +|* +|* Command event +|* +\************************************************************************/ + +void Ruler::Command(const CommandEvent& rCEvt) +{ + if( rCEvt.GetCommand() == COMMAND_CONTEXTMENU && + !pDrViewShell->GetView()->IsTextEdit() ) + { + SvxRuler::Command( rCEvt ); + } +} + +/************************************************************************* +|* +|* ExtraDown +|* +\************************************************************************/ + +void Ruler::ExtraDown() +{ + if( !pDrViewShell->GetView()->IsTextEdit() ) + SvxRuler::ExtraDown(); +} + +} // end of namespace sd + diff --git a/sd/source/ui/view/sdview.cxx b/sd/source/ui/view/sdview.cxx new file mode 100755 index 000000000000..3aed9c6c0d9c --- /dev/null +++ b/sd/source/ui/view/sdview.cxx @@ -0,0 +1,1316 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" +#include <com/sun/star/embed/NoVisualAreaSizeException.hpp> +#include <com/sun/star/linguistic2/XSpellChecker1.hpp> + +#include "View.hxx" +#include <editeng/unolingu.hxx> +#include <sfx2/request.hxx> +#include <svx/obj3d.hxx> +#include <svx/fmview.hxx> +#include <editeng/outliner.hxx> +#ifndef _SVX_SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <svx/svdograf.hxx> +#include <svx/svdoole2.hxx> +#include <svx/svdundo.hxx> +#include <vcl/msgbox.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/app.hxx> +#include <svx/svdpagv.hxx> +#include <sfx2/docfile.hxx> +#include <svx/svdoutl.hxx> +#include <svx/sdr/contact/displayinfo.hxx> + +#include <svx/svdetc.hxx> +#include <editeng/editstat.hxx> + +#include <svx/dialogs.hrc> +#include <sfx2/viewfrm.hxx> +#include <svx/svdopage.hxx> +#include <toolkit/helper/vclunohelper.hxx> +#include <svx/xlndsit.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xlnclit.hxx> +#include <vcl/virdev.hxx> + +#include "app.hrc" +#include "strings.hrc" +#include "Window.hxx" +#include "Client.hxx" +#include "drawdoc.hxx" +#include "DrawDocShell.hxx" +#include "app.hxx" +#include "sdpage.hxx" +#include "glob.hrc" +#include "sdresid.hxx" +#include "DrawViewShell.hxx" +#include "futext.hxx" +#include "fuinsfil.hxx" +#include "slideshow.hxx" +#include "stlpool.hxx" +#include "FrameView.hxx" +#include "ViewClipboard.hxx" +#include "undo/undomanager.hxx" +#include <svx/sdr/contact/viewobjectcontact.hxx> +#include <svx/sdr/contact/viewcontact.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include "EventMultiplexer.hxx" +#include "ViewShellBase.hxx" +#include "ViewShellManager.hxx" + +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <basegfx/color/bcolor.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <drawinglayer/primitive2d/textlayoutdevice.hxx> +#include <drawinglayer/primitive2d/groupprimitive2d.hxx> +#include <svx/sdr/contact/objectcontact.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/primitive2d/textprimitive2d.hxx> +#include <svx/unoapi.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> + +#include <numeric> + +using namespace com::sun::star; +using namespace com::sun::star::uno; +namespace sd { + +#ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED +#define SO2_DECL_SVINPLACEOBJECT_DEFINED +SO2_DECL_REF(SvInPlaceObject) +#endif + +TYPEINIT1(View, FmFormView); + +/************************************************************************* +|* +|* Ctor +|* +\************************************************************************/ + +View::View(SdDrawDocument* pDrawDoc, OutputDevice* pOutDev, + ViewShell* pViewShell) + : FmFormView(pDrawDoc, pOutDev), + mpDoc(pDrawDoc), + mpDocSh( pDrawDoc->GetDocSh() ), + mpViewSh(pViewShell), + mpDragSrcMarkList(NULL), + mpDropMarkerObj(NULL), + mpDropMarker(NULL), + mnDragSrcPgNum(SDRPAGE_NOTFOUND), + mnAction(DND_ACTION_NONE), + mnLockRedrawSmph(0), + mpLockedRedraws(NULL), + mbIsDropAllowed(TRUE), + maSmartTags(*this), + mpClipboard (new ViewClipboard (*this)) +{ + // #i73602# Use default from the configuration + SetBufferedOverlayAllowed(getOptionsDrawinglayer().IsOverlayBuffer_DrawImpress()); + + // #i74769#, #i75172# Use default from the configuration + SetBufferedOutputAllowed(getOptionsDrawinglayer().IsPaintBuffer_DrawImpress()); + + EnableExtendedKeyInputDispatcher(FALSE); + EnableExtendedMouseEventDispatcher(FALSE); + EnableExtendedCommandEventDispatcher(FALSE); + + SetUseIncompatiblePathCreateInterface(FALSE); + SetMarkHdlWhenTextEdit(TRUE); + EnableTextEditOnObjectsWithoutTextIfTextTool(TRUE); + + SetMinMoveDistancePixel(2); + SetHitTolerancePixel(2); + SetMeasureLayer(String(SdResId(STR_LAYER_MEASURELINES))); + + // Timer fuer verzoegertes Drop (muss fuer MAC sein) + maDropErrorTimer.SetTimeoutHdl( LINK(this, View, DropErrorHdl) ); + maDropErrorTimer.SetTimeout(50); + maDropInsertFileTimer.SetTimeoutHdl( LINK(this, View, DropInsertFileHdl) ); + maDropInsertFileTimer.SetTimeout(50); +} + +void View::ImplClearDrawDropMarker() +{ + if(mpDropMarker) + { + delete mpDropMarker; + mpDropMarker = 0L; + } +} + +/************************************************************************* +|* +|* Dtor +|* +\************************************************************************/ + +View::~View() +{ + maSmartTags.Dispose(); + + // release content of selection clipboard, if we own the content + UpdateSelectionClipboard( TRUE ); + + maDropErrorTimer.Stop(); + maDropInsertFileTimer.Stop(); + + ImplClearDrawDropMarker(); + + while(PaintWindowCount()) + { + // Alle angemeldeten OutDevs entfernen + DeleteWindowFromPaintView(GetFirstOutputDevice() /*GetWin(0)*/); + } + + // gespeicherte Redraws loeschen + if (mpLockedRedraws) + { + SdViewRedrawRec* pRec = (SdViewRedrawRec*)mpLockedRedraws->First(); + while (pRec) + { + delete pRec; + pRec = (SdViewRedrawRec*)mpLockedRedraws->Next(); + } + delete mpLockedRedraws; + } +} + + +class ViewRedirector : public ::sdr::contact::ViewObjectContactRedirector +{ +public: + ViewRedirector(); + virtual ~ViewRedirector(); + + // all default implementations just call the same methods at the original. To do something + // different, overload the method and at least do what the method does. + virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence( + const sdr::contact::ViewObjectContact& rOriginal, + const sdr::contact::DisplayInfo& rDisplayInfo); +}; + +ViewRedirector::ViewRedirector() +{ +} + +ViewRedirector::~ViewRedirector() +{ +} + +drawinglayer::primitive2d::Primitive2DSequence ViewRedirector::createRedirectedPrimitive2DSequence( + const sdr::contact::ViewObjectContact& rOriginal, + const sdr::contact::DisplayInfo& rDisplayInfo) +{ + SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject(); + drawinglayer::primitive2d::Primitive2DSequence xRetval; + + if(pObject && pObject->GetPage()) + { + const bool bDoCreateGeometry(pObject->GetPage()->checkVisibility( rOriginal, rDisplayInfo, true )); + + if(!bDoCreateGeometry && !(( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_PAGE )) ) + return xRetval; + + PresObjKind eKind(PRESOBJ_NONE); + const bool bSubContentProcessing(rDisplayInfo.GetSubContentActive()); + const bool bIsMasterPageObject(pObject->GetPage()->IsMasterPage()); + const bool bIsPrinting(rOriginal.GetObjectContact().isOutputToPrinter()); + const SdrPageView* pPageView = rOriginal.GetObjectContact().TryToGetSdrPageView(); + const SdrPage* pVisualizedPage = GetSdrPageFromXDrawPage(rOriginal.GetObjectContact().getViewInformation2D().getVisualizedPage()); + const SdPage* pObjectsSdPage = dynamic_cast< SdPage* >(pObject->GetPage()); + const bool bIsInsidePageObj(pPageView && pPageView->GetPage() != pVisualizedPage); + + // check if we need to draw a placeholder border. Never do it for + // objects inside a SdrPageObj and never when printing + if(!bIsInsidePageObj && !bIsPrinting) + { + bool bCreateOutline(false); + + if( pObject->IsEmptyPresObj() && pObject->ISA(SdrTextObj) ) + { + if( !bSubContentProcessing || !pObject->IsNotVisibleAsMaster() ) + { + eKind = pObjectsSdPage ? pObjectsSdPage->GetPresObjKind(pObject) : PRESOBJ_NONE; + bCreateOutline = true; + } + } + else if( ( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_TEXT ) ) + { + if( pObjectsSdPage ) + { + eKind = pObjectsSdPage->GetPresObjKind(pObject); + + if((eKind == PRESOBJ_FOOTER) || (eKind == PRESOBJ_HEADER) || (eKind == PRESOBJ_DATETIME) || (eKind == PRESOBJ_SLIDENUMBER) ) + { + if( !bSubContentProcessing ) + { + // only draw a boundary for header&footer objects on the masterpage itself + bCreateOutline = true; + } + } + } + } + else if( ( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_PAGE ) ) + { + // only for handout page, else this frame will be created for each + // page preview object in SlideSorter and PagePane + if(pObjectsSdPage && PK_HANDOUT == pObjectsSdPage->GetPageKind()) + { + bCreateOutline = true; + } + } + + if(bCreateOutline) + { + // empty presentation objects get a gray frame + const svtools::ColorConfig aColorConfig; + const svtools::ColorConfigValue aColor( aColorConfig.GetColorValue( svtools::OBJECTBOUNDARIES ) ); + + if( aColor.bIsVisible ) + { + // get basic object transformation + const basegfx::BColor aRGBColor(Color(aColor.nColor).getBColor()); + basegfx::B2DHomMatrix aObjectMatrix; + basegfx::B2DPolyPolygon aObjectPolyPolygon; + pObject->TRGetBaseGeometry(aObjectMatrix, aObjectPolyPolygon); + + // create dashed border + { + // create object polygon + basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon()); + aPolygon.transform(aObjectMatrix); + + // create line and stroke attribute + ::std::vector< double > aDotDashArray; + + aDotDashArray.push_back(160.0); + aDotDashArray.push_back(80.0); + + const double fFullDotDashLen(::std::accumulate(aDotDashArray.begin(), aDotDashArray.end(), 0.0)); + const drawinglayer::attribute::LineAttribute aLine(aRGBColor); + const drawinglayer::attribute::StrokeAttribute aStroke(aDotDashArray, fFullDotDashLen); + + // create primitive and add + const drawinglayer::primitive2d::Primitive2DReference xRef(new drawinglayer::primitive2d::PolygonStrokePrimitive2D( + aPolygon, + aLine, + aStroke)); + drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xRef); + } + + // now paint the placeholder description, but only when masterpage + // is displayed as page directly (MasterPage view) + if(!bSubContentProcessing && bIsMasterPageObject) + { + String aObjectString; + + switch( eKind ) + { + case PRESOBJ_TITLE: + { + if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PK_STANDARD) + { + static String aTitleAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_TITLE ) ); + aObjectString = aTitleAreaStr; + } + + break; + } + case PRESOBJ_OUTLINE: + { + static String aOutlineAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_OUTLINE ) ); + aObjectString = aOutlineAreaStr; + break; + } + case PRESOBJ_FOOTER: + { + static String aFooterAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_FOOTER ) ); + aObjectString = aFooterAreaStr; + break; + } + case PRESOBJ_HEADER: + { + static String aHeaderAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_HEADER ) ); + aObjectString = aHeaderAreaStr; + break; + } + case PRESOBJ_DATETIME: + { + static String aDateTimeStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_DATETIME ) ); + aObjectString = aDateTimeStr; + break; + } + case PRESOBJ_NOTES: + { + static String aDateTimeStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_NOTES ) ); + aObjectString = aDateTimeStr; + break; + } + case PRESOBJ_SLIDENUMBER: + { + if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PK_STANDARD) + { + static String aSlideAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_SLIDE ) ); + aObjectString = aSlideAreaStr; + } + else + { + static String aNumberAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_NUMBER ) ); + aObjectString = aNumberAreaStr; + } + break; + } + default: + { + break; + } + } + + if( aObjectString.Len() ) + { + // decompose object matrix to be able to place text correctly + basegfx::B2DTuple aScale; + basegfx::B2DTuple aTranslate; + double fRotate, fShearX; + aObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX); + + // create font + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObject ); + const SdrTextVertAdjust eTVA(pTextObj ? pTextObj->GetTextVerticalAdjust() : SDRTEXTVERTADJUST_CENTER); + Font aScaledVclFont; + + // use a text size factor to get more reliable text sizes from the text layouter + // (and from vcl), tipp from HDU + static sal_uInt32 nTextSizeFactor(100); + + // use a factor to get more linear text size calculations + aScaledVclFont.SetHeight( 500 * nTextSizeFactor ); + + // get basic geometry and get text size + drawinglayer::primitive2d::TextLayouterDevice aTextLayouter; + aTextLayouter.setFont(aScaledVclFont); + const xub_StrLen nTextLength(aObjectString.Len()); + + // do not forget to use the factor again to get the width for the 500 + const double fTextWidth(aTextLayouter.getTextWidth(aObjectString, 0, nTextLength) * (1.0 / nTextSizeFactor)); + const double fTextHeight(aTextLayouter.getTextHeight() * (1.0 / nTextSizeFactor)); + + // calculate text primitive position. If text is at bottom, use top for + // the extra text and vice versa + const double fHorDist(125); + const double fVerDist(125); + const double fPosX((aTranslate.getX() + aScale.getX()) - fTextWidth - fHorDist); + const double fPosY((SDRTEXTVERTADJUST_BOTTOM == eTVA) + ? aTranslate.getY() - fVerDist + fTextHeight + : (aTranslate.getY() + aScale.getY()) - fVerDist); + + // get font attributes; use normally scaled font + const basegfx::BColor aFontColor(aRGBColor); + Font aVclFont; + basegfx::B2DVector aTextSizeAttribute; + + aVclFont.SetHeight( 500 ); + + const drawinglayer::attribute::FontAttribute aFontAttribute( + drawinglayer::primitive2d::getFontAttributeFromVclFont( + aTextSizeAttribute, + aVclFont, + false, + false)); + + // fill text matrix + const basegfx::B2DHomMatrix aTextMatrix(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix( + aTextSizeAttribute.getX(), aTextSizeAttribute.getY(), + fShearX, + fRotate, + fPosX, fPosY)); + + // create DXTextArray (can be empty one) + const ::std::vector< double > aDXArray; + + // create locale; this may need some more information in the future + const ::com::sun::star::lang::Locale aLocale; + + // create primitive and add + const drawinglayer::primitive2d::Primitive2DReference xRef( + new drawinglayer::primitive2d::TextSimplePortionPrimitive2D( + aTextMatrix, + aObjectString, + 0, + nTextLength, + aDXArray, + aFontAttribute, + aLocale, + aFontColor)); + drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xRef); + } + } + } + } + } + + if(bDoCreateGeometry) + { + drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence( + xRetval, + sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence( + rOriginal, + rDisplayInfo)); + } + } + else + { + // not a SdrObject visualisation (maybe e.g. page) or no page + xRetval = sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo); + } + + return xRetval; +} + +/************************************************************************* +|* +|* Paint-Methode: das Ereignis wird an die View weitergeleitet +|* +\************************************************************************/ + +void View::CompleteRedraw(OutputDevice* pOutDev, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector /*=0L*/) +{ + // ausfuehren ?? + if (mnLockRedrawSmph == 0) + { + SdrPageView* pPgView = GetSdrPageView(); + + if (pPgView) + { + SdPage* pPage = (SdPage*) pPgView->GetPage(); + if( pPage ) + { + SdrOutliner& rOutl=mpDoc->GetDrawOutliner(NULL); + bool bScreenDisplay(true); + + if(bScreenDisplay && pOutDev && OUTDEV_PRINTER == pOutDev->GetOutDevType()) + { + // #i75566# printing; suppress AutoColor BackgroundColor generation + // for visibility reasons by giving GetPageBackgroundColor() + // the needed hint + bScreenDisplay = false; + } + + if(bScreenDisplay && pOutDev && pOutDev->GetPDFWriter()) + { + // #i75566# PDF export; suppress AutoColor BackgroundColor generation (see above) + bScreenDisplay = false; + } + + // #i75566# Name change GetBackgroundColor -> GetPageBackgroundColor and + // hint value if screen display. Only then the AutoColor mechanisms shall be applied + rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor(pPgView, bScreenDisplay) ); + } + } + + ViewRedirector aViewRedirector; + FmFormView::CompleteRedraw(pOutDev, rReg, pRedirector ? pRedirector : &aViewRedirector); + } + // oder speichern? + else + { + if (!mpLockedRedraws) + mpLockedRedraws = new List; + + SdViewRedrawRec* pRec = new SdViewRedrawRec; + pRec->mpOut = pOutDev; + pRec->aRect = rReg.GetBoundRect(); + mpLockedRedraws->Insert(pRec, LIST_APPEND); + } +} + + +/************************************************************************* +|* +|* Selektion hat sich geaendert +|* +\************************************************************************/ + +void View::MarkListHasChanged() +{ + FmFormView::MarkListHasChanged(); + + if( GetMarkedObjectCount() > 0 ) + maSmartTags.deselect(); +} + + +/************************************************************************* +|* +|* Attribute setzen +|* +\************************************************************************/ + +BOOL View::SetAttributes(const SfxItemSet& rSet, BOOL bReplaceAll) +{ + BOOL bOk = FmFormView::SetAttributes(rSet, bReplaceAll); + return (bOk); +} + + +/************************************************************************* +|* +|* Attribute holen +|* +\************************************************************************/ + +BOOL View::GetAttributes( SfxItemSet& rTargetSet, BOOL bOnlyHardAttr ) const +{ + return( FmFormView::GetAttributes( rTargetSet, bOnlyHardAttr ) ); +} + + +/************************************************************************* +|* +|* Ist ein Praesentationsobjekt selektiert? +|* +\************************************************************************/ + +BOOL View::IsPresObjSelected(BOOL bOnPage, BOOL bOnMasterPage, BOOL bCheckPresObjListOnly, BOOL bCheckLayoutOnly) const +{ + /************************************************************************** + * Ist ein Presentationsobjekt selektiert? + **************************************************************************/ + SdrMarkList* pMarkList; + + if (mnDragSrcPgNum != SDRPAGE_NOTFOUND && + mnDragSrcPgNum != GetSdrPageView()->GetPage()->GetPageNum()) + { + // Es laeuft gerade Drag&Drop + // Source- und Destination-Page unterschiedlich: + // es wird die gemerkte MarkList verwendet + pMarkList = mpDragSrcMarkList; + } + else + { + // Es wird die aktuelle MarkList verwendet + pMarkList = new SdrMarkList(GetMarkedObjectList()); + } + + SdrMark* pMark; + SdPage* pPage; + SdrObject* pObj; + + BOOL bSelected = FALSE; + BOOL bMasterPage = FALSE; + long nMark; + long nMarkMax = long(pMarkList->GetMarkCount()) - 1; + + for (nMark = nMarkMax; (nMark >= 0) && !bSelected; nMark--) + { + // Rueckwaerts durch die Marklist + pMark = pMarkList->GetMark(nMark); + pObj = pMark->GetMarkedSdrObj(); + + if ( pObj && ( bCheckPresObjListOnly || pObj->IsEmptyPresObj() || pObj->GetUserCall() ) ) + { + pPage = (SdPage*) pObj->GetPage(); + bMasterPage = pPage->IsMasterPage(); + + if ( (bMasterPage && bOnMasterPage) || (!bMasterPage && bOnPage) ) + { + if ( pPage && pPage->IsPresObj(pObj) ) + { + if( bCheckLayoutOnly ) + { + PresObjKind eKind = pPage->GetPresObjKind(pObj); + + if((eKind != PRESOBJ_FOOTER) && (eKind != PRESOBJ_HEADER) && (eKind != PRESOBJ_DATETIME) && (eKind != PRESOBJ_SLIDENUMBER) ) + bSelected = TRUE; + } + else + { + bSelected = TRUE; + } + } + } + } + } + + if (pMarkList != mpDragSrcMarkList) + { + delete pMarkList; + } + + return (bSelected); +} + +/************************************************************************* +|* +|* Alles selektieren +|* +\************************************************************************/ + +void View::SelectAll() +{ + if ( IsTextEdit() ) + { + OutlinerView* pOLV = GetTextEditOutlinerView(); + const ::Outliner* pOutliner = GetTextEditOutliner(); + pOLV->SelectRange( 0, (USHORT) pOutliner->GetParagraphCount() ); + } + else + { + MarkAll(); + } +} + + +/************************************************************************* +|* +|* Dokument hat sich geaendert +|* +\************************************************************************/ + +void View::ModelHasChanged() +{ + // Erst SdrView benachrichtigen + FmFormView::ModelHasChanged(); +} + +/************************************************************************* +|* +|* StyleSheet setzen +|* +\************************************************************************/ + +BOOL View::SetStyleSheet(SfxStyleSheet* pStyleSheet, BOOL bDontRemoveHardAttr) +{ + // weiter an SdrView + return FmFormView::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr); +} + + +/************************************************************************* +|* +|* Texteingabe beginnen +|* +\************************************************************************/ + +static void SetSpellOptions( SdDrawDocument* pDoc, ULONG& rCntrl ) +{ + BOOL bOnlineSpell = pDoc->GetOnlineSpell(); + + if( bOnlineSpell ) + rCntrl |= EE_CNTRL_ONLINESPELLING; + else + rCntrl &= ~EE_CNTRL_ONLINESPELLING; +} + +sal_Bool View::SdrBeginTextEdit( + SdrObject* pObj, SdrPageView* pPV, ::Window* pWin, + sal_Bool bIsNewObj, + SdrOutliner* pOutl, OutlinerView* pGivenOutlinerView, + sal_Bool bDontDeleteOutliner, sal_Bool bOnlyOneView, sal_Bool bGrabFocus ) +{ + GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent( + sd::tools::EventMultiplexerEvent::EID_BEGIN_TEXT_EDIT, (void*)pObj ); + + if( pOutl==NULL && pObj ) + pOutl = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, pObj->GetModel() ); + + // make draw&impress specific initialisations + if( pOutl ) + { + pOutl->SetStyleSheetPool((SfxStyleSheetPool*) mpDoc->GetStyleSheetPool()); + pOutl->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl)); + ULONG nCntrl = pOutl->GetControlWord(); + nCntrl |= EE_CNTRL_ALLOWBIGOBJS; + nCntrl |= EE_CNTRL_URLSFXEXECUTE; + nCntrl |= EE_CNTRL_MARKFIELDS; + nCntrl |= EE_CNTRL_AUTOCORRECT; + + nCntrl &= ~EE_CNTRL_ULSPACESUMMATION; + if ( mpDoc->IsSummationOfParagraphs() ) + nCntrl |= EE_CNTRL_ULSPACESUMMATION; + + SetSpellOptions( mpDoc, nCntrl ); + + pOutl->SetControlWord(nCntrl); + + Reference< linguistic2::XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() ); + if ( xSpellChecker.is() ) + pOutl->SetSpeller( xSpellChecker ); + + Reference< linguistic2::XHyphenator > xHyphenator( LinguMgr::GetHyphenator() ); + if( xHyphenator.is() ) + pOutl->SetHyphenator( xHyphenator ); + + pOutl->SetDefaultLanguage( Application::GetSettings().GetLanguage() ); + } + + sal_Bool bReturn = FmFormView::SdrBeginTextEdit( + pObj, pPV, pWin, bIsNewObj, pOutl, + pGivenOutlinerView, bDontDeleteOutliner, + bOnlyOneView, bGrabFocus); + + if (bReturn) + { + ::Outliner* pOL = GetTextEditOutliner(); + + if( pObj && pObj->GetPage() ) + { + Color aBackground; + if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_TABLE ) + { + aBackground = GetTextEditBackgroundColor(*this); + } + else + { + aBackground = pObj->GetPage()->GetPageBackgroundColor(pPV); + } + pOL->SetBackgroundColor( aBackground ); + } + + pOL->SetParaInsertedHdl(LINK(this, View, OnParagraphInsertedHdl)); + pOL->SetParaRemovingHdl(LINK(this, View, OnParagraphRemovingHdl)); + } + + return(bReturn); +} + +/** ends current text editing */ +SdrEndTextEditKind View::SdrEndTextEdit(BOOL bDontDeleteReally ) +{ + SdrObjectWeakRef xObj( GetTextEditObject() ); + + BOOL bDefaultTextRestored = RestoreDefaultText( dynamic_cast< SdrTextObj* >( GetTextEditObject() ) ); + + SdrEndTextEditKind eKind = FmFormView::SdrEndTextEdit(bDontDeleteReally); + + if( bDefaultTextRestored ) + { + if( xObj.is() && !xObj->IsEmptyPresObj() ) + { + xObj->SetEmptyPresObj( TRUE ); + } + else + { + eKind = SDRENDTEXTEDIT_UNCHANGED; + } + } + else if( xObj.is() && xObj->IsEmptyPresObj() ) + { + SdrTextObj* pObj = dynamic_cast< SdrTextObj* >( xObj.get() ); + if( pObj && pObj->HasText() ) + { + SdrPage* pPage = pObj->GetPage(); + if( !pPage || !pPage->IsMasterPage() ) + pObj->SetEmptyPresObj( FALSE ); + } + } + + GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(sd::tools::EventMultiplexerEvent::EID_END_TEXT_EDIT, (void*)xObj.get() ); + + if( xObj.is() ) + { + SdPage* pPage = dynamic_cast< SdPage* >( xObj->GetPage() ); + if( pPage ) + pPage->onEndTextEdit( xObj.get() ); + } + + return(eKind); +} + +// -------------------------------------------------------------------- + +/** restores the default text if the given text object is currently in edit mode and + no text has been entered already. Is only usefull just before text edit ends. */ +bool View::RestoreDefaultText( SdrTextObj* pTextObj ) +{ + bool bRestored = false; + + if( pTextObj && (pTextObj == GetTextEditObject()) ) + { + if( !pTextObj->HasText() ) + { + SdPage* pPage = dynamic_cast< SdPage* >( pTextObj->GetPage() ); + + if(pPage) + { + bRestored = pPage->RestoreDefaultText( pTextObj ); + if( bRestored ) + { + SdrOutliner* pOutliner = GetTextEditOutliner(); + pTextObj->SetTextEditOutliner( pOutliner ); + OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject(); + if (pOutliner) + pOutliner->SetText(*pParaObj); + } + } + } + } + + return bRestored; +} + +/************************************************************************* +|* +|* Originalgroesse der markierten Objekte setzen +|* +\************************************************************************/ + +void View::SetMarkedOriginalSize() +{ + SdrUndoGroup* pUndoGroup = new SdrUndoGroup(*mpDoc); + ULONG nCount = GetMarkedObjectCount(); + BOOL bOK = FALSE; + + for( sal_uInt32 i = 0; i < nCount; i++ ) + { + SdrObject* pObj = GetMarkedObjectByIndex(i); + + if( pObj->GetObjInventor() == SdrInventor ) + { + if( pObj->GetObjIdentifier() == OBJ_OLE2 ) + { + uno::Reference < embed::XEmbeddedObject > xObj = ((SdrOle2Obj*)pObj)->GetObjRef(); + if( xObj.is() ) + { + // TODO/LEAN: working with VisualArea can switch object to running state + + sal_Int64 nAspect = ((SdrOle2Obj*)pObj)->GetAspect(); + Size aOleSize; + + if ( nAspect == embed::Aspects::MSOLE_ICON ) + { + MapMode aMap100( MAP_100TH_MM ); + aOleSize = ((SdrOle2Obj*)pObj)->GetOrigObjSize( &aMap100 ); + bOK = TRUE; + } + else + { + MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) ); + try + { + awt::Size aSz = xObj->getVisualAreaSize( nAspect ); + aOleSize = OutputDevice::LogicToLogic( Size( aSz.Width, aSz.Height ), aUnit, MAP_100TH_MM ); + bOK = TRUE; + } + catch( embed::NoVisualAreaSizeException& ) + {} + } + + if ( bOK ) + { + Rectangle aDrawRect( pObj->GetLogicRect() ); + + pUndoGroup->AddAction( mpDoc->GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) ); + pObj->Resize( aDrawRect.TopLeft(), Fraction( aOleSize.Width(), aDrawRect.GetWidth() ), + Fraction( aOleSize.Height(), aDrawRect.GetHeight() ) ); + } + } + } + else if( pObj->GetObjIdentifier() == OBJ_GRAF ) + { + const MapMode aMap100( MAP_100TH_MM ); + Size aSize; + + if ( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefMapMode().GetMapUnit() == MAP_PIXEL ) + aSize = Application::GetDefaultDevice()->PixelToLogic( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefSize(), aMap100 ); + else + { + aSize = OutputDevice::LogicToLogic( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefSize(), + static_cast< SdrGrafObj* >( pObj )->GetGrafPrefMapMode(), + aMap100 ); + } + + pUndoGroup->AddAction( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj ) ); + Rectangle aRect( pObj->GetLogicRect() ); + aRect.SetSize( aSize ); + pObj->SetLogicRect( aRect ); + + bOK = TRUE; + } + } + } + + if( bOK ) + { + pUndoGroup->SetComment( String(SdResId(STR_UNDO_ORIGINALSIZE)) ); + mpDocSh->GetUndoManager()->AddUndoAction(pUndoGroup); + } + else + delete pUndoGroup; +} + +/************************************************************************* +|* +|* OLE-Obj am Client connecten +|* +\************************************************************************/ + +void View::DoConnect(SdrOle2Obj* pObj) +{ + if (mpViewSh) + { + uno::Reference < embed::XEmbeddedObject > xObj( pObj->GetObjRef() ); + if( xObj.is() ) + { + ::sd::Window* pWindow = mpViewSh->GetActiveWindow(); + SfxInPlaceClient* pSdClient = mpViewSh-> GetViewShellBase().FindIPClient( xObj, pWindow ); + if ( !pSdClient ) + { + pSdClient = new Client(pObj, mpViewSh, pWindow); + Rectangle aRect = pObj->GetLogicRect(); + { + // TODO/LEAN: working with visual area can switch object to running state + Size aDrawSize = aRect.GetSize(); + awt::Size aSz; + + MapMode aMapMode( mpDoc->GetScaleUnit() ); + Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode ); + + Fraction aScaleWidth (aDrawSize.Width(), aObjAreaSize.Width() ); + Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() ); + aScaleWidth.ReduceInaccurate(10); // kompatibel zum SdrOle2Obj + aScaleHeight.ReduceInaccurate(10); + pSdClient->SetSizeScale(aScaleWidth, aScaleHeight); + + // sichtbarer Ausschnitt wird nur inplace veraendert! + // the object area must be set after the scaling, since it triggers resize + aRect.SetSize(aObjAreaSize); + pSdClient->SetObjArea(aRect); + } + } + } + } +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +BOOL View::IsMorphingAllowed() const +{ + const SdrMarkList& rMarkList = GetMarkedObjectList(); + BOOL bRet = FALSE; + + if ( rMarkList.GetMarkCount() == 2 ) + { + const SdrObject* pObj1 = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + const SdrObject* pObj2 = rMarkList.GetMark( 1 )->GetMarkedSdrObj(); + const UINT16 nKind1 = pObj1->GetObjIdentifier(); + const UINT16 nKind2 = pObj2->GetObjIdentifier(); + + if ( ( nKind1 != OBJ_TEXT && nKind2 != OBJ_TEXT ) && + ( nKind1 != OBJ_TITLETEXT && nKind2 != OBJ_TITLETEXT ) && + ( nKind1 != OBJ_OUTLINETEXT && nKind2 != OBJ_OUTLINETEXT ) && + ( nKind1 != OBJ_GRUP && nKind2 != OBJ_GRUP ) && + ( nKind1 != OBJ_LINE && nKind2 != OBJ_LINE ) && + ( nKind1 != OBJ_PLIN && nKind2 != OBJ_PLIN ) && + ( nKind1 != OBJ_PATHLINE && nKind2 != OBJ_PATHLINE ) && + ( nKind1 != OBJ_FREELINE && nKind2 != OBJ_FREELINE ) && + ( nKind1 != OBJ_PATHPLIN && nKind2 != OBJ_PATHPLIN ) && + ( nKind1 != OBJ_MEASURE && nKind2 != OBJ_MEASURE ) && + ( nKind1 != OBJ_EDGE && nKind2 != OBJ_EDGE ) && + ( nKind1 != OBJ_GRAF && nKind2 != OBJ_GRAF ) && + ( nKind1 != OBJ_OLE2 && nKind2 != OBJ_OLE2 ) && + ( nKind1 != OBJ_CAPTION && nKind2 != OBJ_CAPTION ) && + !pObj1->ISA( E3dObject) && !pObj2->ISA( E3dObject) ) + { + SfxItemSet aSet1( mpDoc->GetPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE ); + SfxItemSet aSet2( mpDoc->GetPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE ); + + aSet1.Put(pObj1->GetMergedItemSet()); + aSet2.Put(pObj2->GetMergedItemSet()); + + const XFillStyle eFillStyle1 = ( (const XFillStyleItem&) aSet1.Get( XATTR_FILLSTYLE ) ).GetValue(); + const XFillStyle eFillStyle2 = ( (const XFillStyleItem&) aSet2.Get( XATTR_FILLSTYLE ) ).GetValue(); + + if( ( eFillStyle1 == XFILL_NONE || eFillStyle1 == XFILL_SOLID ) && + ( eFillStyle2 == XFILL_NONE || eFillStyle2 == XFILL_SOLID ) ) + bRet = TRUE; + } + } + + return bRet; +} + +/************************************************************************* +|* +|* +|* +\************************************************************************/ + +BOOL View::IsVectorizeAllowed() const +{ + const SdrMarkList& rMarkList = GetMarkedObjectList(); + BOOL bRet = FALSE; + + if( rMarkList.GetMarkCount() == 1 ) + { + const SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + + if( pObj->ISA( SdrGrafObj ) && ( (SdrGrafObj*) pObj )->GetGraphicType() == GRAPHIC_BITMAP ) + bRet = TRUE; + } + + return bRet; +} + +void View::onAccessibilityOptionsChanged() +{ + if( mpViewSh ) + { + ::sd::Window* pWindow = mpViewSh->GetActiveWindow(); + if( pWindow ) + { + const StyleSettings& rStyleSettings = pWindow->GetSettings().GetStyleSettings(); + + USHORT nOutputSlot, nPreviewSlot; + + SvtAccessibilityOptions& aAccOptions = getAccessibilityOptions(); + + if( mpViewSh->GetViewFrame() && mpViewSh->GetViewFrame()->GetDispatcher() ) + { + if( rStyleSettings.GetHighContrastMode() ) + { + nOutputSlot = SID_OUTPUT_QUALITY_CONTRAST; + } + else + { + nOutputSlot = SID_OUTPUT_QUALITY_COLOR; + } + + if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() ) + { + nPreviewSlot = SID_PREVIEW_QUALITY_CONTRAST; + } + else + { + nPreviewSlot = SID_PREVIEW_QUALITY_COLOR; + } + + mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nOutputSlot, SFX_CALLMODE_ASYNCHRON ); + mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nPreviewSlot, SFX_CALLMODE_ASYNCHRON ); + } + + mpViewSh->Invalidate(); + } + } +} + +IMPL_LINK( View, OnParagraphInsertedHdl, ::Outliner *, pOutliner ) +{ + Paragraph* pPara = pOutliner->GetHdlParagraph(); + SdrObject* pObj = GetTextEditObject(); + + if( pPara && pObj ) + { + SdPage* pPage = dynamic_cast< SdPage* >( pObj->GetPage() ); + if( pPage ) + pPage->onParagraphInserted( pOutliner, pPara, pObj ); + } + return 0; +} + +/************************************************************************* +|* +|* Handler fuer das Loeschen von Seiten (Absaetzen) +|* +\************************************************************************/ + +IMPL_LINK( View, OnParagraphRemovingHdl, ::Outliner *, pOutliner ) +{ + Paragraph* pPara = pOutliner->GetHdlParagraph(); + SdrObject* pObj = GetTextEditObject(); + + if( pPara && pObj ) + { + SdPage* pPage = dynamic_cast< SdPage* >( pObj->GetPage() ); + if( pPage ) + pPage->onParagraphRemoving( pOutliner, pPara, pObj ); + } + return 0; +} + +bool View::isRecordingUndo() const +{ + if( mpDoc && mpDoc->IsUndoEnabled() ) + { + sd::UndoManager* pUndoManager = mpDoc ? mpDoc->GetUndoManager() : 0; + return pUndoManager && pUndoManager->isInListAction(); + } + else + { + return false; + } +} + +void View::AddCustomHdl() +{ + maSmartTags.addCustomHandles( aHdl ); +} + +void View::updateHandles() +{ + AdjustMarkHdl(); +} + +SdrViewContext View::GetContext() const +{ + SdrViewContext eContext = SDRCONTEXT_STANDARD; + if( maSmartTags.getContext( eContext ) ) + return eContext; + else + return FmFormView::GetContext(); +} + +BOOL View::HasMarkablePoints() const +{ + if( maSmartTags.HasMarkablePoints() ) + return true; + else + return FmFormView::HasMarkablePoints(); +} + +ULONG View::GetMarkablePointCount() const +{ + ULONG nCount = FmFormView::GetMarkablePointCount(); + nCount += maSmartTags.GetMarkablePointCount(); + return nCount; +} + +BOOL View::HasMarkedPoints() const +{ + if( maSmartTags.HasMarkedPoints() ) + return true; + else + return FmFormView::HasMarkedPoints(); +} + +ULONG View::GetMarkedPointCount() const +{ + ULONG nCount = FmFormView::GetMarkedPointCount(); + nCount += maSmartTags.GetMarkedPointCount(); + return nCount; +} + +BOOL View::IsPointMarkable(const SdrHdl& rHdl) const +{ + if( maSmartTags.IsPointMarkable( rHdl ) ) + return true; + else + return FmFormView::IsPointMarkable( rHdl ); +} + +BOOL View::MarkPoint(SdrHdl& rHdl, BOOL bUnmark ) +{ + if( maSmartTags.MarkPoint( rHdl, bUnmark ) ) + return true; + else + return FmFormView::MarkPoint( rHdl, bUnmark ); +} + +BOOL View::MarkPoints(const Rectangle* pRect, BOOL bUnmark) +{ + if( maSmartTags.MarkPoints( pRect, bUnmark ) ) + return true; + else + return FmFormView::MarkPoints( pRect, bUnmark ); +} + +void View::CheckPossibilities() +{ + FmFormView::CheckPossibilities(); + maSmartTags.CheckPossibilities(); +} + +void View::OnBeginPasteOrDrop( PasteOrDropInfos* /*pInfos*/ ) +{ +} + +/** this is called after a paste or drop operation, make sure that the newly inserted paragraphs + get the correct style sheet. */ +void View::OnEndPasteOrDrop( PasteOrDropInfos* pInfos ) +{ + SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( GetTextEditObject() ); + SdrOutliner* pOutliner = GetTextEditOutliner(); + if( pOutliner && pTextObj && pTextObj->GetPage() ) + { + SdPage* pPage = static_cast< SdPage* >( pTextObj->GetPage() ); + + SfxStyleSheet* pStyleSheet = 0; + + const PresObjKind eKind = pPage->GetPresObjKind(pTextObj); + if( eKind != PRESOBJ_NONE ) + pStyleSheet = pPage->GetStyleSheetForPresObj(eKind); + else + pStyleSheet = pTextObj->GetStyleSheet(); + + if( eKind == PRESOBJ_OUTLINE ) + { + // for outline shapes, set the correct outline style sheet for each + // new paragraph, depending on the paragraph depth + SfxStyleSheetBasePool* pStylePool = GetDoc()->GetStyleSheetPool(); + + for ( sal_uInt16 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ ) + { + sal_Int16 nDepth = pOutliner->GetDepth( nPara ); + + SfxStyleSheet* pStyle = 0; + if( nDepth > 0 ) + { + String aStyleSheetName( pStyleSheet->GetName() ); + aStyleSheetName.Erase( aStyleSheetName.Len() - 1, 1 ); + aStyleSheetName += String::CreateFromInt32( nDepth ); + pStyle = static_cast<SfxStyleSheet*>( pStylePool->Find( aStyleSheetName, pStyleSheet->GetFamily() ) ); + DBG_ASSERT( pStyle, "sd::View::OnEndPasteOrDrop(), Style not found!" ); + } + + if( !pStyle ) + pStyle = pStyleSheet; + + pOutliner->SetStyleSheet( nPara, pStyle ); + } + } + else + { + // just put the object style on each new paragraph + for ( sal_uInt16 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ ) + { + pOutliner->SetStyleSheet( nPara, pStyleSheet ); + } + } + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/sdview2.cxx b/sd/source/ui/view/sdview2.cxx new file mode 100644 index 000000000000..ea4d120b1219 --- /dev/null +++ b/sd/source/ui/view/sdview2.cxx @@ -0,0 +1,1038 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + + +#include "View.hxx" + +#include <vector> +#include <com/sun/star/embed/XEmbedPersist.hpp> +#include <tools/ref.hxx> +#include <tools/urlobj.hxx> +#ifndef _MSGBOX_HXX //autogen +#include <vcl/msgbox.hxx> +#endif +#include <svx/svdetc.hxx> +#include <svx/svdoole2.hxx> +#include <svx/svdograf.hxx> +#include <vcl/graph.hxx> +#include <svx/xexch.hxx> +#include <svx/svxdlg.hxx> +#include <svx/dialogs.hrc> +#include <sfx2/docfile.hxx> +#include <sfx2/childwin.hxx> +#include <svx/svdundo.hxx> +#include <svx/svdpagv.hxx> +#include <svl/urlbmk.hxx> +#include <svl/urlbmk.hxx> +#include <editeng/outliner.hxx> +#include <svx/xflclit.hxx> +#include <svx/dbexch.hrc> +#include <sot/formats.hxx> +#include <editeng/editeng.hxx> +#include <svx/svditer.hxx> +#include <svx/obj3d.hxx> +#include <svx/scene3d.hxx> + +#include <sfx2/objsh.hxx> +#include <svtools/embedtransfer.hxx> + +#include "navigatr.hxx" +#include "anminfo.hxx" +#include "strings.hrc" +#include "glob.hrc" +#include "sdxfer.hxx" +#include "sdresid.hxx" +#include "sdmod.hxx" +#include "DrawViewShell.hxx" +#include "DrawDocShell.hxx" +#include "fudraw.hxx" +#include "drawdoc.hxx" +#include "Window.hxx" +#include "sdpage.hxx" +#include "unoaprms.hxx" +#include "drawview.hxx" +#include "helpids.h" +#include <vcl/svapp.hxx> + +#include "slideshow.hxx" + +namespace sd { + +#ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED +#define SO2_DECL_SVINPLACEOBJECT_DEFINED +SO2_DECL_REF(SvInPlaceObject) +#endif +#ifndef SO2_DECL_SVSTORAGE_DEFINED +#define SO2_DECL_SVSTORAGE_DEFINED +SO2_DECL_REF(SvStorage) +#endif + +using namespace ::com::sun::star; + +// ------------------------ +// - SdNavigatorDropEvent - +// ------------------------ + +struct SdNavigatorDropEvent : public ExecuteDropEvent +{ + DropTargetHelper& mrTargetHelper; + ::sd::Window* mpTargetWindow; + USHORT mnPage; + USHORT mnLayer; + + SdNavigatorDropEvent ( + const ExecuteDropEvent& rEvt, + DropTargetHelper& rTargetHelper, + ::sd::Window* pTargetWindow, + USHORT nPage, + USHORT nLayer ) + : ExecuteDropEvent( rEvt ), + mrTargetHelper( rTargetHelper ), + mpTargetWindow( pTargetWindow ), + mnPage( nPage ), + mnLayer( nLayer ) + {} +}; + +// ----------------------------------------------------------------------------- + +::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > View::CreateClipboardDataObject( View*, ::Window& ) +{ + // since SdTransferable::CopyToClipboard is called, this + // dynamically created object ist destroyed automatically + SdTransferable* pTransferable = new SdTransferable( mpDoc, NULL, FALSE ); + ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > xRet( pTransferable ); + + SD_MOD()->pTransferClip = pTransferable; + + mpDoc->CreatingDataObj( pTransferable ); + pTransferable->SetWorkDocument( (SdDrawDocument*) GetAllMarkedModel() ); + mpDoc->CreatingDataObj( NULL ); + + const Rectangle aMarkRect( GetAllMarkedRect() ); + TransferableObjectDescriptor aObjDesc; + String aDisplayName; + SdrOle2Obj* pSdrOleObj = NULL; + SdrPageView* pPgView = GetSdrPageView(); + SdPage* pOldPage = pPgView ? ( (SdPage*) pPgView->GetPage() ) : NULL; + SdPage* pNewPage = (SdPage*) pTransferable->GetWorkDocument()->GetPage( 0 ); + + if( pOldPage ) + { + pNewPage->SetSize( pOldPage->GetSize() ); + pNewPage->SetLayoutName( pOldPage->GetLayoutName() ); + } + + if( GetMarkedObjectCount() == 1 ) + { + SdrObject* pObj = GetMarkedObjectByIndex(0); + + if( pObj && pObj->ISA(SdrOle2Obj) && ((SdrOle2Obj*) pObj)->GetObjRef().is() ) + { + // If object has no persistence it must be copied as part of the document + try + { + uno::Reference< embed::XEmbedPersist > xPersObj( ((SdrOle2Obj*)pObj)->GetObjRef(), uno::UNO_QUERY ); + if ( xPersObj.is() && xPersObj->hasEntry() ) + pSdrOleObj = (SdrOle2Obj*) pObj; + } + catch( uno::Exception& ) + {} + } + } + + if( pSdrOleObj ) + SvEmbedTransferHelper::FillTransferableObjectDescriptor( aObjDesc, pSdrOleObj->GetObjRef(), pSdrOleObj->GetGraphic(), pSdrOleObj->GetAspect() ); + else + pTransferable->GetWorkDocument()->GetDocSh()->FillTransferableObjectDescriptor( aObjDesc ); + + if( mpDocSh ) + aObjDesc.maDisplayName = mpDocSh->GetMedium()->GetURLObject().GetURLNoPass(); + + aObjDesc.maSize = aMarkRect.GetSize(); + + pTransferable->SetStartPos( aMarkRect.TopLeft() ); + pTransferable->SetObjectDescriptor( aObjDesc ); + pTransferable->CopyToClipboard( mpViewSh->GetActiveWindow() ); + + return xRet; +} + +// ----------------------------------------------------------------------------- + +::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > View::CreateDragDataObject( View* pWorkView, ::Window& rWindow, const Point& rDragPos ) +{ + SdTransferable* pTransferable = new SdTransferable( mpDoc, pWorkView, FALSE ); + ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > xRet( pTransferable ); + + SD_MOD()->pTransferDrag = pTransferable; + + TransferableObjectDescriptor aObjDesc; + String aDisplayName; + SdrOle2Obj* pSdrOleObj = NULL; + + if( GetMarkedObjectCount() == 1 ) + { + SdrObject* pObj = GetMarkedObjectByIndex( 0 ); + + if( pObj && pObj->ISA( SdrOle2Obj ) && ( (SdrOle2Obj*) pObj )->GetObjRef().is() ) + { + // If object has no persistence it must be copied as part of the document + try + { + uno::Reference< embed::XEmbedPersist > xPersObj( ((SdrOle2Obj*)pObj)->GetObjRef(), uno::UNO_QUERY ); + if ( xPersObj.is() && xPersObj->hasEntry() ) + pSdrOleObj = (SdrOle2Obj*) pObj; + } + catch( uno::Exception& ) + {} + } + } + + if( mpDocSh ) + aDisplayName = mpDocSh->GetMedium()->GetURLObject().GetURLNoPass(); + + if( pSdrOleObj ) + SvEmbedTransferHelper::FillTransferableObjectDescriptor( aObjDesc, pSdrOleObj->GetObjRef(), pSdrOleObj->GetGraphic(), pSdrOleObj->GetAspect() ); + else + mpDocSh->FillTransferableObjectDescriptor( aObjDesc ); + + aObjDesc.maSize = GetAllMarkedRect().GetSize(); + aObjDesc.maDragStartPos = rDragPos; + aObjDesc.maDisplayName = aDisplayName; + aObjDesc.mbCanLink = FALSE; + + pTransferable->SetStartPos( rDragPos ); + pTransferable->SetObjectDescriptor( aObjDesc ); + pTransferable->StartDrag( &rWindow, DND_ACTION_COPYMOVE | DND_ACTION_LINK ); + + return xRet; +} + +// ----------------------------------------------------------------------------- + +::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > View::CreateSelectionDataObject( View* pWorkView, ::Window& rWindow ) +{ + SdTransferable* pTransferable = new SdTransferable( mpDoc, pWorkView, TRUE ); + ::com::sun::star::uno::Reference< ::com::sun::star::datatransfer::XTransferable > xRet( pTransferable ); + TransferableObjectDescriptor aObjDesc; + const Rectangle aMarkRect( GetAllMarkedRect() ); + String aDisplayName; + + SD_MOD()->pTransferSelection = pTransferable; + + if( mpDocSh ) + { + aDisplayName = mpDocSh->GetMedium()->GetURLObject().GetURLNoPass(); + mpDocSh->FillTransferableObjectDescriptor( aObjDesc ); + } + + aObjDesc.maSize = aMarkRect.GetSize(); + + pTransferable->SetStartPos( aMarkRect.TopLeft() ); + pTransferable->SetObjectDescriptor( aObjDesc ); + pTransferable->CopyToSelection( &rWindow ); + + return xRet; +} + +// ----------------------------------------------------------------------------- + +void View::UpdateSelectionClipboard( BOOL bForceDeselect ) +{ + if( mpViewSh && mpViewSh->GetActiveWindow() ) + { + if( !bForceDeselect && GetMarkedObjectList().GetMarkCount() ) + CreateSelectionDataObject( this, *mpViewSh->GetActiveWindow() ); + else if( SD_MOD()->pTransferSelection && ( SD_MOD()->pTransferSelection->GetView() == this ) ) + { + TransferableHelper::ClearSelection( mpViewSh->GetActiveWindow() ); + SD_MOD()->pTransferSelection = NULL; + } + } +} + +// ----------------------------------------------------------------------------- + +void View::DoCut(::Window* ) +{ + const OutlinerView* pOLV = GetTextEditOutlinerView(); + + if( pOLV ) + ( (OutlinerView*) pOLV)->Cut(); + else if( AreObjectsMarked() ) + { + String aStr( SdResId(STR_UNDO_CUT) ); + + DoCopy(); + BegUndo( ( aStr += sal_Unicode(' ') ) += GetDescriptionOfMarkedObjects() ); + DeleteMarked(); + EndUndo(); + } +} + +// ----------------------------------------------------------------------------- + +void View::DoCopy (::Window* pWindow) +{ + const OutlinerView* pOLV = GetTextEditOutlinerView(); + + if( pOLV ) + ( (OutlinerView*) pOLV)->Copy(); + else if( AreObjectsMarked() ) + { + BrkAction(); + CreateClipboardDataObject( this, *pWindow ); + } +} + +// ----------------------------------------------------------------------------- + +void View::DoPaste (::Window* pWindow) +{ + TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( mpViewSh->GetActiveWindow() ) ); + if( !aDataHelper.GetTransferable().is() ) + return; // empty clipboard? + + const OutlinerView* pOLV = GetTextEditOutlinerView(); + + if( pOLV && EditEngine::HasValidData( aDataHelper.GetTransferable() ) ) + { + const_cast< OutlinerView* >(pOLV)->PasteSpecial(); + + SdrObject* pObj = GetTextEditObject(); + SdPage* pPage = (SdPage*)( pObj ? pObj->GetPage() : NULL ); + ::Outliner* pOutliner = pOLV->GetOutliner(); + + if( pOutliner) + { + if( pObj && pPage && pPage->GetPresObjKind(pObj) == PRESOBJ_TITLE ) + { + // remove all hard linebreaks from the title + if( pOutliner && pOutliner->GetParagraphCount() > 1 ) + { + BOOL bOldUpdateMode = pOutliner->GetUpdateMode(); + + pOutliner->SetUpdateMode( FALSE ); + + const EditEngine& rEdit = pOutliner->GetEditEngine(); + const int nParaCount = rEdit.GetParagraphCount(); + + for( int nPara = nParaCount - 2; nPara >= 0; nPara-- ) + { + const USHORT nParaLen = (USHORT)rEdit.GetTextLen( (USHORT)nPara ); + pOutliner->QuickDelete( ESelection( (USHORT)nPara, nParaLen, (USHORT)nPara+1, 0 ) ); + pOutliner->QuickInsertLineBreak( ESelection( (USHORT)nPara, nParaLen, (USHORT)nPara, nParaLen ) ); + } + + DBG_ASSERT( rEdit.GetParagraphCount() <= 1, "Titelobjekt contains hard line breaks" ); + pOutliner->SetUpdateMode(bOldUpdateMode); + } + } + + if( !mpDoc->IsChanged() ) + { + if( pOutliner && pOutliner->IsModified() ) + mpDoc->SetChanged( TRUE ); + } + } + } + else + { + Point aPos; + sal_Int8 nDnDAction = DND_ACTION_COPY; + + if( pWindow ) + aPos = pWindow->PixelToLogic( Rectangle( aPos, pWindow->GetOutputSizePixel() ).Center() ); + + DrawViewShell* pDrViewSh = (DrawViewShell*) mpDocSh->GetViewShell(); + + if (pDrViewSh != NULL) + { + if( !InsertData( aDataHelper, aPos, nDnDAction, FALSE ) ) + { + INetBookmark aINetBookmark( aEmptyStr, aEmptyStr ); + + if( ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, aINetBookmark ) ) || + ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR, aINetBookmark ) ) || + ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR, aINetBookmark ) ) ) + { + pDrViewSh->InsertURLField( aINetBookmark.GetURL(), aINetBookmark.GetDescription(), aEmptyStr, NULL ); + } + } + } + } +} + +// ----------------------------------------------------------------------------- + +void View::StartDrag( const Point& rStartPos, ::Window* pWindow ) +{ + if( AreObjectsMarked() && IsAction() && mpViewSh && pWindow && !mpDragSrcMarkList ) + { + BrkAction(); + + if( IsTextEdit() ) + SdrEndTextEdit(); + + DrawViewShell* pDrawViewShell = dynamic_cast< DrawViewShell* >( mpDocSh ? mpDocSh->GetViewShell() : 0 ); + + if( pDrawViewShell ) + { + FunctionReference xFunction( pDrawViewShell->GetCurrentFunction() ); + + if( xFunction.is() && xFunction->ISA( FuDraw ) ) + static_cast<FuDraw*>(xFunction.get())->ForcePointer( NULL ); + } + + mpDragSrcMarkList = new SdrMarkList(GetMarkedObjectList()); + mnDragSrcPgNum = GetSdrPageView()->GetPage()->GetPageNum(); + + if( IsUndoEnabled() ) + { + String aStr( SdResId(STR_UNDO_DRAGDROP) ); + aStr += sal_Unicode(' '); + aStr += mpDragSrcMarkList->GetMarkDescription(); + BegUndo(aStr); + } + CreateDragDataObject( this, *pWindow, rStartPos ); + } +} + +// ----------------------------------------------------------------------------- + +void View::DragFinished( sal_Int8 nDropAction ) +{ + const bool bUndo = IsUndoEnabled(); + + SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag; + + if( pDragTransferable ) + pDragTransferable->SetView( NULL ); + + if( ( nDropAction & DND_ACTION_MOVE ) && + pDragTransferable && !pDragTransferable->IsInternalMove() && + mpDragSrcMarkList && mpDragSrcMarkList->GetMarkCount() && + !IsPresObjSelected() ) + { + mpDragSrcMarkList->ForceSort(); + + if( bUndo ) + BegUndo(); + + ULONG nm, nAnz = mpDragSrcMarkList->GetMarkCount(); + + for( nm = nAnz; nm>0; ) + { + nm--; + SdrMark* pM=mpDragSrcMarkList->GetMark(nm); + if( bUndo ) + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoDeleteObject(*pM->GetMarkedSdrObj())); + } + + mpDragSrcMarkList->GetMark(0)->GetMarkedSdrObj()->GetOrdNum(); + + for (nm=nAnz; nm>0;) + { + nm--; + SdrMark* pM=mpDragSrcMarkList->GetMark(nm); + SdrObject* pObj=pM->GetMarkedSdrObj(); + UINT32 nOrdNum=pObj->GetOrdNumDirect(); + + if( pObj && pObj->GetPage() ) + { +#ifdef DBG_UTIL + SdrObject* pChkObj = +#endif + pObj->GetPage()->RemoveObject(nOrdNum); + DBG_ASSERT(pChkObj==pObj,"pChkObj!=pObj beim RemoveObject()"); + } + } + + if( bUndo ) + EndUndo(); + } + + if( pDragTransferable ) + pDragTransferable->SetInternalMove( FALSE ); + + if( bUndo ) + EndUndo(); + mnDragSrcPgNum = SDRPAGE_NOTFOUND; + delete mpDragSrcMarkList; + mpDragSrcMarkList = NULL; +} + +// ----------------------------------------------------------------------------- + +sal_Int8 View::AcceptDrop( const AcceptDropEvent& rEvt, DropTargetHelper& rTargetHelper, + ::sd::Window*, USHORT, USHORT nLayer ) +{ + String aLayerName( GetActiveLayer() ); + SdrPageView* pPV = GetSdrPageView(); + sal_Int8 nDropAction = rEvt.mnAction; + sal_Int8 nRet = DND_ACTION_NONE; + + if( nLayer != SDRLAYER_NOTFOUND ) + { + SdrLayerAdmin& rLayerAdmin = mpDoc->GetLayerAdmin(); + aLayerName = rLayerAdmin.GetLayerPerID(nLayer)->GetName(); + } + + if( mbIsDropAllowed && !pPV->IsLayerLocked( aLayerName ) && pPV->IsLayerVisible( aLayerName ) ) + { + const OutlinerView* pOLV = GetTextEditOutlinerView(); + BOOL bIsInsideOutlinerView = FALSE; + + if( pOLV ) + { + Rectangle aRect( pOLV->GetOutputArea() ); + + if (GetMarkedObjectCount() == 1) + { + SdrMark* pMark = GetSdrMarkByIndex(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + aRect.Union( pObj->GetLogicRect() ); + } + + if( aRect.IsInside( pOLV->GetWindow()->PixelToLogic( rEvt.maPosPixel ) ) ) + { + bIsInsideOutlinerView = TRUE; + } + } + + if( !bIsInsideOutlinerView ) + { + SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag; + + if( pDragTransferable ) + { + const View* pSourceView = pDragTransferable->GetView(); + + if( pDragTransferable->IsPageTransferable() ) + { + nRet = DND_ACTION_COPY; + } + else if( pSourceView ) + { + if( !( nDropAction & DND_ACTION_LINK ) || + pSourceView->GetDocSh()->GetMedium()->GetName().Len() ) + { + nRet = nDropAction; + } + } + } + else + { + const BOOL bDrawing = rTargetHelper.IsDropFormatSupported( SOT_FORMATSTR_ID_DRAWING ); + const BOOL bGraphic = rTargetHelper.IsDropFormatSupported( SOT_FORMATSTR_ID_SVXB ); + const BOOL bMtf = rTargetHelper.IsDropFormatSupported( FORMAT_GDIMETAFILE ); + const BOOL bBitmap = rTargetHelper.IsDropFormatSupported( FORMAT_BITMAP ); + BOOL bBookmark = rTargetHelper.IsDropFormatSupported( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ); + BOOL bXFillExchange = rTargetHelper.IsDropFormatSupported( SOT_FORMATSTR_ID_XFA ); + + // check handle insert + if( !nRet && ( (bXFillExchange && ( SDRDRAG_GRADIENT == GetDragMode() )) || ( SDRDRAG_TRANSPARENCE == GetDragMode() ) ) ) + { + const SdrHdlList& rHdlList = GetHdlList(); + + for( sal_uInt32 n = 0; n < rHdlList.GetHdlCount(); n++ ) + { + SdrHdl* pIAOHandle = rHdlList.GetHdl( n ); + + if( pIAOHandle && ( HDL_COLR == pIAOHandle->GetKind() ) ) + { + if(pIAOHandle->getOverlayObjectList().isHitPixel(rEvt.maPosPixel)) + { + nRet = nDropAction; + static_cast< SdrHdlColor* >( pIAOHandle )->SetSize( SDR_HANDLE_COLOR_SIZE_SELECTED ); + } + else + { + static_cast< SdrHdlColor* >( pIAOHandle )->SetSize( SDR_HANDLE_COLOR_SIZE_NORMAL ); + } + } + } + } + + // check object insert + if( !nRet && ( bXFillExchange || ( ( bDrawing || bGraphic || bMtf || bBitmap || bBookmark ) && ( nDropAction & DND_ACTION_LINK ) ) ) ) + { + SdrObject* pPickObj = NULL; + SdrPageView* pPageView = NULL; + ::sd::Window* pWindow = mpViewSh->GetActiveWindow(); + Point aPos( pWindow->PixelToLogic( rEvt.maPosPixel ) ); + const BOOL bHasPickObj = PickObj( aPos, getHitTolLog(), pPickObj, pPageView ); + BOOL bIsPresTarget = FALSE; + + if( bHasPickObj && pPickObj && ( pPickObj->IsEmptyPresObj() || pPickObj->GetUserCall() ) ) + { + SdPage* pPage = (SdPage*) pPickObj->GetPage(); + + if( pPage && pPage->IsMasterPage() ) + bIsPresTarget = pPage->IsPresObj( pPickObj ); + } + + if( bHasPickObj && !bIsPresTarget && + ( !pPickObj->ISA( SdrGrafObj ) || bGraphic || bMtf || bBitmap || ( bXFillExchange && !pPickObj->ISA( SdrGrafObj ) && !pPickObj->ISA( SdrOle2Obj ) ) ) ) + { + if( mpDropMarkerObj != pPickObj ) + { + mpDropMarkerObj = pPickObj; + ImplClearDrawDropMarker(); + + if(mpDropMarkerObj) + { + mpDropMarker = new SdrDropMarkerOverlay(*this, *mpDropMarkerObj); + } + } + + nRet = nDropAction; + } + else + bXFillExchange = FALSE; + } + + // check normal insert + if( !nRet ) + { + const BOOL bSBAFormat = rTargetHelper.IsDropFormatSupported( SOT_FORMATSTR_ID_SVX_FORMFIELDEXCH ); + const BOOL bEditEngine = rTargetHelper.IsDropFormatSupported( SOT_FORMATSTR_ID_EDITENGINE ); + const BOOL bString = rTargetHelper.IsDropFormatSupported( FORMAT_STRING ); + const BOOL bRTF = rTargetHelper.IsDropFormatSupported( FORMAT_RTF ); + const BOOL bFile = rTargetHelper.IsDropFormatSupported( FORMAT_FILE ); + const BOOL bFileList = rTargetHelper.IsDropFormatSupported( FORMAT_FILE_LIST ); + + if( mpDropMarker ) + { + ImplClearDrawDropMarker(); + mpDropMarkerObj = NULL; + } + + if( bBookmark && bFile && ( nDropAction & DND_ACTION_MOVE ) && mpViewSh && SlideShow::IsRunning(mpViewSh->GetViewShellBase()) ) + bBookmark = FALSE; + + if( bDrawing || bGraphic || bMtf || bBitmap || bBookmark || bFile || bFileList || bXFillExchange || bSBAFormat || bEditEngine || bString || bRTF ) + nRet = nDropAction; + + // For entries from the navigator, change action copy. + if (bBookmark + && rTargetHelper.IsDropFormatSupported( + SdPageObjsTLB::SdPageObjsTransferable::GetListBoxDropFormatId()) + && (nDropAction & DND_ACTION_MOVE)!=0) + { + nRet = DND_ACTION_COPY; + } + } + } + } + } + + // destroy drop marker if this is a leaving event + if( rEvt.mbLeaving && mpDropMarker ) + { + ImplClearDrawDropMarker(); + mpDropMarkerObj = NULL; + } + + return nRet; +} + +// ----------------------------------------------------------------------------- + +sal_Int8 View::ExecuteDrop( const ExecuteDropEvent& rEvt, DropTargetHelper& rTargetHelper, + ::sd::Window* pTargetWindow, USHORT nPage, USHORT nLayer ) +{ + SdrPageView* pPV = GetSdrPageView(); + String aActiveLayer = GetActiveLayer(); + sal_Int8 nDropAction = rEvt.mnAction; + sal_Int8 nRet = DND_ACTION_NONE; + + // destroy drop marker if it is shown + if( mpDropMarker ) + { + ImplClearDrawDropMarker(); + mpDropMarkerObj = NULL; + } + + if( !pPV->IsLayerLocked( aActiveLayer ) ) + { + const OutlinerView* pOLV = GetTextEditOutlinerView(); + BOOL bIsInsideOutlinerView = FALSE; + + if( pOLV ) + { + Rectangle aRect( pOLV->GetOutputArea() ); + + if( GetMarkedObjectCount() == 1 ) + { + SdrMark* pMark = GetSdrMarkByIndex(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + aRect.Union( pObj->GetLogicRect() ); + } + + Point aPos( pOLV->GetWindow()->PixelToLogic( rEvt.maPosPixel ) ); + + if( aRect.IsInside( aPos ) ) + { + bIsInsideOutlinerView = TRUE; + } + } + + if( !bIsInsideOutlinerView ) + { + Point aPos; + TransferableDataHelper aDataHelper( rEvt.maDropEvent.Transferable ); + + if( pTargetWindow ) + aPos = pTargetWindow->PixelToLogic( rEvt.maPosPixel ); + + // handle insert? + if( (!nRet && ( SDRDRAG_GRADIENT == GetDragMode() )) || (( SDRDRAG_TRANSPARENCE == GetDragMode() ) && aDataHelper.HasFormat( SOT_FORMATSTR_ID_XFA )) ) + { + const SdrHdlList& rHdlList = GetHdlList(); + + for( sal_uInt32 n = 0; !nRet && n < rHdlList.GetHdlCount(); n++ ) + { + SdrHdl* pIAOHandle = rHdlList.GetHdl( n ); + + if( pIAOHandle && ( HDL_COLR == pIAOHandle->GetKind() ) ) + { + if(pIAOHandle->getOverlayObjectList().isHitPixel(rEvt.maPosPixel)) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_XFA, xStm ) && xStm.Is() ) + { + XFillExchangeData aFillData( XFillAttrSetItem( &mpDoc->GetPool() ) ); + + *xStm >> aFillData; + const Color aColor( ( (XFillColorItem&) aFillData.GetXFillAttrSetItem()->GetItemSet().Get( XATTR_FILLCOLOR ) ).GetColorValue() ); + static_cast< SdrHdlColor* >( pIAOHandle )->SetColor( aColor, TRUE ); + nRet = nDropAction; + } + } + } + } + } + + // standard insert? + if( !nRet && InsertData( aDataHelper, aPos, nDropAction, TRUE, 0, nPage, nLayer ) ) + nRet = nDropAction; + + // special insert? + if( !nRet && mpViewSh ) + { + String aTmpString1, aTmpString2; + INetBookmark aINetBookmark( aTmpString1, aTmpString2 ); + + // insert bookmark + if( aDataHelper.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) && + aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, aINetBookmark ) ) + { + SdPageObjsTLB::SdPageObjsTransferable* pPageObjsTransferable = SdPageObjsTLB::SdPageObjsTransferable::getImplementation( aDataHelper.GetXTransferable() ); + + if( pPageObjsTransferable && + ( NAVIGATOR_DRAGTYPE_LINK == pPageObjsTransferable->GetDragType() || + NAVIGATOR_DRAGTYPE_EMBEDDED == pPageObjsTransferable->GetDragType() ) ) + { + // insert bookmark from own navigator (handled async. due to possible message box ) + Application::PostUserEvent( LINK( this, View, ExecuteNavigatorDrop ), + new SdNavigatorDropEvent( rEvt, rTargetHelper, pTargetWindow, + nPage, nLayer ) ); + nRet = nDropAction; + } + else + { + SdrObject* pPickObj = NULL; + SdrPageView* pPageView = NULL; + + if( PickObj( aPos, getHitTolLog(), pPickObj, pPageView ) ) + { + // insert as clip action => jump + rtl::OUString aBookmark( aINetBookmark.GetURL() ); + SdAnimationInfo* pInfo = mpDoc->GetAnimationInfo( pPickObj ); + BOOL bCreated = FALSE; + + if( aBookmark.getLength() ) + { + presentation::ClickAction eClickAction = presentation::ClickAction_DOCUMENT; + + sal_Int32 nIndex = aBookmark.indexOf( (sal_Unicode)'#' ); + if( nIndex != -1 ) + { + const String aDocName( aBookmark.copy( 0, nIndex ) ); + + if( mpDocSh->GetMedium()->GetName() == aDocName || mpDocSh->GetName() == aDocName ) + { + // internal jump, only use the part after and including '#' + eClickAction = presentation::ClickAction_BOOKMARK; + aBookmark = aBookmark.copy( nIndex+1 ); + } + } + + if( !pInfo ) + { + pInfo = SdDrawDocument::GetShapeUserData( *pPickObj, true ); + bCreated = TRUE; + } + + // Undo-Action mit alten und neuen Groessen erzeugen + SdAnimationPrmsUndoAction* pAction = new SdAnimationPrmsUndoAction(mpDoc, pPickObj, bCreated); + pAction->SetActive(pInfo->mbActive, pInfo->mbActive); + pAction->SetEffect(pInfo->meEffect, pInfo->meEffect); + pAction->SetTextEffect(pInfo->meTextEffect, pInfo->meTextEffect); + pAction->SetSpeed(pInfo->meSpeed, pInfo->meSpeed); + pAction->SetDim(pInfo->mbDimPrevious, pInfo->mbDimPrevious); + pAction->SetDimColor(pInfo->maDimColor, pInfo->maDimColor); + pAction->SetDimHide(pInfo->mbDimHide, pInfo->mbDimHide); + pAction->SetSoundOn(pInfo->mbSoundOn, pInfo->mbSoundOn); + pAction->SetSound(pInfo->maSoundFile, pInfo->maSoundFile); + pAction->SetPlayFull(pInfo->mbPlayFull, pInfo->mbPlayFull); + pAction->SetPathObj(pInfo->mpPathObj, pInfo->mpPathObj); + pAction->SetClickAction(pInfo->meClickAction, eClickAction); + pAction->SetBookmark(pInfo->GetBookmark(), aBookmark); +// pAction->SetInvisibleInPres(pInfo->mbInvisibleInPresentation, TRUE); + pAction->SetVerb(pInfo->mnVerb, pInfo->mnVerb); + pAction->SetSecondEffect(pInfo->meSecondEffect, pInfo->meSecondEffect); + pAction->SetSecondSpeed(pInfo->meSecondSpeed, pInfo->meSecondSpeed); + pAction->SetSecondSoundOn(pInfo->mbSecondSoundOn, pInfo->mbSecondSoundOn); + pAction->SetSecondPlayFull(pInfo->mbSecondPlayFull, pInfo->mbSecondPlayFull); + + String aString(SdResId(STR_UNDO_ANIMATION)); + pAction->SetComment(aString); + mpDocSh->GetUndoManager()->AddUndoAction(pAction); + pInfo->meClickAction = eClickAction; + pInfo->SetBookmark( aBookmark ); + mpDoc->SetChanged(); + + nRet = nDropAction; + } + } + else if( mpViewSh->ISA( DrawViewShell ) ) + { + // insert as normal URL button + ( (DrawViewShell*) mpViewSh )->InsertURLButton( aINetBookmark.GetURL(), aINetBookmark.GetDescription(), String(), &aPos ); + nRet = nDropAction; + } + } + } + } + } + } + + return nRet; +} + +// ----------------------------------------------------------------------------- + +IMPL_LINK( View, ExecuteNavigatorDrop, SdNavigatorDropEvent*, pSdNavigatorDropEvent ) +{ + TransferableDataHelper aDataHelper( pSdNavigatorDropEvent->maDropEvent.Transferable ); + SdPageObjsTLB::SdPageObjsTransferable* pPageObjsTransferable = SdPageObjsTLB::SdPageObjsTransferable::getImplementation( aDataHelper.GetXTransferable() ); + INetBookmark aINetBookmark; + + if( pPageObjsTransferable && aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, aINetBookmark ) ) + { + Point aPos; + List aBookmarkList; + String aBookmark; + SdPage* pPage = (SdPage*) GetSdrPageView()->GetPage(); + USHORT nPgPos = 0xFFFF; + + if( pSdNavigatorDropEvent->mpTargetWindow ) + aPos = pSdNavigatorDropEvent->mpTargetWindow->PixelToLogic( pSdNavigatorDropEvent->maPosPixel ); + + const rtl::OUString aURL( aINetBookmark.GetURL() ); + sal_Int32 nIndex = aURL.indexOf( (sal_Unicode)'#' ); + if( nIndex != -1 ) + aBookmark = aURL.copy( nIndex+1 ); + aBookmarkList.Insert( &aBookmark ); + + if( !pPage->IsMasterPage() ) + { + if( pPage->GetPageKind() == PK_STANDARD ) + nPgPos = pPage->GetPageNum() + 2; + else if( pPage->GetPageKind() == PK_NOTES ) + nPgPos = pPage->GetPageNum() + 1; + } + + // Um zu gewaehrleisten, dass alle Seitennamen eindeutig sind, werden + // die einzufuegenden geprueft und gegebenenfalls in einer Ersatzliste + // aufgenommen (bNameOK == FALSE -> Benutzer hat abgebrochen) + List* pExchangeList = NULL; + BOOL bLink = ( NAVIGATOR_DRAGTYPE_LINK == pPageObjsTransferable->GetDragType() ? TRUE : FALSE ); + BOOL bNameOK = GetExchangeList( pExchangeList, &aBookmarkList, 2 ); + BOOL bReplace = FALSE; + + // Da man hier nicht weiss, ob es sich um eine Seite oder ein Objekt handelt, + // wird eine Liste sowohl mit Seiten, als auch mit Objekten gefuellt. + // Sollten Seitennamen und Objektnamen identisch sein gibt es hier natuerlich Probleme !!! + if( bNameOK ) + { + mpDoc->InsertBookmark( &aBookmarkList, pExchangeList, + bLink, bReplace, nPgPos, FALSE, + &pPageObjsTransferable->GetDocShell(), + TRUE, &aPos ); + } + + // Loeschen der ExchangeList + if( pExchangeList ) + { + for( void* p = pExchangeList->First(); p; p = pExchangeList->Next() ) + delete (String*) p; + + delete pExchangeList; + } + } + + delete pSdNavigatorDropEvent; + + return 0; +} + +/************************************************************************* +|* +|* Rueckgabeparameter: +|* pExchangeList == NULL -> Namen sind alle eindeutig +|* bNameOK == FALSE -> Benutzer hat abgebrochen +|* nType == 0 -> Seiten +|* nType == 1 -> Objekte +|* nType == 2 -> Seiten + Objekte +|* +\************************************************************************/ + +BOOL View::GetExchangeList( List*& rpExchangeList, List* pBookmarkList, USHORT nType ) +{ + DBG_ASSERT( !rpExchangeList, "ExchangeList muss NULL sein!"); + + BOOL bListIdentical = TRUE; // BookmarkList und ExchangeList sind gleich + BOOL bNameOK = TRUE; // Name ist eindeutig + + rpExchangeList = new List(); + + if( pBookmarkList ) + { + String* pString = (String*) pBookmarkList->First(); + + while( pString && bNameOK ) + { + String* pNewName = new String( *pString ); + + if( nType == 0 || nType == 2 ) + bNameOK = mpDocSh->CheckPageName ( + mpViewSh->GetActiveWindow(), *pNewName); + + if( bNameOK && ( nType == 1 || nType == 2 ) ) + { + if( mpDoc->GetObj( *pNewName ) ) + { + String aTitle( SdResId( STR_TITLE_NAMEGROUP ) ); + String aDesc( SdResId( STR_DESC_NAMEGROUP ) ); + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + AbstractSvxNameDialog* pDlg = pFact ? pFact->CreateSvxNameDialog( mpViewSh->GetActiveWindow(), *pNewName, aDesc ) : 0; + if( pDlg ) + { + pDlg->SetEditHelpId( HID_SD_NAMEDIALOG_OBJECT ); + + bNameOK = FALSE; + pDlg->SetText( aTitle ); + + while( !bNameOK && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( *pNewName ); + + if( !mpDoc->GetObj( *pNewName ) ) + bNameOK = TRUE; + } + + delete pDlg; + } + } + } + + if( bListIdentical ) + bListIdentical = ( *pString == *pNewName ); + + rpExchangeList->Insert( pNewName, LIST_APPEND ); + pString = (String*) pBookmarkList->Next(); + } + } + + // ExchangeList ist mit BookmarkList identisch + if( rpExchangeList && bListIdentical ) + { + String* pString = (String*) rpExchangeList->First(); + while( pString ) + { + delete pString; + pString = (String*) rpExchangeList->Next(); + } + delete rpExchangeList; + rpExchangeList = NULL; + } + + return( bNameOK ); +} + +typedef std::vector< std::pair< sal_uInt32, sal_uInt32 > > PathSurrogateVector; +typedef std::vector< SdrObject* > SdrObjectVector; + +void ImplProcessObjectList(SdrObject* pObj, SdrObjectVector& rVector ) +{ + sal_Bool bIsGroup(pObj->IsGroupObject()); + if(bIsGroup && pObj->ISA(E3dObject) && !pObj->ISA(E3dScene)) + bIsGroup = sal_False; + + rVector.push_back( pObj ); + + if(bIsGroup) + { + SdrObjList* pObjList = pObj->GetSubList(); + sal_uInt32 a; + for( a = 0; a < pObjList->GetObjCount(); a++) + ImplProcessObjectList(pObjList->GetObj(a), rVector); + } +} + +SdrModel* View::GetMarkedObjModel() const +{ + return FmFormView::GetMarkedObjModel();; +} + +BOOL View::Paste(const SdrModel& rMod, const Point& rPos, SdrObjList* pLst /* =NULL */, UINT32 nOptions /* =0 */) +{ + return FmFormView::Paste( rMod, rPos, pLst,nOptions );; +} + +} // end of namespace sd diff --git a/sd/source/ui/view/sdview3.cxx b/sd/source/ui/view/sdview3.cxx new file mode 100644 index 000000000000..53c0d3636d82 --- /dev/null +++ b/sd/source/ui/view/sdview3.cxx @@ -0,0 +1,1485 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "View.hxx" +#include <com/sun/star/embed/XEmbedObjectClipboardCreator.hpp> +#include <com/sun/star/embed/NoVisualAreaSizeException.hpp> +#include <com/sun/star/lang/XComponent.hpp> +#include <sot/filelist.hxx> +#include <unotools/pathoptions.hxx> +#include <editeng/editdata.hxx> +#include <svl/urlbmk.hxx> +#include <svx/xexch.hxx> +#include <svx/xflclit.hxx> +#include <svx/xlnclit.hxx> +#include <svx/svdpagv.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/colritem.hxx> +#include <sfx2/docfile.hxx> +#include <svx/svditer.hxx> +#include <svx/svdogrp.hxx> +#include <svx/svdoole2.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdetc.hxx> +#include <svx/svdundo.hxx> +#include <sfx2/app.hxx> +#include <svl/itempool.hxx> +#include <sot/clsids.hxx> +#include <svx/fmmodel.hxx> +#include <sot/formats.hxx> +#include <editeng/outliner.hxx> +#include <editeng/editeng.hxx> +#include <svx/obj3d.hxx> +#include <svx/e3dundo.hxx> +#include <svx/dbexch.hrc> +#include <svx/unomodel.hxx> +#include <unotools/streamwrap.hxx> +#include <vcl/metaact.hxx> +#include <svx/svxids.hrc> +#include <toolkit/helper/vclunohelper.hxx> + +#include "DrawDocShell.hxx" +#include "fupoor.hxx" +#include "Window.hxx" +#include "sdxfer.hxx" +#include "sdpage.hxx" +#include "DrawViewShell.hxx" +#include "drawdoc.hxx" +#include "sdresid.hxx" +#include "strings.hrc" +#include "imapinfo.hxx" +#include "SlideSorterViewShell.hxx" +#include "strmname.h" +#include "unomodel.hxx" +#include "ViewClipboard.hxx" + +#include <sfx2/ipclient.hxx> +#include <comphelper/storagehelper.hxx> +#include <comphelper/processfactory.hxx> +#include <tools/stream.hxx> +#include <vcl/cvtgrf.hxx> +#include <svx/sdrhittesthelper.hxx> + +// -------------- +// - Namespaces - +// -------------- + +using namespace ::com::sun::star; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::io; +using namespace ::com::sun::star::datatransfer; +using namespace ::com::sun::star::datatransfer::clipboard; + +namespace sd { + +#define CHECK_FORMAT_TRANS( _def_Type ) ( ( nFormat == (_def_Type) || !nFormat ) && aDataHelper.HasFormat( _def_Type ) ) + +/************************************************************************* +|* +|* Paste +|* +\************************************************************************/ + +// #83525# +struct ImpRememberOrigAndClone +{ + SdrObject* pOrig; + SdrObject* pClone; +}; + +SdrObject* ImpGetClone(Container& aConnectorContainer, SdrObject* pConnObj) +{ + for(sal_uInt32 a(0); a < aConnectorContainer.Count(); a++) + { + if(pConnObj == ((ImpRememberOrigAndClone*)aConnectorContainer.GetObject(a))->pOrig) + return ((ImpRememberOrigAndClone*)aConnectorContainer.GetObject(a))->pClone; + } + return 0L; +} + +// #90129# restrict movement to WorkArea +void ImpCheckInsertPos(Point& rPos, const Size& rSize, const Rectangle& rWorkArea) +{ + if(!rWorkArea.IsEmpty()) + { + Rectangle aMarkRect(Point(rPos.X() - (rSize.Width() / 2), rPos.Y() - (rSize.Height() / 2)), rSize); + + if(!aMarkRect.IsInside(rWorkArea)) + { + if(aMarkRect.Left() < rWorkArea.Left()) + { + rPos.X() += rWorkArea.Left() - aMarkRect.Left(); + } + + if(aMarkRect.Right() > rWorkArea.Right()) + { + rPos.X() -= aMarkRect.Right() - rWorkArea.Right(); + } + + if(aMarkRect.Top() < rWorkArea.Top()) + { + rPos.Y() += rWorkArea.Top() - aMarkRect.Top(); + } + + if(aMarkRect.Bottom() > rWorkArea.Bottom()) + { + rPos.Y() -= aMarkRect.Bottom() - rWorkArea.Bottom(); + } + } + } +} + +bool View::InsertMetaFile( TransferableDataHelper& rDataHelper, const Point& rPos, ImageMap* pImageMap, bool bOptimize ) +{ + GDIMetaFile aMtf; + + if( !rDataHelper.GetGDIMetaFile( FORMAT_GDIMETAFILE, aMtf ) ) + return false; + +/* +SvFileStream aSvOutputStream( String( RTL_CONSTASCII_USTRINGPARAM( "/tmp/test.png" ) ), STREAM_WRITE | STREAM_TRUNC ); +Graphic aMtfGraphic( aMtf ); +Size aPreviewSizePixel( OutputDevice::LogicToLogic( aMtf.GetPrefSize(), aMtf.GetPrefMapMode(), MAP_PIXEL ) ); + +if( aPreviewSizePixel.Width() && aPreviewSizePixel.Height() ) +{ + const double fWH = static_cast< double >( aPreviewSizePixel.Width() ) / static_cast< double >( aPreviewSizePixel.Height() ); + + if( fWH <= 1.0 ) + aPreviewSizePixel.Width() = static_cast< long >( 128.0 * fWH ), aPreviewSizePixel.Height() = 128; + else + aPreviewSizePixel.Width() = 128, aPreviewSizePixel.Height() = static_cast< long >( 128.0 / fWH ); + + if( GraphicConverter::Export( aSvOutputStream, aMtfGraphic.GetBitmapEx( &aPreviewSizePixel ), CVT_PNG ) ) + { + // handle errror case here + } + else + { + // Success + } +} +*/ + bool bVector = false; + Graphic aGraphic; + + // check if metafile only contains a pixel image, if so insert a bitmap instead + if( bOptimize ) + { + MetaAction* pAction = aMtf.FirstAction(); + while( pAction && !bVector ) + { + switch( pAction->GetType() ) + { + case META_POINT_ACTION: + case META_LINE_ACTION: + case META_RECT_ACTION: + case META_ROUNDRECT_ACTION: + case META_ELLIPSE_ACTION: + case META_ARC_ACTION: + case META_PIE_ACTION: + case META_CHORD_ACTION: + case META_POLYLINE_ACTION: + case META_POLYGON_ACTION: + case META_POLYPOLYGON_ACTION: + case META_TEXT_ACTION: + case META_TEXTARRAY_ACTION: + case META_STRETCHTEXT_ACTION: + case META_TEXTRECT_ACTION: + case META_GRADIENT_ACTION: + case META_HATCH_ACTION: + case META_WALLPAPER_ACTION: + case META_EPS_ACTION: + case META_TEXTLINE_ACTION: + case META_FLOATTRANSPARENT_ACTION: + case META_GRADIENTEX_ACTION: + case META_BMPSCALEPART_ACTION: + case META_BMPEXSCALEPART_ACTION: + bVector = true; + break; + case META_BMP_ACTION: + case META_BMPSCALE_ACTION: + case META_BMPEX_ACTION: + case META_BMPEXSCALE_ACTION: + if( aGraphic.GetType() != GRAPHIC_NONE ) + { + bVector = true; + } + else switch( pAction->GetType() ) + { + case META_BMP_ACTION: + { + MetaBmpAction* pBmpAction = dynamic_cast< MetaBmpAction* >( pAction ); + if( pBmpAction ) + aGraphic = Graphic( pBmpAction->GetBitmap() ); + } + break; + case META_BMPSCALE_ACTION: + { + MetaBmpScaleAction* pBmpScaleAction = dynamic_cast< MetaBmpScaleAction* >( pAction ); + if( pBmpScaleAction ) + aGraphic = Graphic( pBmpScaleAction->GetBitmap() ); + } + break; + case META_BMPEX_ACTION: + { + MetaBmpExAction* pBmpExAction = dynamic_cast< MetaBmpExAction* >( pAction ); + if( pBmpExAction ) + aGraphic = Graphic( pBmpExAction->GetBitmapEx() ); + } + break; + case META_BMPEXSCALE_ACTION: + { + MetaBmpExScaleAction* pBmpExScaleAction = dynamic_cast< MetaBmpExScaleAction* >( pAction ); + if( pBmpExScaleAction ) + aGraphic = Graphic( pBmpExScaleAction->GetBitmapEx() ); + } + break; + } + } + + pAction = aMtf.NextAction(); + } + } + + // it is not a vector metafile but it also has no graphic? + if( !bVector && (aGraphic.GetType() == GRAPHIC_NONE) ) + bVector = true; + + // #90129# restrict movement to WorkArea + Point aInsertPos( rPos ); + Size aImageSize; + aImageSize = bVector ? aMtf.GetPrefSize() : aGraphic.GetSizePixel(); + ImpCheckInsertPos(aInsertPos, aImageSize, GetWorkArea()); + + if( bVector ) + aGraphic = Graphic( aMtf ); + + aGraphic.SetPrefMapMode( aMtf.GetPrefMapMode() ); + aGraphic.SetPrefSize( aMtf.GetPrefSize() ); + InsertGraphic( aGraphic, mnAction, aInsertPos, NULL, pImageMap ); + + return true; +} + +BOOL View::InsertData( const TransferableDataHelper& rDataHelper, + const Point& rPos, sal_Int8& rDnDAction, BOOL bDrag, + ULONG nFormat, USHORT nPage, USHORT nLayer ) +{ + maDropPos = rPos; + mnAction = rDnDAction; + mbIsDropAllowed = FALSE; + + TransferableDataHelper aDataHelper( rDataHelper ); + SdrObject* pPickObj = NULL; + SdPage* pPage = NULL; + ImageMap* pImageMap = NULL; + BOOL bReturn = FALSE; + BOOL bLink = ( ( mnAction & DND_ACTION_LINK ) != 0 ); + BOOL bCopy = ( ( ( mnAction & DND_ACTION_COPY ) != 0 ) || bLink ); + ULONG nPasteOptions = SDRINSERT_SETDEFLAYER; + + if (mpViewSh != NULL) + { + OSL_ASSERT (mpViewSh->GetViewShell()!=NULL); + SfxInPlaceClient* pIpClient = mpViewSh->GetViewShell()->GetIPClient(); + if( mpViewSh->ISA(::sd::slidesorter::SlideSorterViewShell) + || (pIpClient!=NULL && pIpClient->IsObjectInPlaceActive())) + nPasteOptions |= SDRINSERT_DONTMARK; + } + + if( bDrag ) + { + SdrPageView* pPV = NULL; + PickObj( rPos, getHitTolLog(), pPickObj, pPV ); + } + + if( nPage != SDRPAGE_NOTFOUND ) + pPage = (SdPage*) mpDoc->GetPage( nPage ); + + SdTransferable* pOwnData = NULL; + SdTransferable* pImplementation = SdTransferable::getImplementation( aDataHelper.GetTransferable() ); + + // try to get own transfer data + if( pImplementation ) + { + if( SD_MOD()->pTransferClip == (SdTransferable*) pImplementation ) + pOwnData = SD_MOD()->pTransferClip; + else if( SD_MOD()->pTransferDrag == (SdTransferable*) pImplementation ) + pOwnData = SD_MOD()->pTransferDrag; + else if( SD_MOD()->pTransferSelection == (SdTransferable*) pImplementation ) + pOwnData = SD_MOD()->pTransferSelection; + } + + // ImageMap? + if( !pOwnData && aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVIM ) ) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_SVIM, xStm ) ) + { + pImageMap = new ImageMap; + // mba: clipboard always must contain absolute URLs (could be from alien source) + pImageMap->Read( *xStm, String() ); + } + } + + bool bTable = false; + // check special cases for pasting table formats as RTL + if( !bLink && (!nFormat || (nFormat == SOT_FORMAT_RTF)) ) + { + // if the objekt supports rtf and there is a table involved, default is to create a table + if( aDataHelper.HasFormat( SOT_FORMAT_RTF ) && ! aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING ) ) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( FORMAT_RTF, xStm ) ) + { + xStm->Seek( 0 ); + + ByteString aLine; + while( xStm->ReadLine(aLine) ) + { + xub_StrLen x = aLine.Search( "\\trowd" ); + if( x != STRING_NOTFOUND ) + { + bTable = true; + nFormat = FORMAT_RTF; + break; + } + } + } + } + } + + if( pOwnData && !nFormat ) + { + const View* pSourceView = pOwnData->GetView(); + + + if( pOwnData->GetDocShell() && pOwnData->IsPageTransferable() && ISA( View ) ) + { + mpClipboard->HandlePageDrop (*pOwnData); + } + else if( pSourceView ) + { + if( pSourceView == this ) + { + // same view + if( nLayer != SDRLAYER_NOTFOUND ) + { + // drop on layer tab bar + SdrLayerAdmin& rLayerAdmin = mpDoc->GetLayerAdmin(); + SdrLayer* pLayer = rLayerAdmin.GetLayerPerID( nLayer ); + SdrPageView* pPV = GetSdrPageView(); + String aLayer( pLayer->GetName() ); + + if( !pPV->IsLayerLocked( aLayer ) ) + { + pOwnData->SetInternalMove( TRUE ); + SortMarkedObjects(); + + for( ULONG nM = 0; nM < GetMarkedObjectCount(); nM++ ) + { + SdrMark* pM = GetSdrMarkByIndex( nM ); + SdrObject* pO = pM->GetMarkedSdrObj(); + + if( pO ) + { + // #i11702# + if( IsUndoEnabled() ) + { + BegUndo(String(SdResId(STR_MODIFYLAYER))); + AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoObjectLayerChange(*pO, pO->GetLayer(), (SdrLayerID)nLayer)); + EndUndo(); + } + + pO->SetLayer( (SdrLayerID) nLayer ); + } + } + + bReturn = TRUE; + } + } + else + { + SdrPageView* pPV = GetSdrPageView(); + BOOL bDropOnTabBar = TRUE; + + if( !pPage && pPV->GetPage()->GetPageNum() != mnDragSrcPgNum ) + { + pPage = (SdPage*) pPV->GetPage(); + bDropOnTabBar = FALSE; + } + + if( pPage ) + { + // drop on other page + String aActiveLayer( GetActiveLayer() ); + + if( !pPV->IsLayerLocked( aActiveLayer ) ) + { + if( !IsPresObjSelected() ) + { + SdrMarkList* pMarkList; + + if( (mnDragSrcPgNum != SDRPAGE_NOTFOUND) && (mnDragSrcPgNum != pPV->GetPage()->GetPageNum()) ) + { + pMarkList = mpDragSrcMarkList; + } + else + { + // actual mark list is used + pMarkList = new SdrMarkList( GetMarkedObjectList()); + } + + pMarkList->ForceSort(); + + // #83525# stuff to remember originals and clones + Container aConnectorContainer(0); + sal_uInt32 a, nConnectorCount(0L); + Point aCurPos; + + // calculate real position of current + // source objects, if necessary (#103207) + if( pOwnData == SD_MOD()->pTransferSelection ) + { + Rectangle aCurBoundRect; + + if( pMarkList->TakeBoundRect( pPV, aCurBoundRect ) ) + aCurPos = aCurBoundRect.TopLeft(); + else + aCurPos = pOwnData->GetStartPos(); + } + else + aCurPos = pOwnData->GetStartPos(); + + const Size aVector( maDropPos.X() - aCurPos.X(), maDropPos.Y() - aCurPos.Y() ); + + for(a = 0; a < pMarkList->GetMarkCount(); a++) + { + SdrMark* pM = pMarkList->GetMark(a); + SdrObject* pObj = pM->GetMarkedSdrObj()->Clone(); + + if(pObj) + { + if(!bDropOnTabBar) + { + // #83525# do a NbcMove(...) instead of setting SnapRects here + pObj->NbcMove(aVector); + } + + pPage->InsertObject(pObj); + + if( IsUndoEnabled() ) + { + BegUndo(String(SdResId(STR_UNDO_DRAGDROP))); + AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoNewObject(*pObj)); + EndUndo(); + } + + // #83525# + ImpRememberOrigAndClone* pRem = new ImpRememberOrigAndClone; + pRem->pOrig = pM->GetMarkedSdrObj(); + pRem->pClone = pObj; + aConnectorContainer.Insert(pRem, CONTAINER_APPEND); + + if(pObj->ISA(SdrEdgeObj)) + nConnectorCount++; + } + } + + // #83525# try to re-establish connections at clones + if(nConnectorCount) + { + for(a = 0; a < aConnectorContainer.Count(); a++) + { + ImpRememberOrigAndClone* pRem = (ImpRememberOrigAndClone*)aConnectorContainer.GetObject(a); + + if(pRem->pClone->ISA(SdrEdgeObj)) + { + SdrEdgeObj* pOrigEdge = (SdrEdgeObj*)pRem->pOrig; + SdrEdgeObj* pCloneEdge = (SdrEdgeObj*)pRem->pClone; + + // test first connection + SdrObjConnection& rConn0 = pOrigEdge->GetConnection(FALSE); + SdrObject* pConnObj = rConn0.GetObject(); + if(pConnObj) + { + SdrObject* pConnClone = ImpGetClone(aConnectorContainer, pConnObj); + if(pConnClone) + { + // if dest obj was cloned, too, re-establish connection + pCloneEdge->ConnectToNode(FALSE, pConnClone); + pCloneEdge->GetConnection(FALSE).SetConnectorId(rConn0.GetConnectorId()); + } + else + { + // set position of connection point of original connected object + const SdrGluePointList* pGlueList = pConnObj->GetGluePointList(); + if(pGlueList) + { + sal_uInt16 nInd = pGlueList->FindGluePoint(rConn0.GetConnectorId()); + + if(SDRGLUEPOINT_NOTFOUND != nInd) + { + const SdrGluePoint& rGluePoint = (*pGlueList)[nInd]; + Point aPosition = rGluePoint.GetAbsolutePos(*pConnObj); + aPosition.X() += aVector.A(); + aPosition.Y() += aVector.B(); + pCloneEdge->SetTailPoint(FALSE, aPosition); + } + } + } + } + + // test second connection + SdrObjConnection& rConn1 = pOrigEdge->GetConnection(TRUE); + pConnObj = rConn1.GetObject(); + if(pConnObj) + { + SdrObject* pConnClone = ImpGetClone(aConnectorContainer, pConnObj); + if(pConnClone) + { + // if dest obj was cloned, too, re-establish connection + pCloneEdge->ConnectToNode(TRUE, pConnClone); + pCloneEdge->GetConnection(TRUE).SetConnectorId(rConn1.GetConnectorId()); + } + else + { + // set position of connection point of original connected object + const SdrGluePointList* pGlueList = pConnObj->GetGluePointList(); + if(pGlueList) + { + sal_uInt16 nInd = pGlueList->FindGluePoint(rConn1.GetConnectorId()); + + if(SDRGLUEPOINT_NOTFOUND != nInd) + { + const SdrGluePoint& rGluePoint = (*pGlueList)[nInd]; + Point aPosition = rGluePoint.GetAbsolutePos(*pConnObj); + aPosition.X() += aVector.A(); + aPosition.Y() += aVector.B(); + pCloneEdge->SetTailPoint(TRUE, aPosition); + } + } + } + } + } + } + } + + // #83525# cleanup remember classes + for(a = 0; a < aConnectorContainer.Count(); a++) + delete (ImpRememberOrigAndClone*)aConnectorContainer.GetObject(a); + + if( pMarkList != mpDragSrcMarkList ) + delete pMarkList; + + bReturn = TRUE; + } + else + { + maDropErrorTimer.Start(); + bReturn = FALSE; + } + } + } + else + { + pOwnData->SetInternalMove( TRUE ); + MoveAllMarked( Size( maDropPos.X() - pOwnData->GetStartPos().X(), + maDropPos.Y() - pOwnData->GetStartPos().Y() ), bCopy ); + bReturn = TRUE; + } + } + } + else + { + // different views + if( !pSourceView->IsPresObjSelected() ) + { + // model is owned by from AllocModel() created DocShell + SdDrawDocument* pSourceDoc = (SdDrawDocument*) pSourceView->GetModel(); + pSourceDoc->CreatingDataObj( pOwnData ); + SdDrawDocument* pModel = (SdDrawDocument*) pSourceView->GetAllMarkedModel(); + bReturn = Paste( *pModel, maDropPos, pPage, nPasteOptions ); + + if( !pPage ) + pPage = (SdPage*) GetSdrPageView()->GetPage(); + + String aLayout( pPage->GetLayoutName() ); + aLayout.Erase( aLayout.SearchAscii( SD_LT_SEPARATOR ) ); + pPage->SetPresentationLayout( aLayout, FALSE, FALSE ); + pSourceDoc->CreatingDataObj( NULL ); + } + else + { + maDropErrorTimer.Start(); + bReturn = FALSE; + } + } + } + else + { + SdDrawDocument* pWorkModel = (SdDrawDocument*) pOwnData->GetWorkDocument(); + SdPage* pWorkPage = (SdPage*) pWorkModel->GetSdPage( 0, PK_STANDARD ); + + pWorkPage->SetRectsDirty(); + + // #104148# Use SnapRect, not BoundRect + Size aSize( pWorkPage->GetAllObjSnapRect().GetSize() ); + + maDropPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 ); + maDropPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 ); + + // delete pages, that are not of any interest for us + for( long i = ( pWorkModel->GetPageCount() - 1 ); i >= 0; i-- ) + { + SdPage* pP = static_cast< SdPage* >( pWorkModel->GetPage( (USHORT) i ) ); + + if( pP->GetPageKind() != PK_STANDARD ) + pWorkModel->DeletePage( (USHORT) i ); + } + + bReturn = Paste( *pWorkModel, maDropPos, pPage, nPasteOptions ); + + if( !pPage ) + pPage = (SdPage*) GetSdrPageView()->GetPage(); + + String aLayout(pPage->GetLayoutName()); + aLayout.Erase(aLayout.SearchAscii(SD_LT_SEPARATOR)); + pPage->SetPresentationLayout( aLayout, FALSE, FALSE ); + } + } + else if( CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_DRAWING ) ) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_DRAWING, xStm ) ) + { + BOOL bChanged = FALSE; + + DrawDocShellRef xShell = new DrawDocShell(SFX_CREATE_MODE_INTERNAL); + xShell->DoInitNew(0); + + SdDrawDocument* pModel = xShell->GetDoc(); + pModel->InsertPage(pModel->AllocPage(false)); + + Reference< XComponent > xComponent( xShell->GetModel(), UNO_QUERY ); + xStm->Seek( 0 ); + + com::sun::star::uno::Reference< com::sun::star::io::XInputStream > xInputStream( new utl::OInputStreamWrapper( *xStm ) ); + bReturn = SvxDrawingLayerImport( pModel, xInputStream, xComponent, "com.sun.star.comp.Impress.XMLOasisImporter" ); + + if( pModel->GetPageCount() == 0 ) + { + DBG_ERROR("empty or invalid drawing xml document on clipboard!" ); + } + else + { + if( bReturn ) + { + if( pModel->GetSdPage( 0, PK_STANDARD )->GetObjCount() == 1 ) + { + // only one object + SdrObject* pObj = pModel->GetSdPage( 0, PK_STANDARD )->GetObj( 0 ); + SdrObject* pPickObj2 = NULL; + SdrPageView* pPV = NULL; + PickObj( rPos, getHitTolLog(), pPickObj2, pPV ); + + if( ( mnAction & DND_ACTION_MOVE ) && pPickObj2 && pObj ) + { + // replace object + SdrObject* pNewObj = pObj->Clone(); + Rectangle aPickObjRect( pPickObj2->GetCurrentBoundRect() ); + Size aPickObjSize( aPickObjRect.GetSize() ); + Point aVec( aPickObjRect.TopLeft() ); + Rectangle aObjRect( pNewObj->GetCurrentBoundRect() ); + Size aObjSize( aObjRect.GetSize() ); + + Fraction aScaleWidth( aPickObjSize.Width(), aObjSize.Width() ); + Fraction aScaleHeight( aPickObjSize.Height(), aObjSize.Height() ); + pNewObj->NbcResize( aObjRect.TopLeft(), aScaleWidth, aScaleHeight ); + + aVec -= aObjRect.TopLeft(); + pNewObj->NbcMove( Size( aVec.X(), aVec.Y() ) ); + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo( String( SdResId(STR_UNDO_DRAGDROP ) ) ); + pNewObj->NbcSetLayer( pPickObj->GetLayer() ); + SdrPage* pWorkPage = GetSdrPageView()->GetPage(); + pWorkPage->InsertObject( pNewObj ); + if( bUndo ) + { + AddUndo( mpDoc->GetSdrUndoFactory().CreateUndoNewObject( *pNewObj ) ); + AddUndo( mpDoc->GetSdrUndoFactory().CreateUndoDeleteObject( *pPickObj2 ) ); + } + pWorkPage->RemoveObject( pPickObj2->GetOrdNum() ); + + if( bUndo ) + { + EndUndo(); + } + else + { + SdrObject::Free(pPickObj2 ); + } + bChanged = TRUE; + mnAction = DND_ACTION_COPY; + } + else if( ( mnAction & DND_ACTION_LINK ) && pPickObj && pObj && !pPickObj->ISA( SdrGrafObj ) && !pPickObj->ISA( SdrOle2Obj ) ) + { + SfxItemSet aSet( mpDoc->GetPool() ); + + // set new attributes to object + const bool bUndo = IsUndoEnabled(); + if( bUndo ) + { + BegUndo( String( SdResId( STR_UNDO_DRAGDROP ) ) ); + AddUndo( mpDoc->GetSdrUndoFactory().CreateUndoAttrObject( *pPickObj ) ); + } + aSet.Put( pObj->GetMergedItemSet() ); + + // Eckenradius soll nicht uebernommen werden. + // In der Gallery stehen Farbverlauefe (Rechtecke) + // welche den Eckenradius == 0 haben. Dieser soll + // nicht auf das Objekt uebertragen werden. + aSet.ClearItem( SDRATTR_ECKENRADIUS ); + + pPickObj->SetMergedItemSetAndBroadcast( aSet ); + + if( pPickObj->ISA( E3dObject ) && pObj->ISA( E3dObject ) ) + { + // Zusaetzlich 3D Attribute handeln + SfxItemSet aNewSet( mpDoc->GetPool(), SID_ATTR_3D_START, SID_ATTR_3D_END, 0 ); + SfxItemSet aOldSet( mpDoc->GetPool(), SID_ATTR_3D_START, SID_ATTR_3D_END, 0 ); + + aOldSet.Put(pPickObj->GetMergedItemSet()); + aNewSet.Put( pObj->GetMergedItemSet() ); + + if( bUndo ) + AddUndo( new E3dAttributesUndoAction( *mpDoc, this, (E3dObject*) pPickObj, aNewSet, aOldSet, FALSE ) ); + pPickObj->SetMergedItemSetAndBroadcast( aNewSet ); + } + + if( bUndo ) + EndUndo(); + bChanged = TRUE; + } + } + } + + if( !bChanged ) + { + SdrPage* pWorkPage = pModel->GetSdPage( 0, PK_STANDARD ); + + pWorkPage->SetRectsDirty(); + + if( pOwnData ) + { + // #104148# Use SnapRect, not BoundRect + Size aSize( pWorkPage->GetAllObjSnapRect().GetSize() ); + + maDropPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 ); + maDropPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 ); + } + + bReturn = Paste( *pModel, maDropPos, pPage, nPasteOptions ); + } + + xShell->DoClose(); + } + } + } + else if( CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE ) ) + { + ::rtl::OUString aOUString; + + if( aDataHelper.GetString( SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE, aOUString ) ) + { + SdrObject* pObj = CreateFieldControl( aOUString ); + + if( pObj ) + { + Rectangle aRect( pObj->GetLogicRect() ); + Size aSize( aRect.GetSize() ); + + maDropPos.X() -= ( aSize.Width() >> 1 ); + maDropPos.Y() -= ( aSize.Height() >> 1 ); + + aRect.SetPos( maDropPos ); + pObj->SetLogicRect( aRect ); + InsertObjectAtView( pObj, *GetSdrPageView(), SDRINSERT_SETDEFLAYER ); + bReturn = TRUE; + } + } + } + else if( !bLink && + ( CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EMBED_SOURCE ) || + CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EMBEDDED_OBJ ) ) && + aDataHelper.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) ) + { + //TODO/LATER: is it possible that this format is binary?! (from old versions of SO) + uno::Reference < io::XInputStream > xStm; + TransferableObjectDescriptor aObjDesc; + + if( aDataHelper.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR, aObjDesc ) && + ( aDataHelper.GetInputStream( nFormat ? nFormat : SOT_FORMATSTR_ID_EMBED_SOURCE, xStm ) || + aDataHelper.GetInputStream( SOT_FORMATSTR_ID_EMBEDDED_OBJ, xStm ) ) ) + { + if( mpDoc->GetDocSh() && ( mpDoc->GetDocSh()->GetClassName() == aObjDesc.maClassName ) ) + { + uno::Reference < embed::XStorage > xStore( ::comphelper::OStorageHelper::GetStorageFromInputStream( xStm ) ); + ::sd::DrawDocShellRef xDocShRef( new ::sd::DrawDocShell( SFX_CREATE_MODE_EMBEDDED, TRUE, mpDoc->GetDocumentType() ) ); + + // mba: BaseURL doesn't make sense for clipboard functionality + SfxMedium *pMedium = new SfxMedium( xStore, String() ); + if( xDocShRef->DoLoad( pMedium ) ) + { + SdDrawDocument* pModel = (SdDrawDocument*) xDocShRef->GetDoc(); + SdPage* pWorkPage = (SdPage*) pModel->GetSdPage( 0, PK_STANDARD ); + + pWorkPage->SetRectsDirty(); + + if( pOwnData ) + { + // #104148# Use SnapRect, not BoundRect + Size aSize( pWorkPage->GetAllObjSnapRect().GetSize() ); + + maDropPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 ); + maDropPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 ); + } + + // delete pages, that are not of any interest for us + for( long i = ( pModel->GetPageCount() - 1 ); i >= 0; i-- ) + { + SdPage* pP = static_cast< SdPage* >( pModel->GetPage( (USHORT) i ) ); + + if( pP->GetPageKind() != PK_STANDARD ) + pModel->DeletePage( (USHORT) i ); + } + + bReturn = Paste( *pModel, maDropPos, pPage, nPasteOptions ); + + if( !pPage ) + pPage = (SdPage*) GetSdrPageView()->GetPage(); + + String aLayout(pPage->GetLayoutName()); + aLayout.Erase(aLayout.SearchAscii(SD_LT_SEPARATOR)); + pPage->SetPresentationLayout( aLayout, FALSE, FALSE ); + } + + xDocShRef->DoClose(); + xDocShRef.Clear(); + + } + else + { + ::rtl::OUString aName; + uno::Reference < embed::XEmbeddedObject > xObj = mpDocSh->GetEmbeddedObjectContainer().InsertEmbeddedObject( xStm, aName ); + if ( xObj.is() ) + { + svt::EmbeddedObjectRef aObjRef( xObj, aObjDesc.mnViewAspect ); + + // try to get the replacement image from the clipboard + Graphic aGraphic; + ULONG nGrFormat = 0; + +// (wg. Selection Manager bei Trustet Solaris) +#ifndef SOLARIS +/* + if( aDataHelper.GetGraphic( SOT_FORMATSTR_ID_SVXB, aGraphic ) ) + nGrFormat = SOT_FORMATSTR_ID_SVXB; + else if( aDataHelper.GetGraphic( FORMAT_GDIMETAFILE, aGraphic ) ) + nGrFormat = SOT_FORMAT_GDIMETAFILE; + else if( aDataHelper.GetGraphic( FORMAT_BITMAP, aGraphic ) ) + nGrFormat = SOT_FORMAT_BITMAP; +*/ +#endif + + // insert replacement image ( if there is one ) into the object helper + if ( nGrFormat ) + { + datatransfer::DataFlavor aDataFlavor; + SotExchange::GetFormatDataFlavor( nGrFormat, aDataFlavor ); + aObjRef.SetGraphic( aGraphic, aDataFlavor.MimeType ); + } + + Size aSize; + if ( aObjDesc.mnViewAspect == embed::Aspects::MSOLE_ICON ) + { + if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() ) + aSize = aObjDesc.maSize; + else + { + MapMode aMapMode( MAP_100TH_MM ); + aSize = aObjRef.GetSize( &aMapMode ); + } + } + else + { + awt::Size aSz; + MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( aObjDesc.mnViewAspect ) ); + if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() ) + { + Size aTmp( OutputDevice::LogicToLogic( aObjDesc.maSize, MAP_100TH_MM, aMapUnit ) ); + aSz.Width = aTmp.Width(); + aSz.Height = aTmp.Height(); + xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz ); + } + + try + { + aSz = xObj->getVisualAreaSize( aObjDesc.mnViewAspect ); + } + catch( embed::NoVisualAreaSizeException& ) + { + // if the size still was not set the default size will be set later + } + + aSize = Size( aSz.Width, aSz.Height ); + + if( !aSize.Width() || !aSize.Height() ) + { + aSize.Width() = 14100; + aSize.Height() = 10000; + aSize = OutputDevice::LogicToLogic( Size(14100, 10000), MAP_100TH_MM, aMapUnit ); + aSz.Width = aSize.Width(); + aSz.Height = aSize.Height(); + xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz ); + } + + aSize = OutputDevice::LogicToLogic( aSize, aMapUnit, MAP_100TH_MM ); + } + + Size aMaxSize( mpDoc->GetMaxObjSize() ); + + maDropPos.X() -= Min( aSize.Width(), aMaxSize.Width() ) >> 1; + maDropPos.Y() -= Min( aSize.Height(), aMaxSize.Height() ) >> 1; + + Rectangle aRect( maDropPos, aSize ); + SdrOle2Obj* pObj = new SdrOle2Obj( aObjRef, aName, aRect ); + SdrPageView* pPV = GetSdrPageView(); + ULONG nOptions = SDRINSERT_SETDEFLAYER; + + if (mpViewSh!=NULL) + { + OSL_ASSERT (mpViewSh->GetViewShell()!=NULL); + SfxInPlaceClient* pIpClient + = mpViewSh->GetViewShell()->GetIPClient(); + if (pIpClient!=NULL && pIpClient->IsObjectInPlaceActive()) + nOptions |= SDRINSERT_DONTMARK; + } + + InsertObjectAtView( pObj, *pPV, nOptions ); + + if( pImageMap ) + pObj->InsertUserData( new SdIMapInfo( *pImageMap ) ); + + bReturn = TRUE; + } + } + } + } + else if( !bLink && + ( CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE ) || + CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE ) ) && + aDataHelper.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR_OLE ) ) + { + // online insert ole if format is forced or no gdi metafile is available + if( (nFormat != 0) || !aDataHelper.HasFormat( FORMAT_GDIMETAFILE ) ) + { + uno::Reference < io::XInputStream > xStm; + TransferableObjectDescriptor aObjDesc; + + if ( aDataHelper.GetTransferableObjectDescriptor( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR_OLE, aObjDesc ) ) + { + uno::Reference < embed::XEmbeddedObject > xObj; + ::rtl::OUString aName; + + if ( aDataHelper.GetInputStream( nFormat ? nFormat : SOT_FORMATSTR_ID_EMBED_SOURCE_OLE, xStm ) || + aDataHelper.GetInputStream( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE, xStm ) ) + { + xObj = mpDocSh->GetEmbeddedObjectContainer().InsertEmbeddedObject( xStm, aName ); + } + else + { + try + { + uno::Reference< embed::XStorage > xTmpStor = ::comphelper::OStorageHelper::GetTemporaryStorage(); + uno::Reference < embed::XEmbedObjectClipboardCreator > xClipboardCreator( + ::comphelper::getProcessServiceFactory()->createInstance( + ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.embed.MSOLEObjectSystemCreator")) ), + uno::UNO_QUERY_THROW ); + + embed::InsertedObjectInfo aInfo = xClipboardCreator->createInstanceInitFromClipboard( + xTmpStor, + ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "DummyName" ) ), + uno::Sequence< beans::PropertyValue >() ); + + // TODO/LATER: in future InsertedObjectInfo will be used to get container related information + // for example whether the object should be an iconified one + xObj = aInfo.Object; + if ( xObj.is() ) + mpDocSh->GetEmbeddedObjectContainer().InsertEmbeddedObject( xObj, aName ); + } + catch( uno::Exception& ) + {} + } + + if ( xObj.is() ) + { + svt::EmbeddedObjectRef aObjRef( xObj, aObjDesc.mnViewAspect ); + + // try to get the replacement image from the clipboard + Graphic aGraphic; + ULONG nGrFormat = 0; + +// (wg. Selection Manager bei Trustet Solaris) +#ifndef SOLARIS + if( aDataHelper.GetGraphic( SOT_FORMATSTR_ID_SVXB, aGraphic ) ) + nGrFormat = SOT_FORMATSTR_ID_SVXB; + else if( aDataHelper.GetGraphic( FORMAT_GDIMETAFILE, aGraphic ) ) + nGrFormat = SOT_FORMAT_GDIMETAFILE; + else if( aDataHelper.GetGraphic( FORMAT_BITMAP, aGraphic ) ) + nGrFormat = SOT_FORMAT_BITMAP; +#endif + + // insert replacement image ( if there is one ) into the object helper + if ( nGrFormat ) + { + datatransfer::DataFlavor aDataFlavor; + SotExchange::GetFormatDataFlavor( nGrFormat, aDataFlavor ); + aObjRef.SetGraphic( aGraphic, aDataFlavor.MimeType ); + } + + Size aSize; + if ( aObjDesc.mnViewAspect == embed::Aspects::MSOLE_ICON ) + { + if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() ) + aSize = aObjDesc.maSize; + else + { + MapMode aMapMode( MAP_100TH_MM ); + aSize = aObjRef.GetSize( &aMapMode ); + } + } + else + { + MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( aObjDesc.mnViewAspect ) ); + + awt::Size aSz; + try{ + aSz = xObj->getVisualAreaSize( aObjDesc.mnViewAspect ); + } + catch( embed::NoVisualAreaSizeException& ) + { + // the default size will be set later + } + + if( aObjDesc.maSize.Width() && aObjDesc.maSize.Height() ) + { + Size aTmp( OutputDevice::LogicToLogic( aObjDesc.maSize, MAP_100TH_MM, aMapUnit ) ); + if ( aSz.Width != aTmp.Width() || aSz.Height != aTmp.Height() ) + { + aSz.Width = aTmp.Width(); + aSz.Height = aTmp.Height(); + xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz ); + } + } + + aSize = Size( aSz.Width, aSz.Height ); + + if( !aSize.Width() || !aSize.Height() ) + { + aSize = OutputDevice::LogicToLogic( Size(14100, 10000), MAP_100TH_MM, aMapUnit ); + aSz.Width = aSize.Width(); + aSz.Height = aSize.Height(); + xObj->setVisualAreaSize( aObjDesc.mnViewAspect, aSz ); + } + + aSize = OutputDevice::LogicToLogic( aSize, aMapUnit, MAP_100TH_MM ); + } + + Size aMaxSize( mpDoc->GetMaxObjSize() ); + + maDropPos.X() -= Min( aSize.Width(), aMaxSize.Width() ) >> 1; + maDropPos.Y() -= Min( aSize.Height(), aMaxSize.Height() ) >> 1; + + Rectangle aRect( maDropPos, aSize ); + SdrOle2Obj* pObj = new SdrOle2Obj( aObjRef, aName, aRect ); + SdrPageView* pPV = GetSdrPageView(); + ULONG nOptions = SDRINSERT_SETDEFLAYER; + + if (mpViewSh!=NULL) + { + OSL_ASSERT (mpViewSh->GetViewShell()!=NULL); + SfxInPlaceClient* pIpClient + = mpViewSh->GetViewShell()->GetIPClient(); + if (pIpClient!=NULL && pIpClient->IsObjectInPlaceActive()) + nOptions |= SDRINSERT_DONTMARK; + } + + InsertObjectAtView( pObj, *pPV, nOptions ); + + if( pImageMap ) + pObj->InsertUserData( new SdIMapInfo( *pImageMap ) ); + + // let the object stay in loaded state after insertion + pObj->Unload(); + bReturn = TRUE; + } + } + } + + if( !bReturn && aDataHelper.HasFormat( FORMAT_GDIMETAFILE ) ) + { + // if no object was inserted, insert a picture + InsertMetaFile( aDataHelper, rPos, pImageMap, true ); + } + } + else if( ( !bLink || pPickObj ) && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_SVXB ) ) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_SVXB, xStm ) ) + { + Point aInsertPos( rPos ); + Graphic aGraphic; + + *xStm >> aGraphic; + + if( pOwnData && pOwnData->GetWorkDocument() ) + { + const SdDrawDocument* pWorkModel = pOwnData->GetWorkDocument(); + SdrPage* pWorkPage = (SdrPage*) ( ( pWorkModel->GetPageCount() > 1 ) ? + pWorkModel->GetSdPage( 0, PK_STANDARD ) : + pWorkModel->GetPage( 0 ) ); + + pWorkPage->SetRectsDirty(); + + // #104148# Use SnapRect, not BoundRect + Size aSize( pWorkPage->GetAllObjSnapRect().GetSize() ); + + aInsertPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 ); + aInsertPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 ); + } + + // #90129# restrict movement to WorkArea + Size aImageMapSize = OutputDevice::LogicToLogic(aGraphic.GetPrefSize(), + aGraphic.GetPrefMapMode(), MapMode(MAP_100TH_MM)); + + ImpCheckInsertPos(aInsertPos, aImageMapSize, GetWorkArea()); + + InsertGraphic( aGraphic, mnAction, aInsertPos, NULL, pImageMap ); + bReturn = TRUE; + } + } + else if( ( !bLink || pPickObj ) && CHECK_FORMAT_TRANS( FORMAT_GDIMETAFILE ) ) + { + Point aInsertPos( rPos ); + + if( pOwnData && pOwnData->GetWorkDocument() ) + + { + const SdDrawDocument* pWorkModel = pOwnData->GetWorkDocument(); + SdrPage* pWorkPage = (SdrPage*) ( ( pWorkModel->GetPageCount() > 1 ) ? + pWorkModel->GetSdPage( 0, PK_STANDARD ) : + pWorkModel->GetPage( 0 ) ); + + pWorkPage->SetRectsDirty(); + + // #104148# Use SnapRect, not BoundRect + Size aSize( pWorkPage->GetAllObjSnapRect().GetSize() ); + + aInsertPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 ); + aInsertPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 ); + } + + bReturn = InsertMetaFile( aDataHelper, aInsertPos, pImageMap, nFormat == 0 ? true : false ) ? TRUE : FALSE; + } + else if( ( !bLink || pPickObj ) && CHECK_FORMAT_TRANS( FORMAT_BITMAP ) ) + { + Bitmap aBmp; + + if( aDataHelper.GetBitmap( FORMAT_BITMAP, aBmp ) ) + { + Point aInsertPos( rPos ); + + if( pOwnData && pOwnData->GetWorkDocument() ) + { + const SdDrawDocument* pWorkModel = pOwnData->GetWorkDocument(); + SdrPage* pWorkPage = (SdrPage*) ( ( pWorkModel->GetPageCount() > 1 ) ? + pWorkModel->GetSdPage( 0, PK_STANDARD ) : + pWorkModel->GetPage( 0 ) ); + + pWorkPage->SetRectsDirty(); + + // #104148# Use SnapRect, not BoundRect + Size aSize( pWorkPage->GetAllObjSnapRect().GetSize() ); + + aInsertPos.X() = pOwnData->GetStartPos().X() + ( aSize.Width() >> 1 ); + aInsertPos.Y() = pOwnData->GetStartPos().Y() + ( aSize.Height() >> 1 ); + } + + // #90129# restrict movement to WorkArea + Size aImageMapSize(aBmp.GetPrefSize()); + ImpCheckInsertPos(aInsertPos, aImageMapSize, GetWorkArea()); + + InsertGraphic( aBmp, mnAction, aInsertPos, NULL, pImageMap ); + bReturn = TRUE; + } + } + else if( pPickObj && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_XFA ) ) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_XFA, xStm ) ) + { + XFillExchangeData aFillData( XFillAttrSetItem( &mpDoc->GetPool() ) ); + + *xStm >> aFillData; + + if( IsUndoEnabled() ) + { + BegUndo( String( SdResId( STR_UNDO_DRAGDROP ) ) ); + AddUndo( GetModel()->GetSdrUndoFactory().CreateUndoAttrObject( *pPickObj ) ); + EndUndo(); + } + + XFillAttrSetItem* pSetItem = aFillData.GetXFillAttrSetItem(); + SfxItemSet rSet = pSetItem->GetItemSet(); + XFillStyle eFill= ( (XFillStyleItem&) rSet.Get( XATTR_FILLSTYLE ) ).GetValue(); + + if( eFill == XFILL_SOLID || eFill == XFILL_NONE ) + { + const XFillColorItem& rColItem = (XFillColorItem&) rSet.Get( XATTR_FILLCOLOR ); + Color aColor( rColItem.GetColorValue() ); + String aName( rColItem.GetName() ); + SfxItemSet aSet( mpDoc->GetPool() ); + BOOL bClosed = pPickObj->IsClosedObj(); + ::sd::Window* pWin = mpViewSh->GetActiveWindow(); + USHORT nHitLog = (USHORT) pWin->PixelToLogic( + Size(FuPoor::HITPIX, 0 ) ).Width(); + const long n2HitLog = nHitLog << 1; + Point aHitPosR( rPos ); + Point aHitPosL( rPos ); + Point aHitPosT( rPos ); + Point aHitPosB( rPos ); + const SetOfByte* pVisiLayer = &GetSdrPageView()->GetVisibleLayers(); + + aHitPosR.X() += n2HitLog; + aHitPosL.X() -= n2HitLog; + aHitPosT.Y() += n2HitLog; + aHitPosB.Y() -= n2HitLog; + + if( bClosed && + SdrObjectPrimitiveHit(*pPickObj, aHitPosR, nHitLog, *GetSdrPageView(), pVisiLayer, false) && + SdrObjectPrimitiveHit(*pPickObj, aHitPosL, nHitLog, *GetSdrPageView(), pVisiLayer, false) && + SdrObjectPrimitiveHit(*pPickObj, aHitPosT, nHitLog, *GetSdrPageView(), pVisiLayer, false) && + SdrObjectPrimitiveHit(*pPickObj, aHitPosB, nHitLog, *GetSdrPageView(), pVisiLayer, false) ) + { + // area fill + if(eFill == XFILL_SOLID ) + aSet.Put(XFillColorItem(aName, aColor)); + + aSet.Put( XFillStyleItem( eFill ) ); + } + else + aSet.Put( XLineColorItem( aName, aColor ) ); + + // Textfarbe hinzufuegen + pPickObj->SetMergedItemSetAndBroadcast( aSet ); + } + } + } + else if( !bLink && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_HTML ) ) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_HTML, xStm ) ) + { + xStm->Seek( 0 ); + // mba: clipboard always must contain absolute URLs (could be from alien source) + bReturn = SdrView::Paste( *xStm, String(), EE_FORMAT_HTML, maDropPos, pPage, nPasteOptions ); + } + } + else if( !bLink && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EDITENGINE ) ) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( SOT_FORMATSTR_ID_EDITENGINE, xStm ) ) + { + OutlinerView* pOLV = GetTextEditOutlinerView(); + + xStm->Seek( 0 ); + + if( pOLV ) + { + Rectangle aRect( pOLV->GetOutputArea() ); + Point aPos( pOLV->GetWindow()->PixelToLogic( maDropPos ) ); + + if( aRect.IsInside( aPos ) || ( !bDrag && IsTextEdit() ) ) + { + // mba: clipboard always must contain absolute URLs (could be from alien source) + pOLV->Read( *xStm, String(), EE_FORMAT_BIN, FALSE, mpDocSh->GetHeaderAttributes() ); + bReturn = TRUE; + } + } + + if( !bReturn ) + // mba: clipboard always must contain absolute URLs (could be from alien source) + bReturn = SdrView::Paste( *xStm, String(), EE_FORMAT_BIN, maDropPos, pPage, nPasteOptions ); + } + } + else if( !bLink && CHECK_FORMAT_TRANS( FORMAT_RTF ) ) + { + SotStorageStreamRef xStm; + + if( aDataHelper.GetSotStorageStream( FORMAT_RTF, xStm ) ) + { + xStm->Seek( 0 ); + + if( bTable ) + { + bReturn = PasteRTFTable( xStm, pPage, nPasteOptions ); + } + else + { + OutlinerView* pOLV = GetTextEditOutlinerView(); + + if( pOLV ) + { + Rectangle aRect( pOLV->GetOutputArea() ); + Point aPos( pOLV->GetWindow()->PixelToLogic( maDropPos ) ); + + if( aRect.IsInside( aPos ) || ( !bDrag && IsTextEdit() ) ) + { + // mba: clipboard always must contain absolute URLs (could be from alien source) + pOLV->Read( *xStm, String(), EE_FORMAT_RTF, FALSE, mpDocSh->GetHeaderAttributes() ); + bReturn = TRUE; + } + } + + if( !bReturn ) + // mba: clipboard always must contain absolute URLs (could be from alien source) + bReturn = SdrView::Paste( *xStm, String(), EE_FORMAT_RTF, maDropPos, pPage, nPasteOptions ); + } + } + } + else if( CHECK_FORMAT_TRANS( FORMAT_FILE_LIST ) ) + { + FileList aDropFileList; + + if( aDataHelper.GetFileList( FORMAT_FILE_LIST, aDropFileList ) ) + { + maDropFileVector.clear(); + + for( ULONG i = 0, nCount = aDropFileList.Count(); i < nCount; i++ ) + maDropFileVector.push_back( aDropFileList.GetFile( i ) ); + + maDropInsertFileTimer.Start(); + } + + bReturn = TRUE; + } + else if( CHECK_FORMAT_TRANS( FORMAT_FILE ) ) + { + String aDropFile; + + if( aDataHelper.GetString( FORMAT_FILE, aDropFile ) ) + { + maDropFileVector.clear(); + maDropFileVector.push_back( aDropFile ); + maDropInsertFileTimer.Start(); + } + + bReturn = TRUE; + } + else if( !bLink && CHECK_FORMAT_TRANS( FORMAT_STRING ) ) + { + if( ( FORMAT_STRING == nFormat ) || + ( !aDataHelper.HasFormat( SOT_FORMATSTR_ID_SOLK ) && + !aDataHelper.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) && + !aDataHelper.HasFormat( SOT_FORMATSTR_ID_FILENAME ) ) ) + { + ::rtl::OUString aOUString; + + if( aDataHelper.GetString( FORMAT_STRING, aOUString ) ) + { + OutlinerView* pOLV = GetTextEditOutlinerView(); + + if( pOLV ) + { + pOLV->InsertText( aOUString ); + bReturn = TRUE; + } + + if( !bReturn ) + bReturn = SdrView::Paste( aOUString, maDropPos, pPage, nPasteOptions ); + } + } + } + + MarkListHasChanged(); + mbIsDropAllowed = TRUE; + rDnDAction = mnAction; + delete pImageMap; + + return bReturn; +} + +extern void CreateTableFromRTF( SvStream& rStream, SdDrawDocument* pModel ); + +bool View::PasteRTFTable( SotStorageStreamRef xStm, SdrPage* pPage, ULONG nPasteOptions ) +{ + SdDrawDocument* pModel = new SdDrawDocument( DOCUMENT_TYPE_IMPRESS, mpDocSh ); + pModel->NewOrLoadCompleted(NEW_DOC); + pModel->GetItemPool().SetDefaultMetric(SFX_MAPUNIT_100TH_MM); + pModel->InsertPage(pModel->AllocPage(false)); + + Reference< XComponent > xComponent( new SdXImpressDocument( pModel, sal_True ) ); + pModel->setUnoModel( Reference< XInterface >::query( xComponent ) ); + + CreateTableFromRTF( *xStm, pModel ); + bool bRet = Paste( *pModel, maDropPos, pPage, nPasteOptions ); + + xComponent->dispose(); + xComponent.clear(); + + delete pModel; + + return bRet; +} + +} // end of namespace sd diff --git a/sd/source/ui/view/sdview4.cxx b/sd/source/ui/view/sdview4.cxx new file mode 100755 index 000000000000..9fbe223c276a --- /dev/null +++ b/sd/source/ui/view/sdview4.cxx @@ -0,0 +1,637 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "View.hxx" +#include <unotools/localfilehelper.hxx> +#include <sfx2/request.hxx> +#include <sfx2/docfilt.hxx> +#include <sfx2/fcontnr.hxx> +#include <sfx2/docfile.hxx> +#include <vcl/msgbox.hxx> +#include <svl/urlbmk.hxx> +#include <svx/svdpagv.hxx> +#include <svx/xfillit.hxx> +#include <svx/svdundo.hxx> +#include <svx/xoutbmp.hxx> +#include <svx/svdograf.hxx> +#include <svx/svdomedia.hxx> +#include <svx/svdoole2.hxx> +#include <sot/storage.hxx> +#include <sfx2/app.hxx> +#include <avmedia/mediawindow.hxx> +#include <svtools/ehdl.hxx> +#include <svtools/sfxecode.hxx> +#include <svtools/filter.hxx> +#include "app.hrc" +#include "Window.hxx" +#include "DrawDocShell.hxx" +#include "DrawViewShell.hxx" +#include "fuinsfil.hxx" +#include "drawdoc.hxx" +#include "sdresid.hxx" +#include "strings.hrc" +#include "imapinfo.hxx" +#include "sdpage.hxx" +#include "view/SlideSorterView.hxx" +#include "undo/undoobjects.hxx" + +#include <comphelper/processfactory.hxx> +#include <com/sun/star/embed/ElementModes.hpp> +#include <com/sun/star/embed/XEmbedPersist.hpp> +#include <com/sun/star/embed/Aspects.hpp> +#include <com/sun/star/embed/NoVisualAreaSizeException.hpp> +#include <svtools/soerr.hxx> + +#include <sfx2/ipclient.hxx> + +using namespace com::sun::star; + +namespace sd { + +#ifdef _MSC_VER +#pragma optimize ( "", off ) +#endif + +/************************************************************************* +|* +|* Graphik einfuegen +|* Wird ein leeres Graphikobjekt uebergeben, so wird dieses gefuellt. +|* Andernfalls wird ein an der gegebenen Position vorhandenes Objekt +|* gefuellt. Ist an der Position kein Objekt vorhanden, so wird ein neues +|* Objekt erzeugt und ein Pointer auf dieses Objekt zurueckgegeben. +|* +\************************************************************************/ + +SdrGrafObj* View::InsertGraphic( const Graphic& rGraphic, sal_Int8& rAction, + const Point& rPos, SdrObject* pObj, ImageMap* pImageMap ) +{ + SdrEndTextEdit(); + mnAction = rAction; + + // Liegt ein Objekt an der Position rPos? + SdrGrafObj* pNewGrafObj = NULL; + SdrPageView* pPV = GetSdrPageView(); + SdrObject* pPickObj = pObj; + + if(pPV && this->ISA(::sd::slidesorter::view::SlideSorterView)) + { + if(!pPV->GetPageRect().IsInside(rPos)) + pPV = 0L; + } + + if( !pPickObj && pPV ) + { + SdrPageView* pPageView = pPV; + PickObj(rPos, getHitTolLog(), pPickObj, pPageView); + } + + if( mnAction == DND_ACTION_LINK && pPickObj && pPV ) + { + const bool bIsGraphic = pPickObj->ISA( SdrGrafObj ); + if( bIsGraphic || pObj->IsEmptyPresObj() ) + { + if( IsUndoEnabled() ) + BegUndo(String(SdResId(STR_INSERTGRAPHIC))); + + SdPage* pPage = (SdPage*) pPickObj->GetPage(); + + if( bIsGraphic ) + { + // Das Objekt wird mit der Bitmap gefuellt + pNewGrafObj = (SdrGrafObj*) pPickObj->Clone(); + pNewGrafObj->SetGraphic(rGraphic); + } + else + { + pNewGrafObj = new SdrGrafObj( rGraphic, pPickObj->GetLogicRect() ); + pNewGrafObj->SetEmptyPresObj(TRUE); + } + + if ( pNewGrafObj->IsEmptyPresObj() ) + { + Rectangle aRect( pNewGrafObj->GetLogicRect() ); + pNewGrafObj->AdjustToMaxRect( aRect, FALSE ); + pNewGrafObj->SetOutlinerParaObject(NULL); + pNewGrafObj->SetEmptyPresObj(FALSE); + } + + if (pPage && pPage->IsPresObj(pPickObj)) + { + // Neues PresObj in die Liste eintragen + pPage->InsertPresObj( pNewGrafObj, PRESOBJ_GRAPHIC ); + pNewGrafObj->SetUserCall(pPickObj->GetUserCall()); + } + + if (pImageMap) + pNewGrafObj->InsertUserData(new SdIMapInfo(*pImageMap)); + + ReplaceObjectAtView(pPickObj, *pPV, pNewGrafObj); // maybe ReplaceObjectAtView + + if( IsUndoEnabled() ) + EndUndo(); + } + else if (pPickObj->IsClosedObj() && !pPickObj->ISA(SdrOle2Obj)) + { + /****************************************************************** + * Das Objekt wird mit der Graphik gefuellt + ******************************************************************/ + if( IsUndoEnabled() ) + { + BegUndo(String(SdResId(STR_UNDO_DRAGDROP))); + AddUndo(GetModel()->GetSdrUndoFactory().CreateUndoAttrObject(*pPickObj)); + EndUndo(); + } + + XOBitmap aXOBitmap( rGraphic.GetBitmap() ); + SfxItemSet aSet(mpDocSh->GetPool(), XATTR_FILLSTYLE, XATTR_FILLBITMAP); + aSet.Put(XFillStyleItem(XFILL_BITMAP)); + aSet.Put(XFillBitmapItem(&mpDocSh->GetPool(), aXOBitmap)); + pPickObj->SetMergedItemSetAndBroadcast(aSet); + } + } + else if ( pPV ) + { + // create new object + Size aSize; + + if ( rGraphic.GetPrefMapMode().GetMapUnit() == MAP_PIXEL ) + { + ::OutputDevice* pOutDev = 0; + if( mpViewSh ) + pOutDev = mpViewSh->GetActiveWindow(); + + if( !pOutDev ) + pOutDev = Application::GetDefaultDevice(); + + if( pOutDev ) + aSize = pOutDev->PixelToLogic( rGraphic.GetPrefSize(), MAP_100TH_MM ); + } + else + { + aSize = OutputDevice::LogicToLogic( rGraphic.GetPrefSize(), + rGraphic.GetPrefMapMode(), + MapMode( MAP_100TH_MM ) ); + } + + pNewGrafObj = new SdrGrafObj( rGraphic, Rectangle( rPos, aSize ) ); + SdrPage* pPage = pPV->GetPage(); + Size aPageSize( pPage->GetSize() ); + aPageSize.Width() -= pPage->GetLftBorder() + pPage->GetRgtBorder(); + aPageSize.Height() -= pPage->GetUppBorder() + pPage->GetLwrBorder(); + pNewGrafObj->AdjustToMaxRect( Rectangle( Point(), aPageSize ), TRUE ); +// pNewGrafObj->AdjustToMaxRect( Rectangle( pPV->GetOffset(), aPageSize ), TRUE ); + + ULONG nOptions = SDRINSERT_SETDEFLAYER; + BOOL bIsPresTarget = FALSE; + + if ((mpViewSh + && mpViewSh->GetViewShell()!=NULL + && mpViewSh->GetViewShell()->GetIPClient() + && mpViewSh->GetViewShell()->GetIPClient()->IsObjectInPlaceActive()) + || this->ISA(::sd::slidesorter::view::SlideSorterView)) + nOptions |= SDRINSERT_DONTMARK; + + if( ( mnAction & DND_ACTION_MOVE ) && pPickObj && (pPickObj->IsEmptyPresObj() || pPickObj->GetUserCall()) ) + { + SdPage* pP = static_cast< SdPage* >( pPickObj->GetPage() ); + + if ( pP && pP->IsMasterPage() ) + bIsPresTarget = pP->IsPresObj(pPickObj); + } + + if( ( mnAction & DND_ACTION_MOVE ) && pPickObj && !bIsPresTarget ) + { + // replace object + if (pImageMap) + pNewGrafObj->InsertUserData(new SdIMapInfo(*pImageMap)); + + Rectangle aPickObjRect(pPickObj->GetCurrentBoundRect()); + Size aPickObjSize(aPickObjRect.GetSize()); + Rectangle aObjRect(pNewGrafObj->GetCurrentBoundRect()); + Size aObjSize(aObjRect.GetSize()); + + Fraction aScaleWidth(aPickObjSize.Width(), aObjSize.Width()); + Fraction aScaleHeight(aPickObjSize.Height(), aObjSize.Height()); + pNewGrafObj->NbcResize(aObjRect.TopLeft(), aScaleWidth, aScaleHeight); + + Point aVec = aPickObjRect.TopLeft() - aObjRect.TopLeft(); + pNewGrafObj->NbcMove(Size(aVec.X(), aVec.Y())); + + const bool bUndo = IsUndoEnabled(); + + if( bUndo ) + BegUndo(String(SdResId(STR_UNDO_DRAGDROP))); + pNewGrafObj->NbcSetLayer(pPickObj->GetLayer()); + SdrPage* pP = pPV->GetPage(); + pP->InsertObject(pNewGrafObj); + if( bUndo ) + { + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoNewObject(*pNewGrafObj)); + AddUndo(mpDoc->GetSdrUndoFactory().CreateUndoDeleteObject(*pPickObj)); + } + pP->RemoveObject(pPickObj->GetOrdNum()); + + if( bUndo ) + { + EndUndo(); + } + else + { + SdrObject::Free(pPickObj); + } + mnAction = DND_ACTION_COPY; + } + else + { + InsertObjectAtView(pNewGrafObj, *pPV, nOptions); + + if( pImageMap ) + pNewGrafObj->InsertUserData(new SdIMapInfo(*pImageMap)); + } + } + + rAction = mnAction; + + return pNewGrafObj; +} + +// ----------------------------------------------------------------------------- + +SdrMediaObj* View::InsertMediaURL( const rtl::OUString& rMediaURL, sal_Int8& rAction, + const Point& rPos, const Size& rSize ) +{ + SdrEndTextEdit(); + mnAction = rAction; + + SdrMediaObj* pNewMediaObj = NULL; + SdrPageView* pPV = GetSdrPageView(); + SdrObject* pPickObj = GetEmptyPresentationObject( PRESOBJ_MEDIA ); + + if(pPV && this->ISA(::sd::slidesorter::view::SlideSorterView )) + { + if(!pPV->GetPageRect().IsInside(rPos)) + pPV = 0L; + } + + if( !pPickObj && pPV ) + { + SdrPageView* pPageView = pPV; + PickObj(rPos, getHitTolLog(), pPickObj, pPageView); + } + + if( mnAction == DND_ACTION_LINK && pPickObj && pPV && pPickObj->ISA( SdrMediaObj ) ) + { + pNewMediaObj = static_cast< SdrMediaObj* >( pPickObj->Clone() ); + pNewMediaObj->setURL( rMediaURL ); + + BegUndo(String(SdResId(STR_UNDO_DRAGDROP))); + ReplaceObjectAtView(pPickObj, *pPV, pNewMediaObj); + EndUndo(); + } + else if( pPV ) + { + Rectangle aRect( rPos, rSize ); + if( pPickObj ) + aRect = pPickObj->GetLogicRect(); + + + pNewMediaObj = new SdrMediaObj( aRect ); + + bool bIsPres = false; + if( pPickObj ) + { + SdPage* pPage = static_cast< SdPage* >(pPickObj->GetPage()); + bIsPres = pPage && pPage->IsPresObj(pPickObj); + if( bIsPres ) + { + pPage->InsertPresObj( pNewMediaObj, PRESOBJ_MEDIA ); + } + } + + if( pPickObj ) + ReplaceObjectAtView(pPickObj, *pPV, pNewMediaObj); + else + InsertObjectAtView( pNewMediaObj, *pPV, SDRINSERT_SETDEFLAYER ); + + pNewMediaObj->setURL( rMediaURL ); + + if( pPickObj ) + { + pNewMediaObj->AdjustToMaxRect( pPickObj->GetLogicRect() ); + if( bIsPres ) + pNewMediaObj->SetUserCall(pPickObj->GetUserCall()); + } + } + + rAction = mnAction; + + return pNewMediaObj; +} + +/************************************************************************* +|* +|* Timer-Handler fuer InsertFile beim Drop() +|* +\************************************************************************/ + +IMPL_LINK( View, DropInsertFileHdl, Timer*, EMPTYARG ) +{ + DBG_ASSERT( mpViewSh, "sd::View::DropInsertFileHdl(), I need a view shell to work!" ); + if( !mpViewSh ) + return 0; + + SfxErrorContext aEc( ERRCTX_ERROR, mpViewSh->GetActiveWindow(), RID_SO_ERRCTX ); + ErrCode nError = 0; + + ::std::vector< String >::const_iterator aIter( maDropFileVector.begin() ); + + while( (aIter != maDropFileVector.end()) && !nError ) + { + String aCurrentDropFile( *aIter ); + INetURLObject aURL( aCurrentDropFile ); + BOOL bOK = FALSE; + + if( aURL.GetProtocol() == INET_PROT_NOT_VALID ) + { + String aURLStr; + ::utl::LocalFileHelper::ConvertPhysicalNameToURL( aCurrentDropFile, aURLStr ); + aURL = INetURLObject( aURLStr ); + } + + GraphicFilter* pGraphicFilter = GraphicFilter::GetGraphicFilter(); + Graphic aGraphic; + + aCurrentDropFile = aURL.GetMainURL( INetURLObject::NO_DECODE ); + + if( !::avmedia::MediaWindow::isMediaURL( aCurrentDropFile ) ) + { + if( !pGraphicFilter->ImportGraphic( aGraphic, aURL ) ) + { + sal_Int8 nTempAction = ( aIter == maDropFileVector.begin() ) ? mnAction : 0; + const bool bLink = ( ( nTempAction & DND_ACTION_LINK ) != 0 ); + SdrGrafObj* pGrafObj = InsertGraphic( aGraphic, nTempAction, maDropPos, NULL, NULL ); + + if( pGrafObj && bLink ) + pGrafObj->SetGraphicLink( aCurrentDropFile, String() ); + + // return action from first inserted graphic + if( aIter == maDropFileVector.begin() ) + mnAction = nTempAction; + + bOK = TRUE; + } + if( !bOK ) + { + const SfxFilter* pFoundFilter = NULL; + SfxMedium aSfxMedium( aCurrentDropFile, STREAM_READ | STREAM_SHARE_DENYNONE, FALSE ); + ErrCode nErr = SFX_APP()->GetFilterMatcher().GuessFilter( aSfxMedium, &pFoundFilter, SFX_FILTER_IMPORT, SFX_FILTER_NOTINSTALLED | SFX_FILTER_EXECUTABLE ); + + if( pFoundFilter && !nErr ) + { + ::std::vector< String > aFilterVector; + const String aFilterName( pFoundFilter->GetFilterName() ); + String aLowerAsciiFileName( aCurrentDropFile ); + aLowerAsciiFileName.ToLowerAscii(); + + FuInsertFile::GetSupportedFilterVector( aFilterVector ); + + if( ( ::std::find( aFilterVector.begin(), aFilterVector.end(), pFoundFilter->GetMimeType() ) != aFilterVector.end() ) || + aFilterName.SearchAscii( "Text" ) != STRING_NOTFOUND || + aFilterName.SearchAscii( "Rich" ) != STRING_NOTFOUND || + aFilterName.SearchAscii( "RTF" ) != STRING_NOTFOUND || + aFilterName.SearchAscii( "HTML" ) != STRING_NOTFOUND || + aLowerAsciiFileName.SearchAscii(".sdd") != STRING_NOTFOUND || + aLowerAsciiFileName.SearchAscii(".sda") != STRING_NOTFOUND || + aLowerAsciiFileName.SearchAscii(".sxd") != STRING_NOTFOUND || + aLowerAsciiFileName.SearchAscii(".sxi") != STRING_NOTFOUND || + aLowerAsciiFileName.SearchAscii(".std") != STRING_NOTFOUND || + aLowerAsciiFileName.SearchAscii(".sti") != STRING_NOTFOUND ) + { + ::sd::Window* pWin = mpViewSh->GetActiveWindow(); + SfxRequest aReq(SID_INSERTFILE, 0, mpDoc->GetItemPool()); + SfxStringItem aItem1( ID_VAL_DUMMY0, aCurrentDropFile ), aItem2( ID_VAL_DUMMY1, pFoundFilter->GetFilterName() ); + + aReq.AppendItem( aItem1 ); + aReq.AppendItem( aItem2 ); + FuInsertFile::Create( mpViewSh, pWin, this, mpDoc, aReq ); + bOK = TRUE; + } + } + } + } + + if( !bOK ) + { + Size aPrefSize; + + if( ::avmedia::MediaWindow::isMediaURL( aCurrentDropFile ) && + ::avmedia::MediaWindow::isMediaURL( aCurrentDropFile, true, &aPrefSize ) ) + { + if( aPrefSize.Width() && aPrefSize.Height() ) + { + ::sd::Window* pWin = mpViewSh->GetActiveWindow(); + + if( pWin ) + aPrefSize = pWin->PixelToLogic( aPrefSize, MAP_100TH_MM ); + else + aPrefSize = Application::GetDefaultDevice()->PixelToLogic( aPrefSize, MAP_100TH_MM ); + } + else + aPrefSize = Size( 5000, 5000 ); + + InsertMediaURL( aCurrentDropFile, mnAction, maDropPos, aPrefSize ) ; + } + else if( mnAction & DND_ACTION_LINK ) + static_cast< DrawViewShell* >( mpViewSh )->InsertURLButton( aCurrentDropFile, aCurrentDropFile, String(), &maDropPos ); + else + { + if( mpViewSh ) + { + try + { + //TODO/MBA: testing + ::rtl::OUString aName; + uno::Sequence < beans::PropertyValue > aMedium(1); + aMedium[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ); + aMedium[0].Value <<= ::rtl::OUString( aCurrentDropFile ); + + uno::Reference < embed::XEmbeddedObject > xObj = mpDocSh->GetEmbeddedObjectContainer(). + InsertEmbeddedObject( aMedium, aName ); + + uno::Reference < embed::XEmbedPersist > xPersist( xObj, uno::UNO_QUERY ); + if ( xPersist.is()) + { + // TODO/LEAN: VisualArea access can switch the object to running state + sal_Int64 nAspect = embed::Aspects::MSOLE_CONTENT; + + xPersist->storeOwn(); + + awt::Size aSz; + try + { + aSz = xObj->getVisualAreaSize( nAspect ); + } + catch( embed::NoVisualAreaSizeException& ) + { + // the default size will be set later + } + + Size aSize( aSz.Width, aSz.Height ); + Rectangle aRect; + + if (!aSize.Width() || !aSize.Height()) + { + aSize.Width() = 1410; + aSize.Height() = 1000; + } + + aRect = Rectangle( maDropPos, aSize ); + + SdrOle2Obj* pOleObj = new SdrOle2Obj( svt::EmbeddedObjectRef( xObj, nAspect ), aName, aRect ); + ULONG nOptions = SDRINSERT_SETDEFLAYER; + + if (mpViewSh != NULL) + { + OSL_ASSERT (mpViewSh->GetViewShell()!=NULL); + SfxInPlaceClient* pIpClient = + mpViewSh->GetViewShell()->GetIPClient(); + if (pIpClient!=NULL && pIpClient->IsObjectInPlaceActive()) + nOptions |= SDRINSERT_DONTMARK; + } + + InsertObjectAtView( pOleObj, *GetSdrPageView(), nOptions ); + pOleObj->SetLogicRect( aRect ); + aSz.Width = aRect.GetWidth(); + aSz.Height = aRect.GetHeight(); + xObj->setVisualAreaSize( nAspect,aSz ); + } + } + catch( uno::Exception& ) + { + nError = ERRCODE_IO_GENERAL; + // TODO/LATER: better error handling + } + } + } + } + + ++aIter; + } + + if( nError ) + ErrorHandler::HandleError( nError ); + + return nError; +} + +/************************************************************************* +|* +|* Timer-Handler fuer Errorhandling beim Drop() +|* +\************************************************************************/ + +IMPL_LINK( View, DropErrorHdl, Timer*, EMPTYARG ) +{ + InfoBox( mpViewSh ? mpViewSh->GetActiveWindow() : 0, String(SdResId(STR_ACTION_NOTPOSSIBLE) ) ).Execute(); + return 0; +} + +#ifdef _MSC_VER +#pragma optimize ( "", on ) +#endif + +/************************************************************************* +|* +|* Redraw sperren oder erlauben +|* +\************************************************************************/ + +void View::LockRedraw(BOOL bLock) +{ + if (bLock) + { + mnLockRedrawSmph++; + DBG_ASSERT(mnLockRedrawSmph, "Ueberlauf im LockRedraw"); + } + else + { + DBG_ASSERT(mnLockRedrawSmph, "Unterlauf im LockRedraw"); + mnLockRedrawSmph--; + + // alle gespeicherten Redraws ausfuehren + if (!mnLockRedrawSmph) + { + while (mpLockedRedraws && mpLockedRedraws->Count()) + { + SdViewRedrawRec* pRec = (SdViewRedrawRec*)mpLockedRedraws->First(); + OutputDevice* pCurrentOut = pRec->mpOut; + Rectangle aBoundRect(pRec->aRect); + mpLockedRedraws->Remove(pRec); + delete pRec; + + pRec = (SdViewRedrawRec*)mpLockedRedraws->First(); + while (pRec) + { + if (pRec->mpOut == pCurrentOut) + { + aBoundRect.Union(pRec->aRect); + mpLockedRedraws->Remove(pRec); + delete pRec; + pRec = (SdViewRedrawRec*)mpLockedRedraws->GetCurObject(); + } + else + { + pRec = (SdViewRedrawRec*)mpLockedRedraws->Next(); + } + } + + CompleteRedraw(pCurrentOut, Region(aBoundRect)); + } + delete mpLockedRedraws; + mpLockedRedraws = NULL; + } + } +} + + + + +/************************************************************************* +|* +|* StyleSheet aus der Sleketion besorgen +|* +\************************************************************************/ + +SfxStyleSheet* View::GetStyleSheet() const +{ + return SdrView::GetStyleSheet(); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/sdview5.cxx b/sd/source/ui/view/sdview5.cxx new file mode 100755 index 000000000000..156544c235ab --- /dev/null +++ b/sd/source/ui/view/sdview5.cxx @@ -0,0 +1,114 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "sdpage.hxx" +#include "View.hxx" +#include "pres.hxx" + +namespace sd { + +static bool implIsMultiPresObj( PresObjKind eKind ) +{ + switch( eKind ) + { + case PRESOBJ_OUTLINE: + case PRESOBJ_GRAPHIC: + case PRESOBJ_OBJECT: + case PRESOBJ_CHART: + case PRESOBJ_ORGCHART: + case PRESOBJ_TABLE: + case PRESOBJ_IMAGE: + case PRESOBJ_MEDIA: + return true; + default: + return false; + } +} + +SdrObject* View::GetEmptyPresentationObject( PresObjKind eKind ) +{ + SdrObject* pEmptyObj = 0; + + SdrPageView* pPV = GetSdrPageView(); + if( pPV ) + { + SdPage* pPage = static_cast< SdPage* >( pPV->GetPage() ); + if( pPage ) + { + // first try selected shape + if ( AreObjectsMarked() ) + { + /********************************************************** + * Is an empty graphic object available? + **********************************************************/ + const SdrMarkList& rMarkList = GetMarkedObjectList(); + + if (rMarkList.GetMarkCount() == 1) + { + SdrMark* pMark = rMarkList.GetMark(0); + SdrObject* pObj = pMark->GetMarkedSdrObj(); + + if( pObj->IsEmptyPresObj() && implIsMultiPresObj( pPage->GetPresObjKind(pObj) ) ) + pEmptyObj = pObj; + } + } + + // try to find empty pres obj of same type + if( !pEmptyObj ) + { + int nIndex = 1; + do + { + pEmptyObj = pPage->GetPresObj(eKind, nIndex++ ); + } + while( (pEmptyObj != 0) && (!pEmptyObj->IsEmptyPresObj()) ); + } + + // last try to find empty pres obj of multiple type + if( !pEmptyObj ) + { + const std::list< SdrObject* >& rShapes = pPage->GetPresentationShapeList().getList(); + + for( std::list< SdrObject* >::const_iterator iter( rShapes.begin() ); iter != rShapes.end(); iter++ ) + { + if( (*iter)->IsEmptyPresObj() && implIsMultiPresObj(pPage->GetPresObjKind(*iter)) ) + { + pEmptyObj = (*iter); + break; + } + } + } + } + } + + return pEmptyObj; +} + +} diff --git a/sd/source/ui/view/sdwindow.cxx b/sd/source/ui/view/sdwindow.cxx new file mode 100755 index 000000000000..28873b3946a3 --- /dev/null +++ b/sd/source/ui/view/sdwindow.cxx @@ -0,0 +1,1210 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "Window.hxx" +#include <sfx2/dispatch.hxx> +#include <sfx2/request.hxx> + +#include <sfx2/viewfrm.hxx> +#include <svx/svxids.hrc> + +#include <editeng/outliner.hxx> +#include <editeng/editview.hxx> + +#include "app.hrc" +#include "helpids.h" +#include "ViewShell.hxx" +#include "DrawViewShell.hxx" +#include "View.hxx" +#include "FrameView.hxx" +#include "OutlineViewShell.hxx" +#include "drawdoc.hxx" +#include "AccessibleDrawDocumentView.hxx" +#include "WindowUpdater.hxx" + +namespace sd { + +#define SCROLL_LINE_FACT 0.05 // Faktor fuer Zeilenscrolling +#define SCROLL_PAGE_FACT 0.5 // Faktor fuer Seitenscrolling +#define SCROLL_SENSITIVE 20 // Sensitiver Bereich (Pixel) +#define ZOOM_MULTIPLICATOR 10000 // Multiplikator um Rundungsfehler zu vermeiden +#define MIN_ZOOM 5 // Minimaler Zoomfaktor +#define MAX_ZOOM 3000 // Maximaler Zoomfaktor + + +/************************************************************************* +|* +|* Konstruktor +|* +\************************************************************************/ + +Window::Window(::Window* pParent) + : ::Window(pParent, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)), + DropTargetHelper( this ), + mpShareWin(NULL), + maWinPos(0, 0), // vorsichtshalber; die Werte sollten aber + maViewOrigin(0, 0), // vom Besitzer des Fensters neu gesetzt + maViewSize(1000, 1000), // werden + mnMinZoom(MIN_ZOOM), + mnMaxZoom(MAX_ZOOM), + mbMinZoomAutoCalc(false), + mbCalcMinZoomByMinSide(true), + mbCenterAllowed(true), + mnTicks (0), + mbDraggedFrom(false), + mpViewShell(NULL), + mbUseDropScroll (true) +{ + SetDialogControlFlags( WINDOW_DLGCTRL_RETURN | WINDOW_DLGCTRL_WANTFOCUS ); + + MapMode aMap(GetMapMode()); + aMap.SetMapUnit(MAP_100TH_MM); + SetMapMode(aMap); + + // Damit im Diamodus die ::WindowColor genommen wird + SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetWindowColor() ) ); + + // adjust contrast mode initially + bool bUseContrast = GetSettings().GetStyleSettings().GetHighContrastMode(); + SetDrawMode( bUseContrast + ? ViewShell::OUTPUT_DRAWMODE_CONTRAST + : ViewShell::OUTPUT_DRAWMODE_COLOR ); + + // Hilfe-ID setzen + // SetHelpId(HID_SD_WIN_DOCUMENT); + SetUniqueId(HID_SD_WIN_DOCUMENT); + + // #i78183# Added after discussed with AF + EnableRTL(FALSE); +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +Window::~Window (void) +{ + if (mpViewShell != NULL) + { + WindowUpdater* pWindowUpdater = mpViewShell->GetWindowUpdater(); + if (pWindowUpdater != NULL) + pWindowUpdater->UnregisterWindow (this); + } +} + + + + +void Window::SetViewShell (ViewShell* pViewSh) +{ + WindowUpdater* pWindowUpdater = NULL; + // Unregister at device updater of old view shell. + if (mpViewShell != NULL) + { + pWindowUpdater = mpViewShell->GetWindowUpdater(); + if (pWindowUpdater != NULL) + pWindowUpdater->UnregisterWindow (this); + } + + mpViewShell = pViewSh; + + // Register at device updater of new view shell + if (mpViewShell != NULL) + { + pWindowUpdater = mpViewShell->GetWindowUpdater(); + if (pWindowUpdater != NULL) + pWindowUpdater->RegisterWindow (this); + } +} + +void Window::CalcMinZoom() +{ + // Are we entitled to change the minimal zoom factor? + if ( mbMinZoomAutoCalc ) + { + // Get current zoom factor. + long nZoom = GetZoom(); + + if ( mpShareWin ) + { + mpShareWin->CalcMinZoom(); + mnMinZoom = mpShareWin->mnMinZoom; + } + else + { + // Get the rectangle of the output area in logical coordinates + // and calculate the scaling factors that would lead to the view + // area (also called application area) to completely fill the + // window. + Size aWinSize = PixelToLogic(GetOutputSizePixel()); + ULONG nX = (ULONG) ((double) aWinSize.Width() + * (double) ZOOM_MULTIPLICATOR / (double) maViewSize.Width()); + ULONG nY = (ULONG) ((double) aWinSize.Height() + * (double) ZOOM_MULTIPLICATOR / (double) maViewSize.Height()); + + // Decide whether to take the larger or the smaller factor. + ULONG nFact; + if (mbCalcMinZoomByMinSide) + nFact = Min(nX, nY); + else + nFact = Max(nX, nY); + + // The factor is tansfomed according to the current zoom factor. + nFact = nFact * nZoom / ZOOM_MULTIPLICATOR; + mnMinZoom = Max((USHORT) MIN_ZOOM, (USHORT) nFact); + } + // If the current zoom factor is smaller than the calculated minimal + // zoom factor then set the new minimal factor as the current zoom + // factor. + if ( nZoom < (long) mnMinZoom ) + SetZoomFactor(mnMinZoom); + } +} + + + + +void Window::SetMinZoom (long int nMin) +{ + mnMinZoom = (USHORT) nMin; +} + + + + +long Window::GetMinZoom (void) const +{ + return mnMinZoom; +} + + + + +void Window::SetMaxZoom (long int nMax) +{ + mnMaxZoom = (USHORT) nMax; +} + + + + +long Window::GetMaxZoom (void) const +{ + return mnMaxZoom; +} + + + + +long Window::GetZoom (void) const +{ + if( GetMapMode().GetScaleX().GetDenominator() ) + { + return GetMapMode().GetScaleX().GetNumerator() * 100L + / GetMapMode().GetScaleX().GetDenominator(); + } + else + { + return 0; + } +} + + + + +/************************************************************************* +|* +|* Resize event +|* +\************************************************************************/ + +void Window::Resize() +{ + ::Window::Resize(); + CalcMinZoom(); + + if( mpViewShell && mpViewShell->GetViewFrame() ) + mpViewShell->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER ); +} + +/************************************************************************* +|* +|* PrePaint event +|* +\************************************************************************/ + +void Window::PrePaint() +{ + if ( mpViewShell ) + mpViewShell->PrePaint(); +} + +/************************************************************************* +|* +|* Paint event +|* +\************************************************************************/ + +void Window::Paint(const Rectangle& rRect) +{ + if ( mpViewShell ) + mpViewShell->Paint(rRect, this); +} + +/************************************************************************* +|* +|* Keyboard event +|* +\************************************************************************/ + +void Window::KeyInput(const KeyEvent& rKEvt) +{ + if (!(mpViewShell && mpViewShell->KeyInput(rKEvt, this))) + { + if (mpViewShell && rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE) + { + mpViewShell->GetViewShell()->Escape(); + } + else + { + ::Window::KeyInput(rKEvt); + } + } +} + +/************************************************************************* +|* +|* MouseButtonDown event +|* +\************************************************************************/ + +void Window::MouseButtonDown(const MouseEvent& rMEvt) +{ + if ( mpViewShell ) + mpViewShell->MouseButtonDown(rMEvt, this); +} + +/************************************************************************* +|* +|* MouseMove event +|* +\************************************************************************/ + +void Window::MouseMove(const MouseEvent& rMEvt) +{ + if ( mpViewShell ) + mpViewShell->MouseMove(rMEvt, this); +} + +/************************************************************************* +|* +|* MouseButtonUp event +|* +\************************************************************************/ + +void Window::MouseButtonUp(const MouseEvent& rMEvt) +{ + mnTicks = 0; + + if ( mpViewShell ) + mpViewShell->MouseButtonUp(rMEvt, this); +} + +/************************************************************************* +|* +|* Command event +|* +\************************************************************************/ + +void Window::Command(const CommandEvent& rCEvt) +{ + if ( mpViewShell ) + mpViewShell->Command(rCEvt, this); +} + +long Window::Notify( NotifyEvent& rNEvt ) +{ + long nResult = FALSE; + if ( mpViewShell ) + { + nResult = mpViewShell->Notify(rNEvt, this); + } + if( !nResult ) + ::Window::Notify( rNEvt ); + + return nResult; +} + + +/************************************************************************* +|* +|* RequestHelp event +|* +\************************************************************************/ + +void Window::RequestHelp(const HelpEvent& rEvt) +{ + if ( mpViewShell ) + { + if( !mpViewShell->RequestHelp( rEvt, this) ) + ::Window::RequestHelp( rEvt ); + } + else + ::Window::RequestHelp( rEvt ); +} + + + + +Point Window::GetWinViewPos (void) const +{ + return maWinPos; +} + + + + +Point Window::GetViewOrigin (void) const +{ + return maViewOrigin; +} + + + + +Size Window::GetViewSize (void) const +{ + return maViewSize; +} + + + + +/************************************************************************* +|* +|* Position der linken oberen Ecke des im Fenster sichtbaren Bereichs +|* setzen +|* +\************************************************************************/ + +void Window::SetWinViewPos(const Point& rPnt) +{ + maWinPos = rPnt; +} + +/************************************************************************* +|* +|* Ursprung der Darstellung in Bezug zur gesamten Arbeitsflaeche setzen +|* +\************************************************************************/ + +void Window::SetViewOrigin(const Point& rPnt) +{ + maViewOrigin = rPnt; +} + +/************************************************************************* +|* +|* Groesse der gesamten Arbeitsflaeche, die mit dem Fenster betrachtet +|* werden kann, setzen +|* +\************************************************************************/ + +void Window::SetViewSize(const Size& rSize) +{ + maViewSize = rSize; + CalcMinZoom(); +} + + + + +void Window::SetCenterAllowed (bool bIsAllowed) +{ + mbCenterAllowed = bIsAllowed; +} + + + + +long Window::SetZoomFactor(long nZoom) +{ + // Clip the zoom factor to the valid range marked by nMinZoom as + // calculated by CalcMinZoom() and the constant MAX_ZOOM. + if ( nZoom > MAX_ZOOM ) + nZoom = MAX_ZOOM; + if ( nZoom < (long) mnMinZoom ) + nZoom = mnMinZoom; + + // Set the zoom factor at the window's map mode. + MapMode aMap(GetMapMode()); + aMap.SetScaleX(Fraction(nZoom, 100)); + aMap.SetScaleY(Fraction(nZoom, 100)); + SetMapMode(aMap); + + // Update the map mode's origin (to what effect?). + UpdateMapOrigin(); + + // Update the view's snapping to the the new zoom factor. + if ( mpViewShell && mpViewShell->ISA(DrawViewShell) ) + ((DrawViewShell*) mpViewShell)->GetView()-> + RecalcLogicSnapMagnetic(*this); + + // Return the zoom factor just in case it has been changed above to lie + // inside the valid range. + return nZoom; +} + +void Window::SetZoomIntegral(long nZoom) +{ + // Clip the zoom factor to the valid range marked by nMinZoom as + // previously calculated by <member>CalcMinZoom()</member> and the + // MAX_ZOOM constant. + if ( nZoom > MAX_ZOOM ) + nZoom = MAX_ZOOM; + if ( nZoom < (long) mnMinZoom ) + nZoom = mnMinZoom; + + // Calculate the window's new origin. + Size aSize = PixelToLogic(GetOutputSizePixel()); + long nW = aSize.Width() * GetZoom() / nZoom; + long nH = aSize.Height() * GetZoom() / nZoom; + maWinPos.X() += (aSize.Width() - nW) / 2; + maWinPos.Y() += (aSize.Height() - nH) / 2; + if ( maWinPos.X() < 0 ) maWinPos.X() = 0; + if ( maWinPos.Y() < 0 ) maWinPos.Y() = 0; + + // Finally update this window's map mode to the given zoom factor that + // has been clipped to the valid range. + SetZoomFactor(nZoom); +} + +long Window::GetZoomForRect( const Rectangle& rZoomRect ) +{ + long nRetZoom = 100; + + if( (rZoomRect.GetWidth() != 0) && (rZoomRect.GetHeight() != 0)) + { + // Calculate the scale factors which will lead to the given + // rectangle being fully visible (when translated accordingly) as + // large as possible in the output area independently in both + // coordinate directions . + ULONG nX(0L); + ULONG nY(0L); + + const Size aWinSize( PixelToLogic(GetOutputSizePixel()) ); + if(rZoomRect.GetHeight()) + { + nX = (ULONG) ((double) aWinSize.Height() + * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetHeight()); + } + + if(rZoomRect.GetWidth()) + { + nY = (ULONG) ((double) aWinSize.Width() + * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetWidth()); + } + + // Use the smaller one of both so that the zoom rectangle will be + // fully visible with respect to both coordinate directions. + ULONG nFact = Min(nX, nY); + + // Transform the current zoom factor so that it leads to the desired + // scaling. + nRetZoom = nFact * GetZoom() / ZOOM_MULTIPLICATOR; + + // Calculate the new origin. + if ( nFact == 0 ) + { + // Don't change anything if the scale factor is degenrate. + nRetZoom = GetZoom(); + } + else + { + // Clip the zoom factor to the valid range marked by nMinZoom as + // previously calculated by <member>CalcMinZoom()</member> and the + // MAX_ZOOM constant. + if ( nRetZoom > MAX_ZOOM ) + nRetZoom = MAX_ZOOM; + if ( nRetZoom < (long) mnMinZoom ) + nRetZoom = mnMinZoom; + } + } + + return nRetZoom; +} + +/** Recalculate the zoom factor and translation so that the given rectangle + is displayed centered and as large as possible while still being fully + visible in the window. +*/ +long Window::SetZoomRect (const Rectangle& rZoomRect) +{ + long nNewZoom = 100; + + if (rZoomRect.GetWidth() == 0 || rZoomRect.GetHeight() == 0) + { + // The given rectangle is degenerate. Use the default zoom factor + // (above) of 100%. + SetZoomIntegral(nNewZoom); + } + else + { + Point aPos = rZoomRect.TopLeft(); + // Transform the output area from pixel coordinates into logical + // coordinates. + Size aWinSize = PixelToLogic(GetOutputSizePixel()); + // Paranoia! The degenerate case of zero width or height has been + // taken care of above. + DBG_ASSERT(rZoomRect.GetWidth(), "ZoomRect-Breite = 0!"); + DBG_ASSERT(rZoomRect.GetHeight(), "ZoomRect-Hoehe = 0!"); + + // Calculate the scale factors which will lead to the given + // rectangle being fully visible (when translated accordingly) as + // large as possible in the output area independently in both + // coordinate directions . + ULONG nX(0L); + ULONG nY(0L); + + if(rZoomRect.GetHeight()) + { + nX = (ULONG) ((double) aWinSize.Height() + * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetHeight()); + } + + if(rZoomRect.GetWidth()) + { + nY = (ULONG) ((double) aWinSize.Width() + * (double) ZOOM_MULTIPLICATOR / (double) rZoomRect.GetWidth()); + } + + // Use the smaller one of both so that the zoom rectangle will be + // fully visible with respect to both coordinate directions. + ULONG nFact = Min(nX, nY); + + // Transform the current zoom factor so that it leads to the desired + // scaling. + long nZoom = nFact * GetZoom() / ZOOM_MULTIPLICATOR; + + // Calculate the new origin. + if ( nFact == 0 ) + { + // Don't change anything if the scale factor is degenrate. + nNewZoom = GetZoom(); + } + else + { + // Calculate the new window position that centers the given + // rectangle on the screen. + if ( nZoom > MAX_ZOOM ) + nFact = nFact * MAX_ZOOM / nZoom; + + maWinPos = maViewOrigin + aPos; + + aWinSize.Width() = (long) ((double) aWinSize.Width() * (double) ZOOM_MULTIPLICATOR / (double) nFact); + maWinPos.X() += (rZoomRect.GetWidth() - aWinSize.Width()) / 2; + aWinSize.Height() = (long) ((double) aWinSize.Height() * (double) ZOOM_MULTIPLICATOR / (double) nFact); + maWinPos.Y() += (rZoomRect.GetHeight() - aWinSize.Height()) / 2; + + if ( maWinPos.X() < 0 ) maWinPos.X() = 0; + if ( maWinPos.Y() < 0 ) maWinPos.Y() = 0; + + // Adapt the window's map mode to the new zoom factor. + nNewZoom = SetZoomFactor(nZoom); + } + } + + return(nNewZoom); +} + + + + +void Window::SetMinZoomAutoCalc (bool bAuto) +{ + mbMinZoomAutoCalc = bAuto; +} + + + + +/************************************************************************* +|* +|* Neuen MapMode-Origin berechnen und setzen; wenn aWinPos.X()/Y() +|* gleich -1 ist, wird die entsprechende Position zentriert +|* (z.B. fuer Initialisierung) +|* +\************************************************************************/ + +void Window::UpdateMapOrigin(BOOL bInvalidate) +{ + BOOL bChanged = FALSE; + Size aWinSize = PixelToLogic(GetOutputSizePixel()); + + if ( mbCenterAllowed ) + { + if ( maWinPos.X() > maViewSize.Width() - aWinSize.Width() ) + { + maWinPos.X() = maViewSize.Width() - aWinSize.Width(); + bChanged = TRUE; + } + if ( maWinPos.Y() > maViewSize.Height() - aWinSize.Height() ) + { + maWinPos.Y() = maViewSize.Height() - aWinSize.Height(); + bChanged = TRUE; + } + if ( aWinSize.Width() > maViewSize.Width() || maWinPos.X() < 0 ) + { + maWinPos.X() = maViewSize.Width() / 2 - aWinSize.Width() / 2; + bChanged = TRUE; + } + if ( aWinSize.Height() > maViewSize.Height() || maWinPos.Y() < 0 ) + { + maWinPos.Y() = maViewSize.Height() / 2 - aWinSize.Height() / 2; + bChanged = TRUE; + } + } + + UpdateMapMode (); + + if (bChanged && bInvalidate) + Invalidate(); +} + + + + +void Window::UpdateMapMode (void) +{ + Size aWinSize = PixelToLogic(GetOutputSizePixel()); + maWinPos -= maViewOrigin; + Size aPix(maWinPos.X(), maWinPos.Y()); + aPix = LogicToPixel(aPix); + // Groesse muss vielfaches von BRUSH_SIZE sein, damit Muster + // richtig dargestellt werden + // #i2237# + // removed old stuff here which still forced zoom to be + // %BRUSH_SIZE which is outdated now + + if (mpViewShell && mpViewShell->ISA(DrawViewShell)) + { + Size aViewSizePixel = LogicToPixel(maViewSize); + Size aWinSizePixel = LogicToPixel(aWinSize); + + // Seite soll nicht am Fensterrand "kleben" + if (aPix.Width() == 0) + { + // #i2237# + // Since BRUSH_SIZE alignment is outdated now, i use the + // former constant here directly + aPix.Width() -= 8; + } + if (aPix.Height() == 0) + { + // #i2237# + // Since BRUSH_SIZE alignment is outdated now, i use the + // former constant here directly + aPix.Height() -= 8; + } + } + + aPix = PixelToLogic(aPix); + maWinPos.X() = aPix.Width(); + maWinPos.Y() = aPix.Height(); + Point aNewOrigin (-maWinPos.X(), -maWinPos.Y()); + maWinPos += maViewOrigin; + + MapMode aMap(GetMapMode()); + aMap.SetOrigin(aNewOrigin); + SetMapMode(aMap); +} + + + + +/************************************************************************* +|* +|* X-Position des sichtbaren Bereichs als Bruchteil (< 1) +|* der gesamten Arbeitsbereichbreite zuruegeben +|* +\************************************************************************/ + +double Window::GetVisibleX() +{ + return ((double) maWinPos.X() / maViewSize.Width()); +} + +/************************************************************************* +|* +|* Y-Position des sichtbaren Bereichs als Bruchteil (< 1) +|* der gesamten Arbeitsbereichhoehe zuruegeben +|* +\************************************************************************/ + +double Window::GetVisibleY() +{ + return ((double) maWinPos.Y() / maViewSize.Height()); +} + +/************************************************************************* +|* +|* X- und Y-Position des sichtbaren Bereichs als Bruchteile (< 1) +|* der gesamten Arbeitsbereichgroesse setzen +|* negative Werte werden ignoriert +|* +\************************************************************************/ + +void Window::SetVisibleXY(double fX, double fY) +{ + long nOldX = maWinPos.X(); + long nOldY = maWinPos.Y(); + + if ( fX >= 0 ) + maWinPos.X() = (long) (fX * maViewSize.Width()); + if ( fY >= 0 ) + maWinPos.Y() = (long) (fY * maViewSize.Height()); + UpdateMapOrigin(FALSE); + // Size sz(nOldX - aWinPos.X(), nOldY - aWinPos.Y()); + // sz = LogicToPixel(sz); + Scroll(nOldX - maWinPos.X(), nOldY - maWinPos.Y(), SCROLL_CHILDREN); + Update(); +} + +/************************************************************************* +|* +|* Breite des sichtbaren Bereichs im Verhaeltnis zur +|* gesamten Arbeitsbereichbreite zuruegeben +|* +\************************************************************************/ + +double Window::GetVisibleWidth() +{ + Size aWinSize = PixelToLogic(GetOutputSizePixel()); + if ( aWinSize.Width() > maViewSize.Width() ) + aWinSize.Width() = maViewSize.Width(); + return ((double) aWinSize.Width() / maViewSize.Width()); +} + +/************************************************************************* +|* +|* Hoehe des sichtbaren Bereichs im Verhaeltnis zur +|* gesamten Arbeitsbereichhoehe zuruegeben +|* +\************************************************************************/ + +double Window::GetVisibleHeight() +{ + Size aWinSize = PixelToLogic(GetOutputSizePixel()); + if ( aWinSize.Height() > maViewSize.Height() ) + aWinSize.Height() = maViewSize.Height(); + return ((double) aWinSize.Height() / maViewSize.Height()); +} + +/************************************************************************* +|* +|* Breite einer Scrollspalte im Verhaeltnis zur gesamten +|* Arbeitsbereichbreite zuruegeben +|* +\************************************************************************/ + +double Window::GetScrlLineWidth() +{ + return (GetVisibleWidth() * SCROLL_LINE_FACT); +} + +/************************************************************************* +|* +|* Breite einer Scrollspalte im Verhaeltnis zur gesamten +|* Arbeitsbereichhoehe zuruegeben +|* +\************************************************************************/ + +double Window::GetScrlLineHeight() +{ + return (GetVisibleHeight() * SCROLL_LINE_FACT); +} + +/************************************************************************* +|* +|* Breite einer Scrollpage im Verhaeltnis zur gesamten +|* Arbeitsbereichbreite zuruegeben +|* +\************************************************************************/ + +double Window::GetScrlPageWidth() +{ + return (GetVisibleWidth() * SCROLL_PAGE_FACT); +} + +/************************************************************************* +|* +|* Breite einer Scrollpage im Verhaeltnis zur gesamten +|* Arbeitsbereichhoehe zuruegeben +|* +\************************************************************************/ + +double Window::GetScrlPageHeight() +{ + return (GetVisibleHeight() * SCROLL_PAGE_FACT); +} + +/************************************************************************* +|* +|* Fenster deaktivieren +|* +\************************************************************************/ + +void Window::LoseFocus() +{ + mnTicks = 0; + ::Window::LoseFocus (); +} + +/************************************************************************* +|* +|* Fenster aktivieren +|* +\************************************************************************/ + +void Window::GrabFocus() +{ + mnTicks = 0; + ::Window::GrabFocus (); +} + + +/************************************************************************* +|* +|* DataChanged +|* +\************************************************************************/ + +void Window::DataChanged( const DataChangedEvent& rDCEvt ) +{ + ::Window::DataChanged( rDCEvt ); + + // PRINTER bei allen Dokumenten weglassen, die keinen Printer benutzen. + // FONTS und FONTSUBSTITUTION weglassen, wenn keine Textausgaben + // vorhanden sind, bzw. wenn das Dokument keinen Text zulaesst. + + if ( (rDCEvt.GetType() == DATACHANGED_PRINTER) || + (rDCEvt.GetType() == DATACHANGED_DISPLAY) || + (rDCEvt.GetType() == DATACHANGED_FONTS) || + (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || + ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && + (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) + { + if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && + (rDCEvt.GetFlags() & SETTINGS_STYLE) ) + { + // When the screen zoom factor has changed then reset the zoom + // factor of the frame to allways display the whole page. + const AllSettings* pOldSettings = rDCEvt.GetOldSettings (); + const AllSettings& rNewSettings = GetSettings (); + if (pOldSettings) + if (pOldSettings->GetStyleSettings().GetScreenZoom() + != rNewSettings.GetStyleSettings().GetScreenZoom()) + mpViewShell->GetViewFrame()->GetDispatcher()-> + Execute(SID_SIZE_PAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + + // ScrollBars neu anordnen bzw. Resize ausloesen, da sich + // ScrollBar-Groesse geaendert haben kann. Dazu muss dann im + // Resize-Handler aber auch die Groesse der ScrollBars aus + // den Settings abgefragt werden. + Resize(); + + // Daten neu Setzen, die aus den Systemeinstellungen bzw. aus + // den Settings uebernommen werden. Evtl. weitere Daten neu + // berechnen, da sich auch die Aufloesung hierdurch geaendert + // haben kann. + if( mpViewShell ) + { + const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); + SvtAccessibilityOptions aAccOptions; + ULONG nOutputMode; + USHORT nPreviewSlot; + + if( rStyleSettings.GetHighContrastMode() ) + nOutputMode = ViewShell::OUTPUT_DRAWMODE_CONTRAST; + else + nOutputMode = ViewShell::OUTPUT_DRAWMODE_COLOR; + + if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() ) + nPreviewSlot = SID_PREVIEW_QUALITY_CONTRAST; + else + nPreviewSlot = SID_PREVIEW_QUALITY_COLOR; + + if( mpViewShell->ISA( DrawViewShell ) ) + { + SetDrawMode( nOutputMode ); + mpViewShell->GetFrameView()->SetDrawMode( nOutputMode ); +// #110094#-7 +// mpViewShell->GetView()->ReleaseMasterPagePaintCache(); + Invalidate(); + } + + // #103100# Overwrite window color for OutlineView + if( mpViewShell->ISA(OutlineViewShell ) ) + { + svtools::ColorConfig aColorConfig; + const Color aDocColor( aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor ); + SetBackground( Wallpaper( aDocColor ) ); + } + + SfxRequest aReq( nPreviewSlot, 0, mpViewShell->GetDocSh()->GetDoc()->GetItemPool() ); + mpViewShell->ExecReq( aReq ); + mpViewShell->Invalidate(); + mpViewShell->ArrangeGUIElements(); + + // #101928# re-create handles to show new outfit + if(mpViewShell->ISA(DrawViewShell)) + { + mpViewShell->GetView()->AdjustMarkHdl(); + } + } + } + + if ( (rDCEvt.GetType() == DATACHANGED_DISPLAY) || + ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && + (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) + { + // Virtuelle Device die auch von der Aufloesung oder von + // Systemeinstellungen abhaengen, sollten geupdatet werden. + // Ansonsten sollte zumindest bei DATACHANGED_DISPLAY + // die virtuellen Devices geupdatet werden, da es einige + // Systeme erlauben die Aufloesung und Farbtiefe waehrend + // der Laufzeit zu aendern oder eben bei Palettenaenderungen + // die virtuellen Device geupdatet werden muessen, da bei + // Ausgaben ein anderes Farbmatching stattfinden kann. + } + + if ( rDCEvt.GetType() == DATACHANGED_FONTS ) + { + // Wenn das Dokument Font-AuswahlBoxen anbietet, muessen + // diese geupdatet werden. Wie dies genau aussehen muss, + // weiss ich leider auch nicht. Aber evtl. kann man das + // ja global handeln. Dies muessten wir evtl. mal + // mit PB absprechen, aber der ist derzeit leider Krank. + // Also bevor dies hier gehandelt wird, vorher mit + // PB und mir absprechen. + } + + if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || + (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ) + { + // Formatierung neu durchfuehren, da Fonts die im Dokument + // vorkommen, nicht mehr vorhanden sein muessen oder + // jetzt vorhanden sind oder durch andere ersetzt wurden + // sind. + if( mpViewShell ) + { + DrawDocShell* pDocSh = mpViewShell->GetDocSh(); + if( pDocSh ) + pDocSh->SetPrinter( pDocSh->GetPrinter( TRUE ) ); + } + } + + if ( rDCEvt.GetType() == DATACHANGED_PRINTER ) + { + // Wie hier die Behandlung aussehen soll, weiss ich leider + // selbst noch nicht. Evtl. mal einen Printer loeschen und + // schauen was gemacht werden muss. Evtl. muesste ich in + // VCL dafuer noch etwas einbauen, wenn der benutze Printer + // geloescht wird. Ansonsten wuerde ich hier evtl. die + // Formatierung neu berechnen, wenn der aktuelle Drucker + // zerstoert wurde. + if( mpViewShell ) + { + DrawDocShell* pDocSh = mpViewShell->GetDocSh(); + if( pDocSh ) + pDocSh->SetPrinter( pDocSh->GetPrinter( TRUE ) ); + } + } + + // Alles neu ausgeben + Invalidate(); + } +} + + + + +/************************************************************************* +|* +|* DropTargetHelper::AcceptDrop +|* +\************************************************************************/ + +sal_Int8 Window::AcceptDrop( const AcceptDropEvent& rEvt ) +{ + sal_Int8 nRet = DND_ACTION_NONE; + + if( mpViewShell && !mpViewShell->GetDocSh()->IsReadOnly() ) + { + if( mpViewShell ) + nRet = mpViewShell->AcceptDrop( rEvt, *this, this, SDRPAGE_NOTFOUND, SDRLAYER_NOTFOUND ); + + if (mbUseDropScroll && ! mpViewShell->ISA(OutlineViewShell)) + DropScroll( rEvt.maPosPixel ); + } + + return nRet; +} + +/************************************************************************* +|* +|* DropTargetHelper::ExecuteDrop +|* +\************************************************************************/ + +sal_Int8 Window::ExecuteDrop( const ExecuteDropEvent& rEvt ) +{ + sal_Int8 nRet = DND_ACTION_NONE; + + if( mpViewShell ) + { + nRet = mpViewShell->ExecuteDrop( rEvt, *this, this, SDRPAGE_NOTFOUND, SDRLAYER_NOTFOUND ); + } + + return nRet; +} + + + + +void Window::SetUseDropScroll (bool bUseDropScroll) +{ + mbUseDropScroll = bUseDropScroll; +} + + + + +/************************************************************************* +|* +|* Scrolling bei AcceptDrop-Events +|* +\************************************************************************/ + +void Window::DropScroll(const Point& rMousePos) +{ + short nDx = 0; + short nDy = 0; + + Size aSize = GetOutputSizePixel(); + + if (aSize.Width() > SCROLL_SENSITIVE * 3) + { + if ( rMousePos.X() < SCROLL_SENSITIVE ) + { + nDx = -1; + } + + if ( rMousePos.X() >= aSize.Width() - SCROLL_SENSITIVE ) + { + nDx = 1; + } + } + + if (aSize.Height() > SCROLL_SENSITIVE * 3) + { + if ( rMousePos.Y() < SCROLL_SENSITIVE ) + { + nDy = -1; + } + + if ( rMousePos.Y() >= aSize.Height() - SCROLL_SENSITIVE ) + { + nDy = 1; + } + } + + if ( (nDx || nDy) && (rMousePos.X()!=0 || rMousePos.Y()!=0 ) ) + { + if (mnTicks > 20) + mpViewShell->ScrollLines(nDx, nDy); + else + mnTicks ++; + } +} + + + + +::com::sun::star::uno::Reference< + ::com::sun::star::accessibility::XAccessible> + Window::CreateAccessible (void) +{ + if (mpViewShell != NULL) + return mpViewShell->CreateAccessibleDocumentView (this); + else + { + OSL_TRACE ("::sd::Window::CreateAccessible: no view shell"); + return ::Window::CreateAccessible (); + } +} + +XubString Window::GetSurroundingText() const +{ + if ( mpViewShell->GetShellType() == ViewShell::ST_OUTLINE ) + { + return XubString(); + } + else if ( mpViewShell->GetView()->IsTextEdit() ) + { + OutlinerView *pOLV = mpViewShell->GetView()->GetTextEditOutlinerView(); + return pOLV->GetEditView().GetSurroundingText(); + } + else + { + return XubString(); + } +} + +Selection Window::GetSurroundingTextSelection() const +{ + if ( mpViewShell->GetShellType() == ViewShell::ST_OUTLINE ) + { + return Selection( 0, 0 ); + } + else if ( mpViewShell->GetView()->IsTextEdit() ) + { + OutlinerView *pOLV = mpViewShell->GetView()->GetTextEditOutlinerView(); + return pOLV->GetEditView().GetSurroundingTextSelection(); + } + else + { + return Selection( 0, 0 ); + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/tabcontr.cxx b/sd/source/ui/view/tabcontr.cxx new file mode 100644 index 000000000000..d9d074eee395 --- /dev/null +++ b/sd/source/ui/view/tabcontr.cxx @@ -0,0 +1,464 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "TabControl.hxx" + +#include <sfx2/viewfrm.hxx> +#include <svx/svdlayer.hxx> +#include <svx/svdpagv.hxx> +#include <sfx2/dispatch.hxx> + + +#include "sdattr.hxx" +#include "app.hxx" +#include "app.hrc" +#include "glob.hrc" +#include "res_bmp.hrc" +#include "DrawViewShell.hxx" +#include "GraphicViewShell.hxx" +#include "helpids.h" +#include "View.hxx" +#include "sdpage.hxx" +#include "drawdoc.hxx" +#include "Window.hxx" +#include "unmodpg.hxx" +#include "DrawDocShell.hxx" +#include "sdresid.hxx" + + +namespace sd { + +#define SWITCH_TIMEOUT 20 + +// ----------------------------------------- +// - SdTabControl::SdPageObjsTransferable - +// ----------------------------------------- + +TabControl::TabControlTransferable::~TabControlTransferable() +{ +} + +// ----------------------------------------------------------------------------- + +void TabControl::TabControlTransferable::AddSupportedFormats() +{ + AddFormat( SOT_FORMATSTR_ID_STARDRAW_TABBAR ); +} + +// ----------------------------------------------------------------------------- + +sal_Bool TabControl::TabControlTransferable::GetData( const ::com::sun::star::datatransfer::DataFlavor& ) +{ + return sal_False; +} + +// ----------------------------------------------------------------------------- + +void TabControl::TabControlTransferable::DragFinished( sal_Int8 nDropAction ) +{ + mrParent.DragFinished( nDropAction ); +} + +/************************************************************************* +|* +|* Standard-Konstruktor +|* +\************************************************************************/ + +TabControl::TabControl(DrawViewShell* pViewSh, Window* pParent) : + TabBar( pParent, WinBits( WB_BORDER | WB_3DLOOK | WB_SCROLL | WB_SIZEABLE | WB_DRAG) ), + DragSourceHelper( this ), + DropTargetHelper( this ), + pDrViewSh(pViewSh), + bInternalMove(FALSE) +{ + EnableEditMode(); + SetSizePixel(Size(0, 0)); + SetMaxPageWidth( 150 ); + SetHelpId( HID_SD_TABBAR_PAGES ); +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +TabControl::~TabControl() +{ +} + +/************************************************************************* +|* +\************************************************************************/ + +void TabControl::Select() +{ + SfxDispatcher* pDispatcher = pDrViewSh->GetViewFrame()->GetDispatcher(); + pDispatcher->Execute(SID_SWITCHPAGE, SFX_CALLMODE_ASYNCHRON | + SFX_CALLMODE_RECORD); +} + +/************************************************************************* +|* +\************************************************************************/ + +void TabControl::MouseButtonDown(const MouseEvent& rMEvt) +{ + if (rMEvt.IsLeft() + && !rMEvt.IsMod1() + && !rMEvt.IsMod2() + && !rMEvt.IsShift()) + { + Point aPos = PixelToLogic( rMEvt.GetPosPixel() ); + USHORT aPageId = GetPageId(aPos); + + if (aPageId == 0) + { + SfxDispatcher* pDispatcher = pDrViewSh->GetViewFrame()->GetDispatcher(); + + pDispatcher->Execute(SID_INSERTPAGE_QUICK, + SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD); + } + } + + // A single left click with pressed control key on a tab page first + // switches to that page before the usual handling (copying with drag + // and drop) takes place. + else if (rMEvt.IsLeft() && rMEvt.IsMod1() && !rMEvt.IsMod2() && !rMEvt.IsShift()) + { + pDrViewSh->SwitchPage (GetPageId (rMEvt.GetPosPixel()) - 1); + } + + // When only the right button is pressed then first process a + // synthesized left button click to make the page the current one + // whose tab has been clicked. When then the actual right button + // click is processed the resulting context menu relates to the + // now current page. + if (rMEvt.IsRight() && ! rMEvt.IsLeft()) + { + MouseEvent aSyntheticEvent ( + rMEvt.GetPosPixel(), + rMEvt.GetClicks(), + rMEvt.GetMode(), + MOUSE_LEFT, + rMEvt.GetModifier()); + TabBar::MouseButtonDown(aSyntheticEvent); + } + + TabBar::MouseButtonDown(rMEvt); +} + +/************************************************************************* +|* +\************************************************************************/ + +void TabControl::DoubleClick() +{ + if (GetCurPageId() != 0) + { + SfxDispatcher* pDispatcher = pDrViewSh->GetViewFrame()->GetDispatcher(); + pDispatcher->Execute( SID_MODIFYPAGE, + SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD ); + } +} + +/************************************************************************* +|* +|* StartDrag-Request +|* +\************************************************************************/ + +void TabControl::StartDrag( sal_Int8, const Point& ) +{ + bInternalMove = TRUE; + + // object is delete by reference mechanismn + ( new TabControl::TabControlTransferable( *this ) )->StartDrag( this, DND_ACTION_COPYMOVE ); +} + +/************************************************************************* +|* +|* DragFinished +|* +\************************************************************************/ + +void TabControl::DragFinished( sal_Int8 ) +{ + bInternalMove = FALSE; +} + +/************************************************************************* +|* +|* AcceptDrop-Event +|* +\************************************************************************/ + +sal_Int8 TabControl::AcceptDrop( const AcceptDropEvent& rEvt ) +{ + sal_Int8 nRet = DND_ACTION_NONE; + + if( rEvt.mbLeaving ) + EndSwitchPage(); + + if( !pDrViewSh->GetDocSh()->IsReadOnly() ) + { + SdDrawDocument* pDoc = pDrViewSh->GetDoc(); + Point aPos( rEvt.maPosPixel ); + + if( bInternalMove ) + { + if( rEvt.mbLeaving || ( pDrViewSh->GetEditMode() == EM_MASTERPAGE ) ) + HideDropPos(); + else + { + ShowDropPos( aPos ); + nRet = rEvt.mnAction; + } + } + else + { + HideDropPos(); + + sal_Int32 nPageId = GetPageId( aPos ) - 1; + + if( ( nPageId >= 0 ) && pDoc->GetPage( (USHORT)nPageId ) ) + { + nRet = pDrViewSh->AcceptDrop( rEvt, *this, NULL, (USHORT)nPageId, SDRLAYER_NOTFOUND ); + SwitchPage( aPos ); + } + } + } + + return nRet; +} + +/************************************************************************* +|* +|* ExecuteDrop-Event +|* +\************************************************************************/ + +sal_Int8 TabControl::ExecuteDrop( const ExecuteDropEvent& rEvt ) +{ + SdDrawDocument* pDoc = pDrViewSh->GetDoc(); + Point aPos( rEvt.maPosPixel ); + sal_Int8 nRet = DND_ACTION_NONE; + + if( bInternalMove ) + { + USHORT nPageId = ShowDropPos( aPos ) - 1; + + switch (rEvt.mnAction) + { + case DND_ACTION_MOVE: + if( pDrViewSh->IsSwitchPageAllowed() && pDoc->MovePages( nPageId ) ) + { + SfxDispatcher* pDispatcher = pDrViewSh->GetViewFrame()->GetDispatcher(); + pDispatcher->Execute(SID_SWITCHPAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + } + break; + + case DND_ACTION_COPY: + { + // Copying the selected page to the place that rEvt points + // takes place in three steps: + // 1. Create a copy of the selected page. This copy will + // lie directly behind the selected page. + // 2. Move the copy to the desired place. + // 3. Select the copy. + if (pDrViewSh->IsSwitchPageAllowed()) + { + // 1. Create a copy. + USHORT nPageNumOfCopy = pDoc->DuplicatePage (GetCurPageId() - 1); + // 2. Move page. For this first switch to the copy: + // MovePages operates on the currently selected page(s). + pDrViewSh->SwitchPage (nPageNumOfCopy); + // Adapt target page id when necessary, i.e. page copy + // has been inserted in front of the target page. + USHORT nPageNum = nPageId; + if ((nPageNumOfCopy <= nPageNum) && (nPageNum != (USHORT)-1)) + nPageNum += 1; + if (pDoc->MovePages(nPageNum)) + { + // 3. Switch to the copy that has been moved to its + // final destination. Use an asynchron slot call to + // be executed after the still pending ones. + if (nPageNumOfCopy >= nPageNum || (nPageNum == (USHORT)-1)) + nPageNum += 1; + SetCurPageId (GetPageId(nPageNum)); + SfxDispatcher* pDispatcher = pDrViewSh->GetViewFrame()->GetDispatcher(); + pDispatcher->Execute(SID_SWITCHPAGE, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + } + } + + break; + } + } + + nRet = rEvt.mnAction; + } + else + { + sal_Int32 nPageId = GetPageId( aPos ) - 1; + + if( ( nPageId >= 0 ) && pDoc->GetPage( (USHORT)nPageId ) ) + { + nRet = pDrViewSh->ExecuteDrop( rEvt, *this, NULL, (USHORT)nPageId, SDRLAYER_NOTFOUND ); + } + } + + HideDropPos(); + EndSwitchPage(); + + return nRet; +} + +/************************************************************************* +|* +\************************************************************************/ + +void TabControl::Command(const CommandEvent& rCEvt) +{ + USHORT nCmd = rCEvt.GetCommand(); + + if ( nCmd == COMMAND_CONTEXTMENU ) + { + BOOL bGraphicShell = pDrViewSh->ISA(GraphicViewShell); + USHORT nResId = bGraphicShell ? RID_GRAPHIC_PAGETAB_POPUP : + RID_DRAW_PAGETAB_POPUP; + SfxDispatcher* pDispatcher = pDrViewSh->GetViewFrame()->GetDispatcher(); + pDispatcher->ExecutePopup( SdResId( nResId ) ); + } +} + +/************************************************************************* +|* +\************************************************************************/ + +long TabControl::StartRenaming() +{ + BOOL bOK = FALSE; + + if (pDrViewSh->GetPageKind() == PK_STANDARD) + { + bOK = TRUE; + + ::sd::View* pView = pDrViewSh->GetView(); + + if ( pView->IsTextEdit() ) + pView->SdrEndTextEdit(); + } + + return( bOK ); +} + +/************************************************************************* +|* +\************************************************************************/ + +long TabControl::AllowRenaming() +{ + BOOL bOK = TRUE; + + String aNewName( GetEditText() ); + String aCompareName( GetPageText( GetEditPageId() ) ); + + if( aCompareName != aNewName ) + { + // Seite umbenennen + if( pDrViewSh->GetDocSh()->CheckPageName( this, aNewName ) ) + { + SetEditText( aNewName ); + EndRenaming(); + } + else + { + bOK = FALSE; + } + } + return( bOK ); +} + +/************************************************************************* +|* +\************************************************************************/ + +void TabControl::EndRenaming() +{ + if( !IsEditModeCanceled() ) + pDrViewSh->RenameSlide( GetEditPageId(), GetEditText() ); +} + + +/************************************************************************* +|* +\************************************************************************/ + +void TabControl::ActivatePage() +{ + if ( /*IsInSwitching && */ pDrViewSh->IsSwitchPageAllowed() ) + { + SfxDispatcher* pDispatcher = pDrViewSh->GetViewFrame()->GetDispatcher(); + pDispatcher->Execute(SID_SWITCHPAGE, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + } +} + + +/************************************************************************* +|* +\************************************************************************/ + +long TabControl::DeactivatePage() +{ + return pDrViewSh->IsSwitchPageAllowed(); +} + + + + +void TabControl::SendActivatePageEvent (void) +{ + CallEventListeners (VCLEVENT_TABBAR_PAGEACTIVATED, + reinterpret_cast<void*>(GetCurPageId())); +} + + + + +void TabControl::SendDeactivatePageEvent (void) +{ + CallEventListeners (VCLEVENT_TABBAR_PAGEDEACTIVATED, + reinterpret_cast<void*>(GetCurPageId())); +} + +} // end of namespace sd diff --git a/sd/source/ui/view/unmodpg.cxx b/sd/source/ui/view/unmodpg.cxx new file mode 100644 index 000000000000..5a7f9830895e --- /dev/null +++ b/sd/source/ui/view/unmodpg.cxx @@ -0,0 +1,249 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#ifndef _SVDLAYER +#include <svx/svdlayer.hxx> +#endif +#include <sfx2/dispatch.hxx> +#include <sfx2/viewfrm.hxx> + + +#include "strings.hrc" +#include "glob.hxx" +#include "glob.hrc" // STR_BCKGRND, STR_BCKGRNDOBJ +#include "app.hrc" // SID_SWITCHPAGE + +#include "unmodpg.hxx" +#include "sdpage.hxx" +#include "sdresid.hxx" +#include "drawdoc.hxx" + + +TYPEINIT1(ModifyPageUndoAction, SdUndoAction); + + +/************************************************************************* +|* +|* Konstruktor +|* +\************************************************************************/ + +ModifyPageUndoAction::ModifyPageUndoAction( + SfxUndoManager* pTheManager, // #67720# + SdDrawDocument* pTheDoc, + SdPage* pThePage, + String aTheNewName, + AutoLayout eTheNewAutoLayout, + BOOL bTheNewBckgrndVisible, + BOOL bTheNewBckgrndObjsVisible) +: SdUndoAction(pTheDoc), + mpManager(pTheManager) +{ + DBG_ASSERT(pThePage, "Undo ohne Seite ???"); + + mpPage = pThePage; + maNewName = aTheNewName; + meNewAutoLayout = eTheNewAutoLayout; + mbNewBckgrndVisible = bTheNewBckgrndVisible; + mbNewBckgrndObjsVisible = bTheNewBckgrndObjsVisible; + + meOldAutoLayout = mpPage->GetAutoLayout(); + + if (!mpPage->IsMasterPage()) + { + maOldName = mpPage->GetName(); + SdrLayerAdmin& rLayerAdmin = mpDoc->GetLayerAdmin(); + BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE); + BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE); + SetOfByte aVisibleLayers = mpPage->TRG_GetMasterPageVisibleLayers(); + + mbOldBckgrndVisible = aVisibleLayers.IsSet(aBckgrnd); + mbOldBckgrndObjsVisible = aVisibleLayers.IsSet(aBckgrndObj); + } + + maComment = String(SdResId(STR_UNDO_MODIFY_PAGE)); +} + +/************************************************************************* +|* +|* Undo() +|* +\************************************************************************/ +#include <svx/svdviter.hxx> +#include <svx/svdview.hxx> +void ModifyPageUndoAction::Undo() +{ + // #94637# invalidate Selection, there could be objects deleted in tis UNDO + // which are no longer allowed to be selected then. + SdrViewIter aIter(mpPage); + SdrView* pView = aIter.FirstView(); + + while(pView) + { + if(pView->AreObjectsMarked()) + pView->UnmarkAll(); + pView = aIter.NextView(); + } + + mpPage->SetAutoLayout( meOldAutoLayout ); + + if (!mpPage->IsMasterPage()) + { + if (mpPage->GetName() != maOldName) + { + mpPage->SetName(maOldName); + + if (mpPage->GetPageKind() == PK_STANDARD) + { + SdPage* pNotesPage = (SdPage*)mpDoc->GetPage(mpPage->GetPageNum() + 1); + pNotesPage->SetName(maOldName); + } + } + + SdrLayerAdmin& rLayerAdmin = mpDoc->GetLayerAdmin(); + BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE); + BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE); + SetOfByte aVisibleLayers; + aVisibleLayers.Set(aBckgrnd, mbOldBckgrndVisible); + aVisibleLayers.Set(aBckgrndObj, mbOldBckgrndObjsVisible); + mpPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers); + } + + // Redisplay + SfxViewFrame::Current()->GetDispatcher()->Execute( + SID_SWITCHPAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD ); +} + +/************************************************************************* +|* +|* Redo() +|* +\************************************************************************/ + +void ModifyPageUndoAction::Redo() +{ + // #94637# invalidate Selection, there could be objects deleted in tis UNDO + // which are no longer allowed to be selected then. + SdrViewIter aIter(mpPage); + SdrView* pView = aIter.FirstView(); + + while(pView) + { + if(pView->AreObjectsMarked()) + pView->UnmarkAll(); + pView = aIter.NextView(); + } + + mpPage->meAutoLayout = meNewAutoLayout; + + if (!mpPage->IsMasterPage()) + { + if (mpPage->GetName() != maNewName) + { + mpPage->SetName(maNewName); + + if (mpPage->GetPageKind() == PK_STANDARD) + { + SdPage* pNotesPage = (SdPage*)mpDoc->GetPage(mpPage->GetPageNum() + 1); + pNotesPage->SetName(maNewName); + } + } + + SdrLayerAdmin& rLayerAdmin = mpDoc->GetLayerAdmin(); + BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE); + BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE); + SetOfByte aVisibleLayers; + aVisibleLayers.Set(aBckgrnd, mbNewBckgrndVisible); + aVisibleLayers.Set(aBckgrndObj, mbNewBckgrndObjsVisible); + mpPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers); + } + + // Redisplay + SfxViewFrame::Current()->GetDispatcher()->Execute( + SID_SWITCHPAGE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD ); +} + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +ModifyPageUndoAction::~ModifyPageUndoAction() +{ +} + +/************************************************************************* +|* +|* Kommentar liefern +|* +\************************************************************************/ + +String ModifyPageUndoAction::GetComment() const +{ + return maComment; +} + +// -------------------------------------------------------------------- + +RenameLayoutTemplateUndoAction::RenameLayoutTemplateUndoAction( SdDrawDocument* pDocument, const String& rOldLayoutName, const String& rNewLayoutName ) +: SdUndoAction(pDocument) +, maOldName( rOldLayoutName ) +, maNewName( rNewLayoutName ) +, maComment(SdResId(STR_TITLE_RENAMESLIDE)) +{ + USHORT nPos = maOldName.SearchAscii( SD_LT_SEPARATOR ); + if( nPos != (USHORT)-1 ) + maOldName.Erase(nPos); +} + +void RenameLayoutTemplateUndoAction::Undo() +{ + String aLayoutName( maNewName ); + aLayoutName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( SD_LT_SEPARATOR )); + aLayoutName.Append( String(SdResId(STR_LAYOUT_OUTLINE))) ; + + mpDoc->RenameLayoutTemplate( aLayoutName, maOldName ); +} + +void RenameLayoutTemplateUndoAction::Redo() +{ + String aLayoutName( maOldName ); + aLayoutName.AppendAscii( RTL_CONSTASCII_STRINGPARAM( SD_LT_SEPARATOR )); + aLayoutName.Append( String(SdResId(STR_LAYOUT_OUTLINE))) ; + + mpDoc->RenameLayoutTemplate( aLayoutName, maNewName ); +} + +String RenameLayoutTemplateUndoAction::GetComment() const +{ + return maComment; +} + diff --git a/sd/source/ui/view/viewoverlaymanager.cxx b/sd/source/ui/view/viewoverlaymanager.cxx new file mode 100755 index 000000000000..447f50ec2222 --- /dev/null +++ b/sd/source/ui/view/viewoverlaymanager.cxx @@ -0,0 +1,619 @@ +/************************************************************************* + * + * 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: $ + * $Revision: $ + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "sddll.hxx" + +#include <com/sun/star/frame/XFrame.hpp> +#include <sfx2/imagemgr.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/app.hxx> +#include <sfx2/request.hxx> +#include <sfx2/dispatch.hxx> + +#include <tools/rcid.h> + +#include <vcl/help.hxx> +#include <vcl/imagerepository.hxx> +#include <vcl/lazydelete.hxx> + +#include <svx/sdrpagewindow.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <svx/sdr/overlay/overlayanimatedbitmapex.hxx> +#include <svx/sdr/overlay/overlaybitmapex.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <svx/svxids.hrc> + +#include "view/viewoverlaymanager.hxx" + +#include "res_bmp.hrc" +#include "DrawDocShell.hxx" +#include "DrawViewShell.hxx" +#include "DrawController.hxx" +#include "glob.hrc" +#include "strings.hrc" +#include "sdresid.hxx" +#include "EventMultiplexer.hxx" +#include "ViewShellManager.hxx" +#include "helpids.h" +#include "sdpage.hxx" +#include "drawdoc.hxx" +#include "smarttag.hxx" + +using ::rtl::OUString; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::frame; + +namespace sd { + +class ImageButtonHdl; + +// -------------------------------------------------------------------- + +static USHORT gButtonSlots[] = { SID_INSERT_TABLE, SID_INSERT_DIAGRAM, SID_INSERT_GRAPHIC, SID_INSERT_AVMEDIA }; +static USHORT gButtonToolTips[] = { STR_INSERT_TABLE, STR_INSERT_CHART, STR_INSERT_PICTURE, STR_INSERT_MOVIE }; + +// -------------------------------------------------------------------- + +static BitmapEx loadImageResource( USHORT nId ) +{ + SdResId aResId( nId ); + aResId.SetRT( RSC_BITMAP ); + + return BitmapEx( aResId ); +} + +// -------------------------------------------------------------------- + +static BitmapEx* getButtonImage( int index, bool large ) +{ + static vcl::DeleteOnDeinit< BitmapEx > gSmallButtonImages[BMP_PLACEHOLDER_SMALL_END - BMP_PLACEHOLDER_SMALL_START] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + static vcl::DeleteOnDeinit< BitmapEx > gLargeButtonImages[BMP_PLACEHOLDER_LARGE_END - BMP_PLACEHOLDER_LARGE_START] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + + if( !gSmallButtonImages[0].get() ) + { + for( sal_uInt16 i = 0; i < (BMP_PLACEHOLDER_SMALL_END-BMP_PLACEHOLDER_SMALL_START); i++ ) + { + gSmallButtonImages[i].set( new BitmapEx( loadImageResource( BMP_PLACEHOLDER_SMALL_START + i ) ) ); + gLargeButtonImages[i].set( new BitmapEx( loadImageResource( BMP_PLACEHOLDER_LARGE_START + i ) ) ); + } + } + + if( large ) + { + return gLargeButtonImages[index].get(); + } + else + { + return gSmallButtonImages[index].get(); + } +} + +// -------------------------------------------------------------------- + +const sal_uInt32 SMART_TAG_HDL_NUM = SAL_MAX_UINT32; + +class ChangePlaceholderTag : public SmartTag +{ + friend class ImageButtonHdl; +public: + ChangePlaceholderTag( ViewOverlayManager& rManager, ::sd::View& rView, SdrObject& rPlaceholderObj ); + virtual ~ChangePlaceholderTag(); + + /** returns true if the SmartTag handled the event. */ + virtual bool MouseButtonDown( const MouseEvent&, SmartHdl& ); + + /** returns true if the SmartTag consumes this event. */ + virtual bool KeyInput( const KeyEvent& rKEvt ); + + BitmapEx createOverlayImage( int nHighlight = -1 ); + +protected: + virtual void addCustomHandles( SdrHdlList& rHandlerList ); + virtual void disposing(); + virtual void select(); + virtual void deselect(); + +private: + ViewOverlayManager& mrManager; + SdrObjectWeakRef mxPlaceholderObj; +}; + +class ImageButtonHdl : public SmartHdl +{ +public: + ImageButtonHdl( const SmartTagReference& xTag, /* USHORT nSID, const Image& rImage, const Image& rImageMO, */ const Point& rPnt ); + virtual ~ImageButtonHdl(); + virtual void CreateB2dIAObject(); + virtual BOOL IsFocusHdl() const; + virtual Pointer GetPointer() const; + virtual bool isMarkable() const; + + virtual void onMouseEnter(const MouseEvent& rMEvt); + virtual void onMouseLeave(); + + int getHighlightId() const { return mnHighlightId; } + + void HideTip(); + +private: + rtl::Reference< ChangePlaceholderTag > mxTag; + + int mnHighlightId; + Size maImageSize; + ULONG mnTip; +}; + +// -------------------------------------------------------------------- + +ImageButtonHdl::ImageButtonHdl( const SmartTagReference& xTag /*, USHORT nSID, const Image& rImage, const Image& rImageMO*/, const Point& rPnt ) +: SmartHdl( xTag, rPnt ) +, mxTag( dynamic_cast< ChangePlaceholderTag* >( xTag.get() ) ) +, mnHighlightId( -1 ) +, maImageSize( 42, 42 ) +, mnTip( 0 ) +{ +} + +// -------------------------------------------------------------------- + +ImageButtonHdl::~ImageButtonHdl() +{ + HideTip(); +} + +// -------------------------------------------------------------------- + +void ImageButtonHdl::HideTip() +{ + if( mnTip ) + { + Help::HideTip( mnTip ); + mnTip = 0; + } +} + +// -------------------------------------------------------------------- + +extern ::rtl::OUString ImplRetrieveLabelFromCommand( const Reference< XFrame >& xFrame, const OUString& aCmdURL ); + +void ImageButtonHdl::onMouseEnter(const MouseEvent& rMEvt) +{ + int nHighlightId = 0; + + if( pHdlList && pHdlList->GetView()) + { + OutputDevice* pDev = pHdlList->GetView()->GetFirstOutputDevice(); + if( pDev == 0 ) + pDev = Application::GetDefaultDevice(); + + Point aMDPos( rMEvt.GetPosPixel() ); + aMDPos -= pDev->LogicToPixel( GetPos() ); + + nHighlightId += aMDPos.X() > maImageSize.Width() ? 1 : 0; + nHighlightId += aMDPos.Y() > maImageSize.Height() ? 2 : 0; + + if( mnHighlightId != nHighlightId ) + { + HideTip(); + + mnHighlightId = nHighlightId; + + if( pHdlList ) + { + SdResId aResId( gButtonToolTips[mnHighlightId] ); + aResId.SetRT( RSC_STRING ); + + String aHelpText( aResId ); + Rectangle aScreenRect( pDev->LogicToPixel( GetPos() ), maImageSize ); + mnTip = Help::ShowTip( static_cast< ::Window* >( pHdlList->GetView()->GetFirstOutputDevice() ), aScreenRect, aHelpText, 0 ) ; + } + Touch(); + } + } +} + +// -------------------------------------------------------------------- + +void ImageButtonHdl::onMouseLeave() +{ + mnHighlightId = -1; + HideTip(); + Touch(); +} + +// -------------------------------------------------------------------- + +void ImageButtonHdl::CreateB2dIAObject() +{ + // first throw away old one + GetRidOfIAObject(); + + const Point aTagPos( GetPos() ); + basegfx::B2DPoint aPosition( aTagPos.X(), aTagPos.Y() ); + + BitmapEx aBitmapEx( mxTag->createOverlayImage( mnHighlightId ) ); // maImageMO.GetBitmapEx() : maImage.GetBitmapEx() ); + maImageSize = aBitmapEx.GetSizePixel(); + maImageSize.Width() >>= 1; + maImageSize.Height() >>= 1; + + if(pHdlList) + { + SdrMarkView* pView = pHdlList->GetView(); + + if(pView && !pView->areMarkHandlesHidden()) + { + SdrPageView* pPageView = pView->GetSdrPageView(); + + if(pPageView) + { + for(sal_uInt32 b = 0; b < pPageView->PageWindowCount(); b++) + { + const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(b); + + SdrPaintWindow& rPaintWindow = rPageWindow.GetPaintWindow(); + if(rPaintWindow.OutputToWindow() && rPageWindow.GetOverlayManager() ) + { + ::sdr::overlay::OverlayObject* pOverlayObject = 0; + + pOverlayObject = new ::sdr::overlay::OverlayBitmapEx( aPosition, aBitmapEx, 0, 0 ); + rPageWindow.GetOverlayManager()->add(*pOverlayObject); + maOverlayGroup.append(*pOverlayObject); + } + } + } + } + } +} + +// -------------------------------------------------------------------- + +BOOL ImageButtonHdl::IsFocusHdl() const +{ + return false; +} + +// -------------------------------------------------------------------- + +bool ImageButtonHdl::isMarkable() const +{ + return false; +} + +// -------------------------------------------------------------------- + +Pointer ImageButtonHdl::GetPointer() const +{ + return Pointer( POINTER_ARROW ); +} + +// ==================================================================== + +ChangePlaceholderTag::ChangePlaceholderTag( ViewOverlayManager& rManager, ::sd::View& rView, SdrObject& rPlaceholderObj ) +: SmartTag( rView ) +, mrManager( rManager ) +, mxPlaceholderObj( &rPlaceholderObj ) +{ +} + +// -------------------------------------------------------------------- + +ChangePlaceholderTag::~ChangePlaceholderTag() +{ +} + +// -------------------------------------------------------------------- + +/** returns true if the ChangePlaceholderTag handled the event. */ +bool ChangePlaceholderTag::MouseButtonDown( const MouseEvent& /*rMEvt*/, SmartHdl& rHdl ) +{ + int nHighlightId = static_cast< ImageButtonHdl& >(rHdl).getHighlightId(); + if( nHighlightId >= 0 ) + { + USHORT nSID = gButtonSlots[nHighlightId]; + + if( mxPlaceholderObj.get() ) + { + // mark placeholder if it is not currently marked (or if also others are marked) + if( !mrView.IsObjMarked( mxPlaceholderObj.get() ) || (mrView.GetMarkedObjectList().GetMarkCount() != 1) ) + { + SdrPageView* pPV = mrView.GetSdrPageView(); + mrView.UnmarkAllObj(pPV ); + mrView.MarkObj(mxPlaceholderObj.get(), pPV, FALSE); + } + } + + mrView.GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( nSID, SFX_CALLMODE_ASYNCHRON); + } + return false; +} + +// -------------------------------------------------------------------- + +/** returns true if the SmartTag consumes this event. */ +bool ChangePlaceholderTag::KeyInput( const KeyEvent& rKEvt ) +{ + USHORT nCode = rKEvt.GetKeyCode().GetCode(); + switch( nCode ) + { + case KEY_DOWN: + case KEY_UP: + case KEY_LEFT: + case KEY_RIGHT: + case KEY_ESCAPE: + case KEY_TAB: + case KEY_RETURN: + case KEY_SPACE: + default: + return false; + } +} + +// -------------------------------------------------------------------- + +BitmapEx ChangePlaceholderTag::createOverlayImage( int nHighlight ) +{ + BitmapEx aRet; + if( mxPlaceholderObj.is() ) + { + SdrObject* pPlaceholder = mxPlaceholderObj.get(); + SmartTagReference xThis( this ); + const Rectangle& rSnapRect = pPlaceholder->GetSnapRect(); + const Point aPoint; + + OutputDevice* pDev = mrView.GetFirstOutputDevice(); + if( pDev == 0 ) + pDev = Application::GetDefaultDevice(); + + Size aShapeSizePix = pDev->LogicToPixel(rSnapRect.GetSize()); + long nShapeSizePix = std::min(aShapeSizePix.Width(),aShapeSizePix.Height()); + + bool bLarge = nShapeSizePix > 250; + + Size aSize( getButtonImage( 0, bLarge )->GetSizePixel() ); + + aRet.SetSizePixel( Size( aSize.Width() << 1, aSize.Height() << 1 ) ); + + const Rectangle aRectSrc( Point( 0, 0 ), aSize ); + + aRet = *(getButtonImage((nHighlight == 0) ? 4 : 0, bLarge)); + aRet.Expand( aSize.Width(), aSize.Height(), NULL, TRUE ); + + aRet.CopyPixel( Rectangle( Point( aSize.Width(), 0 ), aSize ), aRectSrc, getButtonImage((nHighlight == 1) ? 5 : 1, bLarge) ); + aRet.CopyPixel( Rectangle( Point( 0, aSize.Height() ), aSize ), aRectSrc, getButtonImage((nHighlight == 2) ? 6 : 2, bLarge) ); + aRet.CopyPixel( Rectangle( Point( aSize.Width(), aSize.Height() ), aSize ), aRectSrc, getButtonImage((nHighlight == 3) ? 7 : 3, bLarge) ); + } + + return aRet; +} + +void ChangePlaceholderTag::addCustomHandles( SdrHdlList& rHandlerList ) +{ + if( mxPlaceholderObj.is() ) + { + SdrObject* pPlaceholder = mxPlaceholderObj.get(); + SmartTagReference xThis( this ); + const Rectangle& rSnapRect = pPlaceholder->GetSnapRect(); + const Point aPoint; + + OutputDevice* pDev = mrView.GetFirstOutputDevice(); + if( pDev == 0 ) + pDev = Application::GetDefaultDevice(); + + Size aShapeSizePix = pDev->LogicToPixel(rSnapRect.GetSize()); + long nShapeSizePix = std::min(aShapeSizePix.Width(),aShapeSizePix.Height()); + if( 50 > nShapeSizePix ) + return; + + bool bLarge = nShapeSizePix > 250; + + Size aButtonSize( pDev->PixelToLogic( getButtonImage(0, bLarge )->GetSizePixel()) ); + + const int nColumns = 2; + const int nRows = 2; + + long all_width = nColumns * aButtonSize.Width(); + long all_height = nRows * aButtonSize.Height(); + + Point aPos( rSnapRect.Center() ); + aPos.X() -= all_width >> 1; + aPos.Y() -= all_height >> 1; + + ImageButtonHdl* pHdl = new ImageButtonHdl( xThis, aPoint ); + pHdl->SetObjHdlNum( SMART_TAG_HDL_NUM ); + pHdl->SetPageView( mrView.GetSdrPageView() ); + + pHdl->SetPos( aPos ); + + rHandlerList.AddHdl( pHdl ); + } +} + +// -------------------------------------------------------------------- + +void ChangePlaceholderTag::disposing() +{ + SmartTag::disposing(); +} + +// -------------------------------------------------------------------- + +void ChangePlaceholderTag::select() +{ + SmartTag::select(); +} + +// -------------------------------------------------------------------- + +void ChangePlaceholderTag::deselect() +{ + SmartTag::deselect(); +} + +// -------------------------------------------------------------------- + +ViewOverlayManager::ViewOverlayManager( ViewShellBase& rViewShellBase ) +: mrBase( rViewShellBase ) +, mnUpdateTagsEvent( 0 ) +{ + Link aLink( LINK(this,ViewOverlayManager,EventMultiplexerListener) ); + mrBase.GetEventMultiplexer()->AddEventListener(aLink, tools::EventMultiplexerEvent::EID_CURRENT_PAGE + | tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED + | tools::EventMultiplexerEvent::EID_VIEW_ADDED + | tools::EventMultiplexerEvent::EID_BEGIN_TEXT_EDIT + | tools::EventMultiplexerEvent::EID_END_TEXT_EDIT ); + + StartListening( *mrBase.GetDocShell() ); +} + +// -------------------------------------------------------------------- + +ViewOverlayManager::~ViewOverlayManager() +{ + Link aLink( LINK(this,ViewOverlayManager,EventMultiplexerListener) ); + mrBase.GetEventMultiplexer()->RemoveEventListener( aLink ); + + if( mnUpdateTagsEvent ) + { + Application::RemoveUserEvent( mnUpdateTagsEvent ); + mnUpdateTagsEvent = 0; + } + + DisposeTags(); +} + +// -------------------------------------------------------------------- + +void ViewOverlayManager::Notify(SfxBroadcaster&, const SfxHint& rHint) +{ + const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>(&rHint); + if (pSimpleHint != NULL) + { + if (pSimpleHint->GetId() == SFX_HINT_DOCCHANGED) + { + UpdateTags(); + } + } +} + +void ViewOverlayManager::onZoomChanged() +{ + if( !maTagVector.empty() ) + { + UpdateTags(); + } +} + +void ViewOverlayManager::UpdateTags() +{ + if( !mnUpdateTagsEvent ) + mnUpdateTagsEvent = Application::PostUserEvent( LINK( this, ViewOverlayManager, UpdateTagsHdl ) ); +} + +IMPL_LINK(ViewOverlayManager,UpdateTagsHdl, void *, EMPTYARG) +{ + OSL_TRACE("ViewOverlayManager::UpdateTagsHdl"); + + mnUpdateTagsEvent = 0; + bool bChanges = DisposeTags(); + bChanges |= CreateTags(); + + if( bChanges && mrBase.GetDrawView() ) + static_cast< ::sd::View* >( mrBase.GetDrawView() )->updateHandles(); + return 0; +} + +bool ViewOverlayManager::CreateTags() +{ + bool bChanges = false; + + SdPage* pPage = mrBase.GetMainViewShell()->getCurrentPage(); + + if( pPage ) + { + const std::list< SdrObject* >& rShapes = pPage->GetPresentationShapeList().getList(); + + for( std::list< SdrObject* >::const_iterator iter( rShapes.begin() ); iter != rShapes.end(); iter++ ) + { + if( (*iter)->IsEmptyPresObj() && ((*iter)->GetObjIdentifier() == OBJ_OUTLINETEXT) && (mrBase.GetDrawView()->GetTextEditObject() != (*iter)) ) + { + rtl::Reference< SmartTag > xTag( new ChangePlaceholderTag( *this, *mrBase.GetMainViewShell()->GetView(), *(*iter) ) ); + maTagVector.push_back(xTag); + bChanges = true; + } + } + } + + return bChanges; +} + +// -------------------------------------------------------------------- + +bool ViewOverlayManager::DisposeTags() +{ + if( !maTagVector.empty() ) + { + ViewTagVector vec; + vec.swap( maTagVector ); + + ViewTagVector::iterator iter = vec.begin(); + do + { + (*iter++)->Dispose(); + } + while( iter != vec.end() ); + return true; + } + + return false; +} + +// -------------------------------------------------------------------- + +IMPL_LINK(ViewOverlayManager,EventMultiplexerListener, + tools::EventMultiplexerEvent*,pEvent) +{ + switch (pEvent->meEventId) + { + case tools::EventMultiplexerEvent::EID_MAIN_VIEW_ADDED: + case tools::EventMultiplexerEvent::EID_VIEW_ADDED: + case tools::EventMultiplexerEvent::EID_BEGIN_TEXT_EDIT: + case tools::EventMultiplexerEvent::EID_END_TEXT_EDIT: + case tools::EventMultiplexerEvent::EID_CURRENT_PAGE: + UpdateTags(); + break; + } + return 0; +} + +} diff --git a/sd/source/ui/view/viewshe2.cxx b/sd/source/ui/view/viewshe2.cxx new file mode 100755 index 000000000000..616516782be3 --- /dev/null +++ b/sd/source/ui/view/viewshe2.cxx @@ -0,0 +1,1213 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" +#include <com/sun/star/embed/NoVisualAreaSizeException.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/chart2/XChartDocument.hpp> +#include <com/sun/star/drawing/FillStyle.hpp> +#include <com/sun/star/drawing/LineStyle.hpp> + +#include "ViewShell.hxx" +#include "ViewShellHint.hxx" + +#include "ViewShellImplementation.hxx" +#include "FactoryIds.hxx" + +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#ifndef _SCRBAR_HXX //autogen +#include <vcl/scrbar.hxx> +#endif +#include <svx/svdpagv.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/app.hxx> +#include <svx/ruler.hxx> +#include <editeng/outliner.hxx> +#include <svtools/ehdl.hxx> +#include <svx/svdoole2.hxx> +#include <svtools/sfxecode.hxx> +#include <svx/fmshell.hxx> +#include <sfx2/dispatch.hxx> +#include <rtl/ustrbuf.hxx> +#include <unotools/moduleoptions.hxx> +#ifndef _SVX_DIALOGS_HRC +#include <svx/dialogs.hrc> +#endif +#include <sot/clsids.hxx> + +#include "misc.hxx" +#include "strings.hrc" +#include "app.hrc" +#include "unokywds.hxx" + +#include "sdundogr.hxx" +#include "FrameView.hxx" +#include "undopage.hxx" +#include "sdresid.hxx" +#include "drawdoc.hxx" +#include "View.hxx" +#include "fupoor.hxx" +#include "Client.hxx" +#include "DrawDocShell.hxx" +#include "fusearch.hxx" +#include "slideshow.hxx" +#include "sdpage.hxx" +#include "DrawViewShell.hxx" +#include "ViewShellBase.hxx" + +#include "Window.hxx" + +#include <sfx2/viewfrm.hxx> +#include <svtools/soerr.hxx> +#include <toolkit/helper/vclunohelper.hxx> + +#ifdef _MSC_VER +#pragma optimize ( "", off ) +#endif + +using namespace com::sun::star; + +const String aEmptyStr; + +namespace sd { + +/************************************************************************* +|* +|* Scrollbar-Update: Thumbpos und VisibleSize anpassen +|* +\************************************************************************/ + +void ViewShell::UpdateScrollBars() +{ + if (mpHorizontalScrollBar.get() != NULL) + { + long nW = (long)(mpContentWindow->GetVisibleWidth() * 32000); + long nX = (long)(mpContentWindow->GetVisibleX() * 32000); + mpHorizontalScrollBar->SetVisibleSize(nW); + mpHorizontalScrollBar->SetThumbPos(nX); + nW = 32000 - nW; + long nLine = (long) (mpContentWindow->GetScrlLineWidth() * nW); + long nPage = (long) (mpContentWindow->GetScrlPageWidth() * nW); + mpHorizontalScrollBar->SetLineSize(nLine); + mpHorizontalScrollBar->SetPageSize(nPage); + } + + if (mpVerticalScrollBar.get() != NULL) + { + long nH = (long)(mpContentWindow->GetVisibleHeight() * 32000); + long nY = (long)(mpContentWindow->GetVisibleY() * 32000); + + if(IsPageFlipMode()) // ie in zoom mode where no panning + { + SdPage* pPage = static_cast<DrawViewShell*>(this)->GetActualPage(); + USHORT nCurPage = (pPage->GetPageNum() - 1) / 2; + USHORT nTotalPages = GetDoc()->GetSdPageCount(pPage->GetPageKind()); + mpVerticalScrollBar->SetRange(Range(0,256*nTotalPages)); + mpVerticalScrollBar->SetVisibleSize(256); + mpVerticalScrollBar->SetThumbPos(256*nCurPage); + mpVerticalScrollBar->SetLineSize(256); + mpVerticalScrollBar->SetPageSize(256); + } + else + { + mpVerticalScrollBar->SetRange(Range(0,32000)); + mpVerticalScrollBar->SetVisibleSize(nH); + mpVerticalScrollBar->SetThumbPos(nY); + nH = 32000 - nH; + long nLine = (long) (mpContentWindow->GetScrlLineHeight() * nH); + long nPage = (long) (mpContentWindow->GetScrlPageHeight() * nH); + mpVerticalScrollBar->SetLineSize(nLine); + mpVerticalScrollBar->SetPageSize(nPage); + } + } + + if (mbHasRulers) + { + UpdateHRuler(); + UpdateVRuler(); + } + +} +/************************************************************************* +|* +|* Handling fuer horizontale Scrollbars +|* +\************************************************************************/ + +IMPL_LINK_INLINE_START(ViewShell, HScrollHdl, ScrollBar *, pHScroll ) +{ + return VirtHScrollHdl(pHScroll); +} +IMPL_LINK_INLINE_END(ViewShell, HScrollHdl, ScrollBar *, pHScroll ) + +/************************************************************************* +|* +|* virtueller Scroll-Handler fuer horizontale Scrollbars +|* +\************************************************************************/ + +long ViewShell::VirtHScrollHdl(ScrollBar* pHScroll) +{ + long nDelta = pHScroll->GetDelta(); + + if (nDelta != 0) + { + double fX = (double) pHScroll->GetThumbPos() / pHScroll->GetRange().Len(); + + // alle Fenster der Spalte scrollen + ::sd::View* pView = GetView(); + OutlinerView* pOLV = NULL; + + if (pView) + pOLV = pView->GetTextEditOutlinerView(); + + if (pOLV) + pOLV->HideCursor(); + + mpContentWindow->SetVisibleXY(fX, -1); + + Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT); + Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) ); + aVisArea.SetPos(aVisAreaPos); + GetDocSh()->SetVisArea(aVisArea); + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + VisAreaChanged(aVisAreaWin); + + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } + + if (pOLV) + pOLV->ShowCursor(); + + if (mbHasRulers) + UpdateHRuler(); + + } + + return 0; +} + +/************************************************************************* +|* +|* Handling fuer vertikale Scrollbars +|* +\************************************************************************/ + +IMPL_LINK_INLINE_START(ViewShell, VScrollHdl, ScrollBar *, pVScroll ) +{ + return VirtVScrollHdl(pVScroll); +} +IMPL_LINK_INLINE_END(ViewShell, VScrollHdl, ScrollBar *, pVScroll ) + +/************************************************************************* +|* +|* Handling fuer vertikale Scrollbars +|* +\************************************************************************/ + +long ViewShell::VirtVScrollHdl(ScrollBar* pVScroll) +{ + if(IsPageFlipMode()) + { + SdPage* pPage = static_cast<DrawViewShell*>(this)->GetActualPage(); + USHORT nCurPage = (pPage->GetPageNum() - 1) >> 1; + USHORT nNewPage = (USHORT)pVScroll->GetThumbPos()/256; + if( nCurPage != nNewPage ) + static_cast<DrawViewShell*>(this)->SwitchPage(nNewPage); + } + else //panning mode + { + double fY = (double) pVScroll->GetThumbPos() / pVScroll->GetRange().Len(); + + ::sd::View* pView = GetView(); + OutlinerView* pOLV = NULL; + + if (pView) + pOLV = pView->GetTextEditOutlinerView(); + + if (pOLV) + pOLV->HideCursor(); + + mpContentWindow->SetVisibleXY(-1, fY); + + Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT); + Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) ); + aVisArea.SetPos(aVisAreaPos); + GetDocSh()->SetVisArea(aVisArea); + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + VisAreaChanged(aVisAreaWin); + + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } + + if (pOLV) + pOLV->ShowCursor(); + + if (mbHasRulers) + UpdateVRuler(); + + } + + return 0; +} + +SvxRuler* ViewShell::CreateHRuler(::sd::Window* , BOOL ) +{ + return NULL; +} + +SvxRuler* ViewShell::CreateVRuler(::sd::Window* ) +{ + return NULL; +} + +void ViewShell::UpdateHRuler() +{ +} + +void ViewShell::UpdateVRuler() +{ +} + +long ViewShell::GetHCtrlWidth() +{ + return 0; +} + +/************************************************************************* +|* +|* Eine bestimmte Anzahl von Zeilen scrollen (wird beim automatischen +|* Scrollen (Zeichen/Draggen) verwendet) +|* +\************************************************************************/ + +void ViewShell::ScrollLines(long nLinesX, long nLinesY) +{ + if ( nLinesX ) + { + nLinesX *= mpHorizontalScrollBar->GetLineSize(); + } + if ( nLinesY ) + { + nLinesY *= mpVerticalScrollBar->GetLineSize(); + } + + Scroll(nLinesX, nLinesY); +} + +/************************************************************************* +|* +|* Window um nScrollX, nScrollY scrollen +|* +\************************************************************************/ + +void ViewShell::Scroll(long nScrollX, long nScrollY) +{ + if (nScrollX) + { + long nNewThumb = mpHorizontalScrollBar->GetThumbPos() + nScrollX; + mpHorizontalScrollBar->SetThumbPos(nNewThumb); + } + if (nScrollY) + { + long nNewThumb = mpVerticalScrollBar->GetThumbPos() + nScrollY; + mpVerticalScrollBar->SetThumbPos(nNewThumb); + } + double fX = (double) mpHorizontalScrollBar->GetThumbPos() / + mpHorizontalScrollBar->GetRange().Len(); + double fY = (double) mpVerticalScrollBar->GetThumbPos() / + mpVerticalScrollBar->GetRange().Len(); + + GetActiveWindow()->SetVisibleXY(fX, fY); + + Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT); + Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) ); + aVisArea.SetPos(aVisAreaPos); + GetDocSh()->SetVisArea(aVisArea); + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + VisAreaChanged(aVisAreaWin); + + ::sd::View* pView = GetView(); + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } + + if (mbHasRulers) + { + UpdateHRuler(); + UpdateVRuler(); + } +} + +/************************************************************************* +|* +|* Den Zoomfaktor fuer alle Split-Windows setzen +|* +\************************************************************************/ + +void ViewShell::SetZoom(long nZoom) +{ + Fraction aUIScale(nZoom, 100); + aUIScale *= GetDoc()->GetUIScale(); + + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->SetZoom(aUIScale); + + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->SetZoom(aUIScale); + + if (mpContentWindow.get() != NULL) + { + mpContentWindow->SetZoomIntegral(nZoom); + + // #i74769# Here is a 2nd way (besides Window::Scroll) to set the visible prt + // of the window. It needs - like Scroll(SCROLL_CHILDREN) does - also to move + // the child windows. I am trying INVALIDATE_CHILDREN here which makes things better, + // but does not solve the problem completely. Neet to ask PL. + mpContentWindow->Invalidate(INVALIDATE_CHILDREN); + } + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + VisAreaChanged(aVisAreaWin); + + ::sd::View* pView = GetView(); + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } + + UpdateScrollBars(); +} + +/************************************************************************* +|* +|* Zoomrechteck fuer aktives Fenster einstellen und alle Split-Windows +|* auf den gleichen Zoomfaktor setzen +|* +\************************************************************************/ + +void ViewShell::SetZoomRect(const Rectangle& rZoomRect) +{ + long nZoom = GetActiveWindow()->SetZoomRect(rZoomRect); + Fraction aUIScale(nZoom, 100); + aUIScale *= GetDoc()->GetUIScale(); + + Point aPos = GetActiveWindow()->GetWinViewPos(); + + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->SetZoom(aUIScale); + + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->SetZoom(aUIScale); + + if (mpContentWindow.get() != NULL) + { + Point aNewPos = mpContentWindow->GetWinViewPos(); + aNewPos.X() = aPos.X(); + aNewPos.Y() = aPos.Y(); + mpContentWindow->SetZoomIntegral(nZoom); + mpContentWindow->SetWinViewPos(aNewPos); + mpContentWindow->UpdateMapOrigin(); + + // #i74769# see above + mpContentWindow->Invalidate(INVALIDATE_CHILDREN); + } + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + VisAreaChanged(aVisAreaWin); + + ::sd::View* pView = GetView(); + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } + + UpdateScrollBars(); +} + +/************************************************************************* +|* +|* Abbildungsparameter fuer alle Split-Windows initialisieren +|* +\************************************************************************/ + +void ViewShell::InitWindows(const Point& rViewOrigin, const Size& rViewSize, + const Point& rWinPos, BOOL bUpdate) +{ + if (mpContentWindow.get() != NULL) + { + mpContentWindow->SetViewOrigin(rViewOrigin); + mpContentWindow->SetViewSize(rViewSize); + mpContentWindow->SetWinViewPos(rWinPos); + + if ( bUpdate ) + { + mpContentWindow->UpdateMapOrigin(); + mpContentWindow->Invalidate(); + } + } + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + VisAreaChanged(aVisAreaWin); + + ::sd::View* pView = GetView(); + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } +} + +/************************************************************************* +|* +|* Alle Split-Windows unter dem uebergebenen Rechteck invalidieren +|* +\************************************************************************/ + +void ViewShell::InvalidateWindows() +{ + if (mpContentWindow.get() != NULL) + mpContentWindow->Invalidate(); +} + + +/************************************************************************* +|* +|* Auf allen Split-Windows ein Markierungsrechteck mit dem +|* uebergebenen Pen zeichnen +|* +\************************************************************************/ + +void ViewShell::DrawMarkRect(const Rectangle& rRect) const +{ + if (mpContentWindow.get() != NULL) + { + mpContentWindow->InvertTracking(rRect, SHOWTRACK_OBJECT | SHOWTRACK_WINDOW); + } +} + +/************************************************************************* +|* +|* Groesse und Raender aller Seiten setzen +|* +\************************************************************************/ + +void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize, + long nLeft, long nRight, + long nUpper, long nLower, BOOL bScaleAll, + Orientation eOrientation, USHORT nPaperBin, + BOOL bBackgroundFullSize) +{ + SdPage* pPage = 0; + SdUndoGroup* pUndoGroup = NULL; + pUndoGroup = new SdUndoGroup(GetDoc()); + String aString(SdResId(STR_UNDO_CHANGE_PAGEFORMAT)); + pUndoGroup->SetComment(aString); + SfxViewShell* pViewShell = GetViewShell(); + OSL_ASSERT (pViewShell!=NULL); + + USHORT i, nPageCnt = GetDoc()->GetMasterSdPageCount(ePageKind); + + Broadcast (ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_START)); + + for (i = 0; i < nPageCnt; i++) + { + /********************************************************************** + * Erst alle MasterPages bearbeiten + **********************************************************************/ + pPage = GetDoc()->GetMasterSdPage(i, ePageKind); + + SdUndoAction* pUndo = new SdPageFormatUndoAction(GetDoc(), pPage, + pPage->GetSize(), + pPage->GetLftBorder(), pPage->GetRgtBorder(), + pPage->GetUppBorder(), pPage->GetLwrBorder(), + pPage->IsScaleObjects(), + pPage->GetOrientation(), + pPage->GetPaperBin(), + pPage->IsBackgroundFullSize(), + rNewSize, + nLeft, nRight, + nUpper, nLower, + bScaleAll, + eOrientation, + nPaperBin, + bBackgroundFullSize); + pUndoGroup->AddAction(pUndo); + + if (rNewSize.Width() > 0 || + nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0) + { + Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower); + pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll); + + if (rNewSize.Width() > 0) + pPage->SetSize(rNewSize); + } + + if( nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 ) + { + pPage->SetBorder(nLeft, nUpper, nRight, nLower); + } + + pPage->SetOrientation(eOrientation); + pPage->SetPaperBin( nPaperBin ); + pPage->SetBackgroundFullSize( bBackgroundFullSize ); + + if ( ePageKind == PK_STANDARD ) + GetDoc()->GetMasterSdPage(i, PK_NOTES)->CreateTitleAndLayout(); + + pPage->CreateTitleAndLayout(); + } + + nPageCnt = GetDoc()->GetSdPageCount(ePageKind); + + for (i = 0; i < nPageCnt; i++) + { + /********************************************************************** + * Danach alle Pages bearbeiten + **********************************************************************/ + pPage = GetDoc()->GetSdPage(i, ePageKind); + + SdUndoAction* pUndo = new SdPageFormatUndoAction(GetDoc(), pPage, + pPage->GetSize(), + pPage->GetLftBorder(), pPage->GetRgtBorder(), + pPage->GetUppBorder(), pPage->GetLwrBorder(), + pPage->IsScaleObjects(), + pPage->GetOrientation(), + pPage->GetPaperBin(), + pPage->IsBackgroundFullSize(), + rNewSize, + nLeft, nRight, + nUpper, nLower, + bScaleAll, + eOrientation, + nPaperBin, + bBackgroundFullSize); + pUndoGroup->AddAction(pUndo); + + if (rNewSize.Width() > 0 || + nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0) + { + Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower); + pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll); + + if (rNewSize.Width() > 0) + pPage->SetSize(rNewSize); + } + + if( nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 ) + { + pPage->SetBorder(nLeft, nUpper, nRight, nLower); + } + + pPage->SetOrientation(eOrientation); + pPage->SetPaperBin( nPaperBin ); + pPage->SetBackgroundFullSize( bBackgroundFullSize ); + + if ( ePageKind == PK_STANDARD ) + { + SdPage* pNotesPage = GetDoc()->GetSdPage(i, PK_NOTES); + pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() ); + } + + pPage->SetAutoLayout( pPage->GetAutoLayout() ); + } + + // Handoutseite an neues Format der Standardseiten anpassen + if( (ePageKind == PK_STANDARD) || (ePageKind == PK_HANDOUT) ) + GetDoc()->GetSdPage(0, PK_HANDOUT)->CreateTitleAndLayout(TRUE); + + // Undo Gruppe dem Undo Manager uebergeben + pViewShell->GetViewFrame()->GetObjectShell() + ->GetUndoManager()->AddUndoAction(pUndoGroup); + + long nWidth = pPage->GetSize().Width(); + long nHeight = pPage->GetSize().Height(); + + Point aPageOrg = Point(nWidth, nHeight / 2); + Size aViewSize = Size(nWidth * 3, nHeight * 2); + + InitWindows(aPageOrg, aViewSize, Point(-1, -1), TRUE); + + Point aVisAreaPos; + + if ( GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ) + { + aVisAreaPos = GetDocSh()->GetVisArea(ASPECT_CONTENT).TopLeft(); + } + + ::sd::View* pView = GetView(); + if (pView) + { + pView->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aViewSize)); + } + + UpdateScrollBars(); + + Point aNewOrigin(pPage->GetLftBorder(), pPage->GetUppBorder()); + + if (pView) + { + pView->GetSdrPageView()->SetPageOrigin(aNewOrigin); + } + + pViewShell->GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET); + + // auf (neue) Seitengroesse zoomen + pViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); + + Broadcast (ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_END)); +} + +/************************************************************************* +|* +|* Zoom-Faktor fuer InPlace einstellen +|* +\************************************************************************/ + +void ViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction&) +{ + long nZoom = (long)((double) rZoomX * 100); + SetZoom(nZoom); +} + + +/************************************************************************* +|* +|* Aktives Fenster setzen +|* +\************************************************************************/ + +void ViewShell::SetActiveWindow (::sd::Window* pWin) +{ + SfxViewShell* pViewShell = GetViewShell(); + OSL_ASSERT (pViewShell!=NULL); + + if (pViewShell->GetWindow() != pWin) + { + // #i31551# was wrong, it may have been a problem with the repaint at that time. + // For transparent form controls, it is necessary to have that flag set, all apps + // do set it. Enabling again. + if (pWin) + { + pWin->EnableChildTransparentMode(); + } + } + + if (mpActiveWindow != pWin) + mpActiveWindow = pWin; + + // The rest of this function is not guarded anymore against calling this + // method with an already active window because the functions may still + // point to the old window when the new one has already been assigned to + // pWindow elsewhere. + ::sd::View* pView = GetView(); + if (pView) + { + pView->SetActualWin(pWin); + } + if(HasCurrentFunction()) + { + GetCurrentFunction()->SetWindow(pWin); + } +} + + + +/************************************************************************* +|* +|* RequestHelp event +|* +\************************************************************************/ + +BOOL ViewShell::RequestHelp(const HelpEvent& rHEvt, ::sd::Window*) +{ + BOOL bReturn = FALSE; + + if (rHEvt.GetMode()) + { + if( GetView() ) + bReturn = GetView()->getSmartTags().RequestHelp(rHEvt); + + if(!bReturn && HasCurrentFunction()) + { + bReturn = GetCurrentFunction()->RequestHelp(rHEvt); + } + } + + return(bReturn); +} + + + + +FrameView* ViewShell::GetFrameView (void) +{ + return mpFrameView; +} + + + + +void ViewShell::SetFrameView (FrameView* pNewFrameView) +{ + mpFrameView = pNewFrameView; + ReadFrameViewData (mpFrameView); +} + + + + +/************************************************************************* +|* +|* Read FrameViews data and set actual views data +|* +\************************************************************************/ + +void ViewShell::ReadFrameViewData(FrameView*) +{ +} + + + +/************************************************************************* +|* +|* Write actual views data to FrameView +|* +\************************************************************************/ + +void ViewShell::WriteFrameViewData() +{ +} + +/************************************************************************* +|* +|* OLE-Object aktivieren +|* +\************************************************************************/ + +BOOL ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb) +{ + ErrCode aErrCode = 0; + + SfxErrorContext aEC(ERRCTX_SO_DOVERB, GetActiveWindow(), RID_SO_ERRCTX); + BOOL bAbort = FALSE; + GetDocSh()->SetWaitCursor( TRUE ); + SfxViewShell* pViewShell = GetViewShell(); + OSL_ASSERT (pViewShell!=NULL); + bool bChangeDefaultsForChart = false; + + uno::Reference < embed::XEmbeddedObject > xObj = pObj->GetObjRef(); + if ( !xObj.is() ) + { + /********************************************************** + * Leeres OLE-Objekt mit OLE-Objekt versehen + **********************************************************/ + String aName = pObj->GetProgName(); + ::rtl::OUString aObjName; + SvGlobalName aClass; + + if( aName.EqualsAscii( "StarChart" ) || aName.EqualsAscii("StarOrg") ) + { + if( SvtModuleOptions().IsChart() ) + { + aClass = SvGlobalName( SO3_SCH_CLASSID ); + bChangeDefaultsForChart = true; + } + } + else if( aName.EqualsAscii( "StarCalc" )) + { + if( SvtModuleOptions().IsCalc() ) + aClass = SvGlobalName( SO3_SC_CLASSID ); + } + else if( aName.EqualsAscii( "StarMath" )) + { + if( SvtModuleOptions().IsMath() ) + aClass = SvGlobalName( SO3_SM_CLASSID ); + } + + if ( aClass != SvGlobalName() ) + xObj = GetDocSh()->GetEmbeddedObjectContainer().CreateEmbeddedObject( aClass.GetByteSequence(), aObjName ); + + if( !xObj.is() ) + { + aName = String(); + + // Dialog "OLE-Objekt einfuegen" aufrufen + GetDocSh()->SetWaitCursor( FALSE ); + pViewShell->GetViewFrame()->GetDispatcher()->Execute( + SID_INSERT_OBJECT, + SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD); + xObj = pObj->GetObjRef(); + GetDocSh()->SetWaitCursor( TRUE ); + + if (!xObj.is()) + { + bAbort = TRUE; + } + } + + if ( xObj.is() ) + { + /****************************************************** + * OLE-Objekt ist nicht mehr leer + ******************************************************/ + pObj->SetEmptyPresObj(FALSE); + pObj->SetOutlinerParaObject(NULL); + pObj->SetGraphic(NULL); + + /****************************************************** + * Das leere OLE-Objekt bekommt ein neues IPObj + ******************************************************/ + if (aName.Len()) + { + pObj->SetObjRef(xObj); + pObj->SetName(aObjName); + pObj->SetPersistName(aObjName); + } + else + { + // Das Einfuegen hat der Dialog schon gemacht + pObj->SetObjRef(xObj); + } + + Rectangle aRect = pObj->GetLogicRect(); + + if ( pObj->GetAspect() != embed::Aspects::MSOLE_ICON ) + { + awt::Size aSz; + aSz.Width = aRect.GetWidth(); + aSz.Height = aRect.GetHeight(); + xObj->setVisualAreaSize( pObj->GetAspect(), aSz ); + } + + GetViewShellBase().SetVerbs( xObj->getSupportedVerbs() ); + + nVerb = SVVERB_SHOW; + } + else + { + aErrCode = ERRCODE_SFX_OLEGENERAL; + } + } + + if( aErrCode == 0 ) + { + ::sd::View* pView = GetView(); + + if (pView->IsTextEdit()) + { + pView->SdrEndTextEdit(); + } + + SfxInPlaceClient* pSdClient = + static_cast<Client*>(pViewShell->FindIPClient( + pObj->GetObjRef(), GetActiveWindow())); + + if ( !pSdClient ) + { + pSdClient = new Client(pObj, this, GetActiveWindow()); + } + + Rectangle aRect = pObj->GetLogicRect(); + Size aDrawSize = aRect.GetSize(); + + MapMode aMapMode( GetDoc()->GetScaleUnit() ); + Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode ); + if( pObj->IsChart() ) //charts never should be stretched see #i84323# for example + aObjAreaSize = aDrawSize; + + Fraction aScaleWidth (aDrawSize.Width(), aObjAreaSize.Width() ); + Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() ); + aScaleWidth.ReduceInaccurate(10); // kompatibel zum SdrOle2Obj + aScaleHeight.ReduceInaccurate(10); + pSdClient->SetSizeScale(aScaleWidth, aScaleHeight); + + // sichtbarer Ausschnitt wird nur inplace veraendert! + aRect.SetSize(aObjAreaSize); + // the object area size must be set after scaling, since it triggers the resizing + pSdClient->SetObjArea(aRect); + + if( bChangeDefaultsForChart && xObj.is()) + { + AdaptDefaultsForChart( xObj ); + } + + pSdClient->DoVerb(nVerb); // ErrCode wird ggf. vom Sfx ausgegeben + pViewShell->GetViewFrame()->GetBindings().Invalidate( + SID_NAVIGATOR_STATE, TRUE, FALSE); + } + + GetDocSh()->SetWaitCursor( FALSE ); + + if (aErrCode != 0 && !bAbort) + { + ErrorHandler::HandleError(* new StringErrorInfo(aErrCode, String() ) ); + } + + return aErrCode == 0; +} + +/************************************************************************* +|* +|* umschliessendes Rechteck aller (Split-)Fenster zurueckgeben. +|* +\************************************************************************/ + +const Rectangle& ViewShell::GetAllWindowRect() +{ + maAllWindowRectangle.SetPos( + mpContentWindow->OutputToScreenPixel(Point(0,0))); + return maAllWindowRectangle; +} + +/************************************************************************* +|* +|* Read user data +|* +\************************************************************************/ +void ViewShell::ReadUserData(const String&) +{ + // Auf an FrameView gemerkte VisArea zoomen + GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_VISAREA, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD); +} + +/************************************************************************* +|* +|* Write user data +|* +\************************************************************************/ + +void ViewShell::WriteUserData(String&) +{ + // Das Schreiben unserer Daten erfolgt stets in WriteFrameViewData() + WriteFrameViewData(); +} + + +/************************************************************************* +|* +|* Lineale ein- / ausschalten +|* +\************************************************************************/ + +void ViewShell::SetRuler(BOOL bRuler) +{ + mbHasRulers = ( bRuler && !GetDocSh()->IsPreview() ); // no rulers on preview mode + + if (mpHorizontalRuler.get() != NULL) + { + if (mbHasRulers) + { + mpHorizontalRuler->Show(); + } + else + { + mpHorizontalRuler->Hide(); + } + } + + if (mpVerticalRuler.get() != NULL) + { + if (mbHasRulers) + { + mpVerticalRuler->Show(); + } + else + { + mpVerticalRuler->Hide(); + } + } + + OSL_ASSERT(GetViewShell()!=NULL); + if (IsMainViewShell()) + GetViewShell()->InvalidateBorder(); +} + +/************************************************************************* +|* +|* AcceptDrop +|* +\************************************************************************/ + +sal_Int8 ViewShell::AcceptDrop ( + const AcceptDropEvent& rEvt, + DropTargetHelper& rTargetHelper, + ::sd::Window* pTargetWindow, + USHORT nPage, + USHORT nLayer) +{ + ::sd::View* pView = GetView(); + return( pView ? pView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE ); +} + +/************************************************************************* +|* +|* ExecuteDrop +|* +\************************************************************************/ + +sal_Int8 ViewShell::ExecuteDrop ( + const ExecuteDropEvent& rEvt, + DropTargetHelper& rTargetHelper, + ::sd::Window* pTargetWindow, + USHORT nPage, + USHORT nLayer) +{ + ::sd::View* pView = GetView(); + return( pView ? pView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE ); +} + +#ifdef _MSC_VER +#pragma optimize ( "", on ) +#endif + +void ViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < + ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse) +{ + const sal_Int32 nIndex = rSequence.getLength(); + rSequence.realloc( nIndex + 1 ); + + OSL_ASSERT (GetViewShell()!=NULL); + // Get the view id from the view shell in the center pane. This will + // usually be the called view shell, but to be on the safe side we call + // the main view shell explicitly. + sal_uInt16 nViewID (IMPRESS_FACTORY_ID); + if (GetViewShellBase().GetMainViewShell().get() != NULL) + nViewID = GetViewShellBase().GetMainViewShell()->mpImpl->GetViewId(); + rSequence[nIndex].Name = rtl::OUString ( + RTL_CONSTASCII_USTRINGPARAM( sUNO_View_ViewId ) ); + rtl::OUStringBuffer sBuffer ( + rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "view" ) ) ); + sBuffer.append( static_cast<sal_Int32>(nViewID)); + rSequence[nIndex].Value <<= sBuffer.makeStringAndClear(); + + mpFrameView->WriteUserDataSequence( rSequence, bBrowse ); +} + + +void ViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse ) +{ + mpFrameView->ReadUserDataSequence( rSequence, bBrowse ); +} + +void ViewShell::VisAreaChanged(const Rectangle& rRect) +{ + OSL_ASSERT (GetViewShell()!=NULL); + GetViewShell()->VisAreaChanged(rRect); +} + +void ViewShell::SetWinViewPos(const Point& rWinPos, bool bUpdate) +{ + if (mpContentWindow.get() != NULL) + { + mpContentWindow->SetWinViewPos(rWinPos); + + if ( bUpdate ) + { + mpContentWindow->UpdateMapOrigin(); + mpContentWindow->Invalidate(); + } + } + + if (mbHasRulers) + { + UpdateHRuler(); + UpdateVRuler(); + } + + UpdateScrollBars(); + + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) ); + VisAreaChanged(aVisAreaWin); + + ::sd::View* pView = GetView(); + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } +} + +Point ViewShell::GetWinViewPos() const +{ + return mpContentWindow->GetWinViewPos(); +} + +Point ViewShell::GetViewOrigin() const +{ + return mpContentWindow->GetViewOrigin(); +} + +void ViewShell::AdaptDefaultsForChart( + const uno::Reference < embed::XEmbeddedObject > & xEmbObj ) +{ + if( xEmbObj.is()) + { + uno::Reference< chart2::XChartDocument > xChartDoc( xEmbObj->getComponent(), uno::UNO_QUERY ); + OSL_ENSURE( xChartDoc.is(), "Trying to set chart property to non-chart OLE" ); + if( !xChartDoc.is()) + return; + + try + { + // set background to transparent (none) + uno::Reference< beans::XPropertySet > xPageProp( xChartDoc->getPageBackground()); + if( xPageProp.is()) + xPageProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("FillStyle")), + uno::makeAny( drawing::FillStyle_NONE )); + // set no border + if( xPageProp.is()) + xPageProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("LineStyle")), + uno::makeAny( drawing::LineStyle_NONE )); + } + catch( const uno::Exception & ) + { + OSL_ENSURE( false, "Exception caught in AdaptDefaultsForChart" ); + } + } +} + +} // end of namespace sd diff --git a/sd/source/ui/view/viewshe3.cxx b/sd/source/ui/view/viewshe3.cxx new file mode 100755 index 000000000000..8bfdefd240da --- /dev/null +++ b/sd/source/ui/view/viewshe3.cxx @@ -0,0 +1,442 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + + +#include "ViewShell.hxx" +#include "GraphicViewShell.hxx" +#include "GraphicViewShellBase.hxx" + +#include <sfx2/viewfrm.hxx> +#include <com/sun/star/lang/Locale.hpp> + +#include <utility> +#include <vector> + +#include "app.hrc" +#include "strings.hrc" +#include "res_bmp.hrc" +#include "glob.hrc" +#include "sdabstdlg.hxx" + +#include "fupoor.hxx" +#include <sfx2/dispatch.hxx> +#include <svx/prtqry.hxx> +#include <svx/svdopage.hxx> +#include <sfx2/progress.hxx> +#include <svx/svdobj.hxx> +#include <vcl/msgbox.hxx> +#include <sfx2/bindings.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdetc.hxx> +#include <editeng/outliner.hxx> +#include <editeng/editstat.hxx> +#include <tools/multisel.hxx> +#include <svl/intitem.hxx> +#include <svl/style.hxx> +#include <unotools/localedatawrapper.hxx> +#include <comphelper/processfactory.hxx> +#include <rtl/ustrbuf.hxx> +#include "stlsheet.hxx" +#ifndef SD_WINDOW_UPDATER_HXX +#include "WindowUpdater.hxx" +#endif +#include "DrawViewShell.hxx" +#include "OutlineViewShell.hxx" +#include "drawview.hxx" + +#include "sdattr.hxx" +#include "drawdoc.hxx" +#include "sdpage.hxx" +#include "unoaprms.hxx" // Undo-Action +#include "sdundogr.hxx" // Undo Gruppe +#include "Window.hxx" +#include "DrawDocShell.hxx" +#include "FrameView.hxx" +#include "framework/FrameworkHelper.hxx" +#include "optsitem.hxx" +#include "sdresid.hxx" + +// #96090# +#ifndef _SVXIDS_HXX +#include <svx/svxids.hrc> +#endif +#include <sfx2/request.hxx> +#include <svl/aeitem.hxx> +#include <basic/sbstar.hxx> + +using namespace ::com::sun::star; +using namespace ::rtl; + +namespace sd { + +/************************************************************************* +|* +|* Status (Enabled/Disabled) von Menue-SfxSlots setzen +|* +\************************************************************************/ + +void ViewShell::GetMenuState( SfxItemSet &rSet ) +{ + if( SFX_ITEM_AVAILABLE == rSet.GetItemState( SID_STYLE_FAMILY ) ) + { + UINT16 nFamily = (UINT16)GetDocSh()->GetStyleFamily(); + + SdrView* pDrView = GetDrawView(); + + if( pDrView->AreObjectsMarked() ) + { + SfxStyleSheet* pStyleSheet = pDrView->GetStyleSheet(); + if( pStyleSheet ) + { + if (pStyleSheet->GetFamily() == SD_STYLE_FAMILY_MASTERPAGE) + pStyleSheet = ((SdStyleSheet*)pStyleSheet)->GetPseudoStyleSheet(); + + if( pStyleSheet ) + { + SfxStyleFamily eFamily = pStyleSheet->GetFamily(); + if(eFamily == SD_STYLE_FAMILY_GRAPHICS) + nFamily = 2; + else if(eFamily == SD_STYLE_FAMILY_CELL ) + nFamily = 3; + else // SD_STYLE_FAMILY_PSEUDO + nFamily = 5; + + GetDocSh()->SetStyleFamily(nFamily); + } + } + } + rSet.Put(SfxUInt16Item(SID_STYLE_FAMILY, nFamily )); + } + + // #96090# + if(SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_GETUNDOSTRINGS)) + { + ImpGetUndoStrings(rSet); + } + + // #96090# + if(SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_GETREDOSTRINGS)) + { + ImpGetRedoStrings(rSet); + } + + // #96090# + if(SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_UNDO)) + { + SfxUndoManager* pUndoManager = ImpGetUndoManager(); + sal_Bool bActivate(FALSE); + + if(pUndoManager) + { + if(pUndoManager->GetUndoActionCount() != 0) + { + bActivate = TRUE; + } + } + + if(bActivate) + { + // #87229# Set the necessary string like in + // sfx2/source/view/viewfrm.cxx ver 1.23 ln 1072 ff. + String aTmp(ResId(STR_UNDO, *SFX_APP()->GetSfxResManager())); + aTmp += pUndoManager->GetUndoActionComment(0); + rSet.Put(SfxStringItem(SID_UNDO, aTmp)); + } + else + { + rSet.DisableItem(SID_UNDO); + } + } + + // #96090# + if(SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_REDO)) + { + SfxUndoManager* pUndoManager = ImpGetUndoManager(); + sal_Bool bActivate(FALSE); + + if(pUndoManager) + { + if(pUndoManager->GetRedoActionCount() != 0) + { + bActivate = TRUE; + } + } + + if(bActivate) + { + // #87229# Set the necessary string like in + // sfx2/source/view/viewfrm.cxx ver 1.23 ln 1081 ff. + String aTmp(ResId(STR_REDO, *SFX_APP()->GetSfxResManager())); + aTmp += pUndoManager->GetRedoActionComment(0); + rSet.Put(SfxStringItem(SID_REDO, aTmp)); + } + else + { + rSet.DisableItem(SID_REDO); + } + } +} + + + + +/** This method consists basically of three parts: + 1. Process the arguments of the SFX request. + 2. Use the model to create a new page or duplicate an existing one. + 3. Update the tab control and switch to the new page. +*/ +SdPage* ViewShell::CreateOrDuplicatePage ( + SfxRequest& rRequest, + PageKind ePageKind, + SdPage* pPage) +{ + USHORT nSId = rRequest.GetSlot(); + SdDrawDocument* pDocument = GetDoc(); + SdrLayerAdmin& rLayerAdmin = pDocument->GetLayerAdmin(); + BYTE aBckgrnd = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE); + BYTE aBckgrndObj = rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE); + SetOfByte aVisibleLayers; + // Determine the page from which to copy some values, such as layers, + // size, master page, to the new page. This is usually the given page. + // When the given page is NULL then use the first page of the document. + SdPage* pTemplatePage = pPage; + if (pTemplatePage == NULL) + if (pDocument->GetSdPage(0, ePageKind) > 0) + pTemplatePage = pDocument->GetSdPage(0, ePageKind); + if (pTemplatePage != NULL && pTemplatePage->TRG_HasMasterPage()) + aVisibleLayers = pTemplatePage->TRG_GetMasterPageVisibleLayers(); + else + aVisibleLayers.SetAll(); + + String aStandardPageName; + String aNotesPageName; + AutoLayout eStandardLayout (AUTOLAYOUT_NONE); + AutoLayout eNotesLayout (AUTOLAYOUT_NOTES); + BOOL bIsPageBack = aVisibleLayers.IsSet(aBckgrnd); + BOOL bIsPageObj = aVisibleLayers.IsSet(aBckgrndObj); + + // 1. Process the arguments. + const SfxItemSet* pArgs = rRequest.GetArgs(); + if (! pArgs) + { +/* + // Make the layout menu visible in the tool pane. + const ViewShellBase& rBase (GetViewShellBase()); + if (rBase.GetMainViewShell()!=NULL + && rBase.GetMainViewShell()->GetShellType()!=ViewShell::ST_OUTLINE + && rBase.GetMainViewShell()->GetShellType()!=ViewShell::ST_DRAW) + { + framework::FrameworkHelper::Instance(GetViewShellBase())->RequestTaskPanel( + framework::FrameworkHelper::msLayoutTaskPanelURL); + } +*/ + + // AutoLayouts muessen fertig sein + pDocument->StopWorkStartupDelay(); + + // Use the layouts of the previous page and notes page as template. + if (pTemplatePage != NULL) + { + eStandardLayout = pTemplatePage->GetAutoLayout(); + if( eStandardLayout == AUTOLAYOUT_TITLE ) + eStandardLayout = AUTOLAYOUT_ENUM; + + SdPage* pNotesTemplatePage = static_cast<SdPage*>(pDocument->GetPage(pTemplatePage->GetPageNum()+1)); + if (pNotesTemplatePage != NULL) + eNotesLayout = pNotesTemplatePage->GetAutoLayout(); + } + } + else if (pArgs->Count() == 1) + { + pDocument->StopWorkStartupDelay(); + SFX_REQUEST_ARG (rRequest, pLayout, SfxUInt32Item, ID_VAL_WHATLAYOUT, FALSE); + if( pLayout ) + { + if (ePageKind == PK_NOTES) + { + eNotesLayout = (AutoLayout) pLayout->GetValue (); + } + else + { + eStandardLayout = (AutoLayout) pLayout->GetValue (); + } + } + } + else if (pArgs->Count() == 4) + { + // AutoLayouts muessen fertig sein + pDocument->StopWorkStartupDelay(); + + SFX_REQUEST_ARG (rRequest, pPageName, SfxStringItem, ID_VAL_PAGENAME, FALSE); + SFX_REQUEST_ARG (rRequest, pLayout, SfxUInt32Item, ID_VAL_WHATLAYOUT, FALSE); + SFX_REQUEST_ARG (rRequest, pIsPageBack, SfxBoolItem, ID_VAL_ISPAGEBACK, FALSE); + SFX_REQUEST_ARG (rRequest, pIsPageObj, SfxBoolItem, ID_VAL_ISPAGEOBJ, FALSE); + + if (CHECK_RANGE (AUTOLAYOUT__START, (AutoLayout) pLayout->GetValue (), AUTOLAYOUT__END)) + { + if (ePageKind == PK_NOTES) + { + aNotesPageName = pPageName->GetValue (); + eNotesLayout = (AutoLayout) pLayout->GetValue (); + } + else + { + aStandardPageName = pPageName->GetValue (); + eStandardLayout = (AutoLayout) pLayout->GetValue (); + } + + bIsPageBack = pIsPageBack->GetValue (); + bIsPageObj = pIsPageObj->GetValue (); + } + else + { + Cancel(); + + if(HasCurrentFunction( SID_BEZIER_EDIT ) ) + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + + StarBASIC::FatalError (SbERR_BAD_PROP_VALUE); + rRequest.Ignore (); + return NULL; + } + } + else + { + Cancel(); + + if(HasCurrentFunction(SID_BEZIER_EDIT) ) + GetViewFrame()->GetDispatcher()->Execute(SID_OBJECT_SELECT, SFX_CALLMODE_ASYNCHRON); + + StarBASIC::FatalError (SbERR_WRONG_ARGS); + rRequest.Ignore (); + return NULL; + } + + // 2. Create a new page or duplicate an existing one. + View* pDrView = GetView(); + const bool bUndo = pDrView && pDrView->IsUndoEnabled(); + if( bUndo ) + pDrView->BegUndo( String( SdResId(STR_INSERTPAGE) ) ); + + USHORT nNewPageIndex = 0xffff; + switch (nSId) + { + case SID_INSERTPAGE: + case SID_INSERTPAGE_QUICK: + case SID_INSERT_MASTER_PAGE: + // There are three cases. a) pPage is not NULL: we use it as a + // template and create a new slide behind it. b) pPage is NULL + // but the document is not empty: we use the first slide/notes + // page as template, create a new slide after it and move it + // then to the head of the document. c) pPage is NULL and the + // document is empty: We use CreateFirstPages to create the + // first page of the document. + if (pPage == NULL) + if (pTemplatePage == NULL) + { + pDocument->CreateFirstPages(); + nNewPageIndex = 0; + } + else + { + // Create a new page with the first page as template and + // insert it after the first page. + nNewPageIndex = pDocument->CreatePage ( + pTemplatePage, + ePageKind, + aStandardPageName, + aNotesPageName, + eStandardLayout, + eNotesLayout, + bIsPageBack, + bIsPageObj); + // Select exactly the new page. + USHORT nPageCount (pDocument->GetSdPageCount(ePageKind)); + for (USHORT i=0; i<nPageCount; i++) + { + pDocument->GetSdPage(i, PK_STANDARD)->SetSelected( + i == nNewPageIndex); + pDocument->GetSdPage(i, PK_NOTES)->SetSelected( + i == nNewPageIndex); + } + // Move the selected page to the head of the document + pDocument->MovePages ((USHORT)-1); + nNewPageIndex = 0; + } + else + nNewPageIndex = pDocument->CreatePage ( + pPage, + ePageKind, + aStandardPageName, + aNotesPageName, + eStandardLayout, + eNotesLayout, + bIsPageBack, + bIsPageObj); + break; + + case SID_DUPLICATE_PAGE: + // Duplication makes no sense when pPage is NULL. + if (pPage != NULL) + nNewPageIndex = pDocument->DuplicatePage ( + pPage, + ePageKind, + aStandardPageName, + aNotesPageName, + eStandardLayout, + eNotesLayout, + bIsPageBack, + bIsPageObj); + break; + + default: + DBG_WARNING("wrong slot id given to CreateOrDuplicatePage"); + // Try to handle another slot id gracefully. + } + SdPage* pNewPage = 0; + if(nNewPageIndex != 0xffff) + pNewPage = pDocument->GetSdPage(nNewPageIndex, PK_STANDARD); + + if( bUndo ) + { + if( pNewPage ) + { + pDrView->AddUndo(pDocument->GetSdrUndoFactory().CreateUndoNewPage(*pNewPage)); + pDrView->AddUndo(pDocument->GetSdrUndoFactory().CreateUndoNewPage(*pDocument->GetSdPage (nNewPageIndex, PK_NOTES))); + } + + pDrView->EndUndo(); + } + + return pNewPage; +} + + +} // end of namespace sd diff --git a/sd/source/ui/view/viewshel.cxx b/sd/source/ui/view/viewshel.cxx new file mode 100755 index 000000000000..c1f4bc070bcf --- /dev/null +++ b/sd/source/ui/view/viewshel.cxx @@ -0,0 +1,1619 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "ViewShell.hxx" +#include "ViewShellImplementation.hxx" + +#ifndef _COM_SUN_STAR_EMBED_EMBEDSTATE_HPP_ +#include <com/sun/star/embed/EmbedStates.hpp> +#endif +#include "ViewShellBase.hxx" +#include "ShellFactory.hxx" +#include "DrawController.hxx" +#include "LayerTabBar.hxx" + +#include <sfx2/viewfrm.hxx> +#include <sfx2/bindings.hxx> +#include <sfx2/dispatch.hxx> +#ifndef _SCRBAR_HXX //autogen +#include <vcl/scrbar.hxx> +#endif +#include <svl/eitem.hxx> +#include <svx/ruler.hxx> +#ifndef _SVXIDS_HXX +#include <svx/svxids.hrc> +#endif +#include <svx/fmshell.hxx> +#ifndef SD_WINDOW_UPDATER_HXX +#include "WindowUpdater.hxx" +#endif +#include "GraphicViewShell.hxx" +#include <sfx2/childwin.hxx> +#include <sdxfer.hxx> +#include "GraphicViewShell.hxx" +#include <sfx2/childwin.hxx> + +#include "app.hrc" +#include "helpids.h" +#include "strings.hrc" +#include "res_bmp.hrc" +#include "OutlineView.hxx" +#include "Client.hxx" +#include "sdresid.hxx" +#include "DrawDocShell.hxx" +#include "slideshow.hxx" +#include "drawdoc.hxx" +#include "sdpage.hxx" +#include "zoomlist.hxx" +#include "FrameView.hxx" +#include "optsitem.hxx" +#include "BezierObjectBar.hxx" +#include "TextObjectBar.hxx" +#include "GraphicObjectBar.hxx" +#include "MediaObjectBar.hxx" +#include "ViewShellManager.hxx" +#include "FormShellManager.hxx" +#include <svx/fmshell.hxx> +#include <svx/dialogs.hrc> +#include <svx/extrusionbar.hxx> +#include <svx/fontworkbar.hxx> +#include <svx/svdoutl.hxx> + +// #96090# +#include <svl/slstitm.hxx> +#include <sfx2/request.hxx> +#include "SpellDialogChildWindow.hxx" + +#include "Window.hxx" +#include "fupoor.hxx" + +#ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED +#define SO2_DECL_SVINPLACEOBJECT_DEFINED +SO2_DECL_REF(SvInPlaceObject) +#endif + +namespace sd { namespace ui { namespace table { + extern SfxShell* CreateTableObjectBar( ViewShell& rShell, ::sd::View* pView ); +} } } + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::presentation; + +namespace { + +class ViewShellObjectBarFactory + : public ::sd::ShellFactory<SfxShell> +{ +public: + ViewShellObjectBarFactory (::sd::ViewShell& rViewShell); + virtual ~ViewShellObjectBarFactory (void); + virtual SfxShell* CreateShell ( + ::sd::ShellId nId, + ::Window* pParentWindow, + ::sd::FrameView* pFrameView); + virtual void ReleaseShell (SfxShell* pShell); +private: + ::sd::ViewShell& mrViewShell; + /** This cache holds the already created object bars. + */ + typedef ::std::map< ::sd::ShellId,SfxShell*> ShellCache; + ShellCache maShellCache; +}; + + +} // end of anonymous namespace + + +namespace sd { + +static const int DELTA_ZOOM = 10; + +BOOL ViewShell::IsPageFlipMode(void) const +{ + return this->ISA(DrawViewShell) && mpContentWindow.get() != NULL && + mpContentWindow->GetVisibleHeight() >= 1.0; +} + +SfxViewFrame* ViewShell::GetViewFrame (void) const +{ + const SfxViewShell* pViewShell = GetViewShell(); + if (pViewShell != NULL) + { + return pViewShell->GetViewFrame(); + } + else + { + OSL_ASSERT (GetViewShell()!=NULL); + return NULL; + } +} + + +/************************************************************************* +|* +|* SFX-Slotmap und Standardinterface deklarieren +|* +\************************************************************************/ +TYPEINIT1(ViewShell, SfxShell); + + +ViewShell::ViewShell( SfxViewFrame*, ::Window* pParentWindow, ViewShellBase& rViewShellBase, bool bAllowCenter) +: SfxShell(&rViewShellBase) +, mbCenterAllowed(bAllowCenter) +, mpParentWindow(pParentWindow) +{ + construct(); +} + +ViewShell::~ViewShell() +{ + // Keep the content window from accessing in its destructor the + // WindowUpdater. + mpContentWindow->SetViewShell(NULL); + + delete mpZoomList; + + mpLayerTabBar.reset(); + + if (mpImpl->mpSubShellFactory.get() != NULL) + GetViewShellBase().GetViewShellManager()->RemoveSubShellFactory( + this,mpImpl->mpSubShellFactory); +} + + +/************************************************************************* +|* +|* gemeinsamer Initialiserungsanteil der beiden Konstruktoren +|* +\************************************************************************/ + +void ViewShell::construct(void) +{ + mbHasRulers = false; + mpActiveWindow = 0; + mpView = 0; + mpFrameView = 0; + mpZoomList = 0; + mbStartShowWithDialog = FALSE; + mnPrintedHandoutPageNum = 1; + mnPrintedHandoutPageCount = 0; + mpWindowUpdater.reset( new ::sd::WindowUpdater() ); + mpImpl.reset(new Implementation(*this)); + meShellType = ST_NONE; + + OSL_ASSERT (GetViewShell()!=NULL); + + if (IsMainViewShell()) + GetDocSh()->Connect (this); + + mpZoomList = new ZoomList( this ); + + mpContentWindow.reset(new ::sd::Window(GetParentWindow())); + SetActiveWindow (mpContentWindow.get()); + + GetParentWindow()->SetBackground (Wallpaper()); + mpContentWindow->SetBackground (Wallpaper()); + mpContentWindow->SetCenterAllowed(mbCenterAllowed); + mpContentWindow->SetViewShell(this); + mpContentWindow->SetPosSizePixel( + GetParentWindow()->GetPosPixel(),GetParentWindow()->GetSizePixel()); + mpContentWindow->Show(); + static_cast< ::Window*>(mpContentWindow.get())->Resize(); + OSL_TRACE("content window has size %d %d", + mpContentWindow->GetSizePixel().Width(), + mpContentWindow->GetSizePixel().Height()); + + if ( ! GetDocSh()->IsPreview()) + { + // Create scroll bars and the filler between the scroll bars. + mpHorizontalScrollBar.reset (new ScrollBar(GetParentWindow(), WinBits(WB_HSCROLL | WB_DRAG))); + mpHorizontalScrollBar->EnableRTL (FALSE); + mpHorizontalScrollBar->SetRange(Range(0, 32000)); + mpHorizontalScrollBar->SetScrollHdl(LINK(this, ViewShell, HScrollHdl)); + mpHorizontalScrollBar->Show(); + + mpVerticalScrollBar.reset (new ScrollBar(GetParentWindow(), WinBits(WB_VSCROLL | WB_DRAG))); + mpVerticalScrollBar->SetRange(Range(0, 32000)); + mpVerticalScrollBar->SetScrollHdl(LINK(this, ViewShell, VScrollHdl)); + mpVerticalScrollBar->Show(); + maScrBarWH = Size( + mpVerticalScrollBar->GetSizePixel().Width(), + mpHorizontalScrollBar->GetSizePixel().Height()); + + mpScrollBarBox.reset(new ScrollBarBox(GetParentWindow(), WB_SIZEABLE)); + mpScrollBarBox->Show(); + } + + String aName( RTL_CONSTASCII_USTRINGPARAM( "ViewShell" )); + SetName (aName); + + GetDoc()->StartOnlineSpelling(FALSE); + + mpWindowUpdater->SetViewShell (*this); + mpWindowUpdater->SetDocument (GetDoc()); + + // Re-initialize the spell dialog. + ::sd::SpellDialogChildWindow* pSpellDialog = + static_cast< ::sd::SpellDialogChildWindow*> ( + GetViewFrame()->GetChildWindow ( + ::sd::SpellDialogChildWindow::GetChildWindowId())); + if (pSpellDialog != NULL) + pSpellDialog->InvalidateSpellDialog(); + + // Register the sub shell factory. + mpImpl->mpSubShellFactory.reset(new ViewShellObjectBarFactory(*this)); + GetViewShellBase().GetViewShellManager()->AddSubShellFactory(this,mpImpl->mpSubShellFactory); + + GetParentWindow()->Show(); +} + + + + +void ViewShell::Init (bool bIsMainViewShell) +{ + mpImpl->mbIsInitialized = true; + SetIsMainViewShell(bIsMainViewShell); + if (bIsMainViewShell) + SetActiveWindow (mpContentWindow.get()); +} + + + + +void ViewShell::Exit (void) +{ + sd::View* pView = GetView(); + if (pView!=NULL && pView->IsTextEdit()) + { + pView->SdrEndTextEdit(); + pView->UnmarkAll(); + } + + Deactivate (TRUE); + + if (IsMainViewShell()) + { + GetDocSh()->Disconnect(this); + } + + SetIsMainViewShell(false); +} + + + + +/************************************************************************* +|* +|* Aktivierung: Arbeitsfenster den Fokus zuweisen +|* +\************************************************************************/ + +void ViewShell::Activate(BOOL bIsMDIActivate) +{ + SfxShell::Activate(bIsMDIActivate); + + // Laut MI darf keiner GrabFocus rufen, der nicht genau weiss von + // welchem Window der Focus gegrabt wird. Da Activate() vom SFX teilweise + // asynchron verschickt wird, kann es sein, dass ein falsches Window + // den Focus hat (#29682#): + //GetViewFrame()->GetWindow().GrabFocus(); + + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->SetActive(TRUE); + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->SetActive(TRUE); + + if (bIsMDIActivate) + { + // Damit der Navigator auch einen aktuellen Status bekommt + SfxBoolItem aItem( SID_NAVIGATOR_INIT, TRUE ); + if (GetDispatcher() != NULL) + GetDispatcher()->Execute( + SID_NAVIGATOR_INIT, + SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, + &aItem, + 0L); + + SfxViewShell* pViewShell = GetViewShell(); + OSL_ASSERT (pViewShell!=NULL); + SfxBindings& rBindings = pViewShell->GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_3D_STATE, TRUE, FALSE ); + + rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if(xSlideShow.is() && xSlideShow->isRunning() ) + { + xSlideShow->activate(GetViewShellBase()); + } + if(HasCurrentFunction()) + { + GetCurrentFunction()->Activate(); + } + + if(!GetDocSh()->IsUIActive()) + UpdatePreview( GetActualPage(), TRUE ); + + //HMH::sd::View* pView = GetView(); + + //HMHif (pView) + //HMH{ + //HMH pView->ShowMarkHdl(); + //HMH} + } + + ReadFrameViewData( mpFrameView ); + + if (IsMainViewShell()) + GetDocSh()->Connect(this); +} + +void ViewShell::UIActivating( SfxInPlaceClient* ) +{ + OSL_ASSERT (GetViewShell()!=NULL); + GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed(); +} + + + +void ViewShell::UIDeactivated( SfxInPlaceClient* ) +{ + OSL_ASSERT (GetViewShell()!=NULL); + GetViewShellBase().GetToolBarManager()->ToolBarsDestroyed(); + if ( GetDrawView() ) + GetViewShellBase().GetToolBarManager()->SelectionHasChanged(*this, *GetDrawView()); +} + +/************************************************************************* +|* +|* Deaktivierung +|* +\************************************************************************/ + +void ViewShell::Deactivate(BOOL bIsMDIActivate) +{ + // remove view from a still active drag'n'drop session + SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag; + + if (IsMainViewShell()) + GetDocSh()->Disconnect(this); + + if( pDragTransferable ) + pDragTransferable->SetView( NULL ); + + OSL_ASSERT (GetViewShell()!=NULL); + + // View-Attribute an der FrameView merken + WriteFrameViewData(); + + if (bIsMDIActivate) + { + rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if(xSlideShow.is() && xSlideShow->isRunning() ) + { + xSlideShow->deactivate(GetViewShellBase()); + } + if(HasCurrentFunction()) + { + GetCurrentFunction()->Deactivate(); + } + } + + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->SetActive(FALSE); + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->SetActive(FALSE); + + SfxShell::Deactivate(bIsMDIActivate); +} + + + + +void ViewShell::Shutdown (void) +{ + Exit (); +} + + + + +/************************************************************************* +|* +|* Keyboard event +|* +\************************************************************************/ + +BOOL ViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin) +{ + BOOL bReturn(FALSE); + + if(pWin) + { + SetActiveWindow(pWin); + } + + if(!bReturn) + { + // #76008# + // give key input first to SfxViewShell to give CTRL+Key + // (e.g. CTRL+SHIFT+'+', to front) priority. + OSL_ASSERT (GetViewShell()!=NULL); + bReturn = (BOOL)GetViewShell()->KeyInput(rKEvt); + } + + if(!bReturn) + { + rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + if(xSlideShow.is() && xSlideShow->isRunning()) + { + bReturn = xSlideShow->keyInput(rKEvt); + } + else + { + bool bConsumed = false; + if( GetView() ) + bConsumed = GetView()->getSmartTags().KeyInput(rKEvt); + + + if( !bConsumed ) + { + rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); + if( !xSelectionController.is() || !xSelectionController->onKeyInput( rKEvt, pWin ) ) + { + if(HasCurrentFunction()) + bReturn = GetCurrentFunction()->KeyInput(rKEvt); + } + else + { + bReturn = TRUE; + } + } + } + } + + if(!bReturn && GetActiveWindow()) + { + KeyCode aKeyCode = rKEvt.GetKeyCode(); + + if (aKeyCode.IsMod1() && aKeyCode.IsShift() + && aKeyCode.GetCode() == KEY_R) + { + InvalidateWindows(); + bReturn = TRUE; + } + } + + return(bReturn); +} + +/************************************************************************* +|* +|* MouseButtonDown event +|* +\************************************************************************/ + +void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin) +{ + // We have to lock tool bar updates while the mouse button is pressed in + // order to prevent the shape under the mouse to be moved (this happens + // when the number of docked tool bars changes as result of a changed + // selection; this changes the window size and thus the mouse position + // in model coordinates: with respect to model coordinates the mouse + // moves.) + OSL_ASSERT(mpImpl->mpUpdateLockForMouse.expired()); + mpImpl->mpUpdateLockForMouse = ViewShell::Implementation::ToolBarManagerLock::Create( + GetViewShellBase().GetToolBarManager()); + + if ( pWin && !pWin->HasFocus() ) + { + pWin->GrabFocus(); + SetActiveWindow(pWin); +// GetViewFrame()->GetWindow().GrabFocus(); + } + + // MouseEvent in E3dView eintragen + if (GetView() != NULL) + GetView()->SetMouseEvent(rMEvt); + + bool bConsumed = false; + if( GetView() ) + bConsumed = GetView()->getSmartTags().MouseButtonDown( rMEvt ); + + if( !bConsumed ) + { + rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); + if( !xSelectionController.is() || !xSelectionController->onMouseButtonDown( rMEvt, pWin ) ) + { + if(HasCurrentFunction()) + { + GetCurrentFunction()->MouseButtonDown(rMEvt); + } + } + } +} + +/************************************************************************* +|* +|* MouseMove event +|* +\************************************************************************/ + +void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin) +{ + if (rMEvt.IsLeaveWindow()) + { + if ( ! mpImpl->mpUpdateLockForMouse.expired()) + { + ::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock( + mpImpl->mpUpdateLockForMouse); + if (pLock.get() != NULL) + pLock->Release(); + } + } + + if ( pWin ) + { + SetActiveWindow(pWin); + } + + // MouseEvent in E3dView eintragen + if (GetView() != NULL) + GetView()->SetMouseEvent(rMEvt); + + if(HasCurrentFunction()) + { + rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); + if( !xSelectionController.is() || !xSelectionController->onMouseMove( rMEvt, pWin ) ) + { + if(HasCurrentFunction()) + GetCurrentFunction()->MouseMove(rMEvt); + } + } +} + +/************************************************************************* +|* +|* MouseButtonUp event +|* +\************************************************************************/ + +void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin) +{ + if ( pWin ) + { + SetActiveWindow(pWin); + } + + // MouseEvent in E3dView eintragen + if (GetView() != NULL) + GetView()->SetMouseEvent(rMEvt); + + if( HasCurrentFunction()) + { + rtl::Reference< sdr::SelectionController > xSelectionController( GetView()->getSelectionController() ); + if( !xSelectionController.is() || !xSelectionController->onMouseButtonUp( rMEvt, pWin ) ) + { + if(HasCurrentFunction()) + GetCurrentFunction()->MouseButtonUp(rMEvt); + } + } + + if ( ! mpImpl->mpUpdateLockForMouse.expired()) + { + ::boost::shared_ptr<ViewShell::Implementation::ToolBarManagerLock> pLock( + mpImpl->mpUpdateLockForMouse); + if (pLock.get() != NULL) + pLock->Release(); + } +} + + +/************************************************************************* +|* +|* Command event +|* +\************************************************************************/ + +void ViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin) +{ + BOOL bDone = HandleScrollCommand (rCEvt, pWin); + + if( !bDone ) + { + if( rCEvt.GetCommand() == COMMAND_INPUTLANGUAGECHANGE ) + { + //#i42732# update state of fontname if input language changes + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONT ); + GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT ); + } + else + { + bool bConsumed = false; + if( GetView() ) + { + bConsumed = GetView()->getSmartTags().Command(rCEvt); + } + + if( !bConsumed && HasCurrentFunction()) + { + GetCurrentFunction()->Command(rCEvt); + } + } + } +} + +long ViewShell::Notify(NotifyEvent& rNEvt, ::sd::Window* pWin) +{ + // handle scroll commands when they arrived at child windows + long nRet = FALSE; + if( rNEvt.GetType() == EVENT_COMMAND ) + { + // note: dynamic_cast is not possible as GetData() returns a void* + CommandEvent* pCmdEvent = reinterpret_cast< CommandEvent* >(rNEvt.GetData()); + nRet = HandleScrollCommand(*pCmdEvent, pWin); + } + return nRet; +} + + +BOOL ViewShell::HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin) +{ + BOOL bDone = FALSE; + + switch( rCEvt.GetCommand() ) + { + case COMMAND_WHEEL: + { + Reference< XSlideShowController > xSlideShowController( SlideShow::GetSlideShowController(GetViewShellBase() ) ); + if( xSlideShowController.is() ) + { + // We ignore zooming with control+mouse wheel. + const CommandWheelData* pData = rCEvt.GetWheelData(); + if( pData && !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) && !pData->IsHorz() ) + { + long nDelta = pData->GetDelta(); + if( nDelta > 0 ) + { + xSlideShowController->gotoPreviousSlide(); + } + else if( nDelta < 0 ) + { + xSlideShowController->gotoNextEffect(); + } + } + break; + } + } + // fall through when not running slideshow + case COMMAND_STARTAUTOSCROLL: + case COMMAND_AUTOSCROLL: + { + const CommandWheelData* pData = rCEvt.GetWheelData(); + + if (pData != NULL) + { + if (pData->IsMod1()) + { + if( !GetDocSh()->IsUIActive() ) + { + const long nOldZoom = GetActiveWindow()->GetZoom(); + long nNewZoom; + + if( pData->GetDelta() < 0L ) + nNewZoom = Max( (long) pWin->GetMinZoom(), (long)(nOldZoom - DELTA_ZOOM) ); + else + nNewZoom = Min( (long) pWin->GetMaxZoom(), (long)(nOldZoom + DELTA_ZOOM) ); + + SetZoom( nNewZoom ); + Invalidate( SID_ATTR_ZOOM ); + Invalidate( SID_ATTR_ZOOMSLIDER ); + + bDone = TRUE; + } + } + else + { + if( mpContentWindow.get() == pWin ) + { + ULONG nScrollLines = pData->GetScrollLines(); + if(IsPageFlipMode()) + nScrollLines = COMMAND_WHEEL_PAGESCROLL; + CommandWheelData aWheelData( pData->GetDelta(),pData->GetNotchDelta(), + nScrollLines,pData->GetMode(),pData->GetModifier(),pData->IsHorz() ); + CommandEvent aReWrite( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(), + rCEvt.IsMouseEvent(),(const void *) &aWheelData ); + bDone = pWin->HandleScrollCommand( aReWrite, + mpHorizontalScrollBar.get(), + mpVerticalScrollBar.get()); + } + } + } + } + break; + + default: + break; + } + + return bDone; +} + + + +void ViewShell::SetupRulers (void) +{ + if(mbHasRulers && (mpContentWindow.get() != NULL) && !SlideShow::IsRunning(GetViewShellBase())) + { + long nHRulerOfs = 0; + + if ( mpVerticalRuler.get() == NULL ) + { + mpVerticalRuler.reset(CreateVRuler(GetActiveWindow())); + if ( mpVerticalRuler.get() != NULL ) + { + nHRulerOfs = mpVerticalRuler->GetSizePixel().Width(); + mpVerticalRuler->SetActive(TRUE); + mpVerticalRuler->Show(); + } + } + if ( mpHorizontalRuler.get() == NULL ) + { + mpHorizontalRuler.reset(CreateHRuler(GetActiveWindow(), TRUE)); + if ( mpHorizontalRuler.get() != NULL ) + { + mpHorizontalRuler->SetWinPos(nHRulerOfs); + mpHorizontalRuler->SetActive(TRUE); + mpHorizontalRuler->Show(); + } + } + } +} + + + + +BOOL ViewShell::HasRuler (void) +{ + return mbHasRulers; +} + + + + +void ViewShell::Resize (void) +{ + SetupRulers (); + + if (mpParentWindow == NULL) + return; + + // Make sure that the new size is not degenerate. + const Size aSize (mpParentWindow->GetSizePixel()); + if (aSize.Width()==0 || aSize.Height()==0) + return; + + // Remember the new position and size. + maViewPos = Point(0,0); //mpParentWindow->GetPosPixel(); + maViewSize = aSize; + + // Rearrange the UI elements to take care of the new position and size. + ArrangeGUIElements (); + // end of included AdjustPosSizePixel. + + Size aS (GetParentWindow()->GetOutputSizePixel()); + Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); + Rectangle aVisArea = GetParentWindow()->PixelToLogic( + Rectangle( Point(0,0), aVisSizePixel)); + Rectangle aCurrentVisArea (GetDocSh()->GetVisArea(ASPECT_CONTENT)); + Rectangle aWindowRect = GetActiveWindow()->LogicToPixel(aCurrentVisArea); + if (GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED + && IsMainViewShell()) + { + // GetDocSh()->SetVisArea(aVisArea); + } + + // VisAreaChanged(aVisArea); + + ::sd::View* pView = GetView(); + + if (pView) + { + pView->VisAreaChanged(GetActiveWindow()); + } +} + +SvBorder ViewShell::GetBorder (bool ) +{ + SvBorder aBorder; + + // Horizontal scrollbar. + if (mpHorizontalScrollBar.get()!=NULL + && mpHorizontalScrollBar->IsVisible()) + { + aBorder.Bottom() = maScrBarWH.Height(); + } + + // Vertical scrollbar. + if (mpVerticalScrollBar.get()!=NULL + && mpVerticalScrollBar->IsVisible()) + { + aBorder.Right() = maScrBarWH.Width(); + } + + // Place horizontal ruler below tab bar. + if (mbHasRulers && mpContentWindow.get() != NULL) + { + SetupRulers(); + if (mpHorizontalRuler.get() != NULL) + aBorder.Top() = mpHorizontalRuler->GetSizePixel().Height(); + if (mpVerticalRuler.get() != NULL) + aBorder.Left() = mpVerticalRuler->GetSizePixel().Width(); + } + + return aBorder; +} + + + + +void ViewShell::ArrangeGUIElements (void) +{ + if (mpImpl->mbArrangeActive) + return; + mpImpl->mbArrangeActive = true; + + // Calculate border for in-place editing. + long nLeft = maViewPos.X(); + long nTop = maViewPos.Y(); + long nRight = maViewPos.X() + maViewSize.Width(); + long nBottom = maViewPos.Y() + maViewSize.Height(); + + // Horizontal scrollbar. + if (mpHorizontalScrollBar.get()!=NULL + && mpHorizontalScrollBar->IsVisible()) + { + int nLocalLeft = nLeft; + if (mpLayerTabBar.get()!=NULL && mpLayerTabBar->IsVisible()) + nLocalLeft += mpLayerTabBar->GetSizePixel().Width(); + nBottom -= maScrBarWH.Height(); + mpHorizontalScrollBar->SetPosSizePixel ( + Point(nLocalLeft,nBottom), + Size(nRight-nLocalLeft-maScrBarWH.Width(),maScrBarWH.Height())); + } + + // Vertical scrollbar. + if (mpVerticalScrollBar.get()!=NULL + && mpVerticalScrollBar->IsVisible()) + { + nRight -= maScrBarWH.Width(); + mpVerticalScrollBar->SetPosSizePixel ( + Point(nRight,nTop), + Size (maScrBarWH.Width(),nBottom-nTop)); + } + + // Filler in the lower right corner. + if (mpScrollBarBox.get() != NULL) + { + if (mpHorizontalScrollBar.get()!=NULL + && mpHorizontalScrollBar->IsVisible() + && mpVerticalScrollBar.get()!=NULL + && mpVerticalScrollBar->IsVisible()) + { + mpScrollBarBox->Show(); + mpScrollBarBox->SetPosSizePixel(Point(nRight, nBottom), maScrBarWH); + } + else + mpScrollBarBox->Hide(); + } + + // Place horizontal ruler below tab bar. + if (mbHasRulers && mpContentWindow.get() != NULL) + { + if (mpHorizontalRuler.get() != NULL) + { + Size aRulerSize = mpHorizontalRuler->GetSizePixel(); + aRulerSize.Width() = nRight - nLeft; + mpHorizontalRuler->SetPosSizePixel ( + Point(nLeft,nTop), aRulerSize); + if (mpVerticalRuler.get() != NULL) + mpHorizontalRuler->SetBorderPos( + mpVerticalRuler->GetSizePixel().Width()-1); + nTop += aRulerSize.Height(); + } + if (mpVerticalRuler.get() != NULL) + { + Size aRulerSize = mpVerticalRuler->GetSizePixel(); + aRulerSize.Height() = nBottom - nTop; + mpVerticalRuler->SetPosSizePixel ( + Point (nLeft,nTop), aRulerSize); + nLeft += aRulerSize.Width(); + } + } + + rtl::Reference< SlideShow > xSlideShow( SlideShow::GetSlideShow( GetViewShellBase() ) ); + + // The size of the window of the center pane is set differently from + // that of the windows in the docking windows. + bool bSlideShowActive = (xSlideShow.is() && xSlideShow->isRunning()) && !xSlideShow->isFullScreen() && xSlideShow->getAnimationMode() == ANIMATIONMODE_SHOW; + if ( !bSlideShowActive) + { + OSL_ASSERT (GetViewShell()!=NULL); + + mpContentWindow->SetPosSizePixel( + Point(nLeft,nTop), + Size(nRight-nLeft,nBottom-nTop)); + } + + // Windows in the center and rulers at the left and top side. + maAllWindowRectangle = Rectangle( + maViewPos, + Size(maViewSize.Width()-maScrBarWH.Width(), + maViewSize.Height()-maScrBarWH.Height())); + + if (mpContentWindow.get() != NULL) + { + mpContentWindow->UpdateMapOrigin(); + } + + UpdateScrollBars(); + + mpImpl->mbArrangeActive = false; +} + + + + +void ViewShell::SetUIUnit(FieldUnit eUnit) +{ + // Set unit at horizontal and vertical rulers. + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->SetUnit(eUnit); + + + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->SetUnit(eUnit); +} + +/************************************************************************* +|* +|* DefTab an den horizontalen Linealen setzen +|* +\************************************************************************/ +void ViewShell::SetDefTabHRuler( UINT16 nDefTab ) +{ + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->SetDefTabDist( nDefTab ); +} + + + + +/** Tell the FmFormShell that the view shell is closing. Give it the + oportunity to prevent that. +*/ +USHORT ViewShell::PrepareClose (BOOL bUI, BOOL bForBrowsing) +{ + USHORT nResult = TRUE; + + FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager()->GetFormShell(); + if (pFormShell != NULL) + nResult = pFormShell->PrepareClose (bUI, bForBrowsing); + + return nResult; +} + + + + +void ViewShell::UpdatePreview (SdPage*, BOOL ) +{ + // Do nothing. After the actual preview has been removed, + // OutlineViewShell::UpdatePreview() is the place where something + // usefull is still done. +} + +SfxUndoManager* ViewShell::ImpGetUndoManager (void) const +{ + const ViewShell* pMainViewShell = GetViewShellBase().GetMainViewShell().get(); + + if( pMainViewShell == 0 ) + pMainViewShell = this; + + ::sd::View* pView = pMainViewShell->GetView(); + + // check for text edit our outline view + if( pView ) + { + if( pMainViewShell->GetShellType() == ViewShell::ST_OUTLINE ) + { + OutlineView* pOlView = dynamic_cast< OutlineView* >( pView ); + if( pOlView ) + { + ::Outliner* pOutl = pOlView->GetOutliner(); + if( pOutl ) + return &pOutl->GetUndoManager(); + } + } + else if( pView->IsTextEdit() ) + { + SdrOutliner* pOL = pView->GetTextEditOutliner(); + if( pOL ) + return &pOL->GetUndoManager(); + } + } + + if( GetDocSh() ) + return GetDocSh()->GetUndoManager(); + + return NULL; +} + + + + +void ViewShell::ImpGetUndoStrings(SfxItemSet &rSet) const +{ + SfxUndoManager* pUndoManager = ImpGetUndoManager(); + if(pUndoManager) + { + sal_uInt16 nCount(pUndoManager->GetUndoActionCount()); + if(nCount) + { + // prepare list + List aStringList; + sal_uInt16 a; + + for( a = 0; a < nCount; a++) + { + // generate one String in list per undo step + String* pInsertString = new String(pUndoManager->GetUndoActionComment(a)); + aStringList.Insert(pInsertString, LIST_APPEND); + } + + // set item + rSet.Put(SfxStringListItem(SID_GETUNDOSTRINGS, &aStringList)); + + // delete Strings again + for(a = 0; a < nCount; a++) + delete (String*)aStringList.GetObject(a); + } + else + { + rSet.DisableItem(SID_GETUNDOSTRINGS); + } + } +} + +// ----------------------------------------------------------------------------- + +void ViewShell::ImpGetRedoStrings(SfxItemSet &rSet) const +{ + SfxUndoManager* pUndoManager = ImpGetUndoManager(); + if(pUndoManager) + { + sal_uInt16 nCount(pUndoManager->GetRedoActionCount()); + if(nCount) + { + // prepare list + List aStringList; + sal_uInt16 a; + + for( a = 0; a < nCount; a++) + { + // generate one String in list per undo step + String* pInsertString = new String(pUndoManager->GetRedoActionComment(a)); + aStringList.Insert(pInsertString, LIST_APPEND); + } + + // set item + rSet.Put(SfxStringListItem(SID_GETREDOSTRINGS, &aStringList)); + + // delete Strings again + for(a = 0; a < nCount; a++) + delete (String*)aStringList.GetObject(a); + } + else + { + rSet.DisableItem(SID_GETREDOSTRINGS); + } + } +} + +// ----------------------------------------------------------------------------- + +void ViewShell::ImpSidUndo(BOOL, SfxRequest& rReq) +{ + SfxUndoManager* pUndoManager = ImpGetUndoManager(); + sal_uInt16 nNumber(1); + const SfxItemSet* pReqArgs = rReq.GetArgs(); + + if(pReqArgs) + { + SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_UNDO); + nNumber = pUIntItem->GetValue(); + } + + if(nNumber && pUndoManager) + { + sal_uInt16 nCount(pUndoManager->GetUndoActionCount()); + if(nCount >= nNumber) + { + // #94637# when UndoStack is cleared by ModifyPageUndoAction + // the nCount may have changed, so test GetUndoActionCount() + while(nNumber-- && pUndoManager->GetUndoActionCount()) + { + pUndoManager->Undo(); + } + } + + // #91081# refresh rulers, maybe UNDO was move of TAB marker in ruler + if (mbHasRulers) + { + Invalidate(SID_ATTR_TABSTOP); + } + } + + // This one is corresponding to the default handling + // of SID_UNDO in sfx2 + GetViewFrame()->GetBindings().InvalidateAll(sal_False); + + rReq.Done(); +} + +// ----------------------------------------------------------------------------- + +void ViewShell::ImpSidRedo(BOOL, SfxRequest& rReq) +{ + SfxUndoManager* pUndoManager = ImpGetUndoManager(); + sal_uInt16 nNumber(1); + const SfxItemSet* pReqArgs = rReq.GetArgs(); + + if(pReqArgs) + { + SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_REDO); + nNumber = pUIntItem->GetValue(); + } + + if(nNumber && pUndoManager) + { + sal_uInt16 nCount(pUndoManager->GetRedoActionCount()); + if(nCount >= nNumber) + { + // #94637# when UndoStack is cleared by ModifyPageRedoAction + // the nCount may have changed, so test GetRedoActionCount() + while(nNumber-- && pUndoManager->GetRedoActionCount()) + { + pUndoManager->Redo(); + } + } + + // #91081# refresh rulers, maybe REDO was move of TAB marker in ruler + if (mbHasRulers) + { + Invalidate(SID_ATTR_TABSTOP); + } + } + + // This one is corresponding to the default handling + // of SID_UNDO in sfx2 + GetViewFrame()->GetBindings().InvalidateAll(sal_False); + + rReq.Done(); +} + +// ----------------------------------------------------------------------------- + +void ViewShell::ExecReq( SfxRequest& rReq ) +{ + USHORT nSlot = rReq.GetSlot(); + switch( nSlot ) + { + case SID_MAIL_SCROLLBODY_PAGEDOWN: + { + FunctionReference xFunc( GetCurrentFunction() ); + if( xFunc.is() ) + { + xFunc->ScrollStart(); + ScrollLines( 0, -1 ); + xFunc->ScrollEnd(); + } + + rReq.Done(); + } + break; + + case SID_OUTPUT_QUALITY_COLOR: + case SID_OUTPUT_QUALITY_GRAYSCALE: + case SID_OUTPUT_QUALITY_BLACKWHITE: + case SID_OUTPUT_QUALITY_CONTRAST: + { + ULONG nMode = OUTPUT_DRAWMODE_COLOR; + + switch( nSlot ) + { + case SID_OUTPUT_QUALITY_COLOR: nMode = OUTPUT_DRAWMODE_COLOR; break; + case SID_OUTPUT_QUALITY_GRAYSCALE: nMode = OUTPUT_DRAWMODE_GRAYSCALE; break; + case SID_OUTPUT_QUALITY_BLACKWHITE: nMode = OUTPUT_DRAWMODE_BLACKWHITE; break; + case SID_OUTPUT_QUALITY_CONTRAST: nMode = OUTPUT_DRAWMODE_CONTRAST; break; + } + + GetActiveWindow()->SetDrawMode( nMode ); + mpFrameView->SetDrawMode( nMode ); +// #110094#-7 +// GetView()->ReleaseMasterPagePaintCache(); + GetActiveWindow()->Invalidate(); + + Invalidate(); + rReq.Done(); + break; + } + } +} + + + + +/** This default implemenation returns only an empty reference. See derived + classes for more interesting examples. +*/ +::com::sun::star::uno::Reference< + ::com::sun::star::accessibility::XAccessible> +ViewShell::CreateAccessibleDocumentView (::sd::Window* ) +{ + return ::com::sun::star::uno::Reference< + ::com::sun::star::accessibility::XAccessible> (); +} + + + +::sd::WindowUpdater* ViewShell::GetWindowUpdater (void) const +{ + return mpWindowUpdater.get(); +} + + + + +ViewShellBase& ViewShell::GetViewShellBase (void) const +{ + return *static_cast<ViewShellBase*>(GetViewShell()); +} + + + + +ViewShell::ShellType ViewShell::GetShellType (void) const +{ + return meShellType; +} + + + + +DrawDocShell* ViewShell::GetDocSh (void) const +{ + return GetViewShellBase().GetDocShell(); +} + + + + +SdDrawDocument* ViewShell::GetDoc (void) const +{ + return GetViewShellBase().GetDocument(); +} + +ErrCode ViewShell::DoVerb (long ) +{ + return ERRCODE_NONE; +} + +void ViewShell::SetCurrentFunction( const FunctionReference& xFunction) +{ + if( mxCurrentFunction.is() && (mxOldFunction != mxCurrentFunction) ) + mxCurrentFunction->Dispose(); + FunctionReference xTemp( mxCurrentFunction ); + mxCurrentFunction = xFunction; +} + +void ViewShell::SetOldFunction(const FunctionReference& xFunction) +{ + if( mxOldFunction.is() && (xFunction != mxOldFunction) && (mxCurrentFunction != mxOldFunction) ) + mxOldFunction->Dispose(); + + FunctionReference xTemp( mxOldFunction ); + mxOldFunction = xFunction; +} + +/** this method deactivates the current function. If an old function is + saved, this will become activated and current function. +*/ +void ViewShell::Cancel() +{ + if(mxCurrentFunction.is() && (mxCurrentFunction != mxOldFunction )) + { + FunctionReference xTemp( mxCurrentFunction ); + mxCurrentFunction.clear(); + xTemp->Deactivate(); + xTemp->Dispose(); + } + + if(mxOldFunction.is()) + { + mxCurrentFunction = mxOldFunction; + mxCurrentFunction->Activate(); + } +} + +void ViewShell::DeactivateCurrentFunction( bool bPermanent /* == false */ ) +{ + if( mxCurrentFunction.is() ) + { + if(bPermanent && (mxOldFunction == mxCurrentFunction)) + mxOldFunction.clear(); + + mxCurrentFunction->Deactivate(); + if( mxCurrentFunction != mxOldFunction ) + mxCurrentFunction->Dispose(); + + FunctionReference xTemp( mxCurrentFunction ); + mxCurrentFunction.clear(); + } +} + +void ViewShell::DisposeFunctions() +{ + if(mxCurrentFunction.is()) + { + FunctionReference xTemp( mxCurrentFunction ); + mxCurrentFunction.clear(); + xTemp->Deactivate(); + xTemp->Dispose(); + } + + if(mxOldFunction.is()) + { + FunctionReference xTemp( mxOldFunction ); + mxOldFunction->Dispose(); + mxOldFunction.clear(); + } +} + +bool ViewShell::IsMainViewShell (void) const +{ + return mpImpl->mbIsMainViewShell; + // return GetViewShellBase().GetMainViewShell() == this; +} + +void ViewShell::SetIsMainViewShell (bool bIsMainViewShell) +{ + if (bIsMainViewShell != mpImpl->mbIsMainViewShell) + { + mpImpl->mbIsMainViewShell = bIsMainViewShell; + if (bIsMainViewShell) + { + GetDocSh()->Connect (this); + } + else + { + GetDocSh()->Disconnect (this); + } + } +} + + + + +::sd::Window* ViewShell::GetActiveWindow (void) const +{ + return mpActiveWindow; +} + + + + +void ViewShell::PrePaint() +{ +} + + + + +void ViewShell::Paint (const Rectangle&, ::sd::Window* ) +{ +} + + + + +void ViewShell::Draw(OutputDevice &, const Region &) +{ +} + + + + +ZoomList* ViewShell::GetZoomList (void) +{ + return mpZoomList; +} + + + + +void ViewShell::ShowUIControls (bool bVisible) +{ + mpImpl->mbIsShowingUIControls = bVisible; + + if (mbHasRulers) + { + if (mpHorizontalRuler.get() != NULL) + mpHorizontalRuler->Show( bVisible ); + + if (mpVerticalRuler.get() != NULL) + mpVerticalRuler->Show( bVisible ); + } + + if (mpVerticalScrollBar.get() != NULL) + mpVerticalScrollBar->Show( bVisible ); + + if (mpHorizontalScrollBar.get() != NULL) + mpHorizontalScrollBar->Show( bVisible ); + + if (mpScrollBarBox.get() != NULL) + mpScrollBarBox->Show(bVisible); + + if (mpContentWindow.get() != NULL) + mpContentWindow->Show( bVisible ); +} + + + + + +bool ViewShell::RelocateToParentWindow (::Window* pParentWindow) +{ + mpParentWindow = pParentWindow; + + mpParentWindow->SetBackground (Wallpaper()); + + if (mpContentWindow.get() != NULL) + mpContentWindow->SetParent(pParentWindow); + + if (mpHorizontalScrollBar.get() != NULL) + mpHorizontalScrollBar->SetParent(mpParentWindow); + if (mpVerticalScrollBar.get() != NULL) + mpVerticalScrollBar->SetParent(mpParentWindow); + if (mpScrollBarBox.get() != NULL) + mpScrollBarBox->SetParent(mpParentWindow); + + return true; +} + + + +} // end of namespace sd + + + + + +//===== ViewShellObjectBarFactory ============================================= + +namespace { + +ViewShellObjectBarFactory::ViewShellObjectBarFactory ( + ::sd::ViewShell& rViewShell) + : mrViewShell (rViewShell) +{ +} + + + + +ViewShellObjectBarFactory::~ViewShellObjectBarFactory (void) +{ + for (ShellCache::iterator aI(maShellCache.begin()); + aI!=maShellCache.end(); + aI++) + { + delete aI->second; + } +} + + + + +SfxShell* ViewShellObjectBarFactory::CreateShell ( + ::sd::ShellId nId, + ::Window*, + ::sd::FrameView* ) +{ + SfxShell* pShell = NULL; + + ShellCache::iterator aI (maShellCache.find(nId)); + if (aI == maShellCache.end() || aI->second==NULL) + { + ::sd::View* pView = mrViewShell.GetView(); + switch (nId) + { + case RID_BEZIER_TOOLBOX: + pShell = new ::sd::BezierObjectBar(&mrViewShell, pView); + break; + + case RID_DRAW_TEXT_TOOLBOX: + pShell = new ::sd::TextObjectBar( + &mrViewShell, mrViewShell.GetDoc()->GetPool(), pView); + break; + + case RID_DRAW_GRAF_TOOLBOX: + pShell = new ::sd::GraphicObjectBar(&mrViewShell, pView); + break; + + case RID_DRAW_MEDIA_TOOLBOX: + pShell = new ::sd::MediaObjectBar(&mrViewShell, pView); + break; + + case RID_DRAW_TABLE_TOOLBOX: + pShell = ::sd::ui::table::CreateTableObjectBar( mrViewShell, pView ); + break; + + case RID_SVX_EXTRUSION_BAR: + pShell = new ::svx::ExtrusionBar( + &mrViewShell.GetViewShellBase()); + break; + + case RID_SVX_FONTWORK_BAR: + pShell = new ::svx::FontworkBar( + &mrViewShell.GetViewShellBase()); + break; + + default: + pShell = NULL; + break; + } + } + else + pShell = aI->second; + + return pShell; +} + + + + +void ViewShellObjectBarFactory::ReleaseShell (SfxShell* pShell) +{ + if (pShell != NULL) + delete pShell; +} + +} // end of anonymous namespace diff --git a/sd/source/ui/view/zoomlist.cxx b/sd/source/ui/view/zoomlist.cxx new file mode 100755 index 000000000000..9ae178e3d7a6 --- /dev/null +++ b/sd/source/ui/view/zoomlist.cxx @@ -0,0 +1,197 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * 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. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_sd.hxx" + +#include "zoomlist.hxx" + +#ifndef _SVXIDS_HRC +#include <svx/svxids.hrc> +#endif +#include <sfx2/bindings.hxx> +#include <sfx2/viewfrm.hxx> +#ifndef _SFXVIEWSHELL_HXX +#include <sfx2/viewsh.hxx> +#endif + + +#include "ViewShell.hxx" + +namespace sd { + +#define MAX_ENTRYS 10 + +/************************************************************************* +|* +|* Konstruktor +|* +\************************************************************************/ + +ZoomList::ZoomList(ViewShell* pViewShell) +: List() +, mpViewShell (pViewShell) +, mnCurPos(0) +{ +} + + +/************************************************************************* +|* +|* Destruktor +|* +\************************************************************************/ + +ZoomList::~ZoomList() +{ +#if ( defined GCC && defined C272 ) + for (ULONG nObject=0; nObject<List::Count(); nObject++) +#else + for (ULONG nObject=0; nObject<Count(); nObject++) +#endif + { + // Ggf. ZoomRects loeschen + delete ((Rectangle*) GetObject(nObject)); + } +} + + +/************************************************************************* +|* +|* Neues ZoomRect aufnehmen +|* +\************************************************************************/ + +void ZoomList::InsertZoomRect(const Rectangle& rRect) +{ + ULONG nRectCount = Count(); + + if (nRectCount >= MAX_ENTRYS) + { + delete ((Rectangle*) GetObject(0)); + Remove((ULONG) 0); + } + else if (nRectCount == 0) + { + mnCurPos = 0; + } + else + { + mnCurPos++; + } + + Rectangle* pRect = new Rectangle(rRect); + Insert(pRect, mnCurPos); + + SfxBindings& rBindings = mpViewShell->GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_ZOOM_NEXT ); + rBindings.Invalidate( SID_ZOOM_PREV ); +} + +/************************************************************************* +|* +|* Naechstes ZoomRect herausgeben +|* +\************************************************************************/ + +Rectangle ZoomList::GetNextZoomRect() +{ + mnCurPos++; + ULONG nRectCount = Count(); + + if (nRectCount > 0 && mnCurPos > nRectCount - 1) + { + mnCurPos = nRectCount - 1; + } + + SfxBindings& rBindings = mpViewShell->GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_ZOOM_NEXT ); + rBindings.Invalidate( SID_ZOOM_PREV ); + + Rectangle aRect(*(Rectangle*) GetObject(mnCurPos)); + return (aRect); +} + +/************************************************************************* +|* +|* Letztes ZoomRect herausgeben +|* +\************************************************************************/ + +Rectangle ZoomList::GetPreviousZoomRect() +{ + if (mnCurPos > 0) + { + mnCurPos--; + } + + SfxBindings& rBindings = mpViewShell->GetViewFrame()->GetBindings(); + rBindings.Invalidate( SID_ZOOM_NEXT ); + rBindings.Invalidate( SID_ZOOM_PREV ); + + Rectangle aRect(*(Rectangle*) GetObject(mnCurPos)); + return (aRect); +} + +/************************************************************************* +|* +|* Gibt es ein naechstes ZoomRect? +|* +\************************************************************************/ + +BOOL ZoomList::IsNextPossible() const +{ + BOOL bPossible = FALSE; + ULONG nRectCount = Count(); + + if (nRectCount > 0 && mnCurPos < nRectCount - 1) + { + bPossible = TRUE; + } + + return (bPossible); +} + +/************************************************************************* +|* +|* Gibt es ein vorheriges ZoomRect? +|* +\************************************************************************/ + +BOOL ZoomList::IsPreviousPossible() const +{ + BOOL bPossible = FALSE; + + if (mnCurPos > 0) + { + bPossible = TRUE; + } + + return (bPossible); +} + +} // end of namespace sd |