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