LCOV - code coverage report
Current view: top level - sd/source/ui/annotations - annotationwindow.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 1 396 0.3 %
Date: 2015-06-13 12:38:46 Functions: 2 44 4.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <editeng/fontitem.hxx>
      21             : #include <editeng/eeitem.hxx>
      22             : #include <editeng/fhgtitem.hxx>
      23             : #include <editeng/bulletitem.hxx>
      24             : #include <editeng/udlnitem.hxx>
      25             : #include <editeng/shdditem.hxx>
      26             : #include <editeng/flditem.hxx>
      27             : #include <editeng/frmdir.hxx>
      28             : #include <editeng/frmdiritem.hxx>
      29             : #include <editeng/langitem.hxx>
      30             : #include <editeng/adjustitem.hxx>
      31             : #include <editeng/editview.hxx>
      32             : #include <svx/svdview.hxx>
      33             : #include <svx/sdrpaintwindow.hxx>
      34             : #include <svx/sdr/overlay/overlaymanager.hxx>
      35             : #include <editeng/editstat.hxx>
      36             : #include <editeng/outliner.hxx>
      37             : #include <editeng/editeng.hxx>
      38             : #include <editeng/editobj.hxx>
      39             : #include <editeng/unolingu.hxx>
      40             : #include <editeng/outlobj.hxx>
      41             : #include <editeng/postitem.hxx>
      42             : #include <editeng/wghtitem.hxx>
      43             : #include <editeng/crossedoutitem.hxx>
      44             : #include <svx/svxids.hrc>
      45             : #include <svtools/langtab.hxx>
      46             : #include <svl/slstitm.hxx>
      47             : #include <unotools/securityoptions.hxx>
      48             : #include <unotools/useroptions.hxx>
      49             : #include <svl/languageoptions.hxx>
      50             : #include <svl/zforlist.hxx>
      51             : #include <svtools/svmedit.hxx>
      52             : 
      53             : #include <linguistic/lngprops.hxx>
      54             : 
      55             : #include <sfx2/request.hxx>
      56             : #include <sfx2/viewfrm.hxx>
      57             : #include <sfx2/bindings.hxx>
      58             : #include <sfx2/dispatch.hxx>
      59             : #include <sfx2/mnumgr.hxx>
      60             : 
      61             : #include <vcl/vclenum.hxx>
      62             : #include <vcl/edit.hxx>
      63             : #include <vcl/help.hxx>
      64             : #include <vcl/scrbar.hxx>
      65             : #include <vcl/button.hxx>
      66             : #include <vcl/svapp.hxx>
      67             : #include <vcl/gradient.hxx>
      68             : #include <vcl/cursor.hxx>
      69             : #include <vcl/settings.hxx>
      70             : 
      71             : #include <tools/helpers.hxx>
      72             : 
      73             : #include <basegfx/matrix/b2dhommatrix.hxx>
      74             : #include <basegfx/tuple/b2dtuple.hxx>
      75             : #include <basegfx/polygon/b2dpolygontools.hxx>
      76             : 
      77             : #include "annotations.hrc"
      78             : #include "annotationwindow.hxx"
      79             : #include "annotationmanagerimpl.hxx"
      80             : 
      81             : #include "DrawDocShell.hxx"
      82             : #include "ViewShell.hxx"
      83             : #include "drawdoc.hxx"
      84             : #include "View.hxx"
      85             : #include "textapi.hxx"
      86             : #include "sdresid.hxx"
      87             : 
      88             : #include <boost/scoped_ptr.hpp>
      89             : 
      90             : using namespace ::sd;
      91             : using namespace ::com::sun::star;
      92             : using namespace ::com::sun::star::uno;
      93             : using namespace ::com::sun::star::office;
      94             : using namespace ::com::sun::star::text;
      95             : 
      96             : #define METABUTTON_WIDTH        16
      97             : #define METABUTTON_HEIGHT       18
      98             : #define METABUTTON_AREA_WIDTH   30
      99             : #define POSTIT_META_HEIGHT  (sal_Int32)     30
     100             : 
     101             : namespace sd {
     102             : 
     103           0 : Color ColorFromAlphaColor(sal_uInt8 aTransparency, Color &aFront, Color &aBack )
     104             : {
     105           0 :     return Color((sal_uInt8)(aFront.GetRed()    * aTransparency/(double)255 + aBack.GetRed()    * (1-aTransparency/(double)255)),
     106           0 :                  (sal_uInt8)(aFront.GetGreen()  * aTransparency/(double)255 + aBack.GetGreen()  * (1-aTransparency/(double)255)),
     107           0 :                  (sal_uInt8)(aFront.GetBlue()   * aTransparency/(double)255 + aBack.GetBlue()   * (1-aTransparency/(double)255)));
     108             : }
     109             : 
     110             : /************ AnnotationTextWindow **********************************/
     111             : 
     112           0 : AnnotationTextWindow::AnnotationTextWindow( AnnotationWindow* pParent, WinBits nBits )
     113             : : Control(pParent, nBits)
     114             : , mpOutlinerView(0)
     115           0 : , mpAnnotationWindow( pParent )
     116             : {
     117           0 : }
     118             : 
     119           0 : AnnotationTextWindow::~AnnotationTextWindow()
     120             : {
     121           0 :     disposeOnce();
     122           0 : }
     123             : 
     124           0 : void AnnotationTextWindow::dispose()
     125             : {
     126           0 :     mpAnnotationWindow.clear();
     127           0 :     Control::dispose();
     128           0 : }
     129             : 
     130           0 : void AnnotationTextWindow::Paint( vcl::RenderContext& /*rRenderContext*/, const Rectangle& rRect)
     131             : {
     132           0 :     const bool bHighContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
     133           0 :     if ( !bHighContrast )
     134             :     {
     135           0 :         DrawGradient(Rectangle(Point(0,0),PixelToLogic(GetSizePixel())),
     136           0 :             Gradient(GradientStyle_LINEAR,mpAnnotationWindow->maColorLight,mpAnnotationWindow->maColor));
     137             :      }
     138             : 
     139           0 :     if( mpOutlinerView )
     140             :     {
     141           0 :         Color aBackgroundColor( mpAnnotationWindow->maColor );
     142           0 :         if( bHighContrast )
     143             :         {
     144           0 :             aBackgroundColor = GetSettings().GetStyleSettings().GetWindowColor();
     145             :         }
     146             : 
     147           0 :         mpOutlinerView->SetBackgroundColor( aBackgroundColor );
     148             : 
     149           0 :         mpOutlinerView->Paint( rRect );
     150             :     }
     151           0 : }
     152             : 
     153           0 : void AnnotationTextWindow::KeyInput( const KeyEvent& rKeyEvt )
     154             : {
     155           0 :     const vcl::KeyCode& rKeyCode = rKeyEvt.GetKeyCode();
     156           0 :     sal_uInt16 nKey = rKeyCode.GetCode();
     157             : 
     158           0 :     if ((rKeyCode.IsMod1() && rKeyCode.IsMod2()) && ((nKey == KEY_PAGEUP) || (nKey == KEY_PAGEDOWN)))
     159             :     {
     160           0 :         SfxDispatcher* pDispatcher = mpAnnotationWindow->DocShell()->GetViewShell()->GetViewFrame()->GetDispatcher();
     161           0 :         if( pDispatcher )
     162           0 :             pDispatcher->Execute( nKey == KEY_PAGEDOWN ? SID_NEXT_POSTIT : SID_PREVIOUS_POSTIT );
     163             :     }
     164           0 :     else if (nKey == KEY_INSERT)
     165             :     {
     166           0 :         if (!rKeyCode.IsMod1() && !rKeyCode.IsMod2())
     167           0 :             mpAnnotationWindow->ToggleInsMode();
     168             :     }
     169             :     else
     170             :     {
     171           0 :         long aOldHeight = mpAnnotationWindow->GetPostItTextHeight();
     172           0 :         bool bDone = false;
     173             : 
     174             :         /// HACK: need to switch off processing of Undo/Redo in Outliner
     175           0 :         if ( !( (nKey == KEY_Z || nKey == KEY_Y) && rKeyCode.IsMod1()) )
     176             :         {
     177           0 :             bool bIsProtected = mpAnnotationWindow->IsProtected();
     178           0 :             if (!bIsProtected || (bIsProtected && !EditEngine::DoesKeyChangeText(rKeyEvt)) )
     179             : 
     180           0 :             bDone = mpOutlinerView->PostKeyEvent( rKeyEvt );
     181             :         }
     182           0 :         if (bDone)
     183             :         {
     184           0 :             mpAnnotationWindow->ResizeIfNecessary(aOldHeight,mpAnnotationWindow->GetPostItTextHeight());
     185             :         }
     186             :         else
     187             :         {
     188           0 :             Control::KeyInput(rKeyEvt);
     189             :         }
     190             :     }
     191           0 : }
     192             : 
     193           0 : void AnnotationTextWindow::MouseMove( const MouseEvent& rMEvt )
     194             : {
     195           0 :     if ( mpOutlinerView )
     196             :     {
     197           0 :         mpOutlinerView->MouseMove( rMEvt );
     198           0 :         SetPointer( mpOutlinerView->GetPointer( rMEvt.GetPosPixel() ) );
     199             :     }
     200           0 : }
     201             : 
     202           0 : void AnnotationTextWindow::MouseButtonDown( const MouseEvent& rMEvt )
     203             : {
     204           0 :     GrabFocus();
     205           0 :     if ( mpOutlinerView )
     206           0 :         mpOutlinerView->MouseButtonDown( rMEvt );
     207             :     // todo mpOutlinerView->DocView()->GetViewFrame()->GetBindings().InvalidateAll(sal_False);
     208           0 : }
     209             : 
     210           0 : void AnnotationTextWindow::MouseButtonUp( const MouseEvent& rMEvt )
     211             : {
     212           0 :     if ( mpOutlinerView )
     213           0 :         mpOutlinerView->MouseButtonUp( rMEvt );
     214           0 : }
     215             : 
     216           0 : void AnnotationTextWindow::Command( const CommandEvent& rCEvt )
     217             : {
     218           0 :     if ( rCEvt.GetCommand() == CommandEventId::ContextMenu )
     219             :     {
     220           0 :            mpAnnotationWindow->Command(rCEvt);
     221             :     }
     222             :     else
     223             :     {
     224           0 :         if ( mpOutlinerView )
     225           0 :             mpOutlinerView->Command( rCEvt );
     226             :         else
     227           0 :             Window::Command(rCEvt);
     228             :     }
     229           0 : }
     230             : 
     231           0 : void AnnotationTextWindow::GetFocus()
     232             : {
     233           0 :     Window::GetFocus();
     234           0 : }
     235             : 
     236           0 : void AnnotationTextWindow::LoseFocus()
     237             : {
     238           0 :     Window::LoseFocus();
     239           0 : }
     240             : 
     241           0 : OUString AnnotationTextWindow::GetSurroundingText() const
     242             : {
     243           0 :     if( mpOutlinerView )
     244             :     {
     245           0 :         EditEngine *aEditEngine = mpOutlinerView->GetEditView().GetEditEngine();
     246           0 :         if( mpOutlinerView->HasSelection() )
     247           0 :             return mpOutlinerView->GetSelected();
     248             :         else
     249             :         {
     250           0 :             ESelection aSelection = mpOutlinerView->GetEditView().GetSelection();
     251           0 :             return aEditEngine->GetText(aSelection.nStartPara);
     252             :         }
     253             :     }
     254           0 :     return OUString();
     255             : }
     256             : 
     257           0 : Selection AnnotationTextWindow::GetSurroundingTextSelection() const
     258             : {
     259           0 :     if( mpOutlinerView )
     260             :     {
     261           0 :         if( mpOutlinerView->HasSelection() )
     262           0 :             return Selection( 0, mpOutlinerView->GetSelected().getLength() );
     263             :         else
     264             :         {
     265           0 :             ESelection aSelection = mpOutlinerView->GetEditView().GetSelection();
     266           0 :             return Selection( aSelection.nStartPos, aSelection.nEndPos );
     267             :         }
     268             :     }
     269             :     else
     270           0 :         return Selection( 0, 0 );
     271             : }
     272             : 
     273             : /************** AnnotationWindow***********************************++*/
     274             : 
     275           0 : AnnotationWindow::AnnotationWindow( AnnotationManagerImpl& rManager, DrawDocShell* pDocShell, vcl::Window* pParent )
     276             : : FloatingWindow(pParent, WB_SYSTEMWINDOW|WB_BORDER|WB_NEEDSFOCUS)
     277             : , mrManager( rManager )
     278             : , mpDocShell( pDocShell )
     279           0 : , mpView( pDocShell->GetViewShell()->GetView() )
     280           0 : , mpDoc( pDocShell->GetDoc() )
     281             : , mpOutlinerView(0)
     282             : , mpOutliner(0)
     283             : , mpVScrollbar(0)
     284           0 : , mbReadonly(pDocShell->IsReadOnly())
     285             : , mbProtected(false)
     286             : , mbMouseOverButton(false)
     287             : , mpTextWindow(0)
     288           0 : , mpMeta(0)
     289             : {
     290           0 : }
     291             : 
     292           0 : AnnotationWindow::~AnnotationWindow()
     293             : {
     294           0 :     disposeOnce();
     295           0 : }
     296             : 
     297           0 : void AnnotationWindow::dispose()
     298             : {
     299           0 :     mpMeta.disposeAndClear();
     300           0 :     delete mpOutlinerView;
     301           0 :     delete mpOutliner;
     302           0 :     mpVScrollbar.disposeAndClear();
     303           0 :     mpTextWindow.disposeAndClear();
     304           0 :     FloatingWindow::dispose();
     305           0 : }
     306             : 
     307           0 : void AnnotationWindow::InitControls()
     308             : {
     309             :     // actual window which holds the user text
     310           0 :     mpTextWindow = VclPtr<AnnotationTextWindow>::Create(this, WB_NODIALOGCONTROL);
     311           0 :     mpTextWindow->SetPointer(Pointer(PointerStyle::Text));
     312             : 
     313             :     // window control for author and date
     314           0 :     mpMeta = VclPtr<MultiLineEdit>::Create(this,0);
     315           0 :     mpMeta->SetReadOnly();
     316           0 :     mpMeta->SetRightToLeft(AllSettings::GetLayoutRTL());
     317           0 :     mpMeta->AlwaysDisableInput(true);
     318           0 :     mpMeta->SetCallHandlersOnInputDisabled(true);
     319             : 
     320             :     // we should leave this setting alone, but for this we need a better layout algo
     321             :     // with variable meta size height
     322           0 :     AllSettings aSettings = mpMeta->GetSettings();
     323           0 :     StyleSettings aStyleSettings = aSettings.GetStyleSettings();
     324           0 :     vcl::Font aFont = aStyleSettings.GetFieldFont();
     325           0 :     aFont.SetHeight(8);
     326           0 :     aStyleSettings.SetFieldFont(aFont);
     327           0 :     aSettings.SetStyleSettings(aStyleSettings);
     328           0 :     mpMeta->SetSettings(aSettings);
     329             : 
     330           0 :     mpOutliner = new ::Outliner(GetAnnotationPool(),OUTLINERMODE_TEXTOBJECT);
     331           0 :     Doc()->SetCalcFieldValueHdl( mpOutliner );
     332           0 :     mpOutliner->SetUpdateMode( true );
     333           0 :     Rescale();
     334             : 
     335           0 :     OutputDevice* pDev = Doc()->GetRefDevice();
     336           0 :     if( pDev )
     337             :     {
     338           0 :         mpOutliner->SetRefDevice( pDev );
     339             :     }
     340             : 
     341           0 :     mpTextWindow->EnableRTL( false );
     342           0 :     mpOutlinerView = new OutlinerView ( mpOutliner, mpTextWindow );
     343           0 :     mpOutliner->InsertView(mpOutlinerView );
     344           0 :     mpTextWindow->SetOutlinerView(mpOutlinerView);
     345           0 :     mpOutlinerView->SetOutputArea( PixelToLogic( Rectangle(0,0,1,1) ) );
     346             : 
     347             :     //create Scrollbars
     348           0 :     mpVScrollbar = VclPtr<ScrollBar>::Create(this, WB_3DLOOK |WB_VSCROLL|WB_DRAG);
     349           0 :     mpVScrollbar->EnableNativeWidget(false);
     350           0 :     mpVScrollbar->EnableRTL( false );
     351           0 :     mpVScrollbar->SetScrollHdl(LINK(this, AnnotationWindow, ScrollHdl));
     352           0 :     mpVScrollbar->EnableDrag();
     353             : 
     354           0 :     EEControlBits nCntrl = mpOutliner->GetControlWord();
     355           0 :     nCntrl |= EEControlBits::PASTESPECIAL | EEControlBits::AUTOCORRECT | EEControlBits::USECHARATTRIBS | EEControlBits::NOCOLORS;
     356           0 :     mpOutliner->SetControlWord(nCntrl);
     357             : 
     358           0 :     Engine()->SetModifyHdl( Link<>() );
     359           0 :     Engine()->EnableUndo( false );
     360             : 
     361           0 :     Engine()->ClearModifyFlag();
     362           0 :     Engine()->GetUndoManager().Clear();
     363           0 :     Engine()->EnableUndo( true );
     364             : 
     365           0 :     Invalidate();
     366             : 
     367           0 :     SetLanguage(GetLanguage());
     368             : 
     369           0 :     mpMeta->Show();
     370           0 :     mpVScrollbar->Show();
     371           0 :     mpTextWindow->Show();
     372           0 : }
     373             : 
     374           0 : void AnnotationWindow::StartEdit()
     375             : {
     376           0 :     getView()->SetSelection(ESelection(EE_PARA_MAX_COUNT,EE_TEXTPOS_MAX_COUNT,EE_PARA_MAX_COUNT,EE_TEXTPOS_MAX_COUNT));
     377           0 :     getView()->ShowCursor();
     378           0 : }
     379             : 
     380           0 : void AnnotationWindow::Rescale()
     381             : {
     382           0 :     MapMode aMode(MAP_100TH_MM);
     383           0 :     aMode.SetOrigin( Point() );
     384           0 :     mpOutliner->SetRefMapMode( aMode );
     385           0 :     SetMapMode( aMode );
     386           0 :     mpTextWindow->SetMapMode( aMode );
     387           0 :     if ( mpMeta )
     388             :     {
     389           0 :         vcl::Font aFont( mpMeta->GetSettings().GetStyleSettings().GetFieldFont() );
     390           0 :         sal_Int32 nHeight = aFont.GetHeight();
     391           0 :         nHeight = nHeight * aMode.GetScaleY().GetNumerator() / aMode.GetScaleY().GetDenominator();
     392           0 :         aFont.SetHeight( nHeight );
     393           0 :         mpMeta->SetControlFont( aFont );
     394           0 :     }
     395           0 : }
     396             : 
     397           0 : void AnnotationWindow::DoResize()
     398             : {
     399           0 :     unsigned long aWidth    =   GetSizePixel().Width();
     400           0 :     long aHeight            =   GetSizePixel().Height() - POSTIT_META_HEIGHT;
     401             : 
     402           0 :     mpOutliner->SetPaperSize( PixelToLogic( Size(aWidth,aHeight) ) ) ;
     403           0 :     long aTextHeight        =   LogicToPixel( mpOutliner->CalcTextSize()).Height();
     404             : 
     405           0 :     if( aTextHeight > aHeight )
     406             :     {   // we need vertical scrollbars and have to reduce the width
     407           0 :         aWidth -= GetScrollbarWidth();
     408           0 :         mpVScrollbar->Show();
     409             :     }
     410             :     else
     411             :     {
     412           0 :         mpVScrollbar->Hide();
     413             :     }
     414             : 
     415           0 :     mpTextWindow->setPosSizePixel(0,0,aWidth, aHeight);
     416             : 
     417           0 :     if( mbReadonly )
     418           0 :         mpMeta->setPosSizePixel(0,aHeight,GetSizePixel().Width(),POSTIT_META_HEIGHT);
     419             :     else
     420           0 :         mpMeta->setPosSizePixel(0,aHeight,GetSizePixel().Width()-METABUTTON_AREA_WIDTH,POSTIT_META_HEIGHT);
     421             : 
     422           0 :     mpOutliner->SetPaperSize( PixelToLogic( Size(aWidth,aHeight) ) ) ;
     423           0 :     mpOutlinerView->SetOutputArea( PixelToLogic( Rectangle(0,0,aWidth,aHeight) ) );
     424           0 :     if (!mpVScrollbar->IsVisible())
     425             :     {   // if we do not have a scrollbar anymore, we want to see the complete text
     426           0 :         mpOutlinerView->SetVisArea( PixelToLogic( Rectangle(0,0,aWidth,aHeight) ) );
     427             :     }
     428           0 :     mpVScrollbar->setPosSizePixel( 0 + aWidth, 0, GetScrollbarWidth(), aHeight );
     429           0 :     mpVScrollbar->SetVisibleSize( PixelToLogic(Size(0,aHeight)).Height() );
     430           0 :     mpVScrollbar->SetPageSize( PixelToLogic(Size(0,aHeight)).Height() * 8 / 10 );
     431           0 :     mpVScrollbar->SetLineSize( mpOutliner->GetTextHeight() / 10 );
     432           0 :     SetScrollbar();
     433           0 :     mpVScrollbar->SetRange( Range(0, mpOutliner->GetTextHeight()));
     434             : 
     435           0 :     Point aPos( mpMeta->GetPosPixel());
     436           0 :     Point aBase( aPos.X() + aPos.X() + GetSizePixel().Width(), aPos.Y() );
     437           0 :     Point aLeft = PixelToLogic( Point( aBase.X() - (METABUTTON_WIDTH+5), aBase.Y()+17 ) );
     438           0 :     Point aRight = PixelToLogic( Point( aBase.X() - (METABUTTON_WIDTH-1), aBase.Y()+17 ) );
     439           0 :     Point aBottom = PixelToLogic( Point( aBase.X() - (METABUTTON_WIDTH+2), aBase.Y()+20 ) );
     440             : 
     441           0 :     maPopupTriangle.clear();
     442           0 :     maPopupTriangle.append(basegfx::B2DPoint(aLeft.X(),aLeft.Y()));
     443           0 :     maPopupTriangle.append(basegfx::B2DPoint(aRight.X(),aRight.Y()));
     444           0 :     maPopupTriangle.append(basegfx::B2DPoint(aBottom.X(),aBottom.Y()));
     445           0 :     maPopupTriangle.setClosed(true);
     446             :     maRectMetaButton = PixelToLogic( Rectangle( Point(
     447           0 :             aPos.X()+GetSizePixel().Width()-(METABUTTON_WIDTH+10),
     448           0 :             aPos.Y()+5 ),
     449           0 :             Size( METABUTTON_WIDTH, METABUTTON_HEIGHT ) ) );
     450             : 
     451           0 : }
     452             : 
     453           0 : void AnnotationWindow::SetSizePixel( const Size& rNewSize )
     454             : {
     455           0 :     Window::SetSizePixel(rNewSize);
     456           0 : }
     457             : 
     458           0 : void AnnotationWindow::SetScrollbar()
     459             : {
     460           0 :     mpVScrollbar->SetThumbPos(mpOutlinerView->GetVisArea().Top());
     461           0 : }
     462             : 
     463           0 : void AnnotationWindow::ResizeIfNecessary(long aOldHeight, long aNewHeight)
     464             : {
     465           0 :     if (aOldHeight != aNewHeight)
     466             :     {
     467           0 :         DoResize();
     468           0 :         Invalidate();
     469             :     }
     470             :     else
     471             :     {
     472           0 :         SetScrollbar();
     473             :     }
     474           0 : }
     475             : 
     476           0 : void AnnotationWindow::SetLanguage(const SvxLanguageItem &aNewItem)
     477             : {
     478           0 :     Engine()->SetModifyHdl( Link<>() );
     479           0 :     ESelection aOld = getView()->GetSelection();
     480             : 
     481           0 :     ESelection aNewSelection( 0, 0, Engine()->GetParagraphCount()-1, EE_TEXTPOS_ALL );
     482           0 :     getView()->SetSelection( aNewSelection );
     483           0 :     SfxItemSet aEditAttr(getView()->GetAttribs());
     484           0 :     aEditAttr.Put(aNewItem);
     485           0 :     getView()->SetAttribs( aEditAttr );
     486             : 
     487           0 :     getView()->SetSelection(aOld);
     488             : 
     489           0 :     Invalidate();
     490           0 : }
     491             : 
     492           0 : void AnnotationWindow::ToggleInsMode()
     493             : {
     494           0 :     if( mpOutlinerView )
     495             :     {
     496           0 :         SfxBindings &rBnd = mpDocShell->GetViewShell()->GetViewFrame()->GetBindings();
     497           0 :         rBnd.Invalidate(SID_ATTR_INSERT);
     498           0 :         rBnd.Update(SID_ATTR_INSERT);
     499             :     }
     500           0 : }
     501             : 
     502           0 : long AnnotationWindow::GetPostItTextHeight()
     503             : {
     504           0 :     return mpOutliner ? LogicToPixel(mpOutliner->CalcTextSize()).Height() : 0;
     505             : }
     506             : 
     507           0 : IMPL_LINK(AnnotationWindow, ScrollHdl, ScrollBar*, pScroll)
     508             : {
     509           0 :     long nDiff = getView()->GetEditView().GetVisArea().Top() - pScroll->GetThumbPos();
     510           0 :     getView()->Scroll( 0, nDiff );
     511           0 :     return 0;
     512             : }
     513             : 
     514           0 : SvxLanguageItem AnnotationWindow::GetLanguage()
     515             : {
     516           0 :     return SvxLanguageItem( Doc()->GetLanguage( EE_CHAR_LANGUAGE ), SID_ATTR_LANGUAGE );
     517             : }
     518             : 
     519           0 : TextApiObject* getTextApiObject( const Reference< XAnnotation >& xAnnotation )
     520             : {
     521           0 :     if( xAnnotation.is() )
     522             :     {
     523           0 :         Reference< XText > xText( xAnnotation->getTextRange() );
     524           0 :         return TextApiObject::getImplementation( xText );
     525             :     }
     526           0 :     return 0;
     527             : }
     528             : 
     529           0 : void AnnotationWindow::setAnnotation( const Reference< XAnnotation >& xAnnotation, bool bGrabFocus )
     530             : {
     531           0 :     if( (xAnnotation != mxAnnotation) && xAnnotation.is() )
     532             :     {
     533           0 :         mxAnnotation = xAnnotation;
     534             : 
     535           0 :         SetColor();
     536             : 
     537           0 :         SvtUserOptions aUserOptions;
     538           0 :         mbProtected = aUserOptions.GetFullName() != xAnnotation->getAuthor();
     539             : 
     540           0 :         Engine()->Clear();
     541           0 :         TextApiObject* pTextApi = getTextApiObject( mxAnnotation );
     542             : 
     543           0 :         if( pTextApi )
     544             :         {
     545           0 :             boost::scoped_ptr< OutlinerParaObject > pOPO( pTextApi->CreateText() );
     546           0 :             Engine()->SetText( *pOPO.get() );
     547             :         }
     548             : 
     549           0 :         Engine()->ClearModifyFlag();
     550           0 :         Engine()->GetUndoManager().Clear();
     551             : 
     552           0 :         Invalidate();
     553             : 
     554           0 :         OUString sMeta( xAnnotation->getAuthor() );
     555           0 :         OUString sDateTime( getAnnotationDateTimeString(xAnnotation) );
     556             : 
     557           0 :         if( !sDateTime.isEmpty() )
     558             :         {
     559           0 :             if( !sMeta.isEmpty() )
     560           0 :                 sMeta += "\n";
     561             : 
     562           0 :            sMeta += sDateTime;
     563             :         }
     564           0 :         mpMeta->SetText(sMeta);
     565             : 
     566           0 :         if( bGrabFocus )
     567           0 :             GrabFocus();
     568             :     }
     569           0 : }
     570             : 
     571           0 : void AnnotationWindow::SetColor()
     572             : {
     573           0 :     sal_uInt16 nAuthorIdx = mpDoc->GetAnnotationAuthorIndex( mxAnnotation->getAuthor() );
     574             : 
     575           0 :     const bool bHighContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
     576           0 :     if( bHighContrast )
     577             :     {
     578           0 :         StyleSettings aStyleSettings = GetSettings().GetStyleSettings();
     579             : 
     580           0 :         maColor = aStyleSettings.GetWindowColor();
     581           0 :         maColorDark = maColor;
     582           0 :         maColorLight = aStyleSettings.GetWindowTextColor();
     583             :     }
     584             :     else
     585             :     {
     586           0 :         maColor = AnnotationManagerImpl::GetColor( nAuthorIdx );
     587           0 :         maColorDark = AnnotationManagerImpl::GetColorDark( nAuthorIdx );
     588           0 :         maColorLight = AnnotationManagerImpl::GetColorLight( nAuthorIdx );
     589             :     }
     590             : 
     591           0 :     mpOutlinerView->SetBackgroundColor(maColor);
     592           0 :     Engine()->SetBackgroundColor(maColor);
     593             : 
     594             :     {
     595           0 :         SvtAccessibilityOptions aOptions;
     596           0 :         Engine()->ForceAutoColor( bHighContrast || aOptions.GetIsAutomaticFontColor() );
     597             :     }
     598             : 
     599           0 :     mpMeta->SetControlBackground(maColor);
     600           0 :     AllSettings aSettings = mpMeta->GetSettings();
     601           0 :     StyleSettings aStyleSettings = aSettings.GetStyleSettings();
     602           0 :     aStyleSettings.SetFieldTextColor( bHighContrast ? maColorLight : maColorDark);
     603           0 :     aSettings.SetStyleSettings(aStyleSettings);
     604           0 :     mpMeta->SetSettings(aSettings);
     605             : 
     606           0 :     AllSettings aSettings2 = mpVScrollbar->GetSettings();
     607           0 :     StyleSettings aStyleSettings2 = aSettings2.GetStyleSettings();
     608           0 :     aStyleSettings2.SetButtonTextColor(Color(0,0,0));
     609           0 :     aStyleSettings2.SetCheckedColor(maColorLight); //hintergund
     610           0 :     aStyleSettings2.SetShadowColor(maColorDark);
     611           0 :     aStyleSettings2.SetFaceColor(maColor);
     612           0 :     aSettings2.SetStyleSettings(aStyleSettings2);
     613           0 :     mpVScrollbar->SetSettings(aSettings2);
     614           0 : }
     615             : 
     616           0 : void AnnotationWindow::Deactivate()
     617             : {
     618           0 :     Reference< XAnnotation > xAnnotation( mxAnnotation );
     619             : 
     620             :     // write changed text back to annotation
     621           0 :     if ( Engine()->IsModified() )
     622             :     {
     623           0 :         TextApiObject* pTextApi = getTextApiObject( xAnnotation );
     624             : 
     625           0 :         if( pTextApi )
     626             :         {
     627           0 :             OutlinerParaObject* pOPO = Engine()->CreateParaObject();
     628           0 :             if( pOPO )
     629             :             {
     630           0 :                 if( mpDoc->IsUndoEnabled() )
     631           0 :                     mpDoc->BegUndo( SD_RESSTR( STR_ANNOTATION_UNDO_EDIT ) );
     632             : 
     633           0 :                 pTextApi->SetText( *pOPO );
     634           0 :                 delete pOPO;
     635             : 
     636             :                 // set current time to changed annotation
     637           0 :                 xAnnotation->setDateTime( getCurrentDateTime() );
     638             : 
     639           0 :                 if( mpDoc->IsUndoEnabled() )
     640           0 :                     mpDoc->EndUndo();
     641             : 
     642           0 :                 DocView()->GetDocSh()->SetModified(true);
     643             :             }
     644             : 
     645             :         }
     646             :     }
     647           0 :     Engine()->ClearModifyFlag();
     648             : 
     649           0 :     Engine()->GetUndoManager().Clear();
     650           0 : }
     651             : 
     652           0 : void AnnotationWindow::Paint(vcl::RenderContext& rRenderContext, const Rectangle& rRect)
     653             : {
     654           0 :     FloatingWindow::Paint(rRenderContext, rRect);
     655             : 
     656           0 :     if(mpMeta->IsVisible() && !mbReadonly)
     657             :     {
     658           0 :         const bool bHighContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
     659             :         //draw left over space
     660           0 :         if ( bHighContrast )
     661           0 :             SetFillColor(COL_BLACK);
     662             :         else
     663           0 :             SetFillColor(maColor);
     664           0 :         SetLineColor();
     665           0 :         DrawRect(PixelToLogic(Rectangle(Point(mpMeta->GetPosPixel().X()+mpMeta->GetSizePixel().Width(),mpMeta->GetPosPixel().Y()),Size(METABUTTON_AREA_WIDTH,mpMeta->GetSizePixel().Height()))));
     666             : 
     667           0 :         if ( bHighContrast )
     668             :         {
     669             :             //draw rect around button
     670           0 :             SetFillColor(COL_BLACK);
     671           0 :             SetLineColor(COL_WHITE);
     672             :         }
     673             :         else
     674             :         {
     675             :             //draw button
     676           0 :             Gradient aGradient;
     677           0 :             if (mbMouseOverButton)
     678           0 :                 aGradient = Gradient(GradientStyle_LINEAR,ColorFromAlphaColor(80,maColorDark,maColor),ColorFromAlphaColor(15,maColorDark,maColor));
     679             :             else
     680           0 :                 aGradient = Gradient(GradientStyle_LINEAR,ColorFromAlphaColor(15,maColorDark,maColor),ColorFromAlphaColor(80,maColorDark,maColor));
     681           0 :             DrawGradient(maRectMetaButton,aGradient);
     682             :             //draw rect around button
     683           0 :             SetFillColor();
     684           0 :             SetLineColor(ColorFromAlphaColor(90,maColorDark,maColor));
     685             :         }
     686           0 :         DrawRect(maRectMetaButton);
     687             : 
     688             :         //draw arrow
     689           0 :         if( bHighContrast )
     690           0 :             SetFillColor(COL_WHITE);
     691             :         else
     692           0 :             SetFillColor(COL_BLACK);
     693           0 :         SetLineColor();
     694           0 :         DrawPolygon(Polygon(maPopupTriangle));
     695             :     }
     696           0 : }
     697             : 
     698           0 : void AnnotationWindow::MouseMove( const MouseEvent& rMEvt )
     699             : {
     700           0 :     if( !mbReadonly )
     701             :     {
     702           0 :         if (maRectMetaButton.IsInside(PixelToLogic(rMEvt.GetPosPixel())))
     703             :         {
     704           0 :             if (!mbMouseOverButton)
     705             :             {
     706           0 :                 Invalidate(maRectMetaButton);
     707           0 :                 mbMouseOverButton = true;
     708             :             }
     709             :         }
     710             :         else
     711             :         {
     712           0 :             if (mbMouseOverButton)
     713             :             {
     714           0 :                 Invalidate(maRectMetaButton);
     715           0 :                 mbMouseOverButton = false;
     716             :             }
     717             :         }
     718             :     }
     719           0 : }
     720             : 
     721           0 : void AnnotationWindow::MouseButtonDown( const MouseEvent& rMEvt )
     722             : {
     723           0 :     if (!mbReadonly && maRectMetaButton.IsInside(PixelToLogic(rMEvt.GetPosPixel())) && rMEvt.IsLeft())
     724             :     {
     725             :         // context menu
     726           0 :         Rectangle aRect(LogicToPixel(maRectMetaButton.BottomLeft()),LogicToPixel(maRectMetaButton.BottomLeft()));
     727           0 :         mrManager.ExecuteAnnotationContextMenu( mxAnnotation, static_cast<vcl::Window*>(this), aRect, true );
     728             :     }
     729           0 : }
     730             : 
     731           0 : void AnnotationWindow::Command( const CommandEvent& rCEvt )
     732             : {
     733           0 :     if ( rCEvt.GetCommand() == CommandEventId::ContextMenu )
     734             :     {
     735           0 :         if( mpMeta->IsVisible() &&(mpMeta->GetPosPixel().Y() < rCEvt.GetMousePosPixel().Y()) )
     736           0 :             return;
     737           0 :         mrManager.ExecuteAnnotationContextMenu( mxAnnotation, this, Rectangle(rCEvt.GetMousePosPixel(),Size(1,1)) );
     738             :     }
     739             :     else
     740             :     {
     741           0 :         FloatingWindow::Command(rCEvt);
     742             :     }
     743             : }
     744             : 
     745           0 : void AnnotationWindow::GetFocus()
     746             : {
     747           0 :     if( mpTextWindow )
     748           0 :         mpTextWindow->GrabFocus();
     749             :     else
     750           0 :         FloatingWindow::GetFocus();
     751           0 : }
     752             : 
     753           0 : void AnnotationWindow::ExecuteSlot( sal_uInt16 nSID )
     754             : {
     755           0 :     if( nSID == SID_COPY )
     756             :     {
     757           0 :         getView()->Copy();
     758             :     }
     759           0 :     else if( nSID == SID_PASTE )
     760             :     {
     761           0 :         getView()->PasteSpecial();
     762           0 :         DoResize();
     763             :     }
     764             :     else
     765             :     {
     766           0 :         SfxItemSet aEditAttr(getView()->GetAttribs());
     767           0 :         SfxItemSet aNewAttr(mpOutliner->GetEmptyItemSet());
     768             : 
     769           0 :         switch( nSID )
     770             :         {
     771             :         case SID_ATTR_CHAR_WEIGHT:
     772             :         {
     773           0 :             FontWeight eFW = static_cast<const SvxWeightItem&>( aEditAttr.Get( EE_CHAR_WEIGHT ) ).GetWeight();
     774           0 :             aNewAttr.Put( SvxWeightItem( eFW == WEIGHT_NORMAL ? WEIGHT_BOLD : WEIGHT_NORMAL, EE_CHAR_WEIGHT ) );
     775             :         }
     776           0 :         break;
     777             :         case SID_ATTR_CHAR_POSTURE:
     778             :         {
     779           0 :             FontItalic eFI = static_cast<const SvxPostureItem&>( aEditAttr.Get( EE_CHAR_ITALIC ) ).GetPosture();
     780           0 :             aNewAttr.Put( SvxPostureItem( eFI == ITALIC_NORMAL ? ITALIC_NONE : ITALIC_NORMAL, EE_CHAR_ITALIC ) );
     781             :         }
     782           0 :         break;
     783             :         case SID_ATTR_CHAR_UNDERLINE:
     784             :         {
     785           0 :             FontUnderline eFU = static_cast<const SvxUnderlineItem&>( aEditAttr. Get( EE_CHAR_UNDERLINE ) ).GetLineStyle();
     786           0 :             aNewAttr.Put( SvxUnderlineItem( eFU == UNDERLINE_SINGLE ? UNDERLINE_NONE : UNDERLINE_SINGLE, EE_CHAR_UNDERLINE ) );
     787             :         }
     788           0 :         break;
     789             :         case SID_ATTR_CHAR_STRIKEOUT:
     790             :         {
     791           0 :             FontStrikeout eFSO = static_cast<const SvxCrossedOutItem&>( aEditAttr.Get( EE_CHAR_STRIKEOUT ) ).GetStrikeout();
     792           0 :             aNewAttr.Put( SvxCrossedOutItem( eFSO == STRIKEOUT_SINGLE ? STRIKEOUT_NONE : STRIKEOUT_SINGLE, EE_CHAR_STRIKEOUT ) );
     793             :         }
     794           0 :         break;
     795             :         }
     796           0 :         getView()->SetAttribs( aNewAttr );
     797             :     }
     798           0 : }
     799             : 
     800          66 : }
     801             : 
     802             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11