sd/source/ui/view/drviews4.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: drviews4.cxx,v $
  10  * $Revision: 1.41 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include <com/sun/star/drawing/XDrawPagesSupplier.hpp>
  35
  36 #include "DrawViewShell.hxx"
  37 #include <vcl/msgbox.hxx>
  38 #include <svtools/urlbmk.hxx>
  39 #include <svx/svdpagv.hxx>
  40 #include <svx/svdundo.hxx>
  41 #include <svx/fmglob.hxx>
  42 #include <svx/eeitem.hxx>
  43 #ifndef _FLDITEM_HXX
  44 #include <svx/flditem.hxx>
  45 #endif
  46 #ifndef _SVXIDS_HRC
  47 #include <svx/svxids.hrc>
  48 #endif
  49 #include <svx/ruler.hxx>
  50 #ifndef _GLOBL3D_HXX
  51 #include <svx/globl3d.hxx>
  52 #endif
  53 #include <svx/outliner.hxx>
  54 #ifndef _SFX_CLIENTSH_HXX
  55 #include <sfx2/ipclient.hxx>
  56 #endif
  57 #include <sfx2/request.hxx>
  58 #include <sfx2/dispatch.hxx>
  59 #include <svx/svdopath.hxx>
  60 #include <sfx2/viewfrm.hxx>
  61 #include <svx/editview.hxx>
  62 #include <vcl/cursor.hxx>
  63
  64
  65 #include "app.hrc"
  66 #include "glob.hrc"
  67 #include "strings.hrc"
  68 #include "res_bmp.hrc"
  69 #include "DrawDocShell.hxx"
  70 #include "drawdoc.hxx"
  71 #include "Window.hxx"
  72 #include "fupoor.hxx"
  73 #include "fusnapln.hxx"
  74 #include "app.hxx"
  75 #include "Ruler.hxx"
  76 #include "sdresid.hxx"
  77 #include "GraphicViewShell.hxx"
  78 #include "sdpage.hxx"
  79 #include "slideshow.hxx"
  80 #include "anminfo.hxx"
  81 #include "sdpopup.hxx"
  82 #include "drawview.hxx"
  83 #include <svx/bmpmask.hxx>
  84 #include "LayerTabBar.hxx"
  85
  86 // #97016# IV
  87 #include <svx/svditer.hxx>
  88
  89 namespace sd {
  90
  91 #define PIPETTE_RANGE 0
  92
  93 #ifdef _MSC_VER
  94 #pragma optimize ( "", off )
  95 #endif
  96
  97 using namespace ::com::sun::star::uno;
  98 using namespace ::com::sun::star::drawing;
  99
 100 /*************************************************************************
 101 |*
 102 |* aktuelle Seite loeschen
 103 |*
 104 \************************************************************************/
 105
 106 void DrawViewShell::DeleteActualPage()
 107 {
 108     USHORT                      nPage = maTabControl.GetCurPageId() - 1;
 109
 110     mpDrawView->SdrEndTextEdit();
 111
 112     try
 113     {
 114         Reference<XDrawPagesSupplier> xDrawPagesSupplier( GetDoc()->getUnoModel(), UNO_QUERY_THROW );
 115         Reference<XDrawPages> xPages( xDrawPagesSupplier->getDrawPages(), UNO_QUERY_THROW );
 116         Reference< XDrawPage > xPage( xPages->getByIndex( nPage ), UNO_QUERY_THROW );
 117         xPages->remove( xPage );
 118     }
 119     catch( Exception& )
 120     {
 121         DBG_ERROR("SelectionManager::DeleteSelectedMasterPages(), exception caught!");
 122     }
 123 }
 124
 125 /*************************************************************************
 126 |*
 127 |* aktuelle Ebene loeschen
 128 |*
 129 \************************************************************************/
 130
 131 void DrawViewShell::DeleteActualLayer()
 132 {
 133     SdrLayerAdmin& rAdmin = GetDoc()->GetLayerAdmin();
 134     const String&  rName  = GetLayerTabControl()->GetPageText(GetLayerTabControl()->GetCurPageId());
 135     String         aString(SdResId(STR_ASK_DELETE_LAYER));
 136
 137     // Platzhalter ersetzen
 138     USHORT nPos = aString.Search(sal_Unicode('$'));
 139     aString.Erase(nPos, 1);
 140     aString.Insert(rName, nPos);
 141
 142     if (QueryBox(GetActiveWindow(), WB_YES_NO, aString).Execute() == RET_YES)
 143     {
 144         const SdrLayer* pLayer = rAdmin.GetLayer(rName, FALSE);
 145         mpDrawView->DeleteLayer( pLayer->GetName() );
 146
 147         // damit TabBar und Window neu gezeichnet werden;
 148         // sollte spaeter wie beim Aendern der Layerfolge durch einen
 149         // Hint von Joe angestossen werden
 150         // ( View::Notify() --> ViewShell::ResetActualLayer() )
 151
 152         mbIsLayerModeActive = false;    // damit ChangeEditMode() ueberhaupt was tut
 153         ChangeEditMode(GetEditMode(), true);
 154     }
 155 }
 156
 157
 158 /*************************************************************************
 159 |*
 160 |* Keyboard event
 161 |*
 162 \************************************************************************/
 163
 164 BOOL DrawViewShell::KeyInput (const KeyEvent& rKEvt, ::sd::Window* pWin)
 165 {
 166     BOOL bRet = FALSE;
 167
 168     if ( !IsInputLocked() || ( rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE ) )
 169     {
 170         // #97016# IV
 171         if(KEY_RETURN == rKEvt.GetKeyCode().GetCode()
 172             && rKEvt.GetKeyCode().IsMod1()
 173             && GetView()->IsTextEdit())
 174         {
 175             // this should be used for cursor travelling.
 176             SdPage* pActualPage = GetActualPage();
 177             const SdrMarkList& rMarkList = GetView()->GetMarkedObjectList();
 178             SdrTextObj* pCandidate = 0L;
 179
 180             if(pActualPage && 1 == rMarkList.GetMarkCount())
 181             {
 182                 SdrMark* pMark = rMarkList.GetMark(0);
 183
 184                 // remember which object was the text in edit mode
 185                 SdrObject* pOldObj = pMark->GetMarkedSdrObj();
 186
 187                 // end text edit now
 188                 GetView()->SdrEndTextEdit();
 189
 190                 // look for a new candidate, a successor of pOldObj
 191                 SdrObjListIter aIter(*pActualPage, IM_DEEPNOGROUPS);
 192                 BOOL bDidVisitOldObject(FALSE);
 193
 194                 while(aIter.IsMore() && !pCandidate)
 195                 {
 196                     SdrObject* pObj = aIter.Next();
 197
 198                     if(pObj && pObj->ISA(SdrTextObj))
 199                     {
 200                         sal_uInt32 nInv(pObj->GetObjInventor());
 201                         sal_uInt16 nKnd(pObj->GetObjIdentifier());
 202
 203                         if(SdrInventor == nInv &&
 204                             (OBJ_TITLETEXT == nKnd || OBJ_OUTLINETEXT == nKnd || OBJ_TEXT == nKnd)
 205                             && bDidVisitOldObject)
 206                         {
 207                             pCandidate = (SdrTextObj*)pObj;
 208                         }
 209
 210                         if(pObj == pOldObj)
 211                         {
 212                             bDidVisitOldObject = TRUE;
 213                         }
 214                     }
 215                 }
 216             }
 217
 218             if(pCandidate)
 219             {
 220                 // set the new candidate to text edit mode
 221                 GetView()->UnMarkAll();
 222                 GetView()->MarkObj(pCandidate, GetView()->GetSdrPageView());
 223
 224                 GetViewFrame()->GetDispatcher()->Execute(
 225                     SID_ATTR_CHAR, SFX_CALLMODE_ASYNCHRON);
 226             }
 227             else
 228             {
 229                 // insert a new page with the same page layout
 230                 GetViewFrame()->GetDispatcher()->Execute(
 231                     SID_INSERTPAGE_QUICK, SFX_CALLMODE_ASYNCHRON);
 232             }
 233         }
 234         else
 235         {
 236             bRet = ViewShell::KeyInput(rKEvt, pWin);
 237         }
 238     }
 239
 240     return bRet;
 241 }
 242
 243 /*************************************************************************
 244 |*
 245 |* Vom Lineal ausgehenden Drag (Hilflinien, Ursprung) beginnen
 246 |*
 247 \************************************************************************/
 248
 249 void DrawViewShell::StartRulerDrag (
 250     const Ruler& rRuler,
 251     const MouseEvent& rMEvt)
 252 {
 253     GetActiveWindow()->CaptureMouse();
 254
 255     Point aWPos = GetActiveWindow()->PixelToLogic(GetActiveWindow()->GetPointerPosPixel());
 256
 257     if ( rRuler.GetExtraRect().IsInside(rMEvt.GetPosPixel()) )
 258     {
 259         mpDrawView->BegSetPageOrg(aWPos);
 260         mbIsRulerDrag = TRUE;
 261     }
 262     else
 263     {
 264         // #i34536# if no guide-lines are visible yet, that show them
 265         if( ! mpDrawView->IsHlplVisible())
 266             mpDrawView->SetHlplVisible( TRUE );
 267
 268         SdrHelpLineKind eKind;
 269
 270         if ( rMEvt.IsMod1() )
 271             eKind = SDRHELPLINE_POINT;
 272         else if ( rRuler.IsHorizontal() )
 273             eKind = SDRHELPLINE_HORIZONTAL;
 274         else
 275             eKind = SDRHELPLINE_VERTICAL;
 276
 277         mpDrawView->BegDragHelpLine(aWPos, eKind);
 278         mbIsRulerDrag = TRUE;
 279     }
 280 }
 281
 282 /*************************************************************************
 283 |*
 284 |* MouseButtonDown event
 285 |*
 286 \************************************************************************/
 287
 288 void DrawViewShell::MouseButtonDown(const MouseEvent& rMEvt,
 289     ::sd::Window* pWin)
 290 {
 291     // We have to check if a context menu is shown and we have an UI
 292     // active inplace client. In that case we have to ignore the mouse
 293     // button down event. Otherwise we would crash (context menu has been
 294     // opened by inplace client and we would deactivate the inplace client,
 295     // the contex menu is closed by VCL asynchronously which in the end
 296     // would work on deleted objects or the context menu has no parent anymore)
 297     // See #126086# and #128122#
 298     SfxInPlaceClient* pIPClient = GetViewShell()->GetIPClient();
 299     BOOL bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() );
 300
 301     if ( bIsOleActive && PopupMenu::IsInExecute() )
 302         return;
 303
 304     if ( !IsInputLocked() )
 305     {
 306         ViewShell::MouseButtonDown(rMEvt, pWin);
 307
 308         if ( mbPipette )
 309             ( (SvxBmpMask*) GetViewFrame()->GetChildWindow( SvxBmpMaskChildWindow::GetChildWindowId() )->GetWindow() )->PipetteClicked();
 310     }
 311 }
 312
 313 /*************************************************************************
 314 |*
 315 |* MouseMove event
 316 |*
 317 \************************************************************************/
 318
 319
 320 void DrawViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin)
 321 {
 322     if ( !IsInputLocked() )
 323     {
 324         if ( mpDrawView->IsAction() )
 325         {
 326             Rectangle aOutputArea(Point(0,0), GetActiveWindow()->GetOutputSizePixel());
 327
 328             if ( !aOutputArea.IsInside(rMEvt.GetPosPixel()) )
 329             {
 330                 BOOL bInsideOtherWindow = FALSE;
 331
 332                 if (mpContentWindow.get() != NULL)
 333                 {
 334                     aOutputArea = Rectangle(Point(0,0),
 335                         mpContentWindow->GetOutputSizePixel());
 336
 337                     Point aPos = mpContentWindow->GetPointerPosPixel();
 338                     if ( aOutputArea.IsInside(aPos) )
 339                         bInsideOtherWindow = TRUE;
 340                 }
 341
 342                 if (! GetActiveWindow()->HasFocus ())
 343                 {
 344                     GetActiveWindow()->ReleaseMouse ();
 345                     mpDrawView->BrkAction ();
 346                     return;
 347                 }
 348                 else if ( bInsideOtherWindow )
 349                 {
 350                     GetActiveWindow()->ReleaseMouse();
 351                     pWin->CaptureMouse ();
 352                 }
 353             }
 354             else if ( pWin != GetActiveWindow() )
 355                  pWin->CaptureMouse();
 356         }
 357
 358         // #109585#
 359         // Since the next MouseMove may execute a IsSolidDraggingNow() in
 360         // SdrCreateView::MovCreateObj and there the ApplicationBackgroundColor
 361         // is needed it is necessary to set it here.
 362         if(mpDrawView!=NULL && GetDoc()!=NULL)
 363         {
 364             svtools::ColorConfig aColorConfig;
 365             Color aFillColor;
 366
 367             if(DOCUMENT_TYPE_IMPRESS == GetDoc()->GetDocumentType())
 368             {
 369                 aFillColor = Color( aColorConfig.GetColorValue( svtools::APPBACKGROUND ).nColor );
 370             }
 371             else
 372             {
 373                 aFillColor = Color( aColorConfig.GetColorValue( svtools::DOCCOLOR ).nColor );
 374             }
 375
 376             mpDrawView->SetApplicationBackgroundColor(aFillColor);
 377         }
 378
 379         ViewShell::MouseMove(rMEvt, pWin);
 380
 381         if( !mbMousePosFreezed )
 382             maMousePos = rMEvt.GetPosPixel();
 383
 384         Rectangle aRect;
 385
 386         if ( mbIsRulerDrag )
 387         {
 388             Point aLogPos = GetActiveWindow()->PixelToLogic(maMousePos);
 389             mpDrawView->MovAction(aLogPos);
 390         }
 391
 392         if ( mpDrawView->IsAction() )
 393         {
 394             mpDrawView->TakeActionRect(aRect);
 395             aRect = GetActiveWindow()->LogicToPixel(aRect);
 396         }
 397         else
 398         {
 399             aRect = Rectangle(maMousePos, maMousePos);
 400         }
 401
 402         ShowMousePosInfo(aRect, pWin);
 403
 404         if ( mbPipette && GetViewFrame()->HasChildWindow( SvxBmpMaskChildWindow::GetChildWindowId() ) )
 405         {
 406             const long          nStartX = maMousePos.X() - PIPETTE_RANGE;
 407             const long          nEndX = maMousePos.X() + PIPETTE_RANGE;
 408             const long          nStartY = maMousePos.Y() - PIPETTE_RANGE;
 409             const long          nEndY = maMousePos.Y() + PIPETTE_RANGE;
 410             long                        nRed = 0;
 411             long                        nGreen = 0;
 412             long                        nBlue = 0;
 413             const double        fDiv = ( ( PIPETTE_RANGE << 1 ) + 1 ) * ( ( PIPETTE_RANGE << 1 ) + 1 );
 414
 415             for ( long nY = nStartY; nY <= nEndY; nY++ )
 416             {
 417                 for( long nX = nStartX; nX <= nEndX; nX++ )
 418                 {
 419                     const Color aCol( pWin->GetPixel( pWin->PixelToLogic( Point( nX, nY ) ) ) );
 420
 421                     nRed += aCol.GetRed();
 422                     nGreen += aCol.GetGreen();
 423                     nBlue += aCol.GetBlue();
 424                 }
 425             }
 426
 427             ( (SvxBmpMask*) GetViewFrame()->GetChildWindow( SvxBmpMaskChildWindow::GetChildWindowId() )->GetWindow() )->
 428                 SetColor( Color( (BYTE) ( nRed / fDiv + .5 ),
 429                                  (BYTE) ( nGreen / fDiv + .5 ),
 430                                  (BYTE) ( nBlue / fDiv + .5 ) ) );
 431         }
 432     }
 433 }
 434
 435
 436 /*************************************************************************
 437 |*
 438 |* MouseButtonUp event
 439 |*
 440 \************************************************************************/
 441
 442 void DrawViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
 443 {
 444     if ( !IsInputLocked() )
 445     {
 446         FASTBOOL bIsSetPageOrg = mpDrawView->IsSetPageOrg();
 447
 448         if (mbIsRulerDrag)
 449         {
 450             Rectangle aOutputArea(Point(0,0), GetActiveWindow()->GetOutputSizePixel());
 451
 452             if (aOutputArea.IsInside(rMEvt.GetPosPixel()))
 453             {
 454                 mpDrawView->EndAction();
 455
 456                 if (bIsSetPageOrg)
 457                     GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);
 458             }
 459             else if (rMEvt.IsLeft() && bIsSetPageOrg)
 460             {
 461                 mpDrawView->BrkAction();
 462                 SdPage* pPage = (SdPage*) mpDrawView->GetSdrPageView()->GetPage();
 463                 Point aOrg(pPage->GetLftBorder(), pPage->GetUppBorder());
 464                 mpDrawView->GetSdrPageView()->SetPageOrigin(aOrg);
 465                 GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);
 466             }
 467             else
 468             {
 469                 mpDrawView->BrkAction();
 470             }
 471
 472             GetActiveWindow()->ReleaseMouse();
 473             mbIsRulerDrag = FALSE;
 474         }
 475         else
 476             ViewShell::MouseButtonUp(rMEvt, pWin);
 477     }
 478 }
 479
 480 /*************************************************************************
 481 |*
 482 |* Command event
 483 |*
 484 \************************************************************************/
 485
 486 void DrawViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin)
 487 {
 488     // The command event is send to the window after a possible context
 489     // menu from an inplace client is closed. Now we have the chance to
 490     // deactivate the inplace client without any problem regarding parent
 491     // windows and code on the stack.
 492     // For more information, see #126086# and #128122#
 493     SfxInPlaceClient* pIPClient = GetViewShell()->GetIPClient();
 494     BOOL bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() );
 495     if ( bIsOleActive && ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU ))
 496     {
 497         // Deactivate OLE object
 498         mpDrawView->UnmarkAll();
 499         SelectionHasChanged();
 500         return;
 501     }
 502
 503     if ( !IsInputLocked() )
 504     {
 505         const bool bNativeShow (SlideShow::IsRunning(GetViewShellBase()));
 506
 507         if( rCEvt.GetCommand() == COMMAND_PASTESELECTION && !bNativeShow )
 508         {
 509             TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSelection( GetActiveWindow() ) );
 510
 511             if( aDataHelper.GetTransferable().is() )
 512             {
 513                 Point       aPos;
 514                 sal_Int8    nDnDAction = DND_ACTION_COPY;
 515
 516                 if( GetActiveWindow() )
 517                     aPos = GetActiveWindow()->PixelToLogic( rCEvt.GetMousePosPixel() );
 518
 519                 if( !mpDrawView->InsertData( aDataHelper, aPos, nDnDAction, FALSE ) )
 520                 {
 521                     INetBookmark        aINetBookmark( aEmptyStr, aEmptyStr );
 522
 523                     if( ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK ) &&
 524                           aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK, aINetBookmark ) ) ||
 525                         ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR ) &&
 526                           aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR, aINetBookmark ) ) ||
 527                         ( aDataHelper.HasFormat( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR ) &&
 528                           aDataHelper.GetINetBookmark( SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR, aINetBookmark ) ) )
 529                     {
 530                         InsertURLField( aINetBookmark.GetURL(), aINetBookmark.GetDescription(), aEmptyStr, NULL );
 531                     }
 532                 }
 533             }
 534         }
 535         else if( rCEvt.GetCommand() == COMMAND_CONTEXTMENU && !bNativeShow &&
 536                  pWin != NULL && !mpDrawView->IsAction() && !SD_MOD()->GetWaterCan() )
 537         {
 538             USHORT nSdResId = 0;          // ResourceID fuer Popup-Menue
 539             BOOL bGraphicShell = this->ISA(GraphicViewShell);
 540
 541             // Ist ein Fangobjekt unter dem Mauszeiger?
 542             SdrPageView* pPV;
 543             Point       aMPos = pWin->PixelToLogic( maMousePos );
 544             USHORT      nHitLog = (USHORT) GetActiveWindow()->PixelToLogic(
 545                 Size(FuPoor::HITPIX, 0 ) ).Width();
 546             USHORT      nHelpLine;
 547             // fuer Klebepunkt
 548             SdrObject*  pObj = NULL;
 549             USHORT              nPickId = 0;
 550             // fuer Feldbefehl
 551             OutlinerView* pOLV = mpDrawView->GetTextEditOutlinerView();
 552             const SvxFieldItem* pFldItem = NULL;
 553             if( pOLV )
 554                 pFldItem = pOLV->GetFieldAtSelection();
 555                 //pFldItem = pOLV->GetFieldUnderMousePointer();
 556
 557             // Hilfslinie
 558             if ( mpDrawView->PickHelpLine( aMPos, nHitLog, *GetActiveWindow(), nHelpLine, pPV) )
 559             {
 560                 nSdResId = RID_DRAW_SNAPOBJECT_POPUP;
 561                 ShowSnapLineContextMenu(*pPV, nHelpLine, rCEvt.GetMousePosPixel());
 562                 return;
 563             }
 564             // Klebepunkt unter dem Mauszeiger markiert?
 565             else if( mpDrawView->PickGluePoint( aMPos, pObj, nPickId, pPV ) &&
 566                      mpDrawView->IsGluePointMarked( pObj, nPickId ) )
 567             {
 568                 nSdResId = RID_DRAW_GLUEPOINT_POPUP;
 569             }
 570             // Feldbefehl ?
 571             else if( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) ||
 572                                  pFldItem->GetField()->ISA( SvxExtTimeField ) ||
 573                                  pFldItem->GetField()->ISA( SvxExtFileField ) ||
 574                                  pFldItem->GetField()->ISA( SvxAuthorField ) ) )
 575             {
 576                 LanguageType eLanguage( LANGUAGE_SYSTEM );
 577
 578                 // #101743# Format popup with outliner language, if possible
 579                 if( pOLV->GetOutliner() )
 580                 {
 581                     ESelection aSelection( pOLV->GetSelection() );
 582                     eLanguage = pOLV->GetOutliner()->GetLanguage( aSelection.nStartPara, aSelection.nStartPos );
 583                 }
 584
 585                 SdFieldPopup aFieldPopup( pFldItem->GetField(), eLanguage );
 586
 587                 if ( rCEvt.IsMouseEvent() )
 588                     aMPos = rCEvt.GetMousePosPixel();
 589                 else
 590                     aMPos = Point( 20, 20 );
 591                 aFieldPopup.Execute( pWin, aMPos );
 592
 593                 SvxFieldData* pField = aFieldPopup.GetField();
 594                 if( pField )
 595                 {
 596                     SvxFieldItem aFieldItem( *pField, EE_FEATURE_FIELD );
 597                     //pOLV->DeleteSelected(); <-- fehlt leider !
 598                     // Feld selektieren, so dass es beim Insert geloescht wird
 599                     ESelection aSel = pOLV->GetSelection();
 600                     BOOL bSel = TRUE;
 601                     if( aSel.nStartPos == aSel.nEndPos )
 602                     {
 603                         bSel = FALSE;
 604                         aSel.nEndPos++;
 605                     }
 606                     pOLV->SetSelection( aSel );
 607
 608                     pOLV->InsertField( aFieldItem );
 609
 610                     // Selektion wird wieder in den Ursprungszustand gebracht
 611                     if( !bSel )
 612                         aSel.nEndPos--;
 613                     pOLV->SetSelection( aSel );
 614
 615                     delete pField;
 616                 }
 617             }
 618             else
 619             {
 620                 // ist etwas selektiert?
 621                 if (mpDrawView->AreObjectsMarked() &&
 622                     mpDrawView->GetMarkedObjectList().GetMarkCount() == 1 )
 623                 {
 624                     pObj = mpDrawView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
 625                     if( HasCurrentFunction(SID_BEZIER_EDIT)     && (dynamic_cast< SdrPathObj * >( pObj ) != 0 ) )
 626                     {
 627                         nSdResId = RID_BEZIER_POPUP;
 628                     }
 629                     else
 630                     {
 631                         if( mpDrawView->GetTextEditObject() )
 632                         {
 633                             OutlinerView* pOutlinerView = mpDrawView->GetTextEditOutlinerView();
 634                             Point aPos(rCEvt.GetMousePosPixel());
 635
 636                             if ( pOutlinerView )
 637                             {
 638                                 if( (  rCEvt.IsMouseEvent() && pOutlinerView->IsWrongSpelledWordAtPos(aPos) ) ||
 639                                     ( !rCEvt.IsMouseEvent() && pOutlinerView->IsCursorAtWrongSpelledWord() ) )
 640                                 {
 641                                     // #91457# Popup for Online-Spelling now handled by DrawDocShell
 642                                     // Link aLink = LINK(GetDoc(), SdDrawDocument, OnlineSpellCallback);
 643                                     Link aLink = LINK(GetDocSh(), DrawDocShell, OnlineSpellCallback);
 644
 645                                     if( !rCEvt.IsMouseEvent() )
 646                                     {
 647                                         aPos = GetActiveWindow()->LogicToPixel( pOutlinerView->GetEditView().GetCursor()->GetPos() );
 648                                     }
 649                                     // While showing the spell context menu
 650                                     // we lock the input so that another
 651                                     // context menu can not be opened during
 652                                     // that time (crash #i43235#).  In order
 653                                     // to not lock the UI completely we
 654                                     // first release the mouse.
 655                                     GetActiveWindow()->ReleaseMouse();
 656                                     LockInput();
 657                                     pOutlinerView->ExecuteSpellPopup(aPos, &aLink);
 658                                     UnlockInput();
 659                                 }
 660                                 else
 661                                 {
 662                                     if( (pObj->GetObjInventor() == SdrInventor) && (pObj->GetObjIdentifier() == OBJ_TABLE) )
 663                                     {
 664                                         nSdResId = RID_DRAW_TABLEOBJ_INSIDE_POPUP;
 665                                     }
 666                                     else
 667                                     {
 668                                         nSdResId = RID_DRAW_TEXTOBJ_INSIDE_POPUP;
 669                                     }
 670                                 }
 671                             }
 672                         }
 673                         else
 674                         {
 675                             UINT32 nInv = pObj->GetObjInventor();
 676                             UINT16 nId = pObj->GetObjIdentifier();
 677
 678                             if (nInv == SdrInventor)
 679                             {
 680                                 switch ( nId )
 681                                 {
 682                                                                         case OBJ_OUTLINETEXT:
 683                                                                                 nSdResId = bGraphicShell ? RID_GRAPHIC_OUTLINETEXTOBJ_POPUP :
 684                                                                                                                                         RID_DRAW_OUTLINETEXTOBJ_POPUP;
 685                                                                                 break;
 686
 687                                     case OBJ_CAPTION:
 688                                     case OBJ_TITLETEXT:
 689                                     case OBJ_TEXT:
 690                                         nSdResId = bGraphicShell ? RID_GRAPHIC_TEXTOBJ_POPUP :
 691                                                                     RID_DRAW_TEXTOBJ_POPUP;
 692                                         break;
 693
 694                                     case OBJ_PATHLINE:
 695                                     case OBJ_PLIN:
 696                                         nSdResId = bGraphicShell ? RID_GRAPHIC_POLYLINEOBJ_POPUP :
 697                                                                     RID_DRAW_POLYLINEOBJ_POPUP;
 698                                         break;
 699
 700                                     case OBJ_FREELINE:
 701                                     case OBJ_EDGE:              // Connector
 702                                         nSdResId = bGraphicShell ? RID_GRAPHIC_EDGEOBJ_POPUP :
 703                                                                     RID_DRAW_EDGEOBJ_POPUP;
 704                                         break;
 705
 706                                     case OBJ_LINE:
 707                                         nSdResId = bGraphicShell ? RID_GRAPHIC_LINEOBJ_POPUP :
 708                                                                     RID_DRAW_LINEOBJ_POPUP;
 709                                         break;
 710
 711                                     case OBJ_MEASURE:
 712                                         nSdResId = bGraphicShell ? RID_GRAPHIC_MEASUREOBJ_POPUP :
 713                                                                     RID_DRAW_MEASUREOBJ_POPUP;
 714                                         break;
 715
 716                                     case OBJ_RECT:
 717                                     case OBJ_CIRC:
 718                                     case OBJ_FREEFILL:
 719                                     case OBJ_PATHFILL:
 720                                     case OBJ_POLY:
 721                                     case OBJ_SECT:
 722                                     case OBJ_CARC:
 723                                     case OBJ_CCUT:
 724                                         nSdResId = bGraphicShell ? RID_GRAPHIC_GEOMOBJ_POPUP :
 725                                                                     RID_DRAW_GEOMOBJ_POPUP;
 726                                         break;
 727
 728                                     case OBJ_CUSTOMSHAPE:
 729                                         nSdResId = bGraphicShell ? RID_GRAPHIC_CUSTOMSHAPE_POPUP :
 730                                                                     RID_DRAW_CUSTOMSHAPE_POPUP;
 731                                         break;
 732
 733                                     case OBJ_GRUP:
 734                                         nSdResId = bGraphicShell ? RID_GRAPHIC_GROUPOBJ_POPUP :
 735                                                                     RID_DRAW_GROUPOBJ_POPUP;
 736                                         break;
 737
 738                                     case OBJ_GRAF:
 739                                         nSdResId = bGraphicShell ? RID_GRAPHIC_GRAPHIC_POPUP :
 740                                                                     RID_DRAW_GRAPHIC_POPUP;
 741                                         break;
 742
 743                                     case OBJ_OLE2:
 744                                         nSdResId = bGraphicShell ? RID_GRAPHIC_OLE2_POPUP :
 745                                                                     RID_DRAW_OLE2_POPUP;
 746                                         break;
 747                                     case OBJ_MEDIA:
 748                                         nSdResId = bGraphicShell ? RID_GRAPHIC_MEDIA_POPUP :
 749                                                                     RID_DRAW_MEDIA_POPUP;
 750                                         break;
 751                                     case OBJ_TABLE:
 752                                         nSdResId = bGraphicShell ? RID_GRAPHIC_TABLE_POPUP :
 753                                                                     RID_DRAW_TABLE_POPUP;
 754                                         break;
 755                                 }
 756                             }
 757                             else if( nInv == E3dInventor /*&& nId == E3D_POLYSCENE_ID*/)
 758                             {
 759                                 if( nId == E3D_POLYSCENE_ID || nId == E3D_SCENE_ID )
 760                                 {
 761                                     if( !mpDrawView->IsGroupEntered() )
 762                                         nSdResId = bGraphicShell ? RID_GRAPHIC_3DSCENE_POPUP :
 763                                                                 RID_DRAW_3DSCENE_POPUP;
 764                                     else
 765                                         nSdResId = bGraphicShell ? RID_GRAPHIC_3DSCENE2_POPUP :
 766                                                                 RID_DRAW_3DSCENE2_POPUP;
 767                                 }
 768                                 else
 769                                     nSdResId = bGraphicShell ? RID_GRAPHIC_3DOBJ_POPUP :
 770                                                                 RID_DRAW_3DOBJ_POPUP;
 771                             }
 772                             else if( nInv == FmFormInventor )
 773                             {
 774                                 nSdResId = RID_FORM_CONTROL_POPUP;
 775                             }
 776                         }
 777                     }
 778                 }
 779
 780                 // Mehrfachselektion
 781                 else if (mpDrawView->AreObjectsMarked() &&
 782                     mpDrawView->GetMarkedObjectList().GetMarkCount() > 1 )
 783                 {
 784                     nSdResId = bGraphicShell ? RID_GRAPHIC_MULTISELECTION_POPUP :
 785                                                 RID_DRAW_MULTISELECTION_POPUP;
 786                 }
 787
 788                 // nichts selektiert
 789                 else
 790                 {
 791                     nSdResId = bGraphicShell ? RID_GRAPHIC_NOSEL_POPUP :
 792                                                 RID_DRAW_NOSEL_POPUP;
 793                 }
 794             }
 795             // Popup-Menue anzeigen
 796             if (nSdResId)
 797             {
 798                 GetActiveWindow()->ReleaseMouse();
 799
 800                 if(rCEvt.IsMouseEvent())
 801                     GetViewFrame()->GetDispatcher()->ExecutePopup(SdResId(nSdResId));
 802                 else
 803                 {
 804                     //#106326# don't open contextmenu at mouse position if not opened via mouse
 805
 806                     //middle of the window if nothing is marked
 807                     Point aMenuPos(GetActiveWindow()->GetSizePixel().Width()/2
 808                             ,GetActiveWindow()->GetSizePixel().Height()/2);
 809
 810                     //middle of the bounding rect if something is marked
 811                     if( mpDrawView->AreObjectsMarked() && mpDrawView->GetMarkedObjectList().GetMarkCount() >= 1 )
 812                     {
 813                         Rectangle aMarkRect;
 814                         mpDrawView->GetMarkedObjectList().TakeBoundRect(NULL,aMarkRect);
 815                         aMenuPos = GetActiveWindow()->LogicToPixel( aMarkRect.Center() );
 816
 817                         //move the point into the visible window area
 818                         if( aMenuPos.X() < 0 )
 819                             aMenuPos.X() = 0;
 820                         if( aMenuPos.Y() < 0 )
 821                             aMenuPos.Y() = 0;
 822                         if( aMenuPos.X() > GetActiveWindow()->GetSizePixel().Width() )
 823                             aMenuPos.X() = GetActiveWindow()->GetSizePixel().Width();
 824                         if( aMenuPos.Y() > GetActiveWindow()->GetSizePixel().Height() )
 825                             aMenuPos.Y() = GetActiveWindow()->GetSizePixel().Height();
 826                     }
 827
 828                     //open context menu at that point
 829                     GetViewFrame()->GetDispatcher()->ExecutePopup(SdResId(nSdResId),GetActiveWindow(),&aMenuPos);
 830                 }
 831                 mbMousePosFreezed = FALSE;
 832             }
 833         }
 834         else
 835         {
 836             ViewShell::Command(rCEvt, pWin);
 837         }
 838     }
 839 }
 840
 841 /*************************************************************************
 842 |*
 843 |* Linealmarkierungen anzeigen
 844 |*
 845 \************************************************************************/
 846
 847 void DrawViewShell::ShowMousePosInfo(const Rectangle& rRect,
 848     ::sd::Window* pWin)
 849 {
 850     if (mbHasRulers && pWin )
 851     {
 852         RulerLine       pHLines[2];
 853         RulerLine       pVLines[2];
 854         long        nHOffs = 0L;
 855         long        nVOffs = 0L;
 856         USHORT          nCnt;
 857
 858         if (mpHorizontalRuler.get() != NULL)
 859             mpHorizontalRuler->SetLines();
 860
 861         if (mpVerticalRuler.get() != NULL)
 862             mpVerticalRuler->SetLines();
 863
 864         if (mpHorizontalRuler.get() != NULL)
 865         {
 866             nHOffs = mpHorizontalRuler->GetNullOffset() +
 867                      mpHorizontalRuler->GetPageOffset();
 868         }
 869
 870         if (mpVerticalRuler.get() != NULL)
 871         {
 872             nVOffs = mpVerticalRuler->GetNullOffset() +
 873                      mpVerticalRuler->GetPageOffset();
 874         }
 875
 876         nCnt = 1;
 877         pHLines[0].nPos = rRect.Left() - nHOffs;
 878         pVLines[0].nPos = rRect.Top()  - nVOffs;
 879         pHLines[0].nStyle = 0;
 880         pVLines[0].nStyle = 0;
 881
 882         if ( rRect.Right() != rRect.Left() || rRect.Bottom() != rRect.Top() )
 883         {
 884             pHLines[1].nPos = rRect.Right()  - nHOffs;
 885             pVLines[1].nPos = rRect.Bottom() - nVOffs;
 886             pHLines[1].nStyle = 0;
 887             pVLines[1].nStyle = 0;
 888             nCnt++;
 889         }
 890
 891         if (mpHorizontalRuler.get() != NULL)
 892             mpHorizontalRuler->SetLines(nCnt, pHLines);
 893         if (mpVerticalRuler.get() != NULL)
 894             mpVerticalRuler->SetLines(nCnt, pVLines);
 895     }
 896
 897     // StatusBar Koordinatenanzeige
 898     OSL_ASSERT (GetViewShell()!=NULL);
 899     if ( !GetViewShell()->GetUIActiveClient() )
 900     {
 901         SfxItemSet aSet(GetPool(), SID_CONTEXT, SID_CONTEXT,
 902                                    SID_ATTR_POSITION, SID_ATTR_POSITION,
 903                                    SID_ATTR_SIZE, SID_ATTR_SIZE,
 904                                    0L);
 905
 906 //                GetStatusBarState(aSet);      nicht performant bei gedrueckter Modifiertaste!!
 907
 908         aSet.Put( SfxStringItem( SID_CONTEXT, mpDrawView->GetStatusText() ) );
 909
 910         SfxBindings& rBindings = GetViewFrame()->GetBindings();
 911         rBindings.SetState(aSet);
 912         rBindings.Invalidate(SID_CONTEXT);
 913         rBindings.Invalidate(SID_ATTR_POSITION);
 914         rBindings.Invalidate(SID_ATTR_SIZE);
 915     }
 916 }
 917
 918 /*************************************************************************
 919 |*
 920 |*
 921 |*
 922 \************************************************************************/
 923
 924 void DrawViewShell::LockInput()
 925 {
 926     mnLockCount++;
 927 }
 928
 929 /*************************************************************************
 930 |*
 931 |*
 932 |*
 933 \************************************************************************/
 934
 935 void DrawViewShell::UnlockInput()
 936 {
 937     DBG_ASSERT( mnLockCount, "Input for this shell is not locked!" );
 938     if ( mnLockCount )
 939         mnLockCount--;
 940 }
 941
 942
 943
 944
 945 void DrawViewShell::ShowSnapLineContextMenu (
 946     SdrPageView& rPageView,
 947     const USHORT nSnapLineIndex,
 948     const Point& rMouseLocation)
 949 {
 950     const SdrHelpLine& rHelpLine (rPageView.GetHelpLines()[nSnapLineIndex]);
 951     ::boost::scoped_ptr<PopupMenu> pMenu (new PopupMenu ());
 952
 953     if (rHelpLine.GetKind() == SDRHELPLINE_POINT)
 954     {
 955         pMenu->InsertItem(
 956             SID_SET_SNAPITEM,
 957             String(SdResId(STR_POPUP_EDIT_SNAPPOINT)));
 958         pMenu->InsertSeparator();
 959         pMenu->InsertItem(
 960             SID_DELETE_SNAPITEM,
 961             String(SdResId(STR_POPUP_DELETE_SNAPPOINT)));
 962     }
 963     else
 964     {
 965         pMenu->InsertItem(
 966             SID_SET_SNAPITEM,
 967             String(SdResId(STR_POPUP_EDIT_SNAPLINE)));
 968         pMenu->InsertSeparator();
 969         pMenu->InsertItem(
 970             SID_DELETE_SNAPITEM,
 971             String(SdResId(STR_POPUP_DELETE_SNAPLINE)));
 972     }
 973
 974     pMenu->RemoveDisabledEntries(FALSE, FALSE);
 975
 976     const USHORT nResult = pMenu->Execute(
 977         GetActiveWindow(),
 978         Rectangle(rMouseLocation, Size(10,10)),
 979         POPUPMENU_EXECUTE_DOWN);
 980     switch (nResult)
 981     {
 982         case SID_SET_SNAPITEM:
 983         {
 984             SfxUInt32Item aHelpLineItem (ID_VAL_INDEX, nSnapLineIndex);
 985             const SfxPoolItem* aArguments[] = {&aHelpLineItem, NULL};
 986             GetViewFrame()->GetDispatcher()->Execute(
 987                 SID_SET_SNAPITEM,
 988                 SFX_CALLMODE_SLOT,
 989                 aArguments);
 990         }
 991         break;
 992
 993         case SID_DELETE_SNAPITEM:
 994         {
 995             rPageView.DeleteHelpLine(nSnapLineIndex);
 996         }
 997         break;
 998
 999         default:
1000             break;
1001     }
1002 }
1003
1004
1005
1006
1007 #ifdef _MSC_VER
1008 #pragma optimize ( "", on )
1009 #endif
1010
1011 } // end of namespace sd