vcl/source/window/split.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 <tools/rc.h>
  21 #include <tools/poly.hxx>
  22
  23 #include <vcl/event.hxx>
  24 #include <vcl/split.hxx>
  25 #include <vcl/svapp.hxx>
  26 #include <vcl/syswin.hxx>
  27 #include <vcl/taskpanelist.hxx>
  28 #include <vcl/gradient.hxx>
  29 #include <vcl/lineinfo.hxx>
  30 #include <vcl/settings.hxx>
  31
  32 #include <rtl/instance.hxx>
  33
  34 #include <window.h>
  35
  36 namespace
  37 {
  38     struct ImplBlackWall
  39         : public rtl::StaticWithInit<Wallpaper, ImplBlackWall> {
  40         Wallpaper operator () () {
  41             return Wallpaper(COL_BLACK);
  42         }
  43     };
  44     struct ImplWhiteWall
  45         : public rtl::StaticWithInit<Wallpaper, ImplWhiteWall> {
  46         Wallpaper operator () () {
  47             return Wallpaper(COL_LIGHTGRAY);
  48         }
  49     };
  50 }
  51
  52 // Should only be called from a ImplInit method for initialization or
  53 // after checking bNew is different from the current mbHorzSplit value.
  54 // The public method that does that check is Splitter::SetHorizontal().
  55 void Splitter::ImplInitHorVer(bool bNew)
  56 {
  57     mbHorzSplit = bNew;
  58
  59     PointerStyle ePointerStyle;
  60     const StyleSettings& rSettings = GetSettings().GetStyleSettings();
  61
  62     if ( mbHorzSplit )
  63     {
  64         ePointerStyle = PointerStyle::HSplit;
  65         SetSizePixel( Size( rSettings.GetSplitSize(), rSettings.GetScrollBarSize() ) );
  66     }
  67     else
  68     {
  69         ePointerStyle = PointerStyle::VSplit;
  70         SetSizePixel( Size( rSettings.GetScrollBarSize(), rSettings.GetSplitSize() ) );
  71     }
  72
  73     SetPointer( Pointer( ePointerStyle ) );
  74 }
  75
  76 void Splitter::ImplInit( vcl::Window* pParent, WinBits nWinStyle )
  77 {
  78     Window::ImplInit( pParent, nWinStyle, nullptr );
  79
  80     mpRefWin = pParent;
  81
  82     ImplInitHorVer(nWinStyle & WB_HSCROLL);
  83
  84     if( GetSettings().GetStyleSettings().GetFaceColor().IsDark() )
  85         SetBackground( ImplWhiteWall::get() );
  86     else
  87         SetBackground( ImplBlackWall::get() );
  88
  89     TaskPaneList *pTList = GetSystemWindow()->GetTaskPaneList();
  90     pTList->AddWindow( this );
  91 }
  92
  93 void Splitter::ImplSplitMousePos( Point& rPos )
  94 {
  95     if ( mbHorzSplit )
  96     {
  97         if ( rPos.X() > maDragRect.Right()-1 )
  98             rPos.X() = maDragRect.Right()-1;
  99         if ( rPos.X() < maDragRect.Left()+1 )
 100             rPos.X() = maDragRect.Left()+1;
 101     }
 102     else
 103     {
 104         if ( rPos.Y() > maDragRect.Bottom()-1 )
 105             rPos.Y() = maDragRect.Bottom()-1;
 106         if ( rPos.Y() < maDragRect.Top()+1 )
 107             rPos.Y() = maDragRect.Top()+1;
 108     }
 109 }
 110
 111 void Splitter::ImplDrawSplitter()
 112 {
 113     Rectangle aInvRect( maDragRect );
 114
 115     if ( mbHorzSplit )
 116     {
 117         aInvRect.Left()     = maDragPos.X() - 1;
 118         aInvRect.Right()    = maDragPos.X() + 1;
 119     }
 120     else
 121     {
 122         aInvRect.Top()      = maDragPos.Y() - 1;
 123         aInvRect.Bottom()   = maDragPos.Y() + 1;
 124     }
 125
 126     mpRefWin->InvertTracking( mpRefWin->PixelToLogic(aInvRect), ShowTrackFlags::Split );
 127 }
 128
 129 Splitter::Splitter( vcl::Window* pParent, WinBits nStyle ) :
 130     Window( WINDOW_SPLITTER ),
 131     mpRefWin( nullptr ),
 132     mnSplitPos( 0 ),
 133     mnLastSplitPos( 0 ),
 134     mnStartSplitPos( 0 ),
 135     mbDragFull( false ),
 136     mbKbdSplitting( false ),
 137     mbInKeyEvent( 0 ),
 138     mnKeyboardStepSize( SPLITTER_DEFAULTSTEPSIZE )
 139 {
 140     ImplGetWindowImpl()->mbSplitter        = true;
 141
 142     ImplInit( pParent, nStyle );
 143
 144     SetLineColor();
 145     SetFillColor();
 146 }
 147
 148 Splitter::~Splitter()
 149 {
 150     disposeOnce();
 151 }
 152
 153 void Splitter::dispose()
 154 {
 155     SystemWindow *pSysWin = GetSystemWindow();
 156     if(pSysWin)
 157     {
 158         TaskPaneList *pTList = pSysWin->GetTaskPaneList();
 159         pTList->RemoveWindow(this);
 160     }
 161     mpRefWin.clear();
 162     Window::dispose();
 163 }
 164
 165 void Splitter::SetHorizontal(bool bNew)
 166 {
 167     if(bNew != (bool)mbHorzSplit)
 168     {
 169         ImplInitHorVer(bNew);
 170     }
 171 }
 172
 173 void Splitter::SetKeyboardStepSize( long nStepSize )
 174 {
 175     mnKeyboardStepSize = nStepSize;
 176 }
 177
 178 Splitter* Splitter::ImplFindSibling()
 179 {
 180     // look for another splitter with the same parent but different orientation
 181     vcl::Window *pWin = GetParent()->GetWindow( GetWindowType::FirstChild );
 182     Splitter *pSplitter = nullptr;
 183     while( pWin )
 184     {
 185         if( pWin->ImplIsSplitter() )
 186         {
 187             pSplitter = static_cast<Splitter*>(pWin);
 188             if( pSplitter != this && IsHorizontal() != pSplitter->IsHorizontal() )
 189                 return pSplitter;
 190         }
 191         pWin = pWin->GetWindow( GetWindowType::Next );
 192     }
 193     return nullptr;
 194 }
 195
 196 bool Splitter::ImplSplitterActive()
 197 {
 198     // is splitter in document or at scrollbar handle ?
 199
 200     bool bActive = true;
 201     const StyleSettings& rSettings = GetSettings().GetStyleSettings();
 202     long nA = rSettings.GetScrollBarSize();
 203     long nB = rSettings.GetSplitSize();
 204
 205     Size aSize = GetOutputSize();
 206     if ( mbHorzSplit )
 207     {
 208         if( aSize.Width() == nB && aSize.Height() == nA )
 209             bActive = false;
 210     }
 211     else
 212     {
 213         if( aSize.Width() == nA && aSize.Height() == nB )
 214             bActive = false;
 215     }
 216     return bActive;
 217 }
 218
 219 void Splitter::MouseButtonDown( const MouseEvent& rMEvt )
 220 {
 221     if ( rMEvt.GetClicks() == 2 )
 222     {
 223         if ( mnLastSplitPos != mnSplitPos )
 224         {
 225             StartSplit();
 226             Point aPos = rMEvt.GetPosPixel();
 227             if ( mbHorzSplit )
 228                 aPos.X() = mnLastSplitPos;
 229             else
 230                 aPos.Y() = mnLastSplitPos;
 231             ImplSplitMousePos( aPos );
 232             long nTemp = mnSplitPos;
 233             if ( mbHorzSplit )
 234                 SetSplitPosPixel( aPos.X() );
 235             else
 236                 SetSplitPosPixel( aPos.Y() );
 237             mnLastSplitPos = nTemp;
 238             Split();
 239             EndSplit();
 240         }
 241     }
 242     else
 243         StartDrag();
 244 }
 245
 246 void Splitter::Tracking( const TrackingEvent& rTEvt )
 247 {
 248     if ( rTEvt.IsTrackingEnded() )
 249     {
 250         if ( !mbDragFull )
 251             ImplDrawSplitter();
 252
 253         if ( !rTEvt.IsTrackingCanceled() )
 254         {
 255             long nNewPos;
 256             if ( mbHorzSplit )
 257                 nNewPos = maDragPos.X();
 258             else
 259                 nNewPos = maDragPos.Y();
 260             if ( nNewPos != mnStartSplitPos )
 261             {
 262                 SetSplitPosPixel( nNewPos );
 263                 mnLastSplitPos = 0;
 264                 Split();
 265             }
 266             EndSplit();
 267         }
 268         else if ( mbDragFull )
 269         {
 270             SetSplitPosPixel( mnStartSplitPos );
 271             Split();
 272         }
 273         mnStartSplitPos = 0;
 274     }
 275     else
 276     {
 277         //Point aNewPos = mpRefWin->ScreenToOutputPixel( OutputToScreenPixel( rTEvt.GetMouseEvent().GetPosPixel() ) );
 278         Point aNewPos = mpRefWin->NormalizedScreenToOutputPixel( OutputToNormalizedScreenPixel( rTEvt.GetMouseEvent().GetPosPixel() ) );
 279         ImplSplitMousePos( aNewPos );
 280
 281         if ( mbHorzSplit )
 282         {
 283             if ( aNewPos.X() == maDragPos.X() )
 284                 return;
 285         }
 286         else
 287         {
 288             if ( aNewPos.Y() == maDragPos.Y() )
 289                 return;
 290         }
 291
 292         if ( mbDragFull )
 293         {
 294             maDragPos = aNewPos;
 295             long nNewPos;
 296             if ( mbHorzSplit )
 297                 nNewPos = maDragPos.X();
 298             else
 299                 nNewPos = maDragPos.Y();
 300             if ( nNewPos != mnSplitPos )
 301             {
 302                 SetSplitPosPixel( nNewPos );
 303                 mnLastSplitPos = 0;
 304                 Split();
 305             }
 306
 307             GetParent()->Update();
 308         }
 309         else
 310         {
 311             ImplDrawSplitter();
 312             maDragPos = aNewPos;
 313             ImplDrawSplitter();
 314         }
 315     }
 316 }
 317
 318 void Splitter::ImplKbdTracking( vcl::KeyCode aKeyCode )
 319 {
 320     sal_uInt16 nCode = aKeyCode.GetCode();
 321     if ( nCode == KEY_ESCAPE || nCode == KEY_RETURN )
 322     {
 323         if( !mbKbdSplitting )
 324             return;
 325         else
 326             mbKbdSplitting = false;
 327
 328         if ( nCode != KEY_ESCAPE )
 329         {
 330             long nNewPos;
 331             if ( mbHorzSplit )
 332                 nNewPos = maDragPos.X();
 333             else
 334                 nNewPos = maDragPos.Y();
 335             if ( nNewPos != mnStartSplitPos )
 336             {
 337                 SetSplitPosPixel( nNewPos );
 338                 mnLastSplitPos = 0;
 339                 Split();
 340             }
 341         }
 342         else
 343         {
 344             SetSplitPosPixel( mnStartSplitPos );
 345             Split();
 346             EndSplit();
 347         }
 348         mnStartSplitPos = 0;
 349     }
 350     else
 351     {
 352         Point aNewPos;
 353         Size aSize = mpRefWin->GetOutputSize();
 354         Point aPos = GetPosPixel();
 355         // depending on the position calc allows continuous moves or snaps to row/columns
 356         // continuous mode is active when position is at the origin or end of the splitter
 357         // otherwise snap mode is active
 358         // default here is snap, holding shift sets continuous mode
 359         if( mbHorzSplit )
 360             aNewPos = Point( ImplSplitterActive() ? aPos.X() : mnSplitPos, aKeyCode.IsShift() ? 0 : aSize.Height()/2);
 361         else
 362             aNewPos = Point( aKeyCode.IsShift() ? 0 : aSize.Width()/2, ImplSplitterActive() ? aPos.Y() : mnSplitPos );
 363
 364         Point aOldWindowPos = GetPosPixel();
 365
 366         int maxiter = 500;  // avoid endless loop
 367         int delta=0;
 368         int delta_step = mbHorzSplit  ? aSize.Width()/10 : aSize.Height()/10;
 369
 370         // use the specified step size if it was set
 371         if( mnKeyboardStepSize != SPLITTER_DEFAULTSTEPSIZE )
 372             delta_step = mnKeyboardStepSize;
 373
 374         while( maxiter-- && aOldWindowPos == GetPosPixel() )
 375         {
 376             // inc/dec position until application performs changes
 377             // thus a single key press really moves the splitter
 378             if( aKeyCode.IsShift() )
 379                 delta++;
 380             else
 381                 delta += delta_step;
 382
 383             switch( nCode )
 384             {
 385             case KEY_LEFT:
 386                 aNewPos.X()-=delta;
 387                 break;
 388             case KEY_RIGHT:
 389                 aNewPos.X()+=delta;
 390                 break;
 391             case KEY_UP:
 392                 aNewPos.Y()-=delta;
 393                 break;
 394             case KEY_DOWN:
 395                 aNewPos.Y()+=delta;
 396                 break;
 397             default:
 398                 maxiter = 0;    // leave loop
 399                 break;
 400             }
 401             ImplSplitMousePos( aNewPos );
 402
 403             if ( mbHorzSplit )
 404             {
 405                 if ( aNewPos.X() == maDragPos.X() )
 406                     continue;
 407             }
 408             else
 409             {
 410                 if ( aNewPos.Y() == maDragPos.Y() )
 411                     continue;
 412             }
 413
 414             maDragPos = aNewPos;
 415             long nNewPos;
 416             if ( mbHorzSplit )
 417                 nNewPos = maDragPos.X();
 418             else
 419                 nNewPos = maDragPos.Y();
 420             if ( nNewPos != mnSplitPos )
 421             {
 422                 SetSplitPosPixel( nNewPos );
 423                 mnLastSplitPos = 0;
 424                 Split();
 425             }
 426             GetParent()->Update();
 427         }
 428     }
 429 }
 430
 431 void Splitter::StartSplit()
 432 {
 433     maStartSplitHdl.Call( this );
 434 }
 435
 436 void Splitter::Split()
 437 {
 438     maSplitHdl.Call( this );
 439 }
 440
 441 void Splitter::EndSplit()
 442 {
 443     maEndSplitHdl.Call( this );
 444 }
 445
 446 void Splitter::SetDragRectPixel( const Rectangle& rDragRect, vcl::Window* _pRefWin )
 447 {
 448     maDragRect = rDragRect;
 449     if ( !_pRefWin )
 450         mpRefWin = GetParent();
 451     else
 452         mpRefWin = _pRefWin;
 453 }
 454
 455 void Splitter::SetSplitPosPixel( long nNewPos )
 456 {
 457     mnSplitPos = nNewPos;
 458 }
 459
 460 void Splitter::StartDrag()
 461 {
 462     if ( IsTracking() )
 463         return;
 464
 465     StartSplit();
 466
 467     // Tracking starten
 468     StartTracking();
 469
 470     // Start-Position ermitteln
 471     maDragPos = mpRefWin->GetPointerPosPixel();
 472     ImplSplitMousePos( maDragPos );
 473     if ( mbHorzSplit )
 474         mnStartSplitPos = maDragPos.X();
 475     else
 476         mnStartSplitPos = maDragPos.Y();
 477
 478     mbDragFull = bool(Application::GetSettings().GetStyleSettings().GetDragFullOptions() & DragFullOptions::Split);
 479     if ( !mbDragFull )
 480         ImplDrawSplitter();
 481 }
 482
 483 void Splitter::ImplStartKbdSplitting()
 484 {
 485     if( mbKbdSplitting )
 486         return;
 487
 488     mbKbdSplitting = true;
 489
 490     StartSplit();
 491
 492     // determine start position
 493     // because we have no mouse position we take either the position
 494     // of the splitter window or the last split position
 495     // the other coordinate is just the center of the reference window
 496     Size aSize = mpRefWin->GetOutputSize();
 497     Point aPos = GetPosPixel();
 498     if( mbHorzSplit )
 499         maDragPos = Point( ImplSplitterActive() ? aPos.X() : mnSplitPos, aSize.Height()/2 );
 500     else
 501         maDragPos = Point( aSize.Width()/2, ImplSplitterActive() ? aPos.Y() : mnSplitPos );
 502     ImplSplitMousePos( maDragPos );
 503     if ( mbHorzSplit )
 504         mnStartSplitPos = maDragPos.X();
 505     else
 506         mnStartSplitPos = maDragPos.Y();
 507 }
 508
 509 void Splitter::ImplRestoreSplitter()
 510 {
 511     // set splitter in the center of the ref window
 512     StartSplit();
 513     Size aSize = mpRefWin->GetOutputSize();
 514     Point aPos = Point( aSize.Width()/2 , aSize.Height()/2);
 515     if ( mnLastSplitPos != mnSplitPos && mnLastSplitPos > 5 )
 516     {
 517         // restore last pos if it was a useful position (>5)
 518         if ( mbHorzSplit )
 519             aPos.X() = mnLastSplitPos;
 520         else
 521             aPos.Y() = mnLastSplitPos;
 522     }
 523
 524     ImplSplitMousePos( aPos );
 525     long nTemp = mnSplitPos;
 526     if ( mbHorzSplit )
 527         SetSplitPosPixel( aPos.X() );
 528     else
 529         SetSplitPosPixel( aPos.Y() );
 530     mnLastSplitPos = nTemp;
 531     Split();
 532     EndSplit();
 533 }
 534
 535 void Splitter::GetFocus()
 536 {
 537     if( !ImplSplitterActive() )
 538         ImplRestoreSplitter();
 539
 540     Invalidate();
 541 }
 542
 543 void Splitter::LoseFocus()
 544 {
 545     if( mbKbdSplitting )
 546     {
 547         vcl::KeyCode aReturnKey( KEY_RETURN );
 548         ImplKbdTracking( aReturnKey );
 549         mbKbdSplitting = false;
 550     }
 551     Invalidate();
 552 }
 553
 554 void Splitter::KeyInput( const KeyEvent& rKEvt )
 555 {
 556     if( mbInKeyEvent )
 557         return;
 558
 559     mbInKeyEvent = 1;
 560
 561     Splitter *pSibling = ImplFindSibling();
 562     vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();
 563     sal_uInt16 nCode = aKeyCode.GetCode();
 564     switch ( nCode )
 565     {
 566         case KEY_UP:
 567         case KEY_DOWN:
 568             if( !mbHorzSplit )
 569             {
 570                 ImplStartKbdSplitting();
 571                 ImplKbdTracking( aKeyCode );
 572             }
 573             else
 574             {
 575                 if( pSibling )
 576                 {
 577                     pSibling->GrabFocus();
 578                     pSibling->KeyInput( rKEvt );
 579                 }
 580             }
 581             break;
 582         case KEY_RIGHT:
 583         case KEY_LEFT:
 584             if( mbHorzSplit )
 585             {
 586                 ImplStartKbdSplitting();
 587                 ImplKbdTracking( aKeyCode );
 588             }
 589             else
 590             {
 591                 if( pSibling )
 592                 {
 593                     pSibling->GrabFocus();
 594                     pSibling->KeyInput( rKEvt );
 595                 }
 596             }
 597             break;
 598
 599         case KEY_DELETE:
 600             if( ImplSplitterActive() )
 601             {
 602                 if( mbKbdSplitting )
 603                 {
 604                     vcl::KeyCode aKey( KEY_ESCAPE );
 605                     ImplKbdTracking( aKey );
 606                 }
 607
 608                 StartSplit();
 609                 Point aPos;
 610                 if ( mbHorzSplit )
 611                     aPos.X() = 0;
 612                 else
 613                     aPos.Y() = 0;
 614                 ImplSplitMousePos( aPos );
 615                 long nTemp = mnSplitPos;
 616                 if ( mbHorzSplit )
 617                     SetSplitPosPixel( aPos.X() );
 618                 else
 619                     SetSplitPosPixel( aPos.Y() );
 620                 mnLastSplitPos = nTemp;
 621                 Split();
 622                 EndSplit();
 623
 624                 // Shift-Del deletes both splitters
 625                 if( aKeyCode.IsShift() && pSibling )
 626                     pSibling->KeyInput( rKEvt );
 627
 628                 GrabFocusToDocument();
 629             }
 630             break;
 631
 632         case KEY_ESCAPE:
 633             if( mbKbdSplitting )
 634                 ImplKbdTracking( aKeyCode );
 635             else
 636                 GrabFocusToDocument();
 637             break;
 638
 639         case KEY_RETURN:
 640             ImplKbdTracking( aKeyCode );
 641             GrabFocusToDocument();
 642             break;
 643         default:    // let any key input fix the splitter
 644             Window::KeyInput( rKEvt );
 645             GrabFocusToDocument();
 646             break;
 647     }
 648     mbInKeyEvent = 0;
 649 }
 650
 651 void Splitter::DataChanged( const DataChangedEvent& rDCEvt )
 652 {
 653     Window::DataChanged( rDCEvt );
 654     if( rDCEvt.GetType() == DataChangedEventType::SETTINGS )
 655     {
 656         const AllSettings* pOldSettings = rDCEvt.GetOldSettings();
 657         if(!pOldSettings)
 658             return;
 659
 660         Color oldFaceColor = pOldSettings->GetStyleSettings().GetFaceColor();
 661         Color newFaceColor = Application::GetSettings().GetStyleSettings().GetFaceColor();
 662         if( oldFaceColor.IsDark() != newFaceColor.IsDark() )
 663         {
 664             if( newFaceColor.IsDark() )
 665                 SetBackground( ImplWhiteWall::get() );
 666             else
 667                 SetBackground( ImplBlackWall::get() );
 668         }
 669     }
 670 }
 671
 672 void Splitter::Paint(vcl::RenderContext& rRenderContext, const Rectangle& rPaintRect)
 673 {
 674     rRenderContext.DrawRect(rPaintRect);
 675
 676     tools::Polygon aPoly(rPaintRect);
 677     tools::PolyPolygon aPolyPoly(aPoly);
 678     rRenderContext.DrawTransparent(aPolyPoly, 85);
 679
 680     if (mbKbdSplitting)
 681     {
 682         LineInfo aInfo( LineStyle::Dash );
 683         //aInfo.SetDashLen( 2 );
 684         //aInfo.SetDashCount( 1 );
 685         aInfo.SetDistance( 1 );
 686         aInfo.SetDotLen( 2 );
 687         aInfo.SetDotCount( 3 );
 688
 689         rRenderContext.DrawPolyLine( aPoly, aInfo );
 690     }
 691     else
 692     {
 693         rRenderContext.DrawRect(rPaintRect);
 694     }
 695 }
 696
 697 Size Splitter::GetOptimalSize() const
 698 {
 699     return LogicToPixel(Size(3, 3), MapUnit::MapAppFont);
 700 }
 701
 702 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */