sd/source/ui/func/fuediglu.cxx

   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 "fuediglu.hxx"
  21 #include <svl/eitem.hxx>
  22 #include <svx/dialogs.hrc>
  23 #include <svx/svdglue.hxx>
  24 #include <sfx2/request.hxx>
  25
  26 #include "app.hrc"
  27 #include "strings.hrc"
  28 #include "res_bmp.hrc"
  29 #include "Window.hxx"
  30 #include "drawdoc.hxx"
  31 #include "FrameView.hxx"
  32 #include "View.hxx"
  33 #include "ViewShell.hxx"
  34 #include "ViewShellBase.hxx"
  35 #include "ToolBarManager.hxx"
  36
  37 namespace sd {
  38
  39 TYPEINIT1( FuEditGluePoints, FuDraw );
  40
  41 FuEditGluePoints::FuEditGluePoints (
  42     ViewShell* pViewSh,
  43     ::sd::Window* pWin,
  44     ::sd::View* pView,
  45     SdDrawDocument* pDoc,
  46     SfxRequest& rReq)
  47     : FuDraw(pViewSh, pWin, pView, pDoc, rReq)
  48      //Add Shift+UP/DOWN/LEFT/RIGHT key to move the position of insert point,
  49      //and SHIFT+ENTER key to decide the position and draw the new insert point
  50      ,bBeginInsertPoint(false),
  51     oldPoint(0,0)
  52 {
  53 }
  54
  55 rtl::Reference<FuPoor> FuEditGluePoints::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq, bool bPermanent )
  56 {
  57     FuEditGluePoints* pFunc;
  58     rtl::Reference<FuPoor> xFunc( pFunc = new FuEditGluePoints( pViewSh, pWin, pView, pDoc, rReq ) );
  59     xFunc->DoExecute(rReq);
  60     pFunc->SetPermanent( bPermanent );
  61     return xFunc;
  62 }
  63
  64 void FuEditGluePoints::DoExecute( SfxRequest& rReq )
  65 {
  66     FuDraw::DoExecute( rReq );
  67     mpView->SetInsGluePointMode(false);
  68     mpViewShell->GetViewShellBase().GetToolBarManager()->AddToolBar(
  69         ToolBarManager::TBG_FUNCTION,
  70         ToolBarManager::msGluePointsToolBar);
  71 }
  72
  73 FuEditGluePoints::~FuEditGluePoints()
  74 {
  75     mpView->BrkAction();
  76     mpView->UnmarkAllGluePoints();
  77     mpView->SetInsGluePointMode(false);
  78 }
  79
  80 bool FuEditGluePoints::MouseButtonDown(const MouseEvent& rMEvt)
  81 {
  82     mpView->SetActualWin( mpWindow );
  83
  84     bool bReturn = FuDraw::MouseButtonDown(rMEvt);
  85
  86     if (mpView->IsAction())
  87     {
  88         if (rMEvt.IsRight())
  89             mpView->BckAction();
  90
  91         return true;
  92     }
  93
  94     if (rMEvt.IsLeft())
  95     {
  96         bReturn = true;
  97         sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
  98         sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
  99         mpWindow->CaptureMouse();
 100
 101         SdrViewEvent aVEvt;
 102         SdrHitKind eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
 103
 104         if (eHit == SDRHIT_HANDLE)
 105         {
 106             // drag handle
 107             SdrHdl* pHdl = aVEvt.pHdl;
 108
 109             if (mpView->IsGluePointMarked(aVEvt.pObj, aVEvt.nGlueId) && rMEvt.IsShift())
 110             {
 111                 mpView->UnmarkGluePoint(aVEvt.pObj, aVEvt.nGlueId, aVEvt.pPV);
 112                 pHdl = NULL;
 113             }
 114
 115             if (pHdl)
 116             {
 117                 // drag handle
 118                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog);
 119             }
 120         }
 121         else if (eHit == SDRHIT_MARKEDOBJECT && mpView->IsInsGluePointMode())
 122         {
 123             // insert glue points
 124             mpView->BegInsGluePoint(aMDPos);
 125         }
 126         else if (eHit == SDRHIT_MARKEDOBJECT && rMEvt.IsMod1())
 127         {
 128             // select glue points
 129             if (!rMEvt.IsShift())
 130                 mpView->UnmarkAllGluePoints();
 131
 132             mpView->BegMarkGluePoints(aMDPos);
 133         }
 134         else if (eHit == SDRHIT_MARKEDOBJECT && !rMEvt.IsShift() && !rMEvt.IsMod2())
 135         {
 136             // move object
 137             mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, NULL, nDrgLog);
 138         }
 139         else if (eHit == SDRHIT_GLUEPOINT)
 140         {
 141             // select glue points
 142             if (!rMEvt.IsShift())
 143                 mpView->UnmarkAllGluePoints();
 144
 145             mpView->MarkGluePoint(aVEvt.pObj, aVEvt.nGlueId, aVEvt.pPV);
 146             SdrHdl* pHdl = mpView->GetGluePointHdl(aVEvt.pObj, aVEvt.nGlueId);
 147
 148             if (pHdl)
 149             {
 150                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
 151             }
 152         }
 153         else
 154         {
 155             // select or drag object
 156             if (!rMEvt.IsShift() && !rMEvt.IsMod2() && eHit == SDRHIT_UNMARKEDOBJECT)
 157             {
 158                mpView->UnmarkAllObj();
 159             }
 160
 161             bool bMarked = false;
 162
 163             if (!rMEvt.IsMod1())
 164             {
 165                 if (rMEvt.IsMod2())
 166                 {
 167                     bMarked = mpView->MarkNextObj(aMDPos, nHitLog, rMEvt.IsShift());
 168                 }
 169                 else
 170                 {
 171                     bMarked = mpView->MarkObj(aMDPos, nHitLog, rMEvt.IsShift());
 172                 }
 173             }
 174
 175             if (bMarked &&
 176                 (!rMEvt.IsShift() || eHit == SDRHIT_MARKEDOBJECT))
 177             {
 178                 // move object
 179                 mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog);
 180             }
 181             else if (mpView->AreObjectsMarked())
 182             {
 183                 // select glue point
 184                 if (!rMEvt.IsShift())
 185                     mpView->UnmarkAllGluePoints();
 186
 187                 mpView->BegMarkGluePoints(aMDPos);
 188             }
 189             else
 190             {
 191                 // select object
 192                 mpView->BegMarkObj(aMDPos);
 193             }
 194         }
 195
 196         ForcePointer(&rMEvt);
 197     }
 198
 199     return bReturn;
 200 }
 201
 202 bool FuEditGluePoints::MouseMove(const MouseEvent& rMEvt)
 203 {
 204     mpView->SetActualWin( mpWindow );
 205
 206     FuDraw::MouseMove(rMEvt);
 207
 208     if (mpView->IsAction())
 209     {
 210         Point aPix(rMEvt.GetPosPixel());
 211         Point aPnt( mpWindow->PixelToLogic(aPix) );
 212         ForceScroll(aPix);
 213         mpView->MovAction(aPnt);
 214     }
 215
 216     ForcePointer(&rMEvt);
 217
 218     return true;
 219 }
 220
 221 bool FuEditGluePoints::MouseButtonUp(const MouseEvent& rMEvt)
 222 {
 223     mpView->SetActualWin( mpWindow );
 224
 225     bool bReturn = false;
 226
 227     if (mpView->IsAction())
 228     {
 229         bReturn = true;
 230         mpView->EndAction();
 231     }
 232
 233     FuDraw::MouseButtonUp(rMEvt);
 234
 235     sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
 236     Point aPos = mpWindow->PixelToLogic( rMEvt.GetPosPixel() );
 237
 238     if (std::abs(aMDPos.X() - aPos.X()) < nDrgLog &&
 239         std::abs(aMDPos.Y() - aPos.Y()) < nDrgLog &&
 240         !rMEvt.IsShift() && !rMEvt.IsMod2())
 241     {
 242         SdrViewEvent aVEvt;
 243         SdrHitKind eHit = mpView->PickAnything(rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
 244
 245         if (eHit == SDRHIT_NONE)
 246         {
 247             // click on position: deselect
 248             mpView->UnmarkAllObj();
 249         }
 250     }
 251
 252     mpWindow->ReleaseMouse();
 253
 254     return bReturn;
 255 }
 256
 257 /**
 258  * Process keyboard input
 259  * @returns sal_True if a KeyEvent is being processed, sal_False otherwise
 260  */
 261 bool FuEditGluePoints::KeyInput(const KeyEvent& rKEvt)
 262 {
 263     mpView->SetActualWin( mpWindow );
 264
 265     //Add Shift+UP/DOWN/LEFT/RIGHT key to move the position of insert point,
 266     //and SHIFT+ENTER key to decide the position and draw the new insert point
 267
 268     bool bReturn = false;
 269
 270     switch (rKEvt.GetKeyCode().GetCode())
 271     {
 272         case KEY_UP:
 273         case KEY_DOWN:
 274         case KEY_LEFT:
 275         case KEY_RIGHT:
 276         {
 277             if(rKEvt.GetKeyCode().IsShift()&& mpView->IsInsGluePointMode() ){
 278                 long nX = 0;
 279                 long nY = 0;
 280                 sal_uInt16  nCode = rKEvt.GetKeyCode().GetCode();
 281                 if (nCode == KEY_UP)
 282                 {
 283                     // Scroll nach oben
 284                     nX = 0;
 285                     nY =-1;
 286                 }
 287                 else if (nCode == KEY_DOWN)
 288                 {
 289                     // Scroll nach unten
 290                     nX = 0;
 291                     nY = 1;
 292                 }
 293                 else if (nCode == KEY_LEFT)
 294                 {
 295                     // Scroll nach links
 296                     nX =-1;
 297                     nY = 0;
 298                 }
 299                 else if (nCode == KEY_RIGHT)
 300                 {
 301                     // Scroll nach rechts
 302                     nX = 1;
 303                     nY = 0;
 304                 }
 305                 Point centerPoint;
 306                 Rectangle rect = mpView->GetMarkedObjRect();
 307                 centerPoint = mpWindow->LogicToPixel(rect.Center());
 308                 Point aPoint = bBeginInsertPoint? oldPoint:centerPoint;
 309                 Point ePoint = aPoint + Point(nX,nY);
 310                 mpWindow->SetPointerPosPixel(ePoint);
 311                 //simulate mouse move action
 312                 MouseEvent eMevt(ePoint, 1, MouseEventModifiers::DRAGMOVE, MOUSE_LEFT, 0);
 313                 MouseMove(eMevt);
 314                 oldPoint = ePoint;
 315                 bBeginInsertPoint = true;
 316                 bReturn = true;
 317             }
 318         }
 319         break;
 320         case KEY_RETURN:
 321             if(rKEvt.GetKeyCode().IsShift() && mpView->IsInsGluePointMode() )
 322             {
 323                 if(bBeginInsertPoint)
 324                 {
 325                     mpWindow->SetPointerPosPixel(oldPoint);
 326                     //simulate mouse button down action
 327                     MouseEvent aMevt(oldPoint, 1,
 328                                      MouseEventModifiers::SIMPLEMOVE | MouseEventModifiers::DRAGMOVE,
 329                                      MOUSE_LEFT, KEY_SHIFT);
 330                     // MT IA2: Not used?
 331                     // sal_uInt16 ubuttons = aMevt.GetButtons();
 332                     // sal_uInt16 uMod      = aMevt.GetModifier();
 333                     MouseButtonDown(aMevt);
 334                     mpWindow->CaptureMouse();
 335                     //simulate mouse button up action
 336                     MouseEvent rMEvt(oldPoint+Point(0,0), 1,
 337                                      MouseEventModifiers::SIMPLEMOVE | MouseEventModifiers::ENTERWINDOW,
 338                                      MOUSE_LEFT, KEY_SHIFT);
 339                     MouseButtonUp(rMEvt);
 340                     bReturn= true;
 341                 }
 342             }
 343             break;
 344     }
 345
 346     if(!bReturn)
 347         bReturn = FuDraw::KeyInput(rKEvt);
 348
 349     return bReturn;
 350 }
 351
 352 //Add Shift+UP/DOWN/LEFT/RIGHT key to move the position of insert point, and
 353 //SHIFT+ENTER key to decide the position and draw the new insert point
 354 void FuEditGluePoints::ForcePointer(const MouseEvent* pMEvt)
 355 {
 356     if(bBeginInsertPoint && pMEvt)
 357     {
 358         MouseEvent aMEvt(pMEvt->GetPosPixel(), pMEvt->GetClicks(),
 359             pMEvt->GetMode(), pMEvt->GetButtons(), pMEvt->GetModifier() & ~KEY_SHIFT);
 360         FuDraw::ForcePointer(&aMEvt);
 361     }
 362     else
 363     {
 364         FuDraw::ForcePointer(pMEvt);
 365     }
 366 }
 367
 368 bool FuEditGluePoints::Command(const CommandEvent& rCEvt)
 369 {
 370     mpView->SetActualWin( mpWindow );
 371     return FuPoor::Command( rCEvt );
 372 }
 373
 374 void FuEditGluePoints::Activate()
 375 {
 376     mpView->SetGluePointEditMode();
 377     FuDraw::Activate();
 378 }
 379
 380 void FuEditGluePoints::Deactivate()
 381 {
 382     mpView->SetGluePointEditMode( false );
 383     FuDraw::Deactivate();
 384 }
 385
 386 void FuEditGluePoints::ReceiveRequest(SfxRequest& rReq)
 387 {
 388     switch (rReq.GetSlot())
 389     {
 390         case SID_GLUE_INSERT_POINT:
 391         {
 392             mpView->SetInsGluePointMode(!mpView->IsInsGluePointMode());
 393         }
 394         break;
 395
 396         case SID_GLUE_ESCDIR_LEFT:
 397         {
 398             mpView->SetMarkedGluePointsEscDir( SdrEscapeDirection::LEFT,
 399                     !mpView->IsMarkedGluePointsEscDir( SdrEscapeDirection::LEFT ) );
 400         }
 401         break;
 402
 403         case SID_GLUE_ESCDIR_RIGHT:
 404         {
 405             mpView->SetMarkedGluePointsEscDir( SdrEscapeDirection::RIGHT,
 406                     !mpView->IsMarkedGluePointsEscDir( SdrEscapeDirection::RIGHT ) );
 407         }
 408         break;
 409
 410         case SID_GLUE_ESCDIR_TOP:
 411         {
 412             mpView->SetMarkedGluePointsEscDir( SdrEscapeDirection::TOP,
 413                     !mpView->IsMarkedGluePointsEscDir( SdrEscapeDirection::TOP ) );
 414         }
 415         break;
 416
 417         case SID_GLUE_ESCDIR_BOTTOM:
 418         {
 419             mpView->SetMarkedGluePointsEscDir( SdrEscapeDirection::BOTTOM,
 420                     !mpView->IsMarkedGluePointsEscDir( SdrEscapeDirection::BOTTOM ) );
 421         }
 422         break;
 423
 424         case SID_GLUE_PERCENT:
 425         {
 426             const SfxItemSet* pSet = rReq.GetArgs();
 427             const SfxPoolItem& rItem = pSet->Get(SID_GLUE_PERCENT);
 428             bool bPercent = static_cast<const SfxBoolItem&>(rItem).GetValue();
 429             mpView->SetMarkedGluePointsPercent(bPercent);
 430         }
 431         break;
 432
 433         case SID_GLUE_HORZALIGN_CENTER:
 434         {
 435             mpView->SetMarkedGluePointsAlign(false, SdrAlign::HORZ_CENTER);
 436         }
 437         break;
 438
 439         case SID_GLUE_HORZALIGN_LEFT:
 440         {
 441             mpView->SetMarkedGluePointsAlign(false, SdrAlign::HORZ_LEFT);
 442         }
 443         break;
 444
 445         case SID_GLUE_HORZALIGN_RIGHT:
 446         {
 447             mpView->SetMarkedGluePointsAlign(false, SdrAlign::HORZ_RIGHT);
 448         }
 449         break;
 450
 451         case SID_GLUE_VERTALIGN_CENTER:
 452         {
 453             mpView->SetMarkedGluePointsAlign(true, SdrAlign::VERT_CENTER);
 454         }
 455         break;
 456
 457         case SID_GLUE_VERTALIGN_TOP:
 458         {
 459             mpView->SetMarkedGluePointsAlign(true, SdrAlign::VERT_TOP);
 460         }
 461         break;
 462
 463         case SID_GLUE_VERTALIGN_BOTTOM:
 464         {
 465             mpView->SetMarkedGluePointsAlign(true, SdrAlign::VERT_BOTTOM);
 466         }
 467         break;
 468     }
 469
 470     // at the end, call base class
 471     FuPoor::ReceiveRequest(rReq);
 472 }
 473
 474 } // end of namespace sd
 475
 476 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */