| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sd.hxx" |
| |
| #include "OutlineViewShell.hxx" |
| |
| #include "ViewShellImplementation.hxx" |
| #include <memory> |
| #include "helpids.h" |
| #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 <sfx2/sidebar/SidebarChildWindow.hxx> |
| #include <sfx2/sidebar/EnumContext.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 ); |
| SFX_CHILDWINDOW_REGISTRATION(::sfx2::sidebar::SidebarChildWindow::GetChildWindowId()); |
| } |
| |
| |
| TYPEINIT1( OutlineViewShell, ViewShell ); |
| |
| |
| /************************************************************************* |
| |* |
| |* gemeinsamer Initialiserungsanteil der beiden Konstruktoren |
| |* |
| \************************************************************************/ |
| |
| void OutlineViewShell::Construct(DrawDocShell* ) |
| { |
| sal_Bool bModified = GetDoc()->IsChanged(); |
| |
| meShellType = ST_OUTLINE; |
| Size aSize(29700, 21000); |
| Point aWinPos (0, 0); |
| Point aViewOrigin(0, 0); |
| GetActiveWindow()->SetMinZoomAutoCalc(sal_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(sal_True); |
| |
| if (!bModified) |
| { |
| pOutl->ClearModifyFlag(); |
| } |
| |
| pLastPage = GetActualPage(); |
| |
| String aName( RTL_CONSTASCII_USTRINGPARAM( "OutlineViewShell" )); |
| SetName (aName); |
| |
| SetHelpId( SD_IF_SDOUTLINEVIEWSHELL ); |
| GetActiveWindow()->SetHelpId( HID_SDOUTLINEVIEWSHELL ); |
| GetActiveWindow()->SetUniqueId( HID_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()); |
| |
| SetContextName(sfx2::sidebar::EnumContext::GetContextName(sfx2::sidebar::EnumContext::Context_OutlineText)); |
| m_StrOldPageName.EmptyString(); |
| } |
| |
| /************************************************************************* |
| |* |
| |* Destruktor |
| |* |
| \************************************************************************/ |
| |
| OutlineViewShell::~OutlineViewShell() |
| { |
| DisposeFunctions(); |
| |
| delete pOlView; |
| |
| mpFrameView->Disconnect(); |
| |
| if ( pClipEvtLstnr ) |
| { |
| pClipEvtLstnr->AddRemoveListener( GetActiveWindow(), sal_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(sal_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) |
| { |
| sal_uInt16 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( sal_Bool bIsMDIActivate ) |
| { |
| if ( ! mbInitialized) |
| { |
| mbInitialized = true; |
| SfxRequest aRequest (SID_EDIT_OUTLINER, 0, GetDoc()->GetItemPool()); |
| FuPermanent (aRequest); |
| } |
| |
| ViewShell::Activate( bIsMDIActivate ); |
| SfxShell::BroadcastContextForActivation(true); |
| |
| pOlView->SetLinks(); |
| pOlView->ConnectToApplication(); |
| |
| if( bIsMDIActivate ) |
| { |
| OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() ); |
| ::Outliner* pOutl = pOutlinerView->GetOutliner(); |
| pOutl->UpdateFields(); |
| } |
| } |
| |
| /************************************************************************* |
| |* |
| |* Deactivate() |
| |* |
| \************************************************************************/ |
| void OutlineViewShell::Deactivate( sal_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, sal_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()); |
| |
| sal_Bool bPreviewState = sal_False; |
| sal_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 = sal_True; |
| } |
| break; |
| |
| case SID_COPY: |
| { |
| if(HasCurrentFunction()) |
| { |
| GetCurrentFunction()->DoCopy(); |
| } |
| else if (pOlView) |
| { |
| pOlView->DoCopy(); |
| } |
| rReq.Done(); |
| bPreviewState = sal_True; |
| } |
| break; |
| |
| case SID_PASTE: |
| { |
| OutlineViewPageChangesGuard aGuard2(pOlView); |
| |
| if(HasCurrentFunction()) |
| { |
| GetCurrentFunction()->DoPaste(); |
| } |
| else if (pOlView) |
| { |
| pOlView->DoPaste(); |
| } |
| rReq.Done(); |
| bPreviewState = sal_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 = sal_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 = sal_True; |
| } |
| break; |
| |
| // #96090# added Undo/Redo handling |
| case SID_UNDO : |
| { |
| OutlineViewPageChangesGuard aGuard2(pOlView); |
| ImpSidUndo(sal_False, rReq); |
| } |
| break; |
| case SID_REDO : |
| { |
| OutlineViewPageChangesGuard aGuard2(pOlView); |
| ImpSidRedo(sal_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, sal_False)); |
| rSet.Put(SfxBoolItem(SID_DRAWINGMODE, sal_False)); |
| rSet.Put(SfxBoolItem(SID_OUTLINEMODE, sal_True)); |
| rSet.Put(SfxBoolItem(SID_NOTESMODE, sal_False)); |
| rSet.Put(SfxBoolItem(SID_HANDOUTMODE, sal_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 ) ) |
| { |
| sal_uLong nParaCount = pOutl->GetParagraphCount(); |
| sal_Bool bDisable = nParaCount == 0; |
| if (!bDisable && nParaCount == 1) |
| { |
| String aTest( pOutl->GetText( pOutl->GetParagraph( 0 ) ) ); |
| if (aTest.Len() == 0) |
| { |
| bDisable = sal_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 |
| sal_uLong nCntrl = pOutl->GetControlWord(); |
| sal_Bool bNoColor = sal_False; |
| if (nCntrl & EE_CNTRL_NOCOLORS) |
| bNoColor = sal_True; |
| |
| rSet.Put( SfxBoolItem( SID_COLORVIEW, bNoColor ) ); |
| } |
| |
| // Buttons der Werkzeugleiste |
| // zunaechst selektionsabhaengige: COLLAPSE, EXPAND |
| sal_Bool bDisableCollapse = sal_True; |
| sal_Bool bDisableExpand = sal_True; |
| sal_Bool bUnique = sal_True; |
| OutlinerView* pOutlinerView = pOlView->GetViewByWindow(GetActiveWindow()); |
| List* pList = pOutlinerView->CreateSelectionList(); |
| Paragraph* pPara = (Paragraph*)pList->First(); |
| |
| sal_Int16 nDepth; |
| sal_Int16 nTmpDepth = pOutl->GetDepth( (sal_uInt16) pOutl->GetAbsPos( pPara ) ); |
| bool bPage = pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE ); |
| while (pPara) |
| { |
| nDepth = pOutl->GetDepth( (sal_uInt16) pOutl->GetAbsPos( pPara ) ); |
| |
| if( nDepth != nTmpDepth ) |
| bUnique = sal_False; |
| if( bPage != pOutl->HasParaFlag( pPara, PARAFLAG_ISPAGE ) ) |
| bUnique = sal_False; |
| if (!pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara)) |
| bDisableExpand = sal_False; |
| if (pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara)) |
| bDisableCollapse = sal_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 = sal_False; |
| rSet.DisableItem(SID_PRESENTATION_TEMPLATES); |
| } |
| |
| if (!bUnique) |
| rSet.DisableItem( SID_PRESENTATIONOBJECT ); |
| |
| // jetzt die selektionsunabhaengigen: COLLAPSE_ALL, EXPAND_ALL |
| sal_Bool bDisableCollapseAll = sal_True; |
| sal_Bool bDisableExpandAll = sal_True; |
| |
| // wenn schon die Selektion etwas kollabierbares/expandierbares enthaelt |
| if (!bDisableCollapse) |
| bDisableCollapseAll = sal_False; |
| if (!bDisableExpand) |
| bDisableExpandAll = sal_False; |
| |
| // schade, so billig kommen wir nicht davon; alle Absaetze durchsuchen |
| if (bDisableCollapseAll || bDisableExpandAll) |
| { |
| sal_uLong nParaPos = 0; |
| pPara = pOutl->GetParagraph( nParaPos ); |
| while (pPara && (bDisableCollapseAll || bDisableExpandAll)) |
| { |
| if (!pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara)) |
| bDisableExpandAll = sal_False; |
| |
| if (pOutl->IsExpanded(pPara) && pOutl->HasChilds(pPara)) |
| bDisableCollapseAll = sal_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(), sal_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(sal_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, sal_True)); |
| } |
| else |
| { |
| rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, sal_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)) |
| { |
| sal_Bool bDisable = sal_True; |
| sal_uInt16 i = 0; |
| sal_uInt16 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!=NULL ) |
| { |
| if( !pObj->IsEmptyPresObj() ) |
| { |
| bDisable = false; |
| } |
| else |
| { |
| // check if the object is in edit, than its temporarely not empty |
| SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj ); |
| if( pTextObj ) |
| { |
| OutlinerParaObject* pParaObj = pTextObj->GetEditOutlinerParaObject(); |
| if( pParaObj ) |
| { |
| delete pParaObj; |
| bDisable = false; |
| } |
| } |
| } |
| } |
| } |
| |
| i++; |
| } |
| |
| if (bDisable) |
| { |
| rSet.DisableItem(SID_EXPAND_PAGE); |
| } |
| } |
| |
| if (SFX_ITEM_AVAILABLE == rSet.GetItemState(SID_SUMMARY_PAGE)) |
| { |
| sal_Bool bDisable = sal_True; |
| sal_uInt16 i = 0; |
| sal_uInt16 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 = sal_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 ) ) |
| { |
| sal_Bool bDisable = sal_True; |
| sal_uInt16 nCount = GetDoc()->GetSdPageCount( PK_STANDARD ); |
| |
| for( sal_uInt16 i = 0; i < nCount && bDisable; i++ ) |
| { |
| SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD); |
| |
| if( !pPage->IsExcluded() ) |
| bDisable = sal_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(sal_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(sal_False); |
| |
| pOlView->InvalidateSlideNumberArea(); |
| |
| return 0; |
| } |
| |
| /************************************************************************* |
| |* |
| |* PrepareClose, wird gerufen, wenn die Shell zestoert werden soll, |
| |* leitet den Aufruf an die View weiter |
| |* |
| \************************************************************************/ |
| |
| sal_uInt16 OutlineViewShell::PrepareClose( sal_Bool bUI, sal_Bool bForBrowsing ) |
| { |
| if( ViewShell::PrepareClose(bUI, bForBrowsing) != sal_True ) |
| return sal_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( sal_True ); // Attribut-Darstellung ausschalten |
| else |
| pOutl->SetFlatMode( sal_False ); // Attribut-Darstellung einschalten |
| |
| sal_uLong nCntrl = pOutl->GetControlWord(); |
| |
| if ( pView->IsNoColors() ) |
| pOutl->SetControlWord(nCntrl | EE_CNTRL_NOCOLORS); // Farbansicht ausschalten |
| else |
| pOutl->SetControlWord(nCntrl & ~EE_CNTRL_NOCOLORS); // Farbansicht einschalten |
| |
| sal_uInt16 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(); |
| |
| sal_uLong nCntrl = pOutl->GetControlWord(); |
| sal_Bool bNoColor = sal_False; |
| if (nCntrl & EE_CNTRL_NOCOLORS) |
| bNoColor = sal_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; |
| sal_uInt16 nZoom = (sal_uInt16) GetActiveWindow()->GetZoom(); |
| |
| pZoomItem = new SvxZoomItem( SVX_ZOOM_PERCENT, nZoom ); |
| |
| // Bereich einschraenken |
| sal_uInt16 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( (sal_uInt16) pActiveWindow->GetZoom(), (sal_uInt16)pActiveWindow->GetMinZoom(), (sal_uInt16)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 ) ) |
| */ |
| sal_uInt16 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? |
| sal_uLong nPos = 0L; |
| while( pFirstPara ) |
| { |
| pFirstPara = pOlView->GetPrevTitle( pFirstPara ); |
| if( pFirstPara ) |
| nPos++; |
| } |
| |
| if( nPos >= GetDoc()->GetSdPageCount( PK_STANDARD ) ) |
| nPos = 0; |
| |
| SdrPage* pPage = GetDoc()->GetSdPage( (sal_uInt16) nPos, PK_STANDARD ); |
| |
| aPageStr = String(SdResId( STR_SD_PAGE )); |
| aPageStr += sal_Unicode(' '); |
| aPageStr += String::CreateFromInt32( (sal_Int32)(nPos + 1) ); // sal_uLong -> sal_Int32 |
| aPageStr.AppendAscii( RTL_CONSTASCII_STRINGPARAM( " / " )); |
| aPageStr += String::CreateFromInt32( nPageCount ); |
| |
| aLayoutStr = pPage->GetLayoutName(); |
| aLayoutStr.Erase( aLayoutStr.SearchAscii( SD_LT_SEPARATOR ) ); |
| //Now, CurrentPage property change is already sent for DrawView and OutlineView, so it is not necessary to send again here |
| if(m_StrOldPageName!=aPageStr) |
| { |
| GetViewShellBase().GetDrawController().fireSwitchCurrentPage(nPos); |
| m_StrOldPageName = aPageStr; |
| } |
| } |
| 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 |
| |* |
| \************************************************************************/ |
| |
| sal_Bool OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin) |
| { |
| sal_Bool bReturn = sal_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(sal_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? |
| |* |
| \************************************************************************/ |
| |
| sal_Bool OutlineViewShell::HasSelection(sal_Bool bText) const |
| { |
| sal_Bool bReturn = sal_False; |
| |
| if (bText) |
| { |
| OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() ); |
| |
| if (pOutlinerView && pOutlinerView->GetSelected().Len() != 0) |
| { |
| bReturn = sal_True; |
| } |
| } |
| |
| return bReturn; |
| } |
| |
| |
| /************************************************************************* |
| |* |
| |* Status der Attribut-Items |
| |* |
| \************************************************************************/ |
| |
| void OutlineViewShell::GetAttrState( SfxItemSet& rSet ) |
| { |
| SfxWhichIter aIter( rSet ); |
| sal_uInt16 nWhich = aIter.FirstWhich(); |
| SfxAllItemSet aAllSet( *rSet.GetPool() ); |
| |
| while ( nWhich ) |
| { |
| sal_uInt16 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, sal_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(); |
| } |
| |
| |
| void OutlineViewShell::UpdatePreview( SdPage* pPage, sal_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 = sal_True; |
| } |
| |
| // if we have a title object and a text, set the text |
| if( pTO ) |
| { |
| pOPO = pOutliner->CreateParaObject( (sal_uInt16) 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( sal_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(sal_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; |
| |
| sal_Bool bNewObject = sal_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? |
| sal_uLong nTitlePara = pOutliner->GetAbsPos( pPara ); |
| sal_uLong nPara = nTitlePara + 1; |
| sal_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( (sal_uInt16) nTitlePara + 1, (sal_uInt16) 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 = sal_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( sal_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(sal_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 |
| |* |
| \************************************************************************/ |
| |
| sal_uLong OutlineViewShell::Read(SvStream& rInput, const String& rBaseURL, sal_uInt16 eFormat) |
| { |
| sal_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 ); |
| |
| sal_uInt16 nParaCount = (sal_uInt16)pOutl->GetParagraphCount(); |
| if ( nParaCount > 0 ) |
| { |
| for ( sal_uInt16 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 ); |
| sal_uInt16 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 (sal_uInt16 i=0; i<GetDoc()->GetSdPageCount(PK_STANDARD); i++) |
| GetDoc()->SetSelected( |
| GetDoc()->GetSdPage(i, PK_STANDARD), |
| sal_False); |
| GetDoc()->SetSelected (pPage, sal_True); |
| |
| DrawController& rController(GetViewShellBase().GetDrawController()); |
| rController.FireSelectionChangeListener(); |
| rController.FireSwitchCurrentPage (pPage); |
| |
| pOlView->SetActualPage(pPage); |
| } |
| |
| |
| } // end of namespace sd |