basctl/source/dlged/dlgedfunc.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 <vcl/scrbar.hxx>
  21 #include <svx/svdview.hxx>
  22 #include "dlgedfunc.hxx"
  23 #include "dlged.hxx"
  24 #include "dlgedview.hxx"
  25 #include <vcl/seleng.hxx>
  26
  27 namespace basctl
  28 {
  29
  30 IMPL_LINK_INLINE_START( DlgEdFunc, ScrollTimeout, Timer *, pTimer )
  31 {
  32     (void)pTimer;
  33     Window& rWindow = rParent.GetWindow();
  34     Point aPos = rWindow.ScreenToOutputPixel( rWindow.GetPointerPosPixel() );
  35     aPos = rWindow.PixelToLogic( aPos );
  36     ForceScroll( aPos );
  37     return 0;
  38 }
  39 IMPL_LINK_INLINE_END( DlgEdFunc, ScrollTimeout, Timer *, pTimer )
  40
  41 void DlgEdFunc::ForceScroll( const Point& rPos )
  42 {
  43     aScrollTimer.Stop();
  44
  45     Window& rWindow  = rParent.GetWindow();
  46
  47     static Point aDefPoint;
  48     Rectangle aOutRect( aDefPoint, rWindow.GetOutputSizePixel() );
  49     aOutRect = rWindow.PixelToLogic( aOutRect );
  50
  51     ScrollBar* pHScroll = rParent.GetHScroll();
  52     ScrollBar* pVScroll = rParent.GetVScroll();
  53     long nDeltaX = pHScroll->GetLineSize();
  54     long nDeltaY = pVScroll->GetLineSize();
  55
  56     if( !aOutRect.IsInside( rPos ) )
  57     {
  58         if( rPos.X() < aOutRect.Left() )
  59             nDeltaX = -nDeltaX;
  60         else if( rPos.X() <= aOutRect.Right() )
  61             nDeltaX = 0;
  62
  63         if( rPos.Y() < aOutRect.Top() )
  64             nDeltaY = -nDeltaY;
  65         else if( rPos.Y() <= aOutRect.Bottom() )
  66             nDeltaY = 0;
  67
  68         if( nDeltaX )
  69             pHScroll->SetThumbPos( pHScroll->GetThumbPos() + nDeltaX );
  70         if( nDeltaY )
  71             pVScroll->SetThumbPos( pVScroll->GetThumbPos() + nDeltaY );
  72
  73         if( nDeltaX )
  74             rParent.DoScroll( pHScroll );
  75         if( nDeltaY )
  76             rParent.DoScroll( pVScroll );
  77     }
  78
  79     aScrollTimer.Start();
  80 }
  81
  82 DlgEdFunc::DlgEdFunc (DlgEditor& rParent_) :
  83     rParent(rParent_)
  84 {
  85     aScrollTimer.SetTimeoutHdl( LINK( this, DlgEdFunc, ScrollTimeout ) );
  86     aScrollTimer.SetTimeout( SELENG_AUTOREPEAT_INTERVAL );
  87 }
  88
  89 DlgEdFunc::~DlgEdFunc()
  90 {
  91 }
  92
  93 bool DlgEdFunc::MouseButtonDown( const MouseEvent& )
  94 {
  95     return true;
  96 }
  97
  98 bool DlgEdFunc::MouseButtonUp( const MouseEvent& )
  99 {
 100     aScrollTimer.Stop();
 101     return true;
 102 }
 103
 104 bool DlgEdFunc::MouseMove( const MouseEvent& )
 105 {
 106     return true;
 107 }
 108
 109 bool DlgEdFunc::KeyInput( const KeyEvent& rKEvt )
 110 {
 111     bool bReturn = false;
 112
 113     SdrView& rView = rParent.GetView();
 114     Window& rWindow = rParent.GetWindow();
 115
 116     KeyCode aCode = rKEvt.GetKeyCode();
 117     sal_uInt16 nCode = aCode.GetCode();
 118
 119     switch ( nCode )
 120     {
 121         case KEY_ESCAPE:
 122         {
 123             if ( rView.IsAction() )
 124             {
 125                 rView.BrkAction();
 126                 bReturn = true;
 127             }
 128             else if ( rView.AreObjectsMarked() )
 129             {
 130                 const SdrHdlList& rHdlList = rView.GetHdlList();
 131                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 132                 if ( pHdl )
 133                     const_cast<SdrHdlList&>(rHdlList).ResetFocusHdl();
 134                 else
 135                     rView.UnmarkAll();
 136
 137                 bReturn = true;
 138             }
 139         }
 140         break;
 141         case KEY_TAB:
 142         {
 143             if ( !aCode.IsMod1() && !aCode.IsMod2() )
 144             {
 145                 // mark next object
 146                 if ( !rView.MarkNextObj( !aCode.IsShift() ) )
 147                 {
 148                     // if no next object, mark first/last
 149                     rView.UnmarkAllObj();
 150                     rView.MarkNextObj( !aCode.IsShift() );
 151                 }
 152
 153                 if ( rView.AreObjectsMarked() )
 154                     rView.MakeVisible( rView.GetAllMarkedRect(), rWindow );
 155
 156                 bReturn = true;
 157             }
 158             else if ( aCode.IsMod1() )
 159             {
 160                 // selected handle
 161                 const SdrHdlList& rHdlList = rView.GetHdlList();
 162                 const_cast<SdrHdlList&>(rHdlList).TravelFocusHdl( !aCode.IsShift() );
 163
 164                 // guarantee visibility of focused handle
 165                 if (SdrHdl* pHdl = rHdlList.GetFocusHdl())
 166                 {
 167                     Point aHdlPosition( pHdl->GetPos() );
 168                     Rectangle aVisRect( aHdlPosition - Point( 100, 100 ), Size( 200, 200 ) );
 169                     rView.MakeVisible( aVisRect, rWindow );
 170                 }
 171
 172                 bReturn = true;
 173             }
 174         }
 175         break;
 176         case KEY_UP:
 177         case KEY_DOWN:
 178         case KEY_LEFT:
 179         case KEY_RIGHT:
 180         {
 181             long nX = 0;
 182             long nY = 0;
 183
 184             if ( nCode == KEY_UP )
 185             {
 186                 // scroll up
 187                 nX =  0;
 188                 nY = -1;
 189             }
 190             else if ( nCode == KEY_DOWN )
 191             {
 192                 // scroll down
 193                 nX =  0;
 194                 nY =  1;
 195             }
 196             else if ( nCode == KEY_LEFT )
 197             {
 198                 // scroll left
 199                 nX = -1;
 200                 nY =  0;
 201             }
 202             else if ( nCode == KEY_RIGHT )
 203             {
 204                 // scroll right
 205                 nX =  1;
 206                 nY =  0;
 207             }
 208
 209             if ( rView.AreObjectsMarked() && !aCode.IsMod1() )
 210             {
 211                 if ( aCode.IsMod2() )
 212                 {
 213                     // move in 1 pixel distance
 214                     Size aPixelSize = rWindow.PixelToLogic(Size(1, 1));
 215                     nX *= aPixelSize.Width();
 216                     nY *= aPixelSize.Height();
 217                 }
 218                 else
 219                 {
 220                     // move in 1 mm distance
 221                     nX *= 100;
 222                     nY *= 100;
 223                 }
 224
 225                 const SdrHdlList& rHdlList = rView.GetHdlList();
 226                 SdrHdl* pHdl = rHdlList.GetFocusHdl();
 227
 228                 if ( pHdl == 0 )
 229                 {
 230                     // no handle selected
 231                     if ( rView.IsMoveAllowed() )
 232                     {
 233                         // restrict movement to work area
 234                         const Rectangle& rWorkArea = rView.GetWorkArea();
 235
 236                         if ( !rWorkArea.IsEmpty() )
 237                         {
 238                             Rectangle aMarkRect( rView.GetMarkedObjRect() );
 239                             aMarkRect.Move( nX, nY );
 240
 241                             if ( !rWorkArea.IsInside( aMarkRect ) )
 242                             {
 243                                 if ( aMarkRect.Left() < rWorkArea.Left() )
 244                                     nX += rWorkArea.Left() - aMarkRect.Left();
 245
 246                                 if ( aMarkRect.Right() > rWorkArea.Right() )
 247                                     nX -= aMarkRect.Right() - rWorkArea.Right();
 248
 249                                 if ( aMarkRect.Top() < rWorkArea.Top() )
 250                                     nY += rWorkArea.Top() - aMarkRect.Top();
 251
 252                                 if ( aMarkRect.Bottom() > rWorkArea.Bottom() )
 253                                     nY -= aMarkRect.Bottom() - rWorkArea.Bottom();
 254                             }
 255                         }
 256
 257                         if ( nX != 0 || nY != 0 )
 258                         {
 259                             rView.MoveAllMarked( Size( nX, nY ) );
 260                             rView.MakeVisible( rView.GetAllMarkedRect(), rWindow );
 261                         }
 262                     }
 263                 }
 264                 else
 265                 {
 266                     // move the handle
 267                     if ( pHdl && ( nX || nY ) )
 268                     {
 269                         Point aStartPoint( pHdl->GetPos() );
 270                         Point aEndPoint( pHdl->GetPos() + Point( nX, nY ) );
 271                         const SdrDragStat& rDragStat = rView.GetDragStat();
 272
 273                         // start dragging
 274                         rView.BegDragObj( aStartPoint, 0, pHdl, 0 );
 275
 276                         if ( rView.IsDragObj() )
 277                         {
 278                             bool const bWasNoSnap = rDragStat.IsNoSnap();
 279                             bool const bWasSnapEnabled = rView.IsSnapEnabled();
 280
 281                             // switch snapping off
 282                             if ( !bWasNoSnap )
 283                                 const_cast<SdrDragStat&>(rDragStat).SetNoSnap(true);
 284                             if ( bWasSnapEnabled )
 285                                 rView.SetSnapEnabled(false);
 286
 287                             rView.MovAction( aEndPoint );
 288                             rView.EndDragObj();
 289
 290                             // restore snap
 291                             if ( !bWasNoSnap )
 292                                 const_cast<SdrDragStat&>(rDragStat).SetNoSnap( bWasNoSnap );
 293                             if ( bWasSnapEnabled )
 294                                 rView.SetSnapEnabled( bWasSnapEnabled );
 295                         }
 296
 297                         // make moved handle visible
 298                         Rectangle aVisRect( aEndPoint - Point( 100, 100 ), Size( 200, 200 ) );
 299                         rView.MakeVisible( aVisRect, rWindow );
 300                     }
 301                 }
 302             }
 303             else
 304             {
 305                 // scroll page
 306                 ScrollBar* pScrollBar = ( nX != 0 ) ? rParent.GetHScroll() : rParent.GetVScroll();
 307                 if ( pScrollBar )
 308                 {
 309                     long nRangeMin = pScrollBar->GetRangeMin();
 310                     long nRangeMax = pScrollBar->GetRangeMax();
 311                     long nThumbPos = pScrollBar->GetThumbPos() + ( ( nX != 0 ) ? nX : nY ) * pScrollBar->GetLineSize();
 312                     if ( nThumbPos < nRangeMin )
 313                         nThumbPos = nRangeMin;
 314                     if ( nThumbPos > nRangeMax )
 315                         nThumbPos = nRangeMax;
 316                     pScrollBar->SetThumbPos( nThumbPos );
 317                     rParent.DoScroll( pScrollBar );
 318                 }
 319             }
 320
 321             bReturn = true;
 322         }
 323         break;
 324         default:
 325         {
 326         }
 327         break;
 328     }
 329
 330     if ( bReturn )
 331         rWindow.ReleaseMouse();
 332
 333     return bReturn;
 334 }
 335
 336 DlgEdFuncInsert::DlgEdFuncInsert (DlgEditor& rParent_) :
 337     DlgEdFunc(rParent_)
 338 {
 339     rParent.GetView().SetCreateMode(true);
 340 }
 341
 342 DlgEdFuncInsert::~DlgEdFuncInsert()
 343 {
 344     rParent.GetView().SetEditMode( true );
 345 }
 346
 347 bool DlgEdFuncInsert::MouseButtonDown( const MouseEvent& rMEvt )
 348 {
 349     if( !rMEvt.IsLeft() )
 350         return true;
 351
 352     SdrView& rView  = rParent.GetView();
 353     Window& rWindow = rParent.GetWindow();
 354     rView.SetActualWin(&rWindow);
 355
 356     Point aPos = rWindow.PixelToLogic( rMEvt.GetPosPixel() );
 357     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
 358     sal_uInt16 nDrgLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
 359
 360     rWindow.CaptureMouse();
 361
 362     if ( rMEvt.IsLeft() && rMEvt.GetClicks() == 1 )
 363     {
 364         SdrHdl* pHdl = rView.PickHandle(aPos);
 365
 366         // if selected object was hit, drag object
 367         if ( pHdl!=NULL || rView.IsMarkedHit(aPos, nHitLog) )
 368             rView.BegDragObj(aPos, (OutputDevice*) NULL, pHdl, nDrgLog);
 369         else if ( rView.AreObjectsMarked() )
 370             rView.UnmarkAll();
 371
 372         // if no action, create object
 373         if ( !rView.IsAction() )
 374             rView.BegCreateObj(aPos);
 375     }
 376     else if ( rMEvt.IsLeft() && rMEvt.GetClicks() == 2 )
 377     {
 378         // if object was hit, show property browser
 379         if ( rView.IsMarkedHit(aPos, nHitLog) && rParent.GetMode() != DlgEditor::READONLY )
 380             rParent.ShowProperties();
 381     }
 382
 383     return true;
 384 }
 385
 386 bool DlgEdFuncInsert::MouseButtonUp( const MouseEvent& rMEvt )
 387 {
 388     DlgEdFunc::MouseButtonUp( rMEvt );
 389
 390     SdrView& rView  = rParent.GetView();
 391     Window& rWindow = rParent.GetWindow();
 392     rView.SetActualWin(&rWindow);
 393
 394     rWindow.ReleaseMouse();
 395
 396     // object creation active?
 397     if ( rView.IsCreateObj() )
 398     {
 399         rView.EndCreateObj(SDRCREATE_FORCEEND);
 400
 401         if ( !rView.AreObjectsMarked() )
 402         {
 403             sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
 404             Point aPos( rWindow.PixelToLogic( rMEvt.GetPosPixel() ) );
 405             rView.MarkObj(aPos, nHitLog);
 406         }
 407
 408         return rView.AreObjectsMarked();
 409     }
 410     else
 411     {
 412         if ( rView.IsDragObj() )
 413             rView.EndDragObj( rMEvt.IsMod1() );
 414         return true;
 415     }
 416 }
 417
 418 bool DlgEdFuncInsert::MouseMove( const MouseEvent& rMEvt )
 419 {
 420     SdrView& rView  = rParent.GetView();
 421     Window& rWindow = rParent.GetWindow();
 422     rView.SetActualWin(&rWindow);
 423
 424     Point aPos = rWindow.PixelToLogic(rMEvt.GetPosPixel());
 425     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
 426
 427     if (rView.IsAction())
 428     {
 429         ForceScroll(aPos);
 430         rView.MovAction(aPos);
 431     }
 432
 433     rWindow.SetPointer( rView.GetPreferredPointer( aPos, &rWindow, nHitLog ) );
 434
 435     return true;
 436 }
 437
 438 DlgEdFuncSelect::DlgEdFuncSelect (DlgEditor& rParent_) :
 439     DlgEdFunc(rParent_),
 440     bMarkAction(false)
 441 {
 442 }
 443
 444 DlgEdFuncSelect::~DlgEdFuncSelect()
 445 {
 446 }
 447
 448 bool DlgEdFuncSelect::MouseButtonDown( const MouseEvent& rMEvt )
 449 {
 450     // get view from parent
 451     SdrView& rView  = rParent.GetView();
 452     Window& rWindow = rParent.GetWindow();
 453     rView.SetActualWin(&rWindow);
 454
 455     sal_uInt16 nDrgLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
 456     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
 457     Point aMDPos = rWindow.PixelToLogic(rMEvt.GetPosPixel());
 458
 459     if ( rMEvt.IsLeft() && rMEvt.GetClicks() == 1 )
 460     {
 461         SdrHdl* pHdl = rView.PickHandle(aMDPos);
 462         SdrObject* pObj;
 463         SdrPageView* pPV;
 464
 465         // hit selected object?
 466         if ( pHdl!=NULL || rView.IsMarkedHit(aMDPos, nHitLog) )
 467         {
 468             rView.BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
 469         }
 470         else
 471         {
 472             // if not multi selection, unmark all
 473             if ( !rMEvt.IsShift() )
 474                 rView.UnmarkAll();
 475             else
 476             {
 477                 if( rView.PickObj( aMDPos, nHitLog, pObj, pPV ) )
 478                 {
 479                     //if (dynamic_cast<DlgEdForm*>(pObj))
 480                     //  rView.UnmarkAll();
 481                     //else
 482                     //  rParent.UnmarkDialog();
 483                 }
 484             }
 485
 486             if ( rView.MarkObj(aMDPos, nHitLog) )
 487             {
 488                 // drag object
 489                 pHdl = rView.PickHandle(aMDPos);
 490                 rView.BegDragObj(aMDPos, (OutputDevice*) NULL, pHdl, nDrgLog);
 491             }
 492             else
 493             {
 494                 // select object
 495                 rView.BegMarkObj(aMDPos);
 496                 bMarkAction = true;
 497             }
 498         }
 499     }
 500     else if ( rMEvt.IsLeft() && rMEvt.GetClicks() == 2 )
 501     {
 502         // if object was hit, show property browser
 503         if ( rView.IsMarkedHit(aMDPos, nHitLog) && rParent.GetMode() != DlgEditor::READONLY )
 504             rParent.ShowProperties();
 505     }
 506
 507     return true;
 508 }
 509
 510 bool DlgEdFuncSelect::MouseButtonUp( const MouseEvent& rMEvt )
 511 {
 512     DlgEdFunc::MouseButtonUp( rMEvt );
 513
 514     // get view from parent
 515     SdrView& rView  = rParent.GetView();
 516     Window& rWindow = rParent.GetWindow();
 517     rView.SetActualWin(&rWindow);
 518
 519     Point aPnt = rWindow.PixelToLogic(rMEvt.GetPosPixel());
 520     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
 521
 522     if ( rMEvt.IsLeft() )
 523     {
 524         if (rView.IsDragObj())
 525         {
 526             // object was dragged
 527             rView.EndDragObj( rMEvt.IsMod1() );
 528             rView.ForceMarkedToAnotherPage();
 529         }
 530         else if (rView.IsAction())
 531         {
 532             rView.EndAction();
 533         }
 534     }
 535
 536     bMarkAction = false;
 537
 538     rWindow.SetPointer( rView.GetPreferredPointer( aPnt, &rWindow, nHitLog ) );
 539     rWindow.ReleaseMouse();
 540
 541     return true;
 542 }
 543
 544 bool DlgEdFuncSelect::MouseMove( const MouseEvent& rMEvt )
 545 {
 546     SdrView& rView  = rParent.GetView();
 547     Window& rWindow = rParent.GetWindow();
 548     rView.SetActualWin(&rWindow);
 549
 550     Point aPnt = rWindow.PixelToLogic(rMEvt.GetPosPixel());
 551     sal_uInt16 nHitLog = static_cast<sal_uInt16>(rWindow.PixelToLogic(Size(3, 0)).Width());
 552
 553     if ( rView.IsAction() )
 554     {
 555         Point aPix = rMEvt.GetPosPixel();
 556         Point aPnt_ = rWindow.PixelToLogic(aPix);
 557
 558         ForceScroll(aPnt_);
 559         rView.MovAction(aPnt_);
 560     }
 561
 562     rWindow.SetPointer( rView.GetPreferredPointer( aPnt, &rWindow, nHitLog ) );
 563
 564     return true;
 565 }
 566
 567 } // namespace basctl
 568
 569 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */