sd/source/ui/func/fuediglu.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: fuediglu.cxx,v $
  10  * $Revision: 1.13 $
  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 "fuediglu.hxx"
  35 #include <svtools/eitem.hxx>
  36 #include <svx/dialogs.hrc>
  37 #include <svx/svdglue.hxx>
  38 #include <sfx2/request.hxx>
  39
  40
  41 #include "app.hrc"
  42 #include "strings.hrc"
  43 #include "res_bmp.hrc"
  44 #ifndef SD_WINDOW_SHELL_HXX
  45 #include "Window.hxx"
  46 #endif
  47 #include "drawdoc.hxx"
  48 #ifndef SD_FRAMW_VIEW_HXX
  49 #include "FrameView.hxx"
  50 #endif
  51 #include "View.hxx"
  52 #include "ViewShell.hxx"
  53 #include "ViewShellBase.hxx"
  54 #include "ToolBarManager.hxx"
  55
  56 namespace sd {
  57
  58 TYPEINIT1( FuEditGluePoints, FuDraw );
  59
  60 /*************************************************************************
  61 |*
  62 |* Konstruktor
  63 |*
  64 \************************************************************************/
  65
  66 FuEditGluePoints::FuEditGluePoints (
  67     ViewShell* pViewSh,
  68     ::sd::Window* pWin,
  69     ::sd::View* pView,
  70     SdDrawDocument*     pDoc,
  71     SfxRequest& rReq)
  72     : FuDraw(pViewSh, pWin, pView, pDoc, rReq)
  73 {
  74 }
  75
  76 FunctionReference FuEditGluePoints::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq, bool bPermanent )
  77 {
  78     FuEditGluePoints* pFunc;
  79     FunctionReference xFunc( pFunc = new FuEditGluePoints( pViewSh, pWin, pView, pDoc, rReq ) );
  80     xFunc->DoExecute(rReq);
  81     pFunc->SetPermanent( bPermanent );
  82     return xFunc;
  83 }
  84
  85 void FuEditGluePoints::DoExecute( SfxRequest& rReq )
  86 {
  87     FuDraw::DoExecute( rReq );
  88     mpView->SetInsGluePointMode(FALSE);
  89     mpViewShell->GetViewShellBase().GetToolBarManager()->AddToolBar(
  90         ToolBarManager::TBG_FUNCTION,
  91         ToolBarManager::msGluePointsToolBar);
  92 }
  93
  94 /*************************************************************************
  95 |*
  96 |* Destruktor
  97 |*
  98 \************************************************************************/
  99
 100 FuEditGluePoints::~FuEditGluePoints()
 101 {
 102     mpView->BrkAction();
 103     mpView->UnmarkAllGluePoints();
 104     mpView->SetInsGluePointMode(FALSE);
 105 }
 106
 107 /*************************************************************************
 108 |*
 109 |* MouseButtonDown-event
 110 |*
 111 \************************************************************************/
 112
 113 BOOL FuEditGluePoints::MouseButtonDown(const MouseEvent& rMEvt)
 114 {
 115     mpView->SetActualWin( mpWindow );
 116
 117     BOOL bReturn = FuDraw::MouseButtonDown(rMEvt);
 118
 119     if (mpView->IsAction())
 120     {
 121         if (rMEvt.IsRight())
 122             mpView->BckAction();
 123
 124         return TRUE;
 125     }
 126
 127     if (rMEvt.IsLeft())
 128     {
 129         bReturn = TRUE;
 130         USHORT nHitLog = USHORT ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
 131         USHORT nDrgLog = USHORT ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
 132         mpWindow->CaptureMouse();
 133
 134         SdrViewEvent aVEvt;
 135         SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
 136
 137         if (eHit == SDRHIT_HANDLE)
 138         {
 139             /******************************************************************
 140             * Handle draggen
 141             ******************************************************************/
 142             SdrHdl* pHdl = aVEvt.pHdl;
 143
 144             if (mpView->IsGluePointMarked(aVEvt.pObj, aVEvt.nGlueId) && rMEvt.IsShift())
 145             {
 146                 mpView->UnmarkGluePoint(aVEvt.pObj, aVEvt.nGlueId, aVEvt.pPV);
 147                 pHdl = NULL;
 148             }
 149
 150             if (pHdl)
 151             {
 152                 // Handle draggen
 153                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog);
 154             }
 155         }
 156         else if (eHit == SDRHIT_MARKEDOBJECT && mpView->IsInsGluePointMode())
 157         {
 158             /******************************************************************
 159             * Klebepunkt einfuegen
 160             ******************************************************************/
 161             mpView->BegInsGluePoint(aMDPos);
 162         }
 163         else if (eHit == SDRHIT_MARKEDOBJECT && rMEvt.IsMod1())
 164         {
 165             /******************************************************************
 166             * Klebepunkt selektieren
 167             ******************************************************************/
 168             if (!rMEvt.IsShift())
 169                 mpView->UnmarkAllGluePoints();
 170
 171             mpView->BegMarkGluePoints(aMDPos);
 172         }
 173         else if (eHit == SDRHIT_MARKEDOBJECT && !rMEvt.IsShift() && !rMEvt.IsMod2())
 174         {
 175             /******************************************************************
 176             * Objekt verschieben
 177             ******************************************************************/
 178             mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, NULL, nDrgLog);
 179         }
 180         else if (eHit == SDRHIT_GLUEPOINT)
 181         {
 182             /******************************************************************
 183             * Klebepunkt selektieren
 184             ******************************************************************/
 185             if (!rMEvt.IsShift())
 186                 mpView->UnmarkAllGluePoints();
 187
 188             mpView->MarkGluePoint(aVEvt.pObj, aVEvt.nGlueId, aVEvt.pPV);
 189             SdrHdl* pHdl = mpView->GetGluePointHdl(aVEvt.pObj, aVEvt.nGlueId);
 190
 191             if (pHdl)
 192             {
 193                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
 194             }
 195         }
 196         else
 197         {
 198             /******************************************************************
 199             * Objekt selektieren oder draggen
 200             ******************************************************************/
 201             if (!rMEvt.IsShift() && !rMEvt.IsMod2() && eHit == SDRHIT_UNMARKEDOBJECT)
 202             {
 203                mpView->UnmarkAllObj();
 204             }
 205
 206             BOOL bMarked = FALSE;
 207
 208             if (!rMEvt.IsMod1())
 209             {
 210                 if (rMEvt.IsMod2())
 211                 {
 212                     bMarked = mpView->MarkNextObj(aMDPos, nHitLog, rMEvt.IsShift());
 213                 }
 214                 else
 215                 {
 216                     bMarked = mpView->MarkObj(aMDPos, nHitLog, rMEvt.IsShift());
 217                 }
 218             }
 219
 220             if (bMarked &&
 221                 (!rMEvt.IsShift() || eHit == SDRHIT_MARKEDOBJECT))
 222             {
 223                 // Objekt verschieben
 224                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog);
 225             }
 226             else if (mpView->AreObjectsMarked())
 227             {
 228                 /**************************************************************
 229                 * Klebepunkt selektieren
 230                 **************************************************************/
 231                 if (!rMEvt.IsShift())
 232                     mpView->UnmarkAllGluePoints();
 233
 234                 mpView->BegMarkGluePoints(aMDPos);
 235             }
 236             else
 237             {
 238                 /**************************************************************
 239                 * Objekt selektieren
 240                 **************************************************************/
 241                 mpView->BegMarkObj(aMDPos);
 242             }
 243         }
 244
 245         ForcePointer(&rMEvt);
 246     }
 247
 248     return bReturn;
 249 }
 250
 251 /*************************************************************************
 252 |*
 253 |* MouseMove-event
 254 |*
 255 \************************************************************************/
 256
 257 BOOL FuEditGluePoints::MouseMove(const MouseEvent& rMEvt)
 258 {
 259     mpView->SetActualWin( mpWindow );
 260
 261     FuDraw::MouseMove(rMEvt);
 262
 263     if (mpView->IsAction())
 264     {
 265         Point aPix(rMEvt.GetPosPixel());
 266         Point aPnt( mpWindow->PixelToLogic(aPix) );
 267         ForceScroll(aPix);
 268         mpView->MovAction(aPnt);
 269     }
 270
 271     ForcePointer(&rMEvt);
 272
 273     return TRUE;
 274 }
 275
 276 /*************************************************************************
 277 |*
 278 |* MouseButtonUp-event
 279 |*
 280 \************************************************************************/
 281
 282 BOOL FuEditGluePoints::MouseButtonUp(const MouseEvent& rMEvt)
 283 {
 284     mpView->SetActualWin( mpWindow );
 285
 286     BOOL bReturn = FALSE;
 287
 288     if (mpView->IsAction())
 289     {
 290         bReturn = TRUE;
 291         mpView->EndAction();
 292     }
 293
 294     FuDraw::MouseButtonUp(rMEvt);
 295
 296     USHORT nDrgLog = USHORT ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
 297     Point aPos = mpWindow->PixelToLogic( rMEvt.GetPosPixel() );
 298
 299     if (Abs(aMDPos.X() - aPos.X()) < nDrgLog &&
 300         Abs(aMDPos.Y() - aPos.Y()) < nDrgLog &&
 301         !rMEvt.IsShift() && !rMEvt.IsMod2())
 302     {
 303         SdrViewEvent aVEvt;
 304         SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
 305
 306         if (eHit == SDRHIT_NONE)
 307         {
 308             // Klick auf der Stelle: deselektieren
 309             mpView->UnmarkAllObj();
 310         }
 311     }
 312
 313     mpWindow->ReleaseMouse();
 314
 315     return bReturn;
 316 }
 317
 318 /*************************************************************************
 319 |*
 320 |* Tastaturereignisse bearbeiten
 321 |*
 322 |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert TRUE, andernfalls
 323 |* FALSE.
 324 |*
 325 \************************************************************************/
 326
 327 BOOL FuEditGluePoints::KeyInput(const KeyEvent& rKEvt)
 328 {
 329     mpView->SetActualWin( mpWindow );
 330
 331     BOOL bReturn = FuDraw::KeyInput(rKEvt);
 332
 333     return bReturn;
 334 }
 335
 336 /*************************************************************************
 337 |*
 338 |* Command-event
 339 |*
 340 \************************************************************************/
 341
 342 BOOL FuEditGluePoints::Command(const CommandEvent& rCEvt)
 343 {
 344     mpView->SetActualWin( mpWindow );
 345     return FuPoor::Command( rCEvt );
 346 }
 347
 348 /*************************************************************************
 349 |*
 350 |* Funktion aktivieren
 351 |*
 352 \************************************************************************/
 353
 354 void FuEditGluePoints::Activate()
 355 {
 356     mpView->SetGluePointEditMode();
 357     FuDraw::Activate();
 358 }
 359
 360 /*************************************************************************
 361 |*
 362 |* Funktion deaktivieren
 363 |*
 364 \************************************************************************/
 365
 366 void FuEditGluePoints::Deactivate()
 367 {
 368     mpView->SetGluePointEditMode( FALSE );
 369     FuDraw::Deactivate();
 370 }
 371
 372 /*************************************************************************
 373 |*
 374 |* Request verarbeiten
 375 |*
 376 \************************************************************************/
 377
 378 void FuEditGluePoints::ReceiveRequest(SfxRequest& rReq)
 379 {
 380     switch (rReq.GetSlot())
 381     {
 382         case SID_GLUE_INSERT_POINT:
 383         {
 384             mpView->SetInsGluePointMode(!mpView->IsInsGluePointMode());
 385         }
 386         break;
 387
 388         case SID_GLUE_ESCDIR_LEFT:
 389         {
 390             mpView->SetMarkedGluePointsEscDir( SDRESC_LEFT,
 391                     !mpView->IsMarkedGluePointsEscDir( SDRESC_LEFT ) );
 392         }
 393         break;
 394
 395         case SID_GLUE_ESCDIR_RIGHT:
 396         {
 397             mpView->SetMarkedGluePointsEscDir( SDRESC_RIGHT,
 398                     !mpView->IsMarkedGluePointsEscDir( SDRESC_RIGHT ) );
 399         }
 400         break;
 401
 402         case SID_GLUE_ESCDIR_TOP:
 403         {
 404             mpView->SetMarkedGluePointsEscDir( SDRESC_TOP,
 405                     !mpView->IsMarkedGluePointsEscDir( SDRESC_TOP ) );
 406         }
 407         break;
 408
 409         case SID_GLUE_ESCDIR_BOTTOM:
 410         {
 411             mpView->SetMarkedGluePointsEscDir( SDRESC_BOTTOM,
 412                     !mpView->IsMarkedGluePointsEscDir( SDRESC_BOTTOM ) );
 413         }
 414         break;
 415
 416         case SID_GLUE_PERCENT:
 417         {
 418             const SfxItemSet* pSet = rReq.GetArgs();
 419             const SfxPoolItem& rItem = pSet->Get(SID_GLUE_PERCENT);
 420             BOOL bPercent = ((const SfxBoolItem&) rItem).GetValue();
 421             mpView->SetMarkedGluePointsPercent(bPercent);
 422         }
 423         break;
 424
 425         case SID_GLUE_HORZALIGN_CENTER:
 426         {
 427             mpView->SetMarkedGluePointsAlign(FALSE, SDRHORZALIGN_CENTER);
 428         }
 429         break;
 430
 431         case SID_GLUE_HORZALIGN_LEFT:
 432         {
 433             mpView->SetMarkedGluePointsAlign(FALSE, SDRHORZALIGN_LEFT);
 434         }
 435         break;
 436
 437         case SID_GLUE_HORZALIGN_RIGHT:
 438         {
 439             mpView->SetMarkedGluePointsAlign(FALSE, SDRHORZALIGN_RIGHT);
 440         }
 441         break;
 442
 443         case SID_GLUE_VERTALIGN_CENTER:
 444         {
 445             mpView->SetMarkedGluePointsAlign(TRUE, SDRVERTALIGN_CENTER);
 446         }
 447         break;
 448
 449         case SID_GLUE_VERTALIGN_TOP:
 450         {
 451             mpView->SetMarkedGluePointsAlign(TRUE, SDRVERTALIGN_TOP);
 452         }
 453         break;
 454
 455         case SID_GLUE_VERTALIGN_BOTTOM:
 456         {
 457             mpView->SetMarkedGluePointsAlign(TRUE, SDRVERTALIGN_BOTTOM);
 458         }
 459         break;
 460     }
 461
 462     // Zum Schluss Basisklasse rufen
 463     FuPoor::ReceiveRequest(rReq);
 464 }
 465
 466
 467 } // end of namespace sd