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