Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 698 insertions, 0 deletions

diff --git a/vcl/source/window/split.cxx b/vcl/source/window/split.cxx
new file mode 100644
index 000000000..df631b270
--- /dev/null
+++ b/vcl/source/window/split.cxx
@@ -0,0 +1,698 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <tools/poly.hxx>
+
+#include <vcl/event.hxx>
+#include <vcl/split.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/syswin.hxx>
+#include <vcl/taskpanelist.hxx>
+#include <vcl/lineinfo.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/ptrstyle.hxx>
+#include <vcl/lazydelete.hxx>
+
+#include <window.h>
+
+namespace
+{
+    Wallpaper& ImplBlackWall()
+    {
+        static vcl::DeleteOnDeinit< Wallpaper > SINGLETON(COL_BLACK);
+        return *SINGLETON.get();
+    }
+    Wallpaper& ImplWhiteWall()
+    {
+        static vcl::DeleteOnDeinit< Wallpaper > SINGLETON(COL_LIGHTGRAY);
+        return *SINGLETON.get();
+    }
+}
+
+// Should only be called from an ImplInit method for initialization or
+// after checking bNew is different from the current mbHorzSplit value.
+// The public method that does that check is Splitter::SetHorizontal().
+void Splitter::ImplInitHorVer(bool bNew)
+{
+    mbHorzSplit = bNew;
+
+    PointerStyle ePointerStyle;
+    const StyleSettings& rSettings = GetSettings().GetStyleSettings();
+
+    if ( mbHorzSplit )
+    {
+        ePointerStyle = PointerStyle::HSplit;
+        SetSizePixel( Size( StyleSettings::GetSplitSize(), rSettings.GetScrollBarSize() ) );
+    }
+    else
+    {
+        ePointerStyle = PointerStyle::VSplit;
+        SetSizePixel( Size( rSettings.GetScrollBarSize(), StyleSettings::GetSplitSize() ) );
+    }
+
+    SetPointer( ePointerStyle );
+}
+
+void Splitter::ImplInit( vcl::Window* pParent, WinBits nWinStyle )
+{
+    Window::ImplInit( pParent, nWinStyle, nullptr );
+
+    mpRefWin = pParent;
+
+    ImplInitHorVer(nWinStyle & WB_HSCROLL);
+
+    if( GetSettings().GetStyleSettings().GetFaceColor().IsDark() )
+        SetBackground( ImplWhiteWall() );
+    else
+        SetBackground( ImplBlackWall() );
+
+    TaskPaneList *pTList = GetSystemWindow()->GetTaskPaneList();
+    pTList->AddWindow( this );
+}
+
+void Splitter::ImplSplitMousePos( Point& rPos )
+{
+    if ( mbHorzSplit )
+    {
+        if ( rPos.X() > maDragRect.Right()-1 )
+            rPos.setX( maDragRect.Right()-1 );
+        if ( rPos.X() < maDragRect.Left()+1 )
+            rPos.setX( maDragRect.Left()+1 );
+    }
+    else
+    {
+        if ( rPos.Y() > maDragRect.Bottom()-1 )
+            rPos.setY( maDragRect.Bottom()-1 );
+        if ( rPos.Y() < maDragRect.Top()+1 )
+            rPos.setY( maDragRect.Top()+1 );
+    }
+}
+
+void Splitter::ImplDrawSplitter()
+{
+    tools::Rectangle aInvRect( maDragRect );
+
+    if ( mbHorzSplit )
+    {
+        aInvRect.SetLeft( maDragPos.X() - 1 );
+        aInvRect.SetRight( maDragPos.X() + 1 );
+    }
+    else
+    {
+        aInvRect.SetTop( maDragPos.Y() - 1 );
+        aInvRect.SetBottom( maDragPos.Y() + 1 );
+    }
+
+    mpRefWin->InvertTracking( mpRefWin->PixelToLogic(aInvRect), ShowTrackFlags::Split );
+}
+
+Splitter::Splitter( vcl::Window* pParent, WinBits nStyle ) :
+    Window( WindowType::SPLITTER ),
+    mpRefWin( nullptr ),
+    mnSplitPos( 0 ),
+    mnLastSplitPos( 0 ),
+    mnStartSplitPos( 0 ),
+    mbDragFull( false ),
+    mbKbdSplitting( false ),
+    mbInKeyEvent( false ),
+    mnKeyboardStepSize( SPLITTER_DEFAULTSTEPSIZE )
+{
+    ImplGetWindowImpl()->mbSplitter        = true;
+
+    ImplInit( pParent, nStyle );
+
+    GetOutDev()->SetLineColor();
+    GetOutDev()->SetFillColor();
+}
+
+Splitter::~Splitter()
+{
+    disposeOnce();
+}
+
+void Splitter::dispose()
+{
+    SystemWindow *pSysWin = GetSystemWindow();
+    if(pSysWin)
+    {
+        TaskPaneList *pTList = pSysWin->GetTaskPaneList();
+        pTList->RemoveWindow(this);
+    }
+    mpRefWin.clear();
+    Window::dispose();
+}
+
+void Splitter::SetHorizontal(bool bNew)
+{
+    if(bNew != mbHorzSplit)
+    {
+        ImplInitHorVer(bNew);
+    }
+}
+
+void Splitter::SetKeyboardStepSize( tools::Long nStepSize )
+{
+    mnKeyboardStepSize = nStepSize;
+}
+
+Splitter* Splitter::ImplFindSibling()
+{
+    // look for another splitter with the same parent but different orientation
+    vcl::Window *pWin = GetParent()->GetWindow( GetWindowType::FirstChild );
+    Splitter *pSplitter = nullptr;
+    while( pWin )
+    {
+        if( pWin->ImplIsSplitter() )
+        {
+            pSplitter = static_cast<Splitter*>(pWin);
+            if( pSplitter != this && IsHorizontal() != pSplitter->IsHorizontal() )
+                return pSplitter;
+        }
+        pWin = pWin->GetWindow( GetWindowType::Next );
+    }
+    return nullptr;
+}
+
+bool Splitter::ImplSplitterActive()
+{
+    // is splitter in document or at scrollbar handle ?
+
+    bool bActive = true;
+    const StyleSettings& rSettings = GetSettings().GetStyleSettings();
+    tools::Long nA = rSettings.GetScrollBarSize();
+    tools::Long nB = StyleSettings::GetSplitSize();
+
+    Size aSize = GetOutDev()->GetOutputSize();
+    if ( mbHorzSplit )
+    {
+        if( aSize.Width() == nB && aSize.Height() == nA )
+            bActive = false;
+    }
+    else
+    {
+        if( aSize.Width() == nA && aSize.Height() == nB )
+            bActive = false;
+    }
+    return bActive;
+}
+
+void Splitter::MouseButtonDown( const MouseEvent& rMEvt )
+{
+    if ( rMEvt.GetClicks() == 2 )
+    {
+        if ( mnLastSplitPos != mnSplitPos )
+        {
+            StartSplit();
+            Point aPos = rMEvt.GetPosPixel();
+            if ( mbHorzSplit )
+                aPos.setX( mnLastSplitPos );
+            else
+                aPos.setY( mnLastSplitPos );
+            ImplSplitMousePos( aPos );
+            tools::Long nTemp = mnSplitPos;
+            if ( mbHorzSplit )
+                SetSplitPosPixel( aPos.X() );
+            else
+                SetSplitPosPixel( aPos.Y() );
+            mnLastSplitPos = nTemp;
+            Split();
+            EndSplit();
+        }
+    }
+    else
+        StartDrag();
+}
+
+void Splitter::Tracking( const TrackingEvent& rTEvt )
+{
+    if ( rTEvt.IsTrackingEnded() )
+    {
+        if ( !mbDragFull )
+            ImplDrawSplitter();
+
+        if ( !rTEvt.IsTrackingCanceled() )
+        {
+            tools::Long nNewPos;
+            if ( mbHorzSplit )
+                nNewPos = maDragPos.X();
+            else
+                nNewPos = maDragPos.Y();
+            if ( nNewPos != mnStartSplitPos )
+            {
+                SetSplitPosPixel( nNewPos );
+                mnLastSplitPos = 0;
+                Split();
+            }
+            EndSplit();
+        }
+        else if ( mbDragFull )
+        {
+            SetSplitPosPixel( mnStartSplitPos );
+            Split();
+        }
+        mnStartSplitPos = 0;
+    }
+    else
+    {
+        //Point aNewPos = mpRefWin->ScreenToOutputPixel( OutputToScreenPixel( rTEvt.GetMouseEvent().GetPosPixel() ) );
+        Point aNewPos = mpRefWin->NormalizedScreenToOutputPixel( OutputToNormalizedScreenPixel( rTEvt.GetMouseEvent().GetPosPixel() ) );
+        ImplSplitMousePos( aNewPos );
+
+        if ( mbHorzSplit )
+        {
+            if ( aNewPos.X() == maDragPos.X() )
+                return;
+        }
+        else
+        {
+            if ( aNewPos.Y() == maDragPos.Y() )
+                return;
+        }
+
+        if ( mbDragFull )
+        {
+            maDragPos = aNewPos;
+            tools::Long nNewPos;
+            if ( mbHorzSplit )
+                nNewPos = maDragPos.X();
+            else
+                nNewPos = maDragPos.Y();
+            if ( nNewPos != mnSplitPos )
+            {
+                SetSplitPosPixel( nNewPos );
+                mnLastSplitPos = 0;
+                Split();
+            }
+
+            GetParent()->PaintImmediately();
+        }
+        else
+        {
+            ImplDrawSplitter();
+            maDragPos = aNewPos;
+            ImplDrawSplitter();
+        }
+    }
+}
+
+void Splitter::ImplKbdTracking( vcl::KeyCode aKeyCode )
+{
+    sal_uInt16 nCode = aKeyCode.GetCode();
+    if ( nCode == KEY_ESCAPE || nCode == KEY_RETURN )
+    {
+        if( !mbKbdSplitting )
+            return;
+        else
+            mbKbdSplitting = false;
+
+        if ( nCode != KEY_ESCAPE )
+        {
+            tools::Long nNewPos;
+            if ( mbHorzSplit )
+                nNewPos = maDragPos.X();
+            else
+                nNewPos = maDragPos.Y();
+            if ( nNewPos != mnStartSplitPos )
+            {
+                SetSplitPosPixel( nNewPos );
+                mnLastSplitPos = 0;
+                Split();
+            }
+        }
+        else
+        {
+            SetSplitPosPixel( mnStartSplitPos );
+            Split();
+            EndSplit();
+        }
+        mnStartSplitPos = 0;
+    }
+    else
+    {
+        Point aNewPos;
+        Size aSize = mpRefWin->GetOutDev()->GetOutputSize();
+        Point aPos = GetPosPixel();
+        // depending on the position calc allows continuous moves or snaps to row/columns
+        // continuous mode is active when position is at the origin or end of the splitter
+        // otherwise snap mode is active
+        // default here is snap, holding shift sets continuous mode
+        if( mbHorzSplit )
+            aNewPos = Point( ImplSplitterActive() ? aPos.X() : mnSplitPos, aKeyCode.IsShift() ? 0 : aSize.Height()/2);
+        else
+            aNewPos = Point( aKeyCode.IsShift() ? 0 : aSize.Width()/2, ImplSplitterActive() ? aPos.Y() : mnSplitPos );
+
+        Point aOldWindowPos = GetPosPixel();
+
+        int maxiter = 500;  // avoid endless loop
+        int delta=0;
+        int delta_step = mbHorzSplit  ? aSize.Width()/10 : aSize.Height()/10;
+
+        // use the specified step size if it was set
+        if( mnKeyboardStepSize != SPLITTER_DEFAULTSTEPSIZE )
+            delta_step = mnKeyboardStepSize;
+
+        while( maxiter-- && aOldWindowPos == GetPosPixel() )
+        {
+            // inc/dec position until application performs changes
+            // thus a single key press really moves the splitter
+            if( aKeyCode.IsShift() )
+                delta++;
+            else
+                delta += delta_step;
+
+            switch( nCode )
+            {
+            case KEY_LEFT:
+                aNewPos.AdjustX( -delta );
+                break;
+            case KEY_RIGHT:
+                aNewPos.AdjustX(delta );
+                break;
+            case KEY_UP:
+                aNewPos.AdjustY( -delta );
+                break;
+            case KEY_DOWN:
+                aNewPos.AdjustY(delta );
+                break;
+            default:
+                maxiter = 0;    // leave loop
+                break;
+            }
+            ImplSplitMousePos( aNewPos );
+
+            if ( mbHorzSplit )
+            {
+                if ( aNewPos.X() == maDragPos.X() )
+                    continue;
+            }
+            else
+            {
+                if ( aNewPos.Y() == maDragPos.Y() )
+                    continue;
+            }
+
+            maDragPos = aNewPos;
+            tools::Long nNewPos;
+            if ( mbHorzSplit )
+                nNewPos = maDragPos.X();
+            else
+                nNewPos = maDragPos.Y();
+            if ( nNewPos != mnSplitPos )
+            {
+                SetSplitPosPixel( nNewPos );
+                mnLastSplitPos = 0;
+                Split();
+            }
+            GetParent()->PaintImmediately();
+        }
+    }
+}
+
+void Splitter::StartSplit()
+{
+    maStartSplitHdl.Call( this );
+}
+
+void Splitter::Split()
+{
+    maSplitHdl.Call( this );
+}
+
+void Splitter::EndSplit()
+{
+    maEndSplitHdl.Call( this );
+}
+
+void Splitter::SetDragRectPixel( const tools::Rectangle& rDragRect, vcl::Window* _pRefWin )
+{
+    maDragRect = rDragRect;
+    if ( !_pRefWin )
+        mpRefWin = GetParent();
+    else
+        mpRefWin = _pRefWin;
+}
+
+void Splitter::SetSplitPosPixel( tools::Long nNewPos )
+{
+    mnSplitPos = nNewPos;
+}
+
+void Splitter::StartDrag()
+{
+    if ( IsTracking() )
+        return;
+
+    StartSplit();
+
+    // Tracking starten
+    StartTracking();
+
+    // Start-Position ermitteln
+    maDragPos = mpRefWin->GetPointerPosPixel();
+    ImplSplitMousePos( maDragPos );
+    if ( mbHorzSplit )
+        mnStartSplitPos = maDragPos.X();
+    else
+        mnStartSplitPos = maDragPos.Y();
+
+    mbDragFull = bool(Application::GetSettings().GetStyleSettings().GetDragFullOptions() & DragFullOptions::Split);
+    if ( !mbDragFull )
+        ImplDrawSplitter();
+}
+
+void Splitter::ImplStartKbdSplitting()
+{
+    if( mbKbdSplitting )
+        return;
+
+    mbKbdSplitting = true;
+
+    StartSplit();
+
+    // determine start position
+    // because we have no mouse position we take either the position
+    // of the splitter window or the last split position
+    // the other coordinate is just the center of the reference window
+    Size aSize = mpRefWin->GetOutDev()->GetOutputSize();
+    Point aPos = GetPosPixel();
+    if( mbHorzSplit )
+        maDragPos = Point( ImplSplitterActive() ? aPos.X() : mnSplitPos, aSize.Height()/2 );
+    else
+        maDragPos = Point( aSize.Width()/2, ImplSplitterActive() ? aPos.Y() : mnSplitPos );
+    ImplSplitMousePos( maDragPos );
+    if ( mbHorzSplit )
+        mnStartSplitPos = maDragPos.X();
+    else
+        mnStartSplitPos = maDragPos.Y();
+}
+
+void Splitter::ImplRestoreSplitter()
+{
+    // set splitter in the center of the ref window
+    StartSplit();
+    Size aSize = mpRefWin->GetOutDev()->GetOutputSize();
+    Point aPos( aSize.Width()/2 , aSize.Height()/2);
+    if ( mnLastSplitPos != mnSplitPos && mnLastSplitPos > 5 )
+    {
+        // restore last pos if it was a useful position (>5)
+        if ( mbHorzSplit )
+            aPos.setX( mnLastSplitPos );
+        else
+            aPos.setY( mnLastSplitPos );
+    }
+
+    ImplSplitMousePos( aPos );
+    tools::Long nTemp = mnSplitPos;
+    if ( mbHorzSplit )
+        SetSplitPosPixel( aPos.X() );
+    else
+        SetSplitPosPixel( aPos.Y() );
+    mnLastSplitPos = nTemp;
+    Split();
+    EndSplit();
+}
+
+void Splitter::GetFocus()
+{
+    if( !ImplSplitterActive() )
+        ImplRestoreSplitter();
+
+    Invalidate();
+}
+
+void Splitter::LoseFocus()
+{
+    if( mbKbdSplitting )
+    {
+        vcl::KeyCode aReturnKey( KEY_RETURN );
+        ImplKbdTracking( aReturnKey );
+        mbKbdSplitting = false;
+    }
+    Invalidate();
+}
+
+void Splitter::KeyInput( const KeyEvent& rKEvt )
+{
+    if( mbInKeyEvent )
+        return;
+
+    mbInKeyEvent = true;
+
+    Splitter *pSibling = ImplFindSibling();
+    vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();
+    sal_uInt16 nCode = aKeyCode.GetCode();
+    switch ( nCode )
+    {
+        case KEY_UP:
+        case KEY_DOWN:
+            if( !mbHorzSplit )
+            {
+                ImplStartKbdSplitting();
+                ImplKbdTracking( aKeyCode );
+            }
+            else
+            {
+                if( pSibling )
+                {
+                    pSibling->GrabFocus();
+                    pSibling->KeyInput( rKEvt );
+                }
+            }
+            break;
+        case KEY_RIGHT:
+        case KEY_LEFT:
+            if( mbHorzSplit )
+            {
+                ImplStartKbdSplitting();
+                ImplKbdTracking( aKeyCode );
+            }
+            else
+            {
+                if( pSibling )
+                {
+                    pSibling->GrabFocus();
+                    pSibling->KeyInput( rKEvt );
+                }
+            }
+            break;
+
+        case KEY_DELETE:
+            if( ImplSplitterActive() )
+            {
+                if( mbKbdSplitting )
+                {
+                    vcl::KeyCode aKey( KEY_ESCAPE );
+                    ImplKbdTracking( aKey );
+                }
+
+                StartSplit();
+                Point aPos;
+                if ( mbHorzSplit )
+                    aPos.setX( 0 );
+                else
+                    aPos.setY( 0 );
+                ImplSplitMousePos( aPos );
+                tools::Long nTemp = mnSplitPos;
+                if ( mbHorzSplit )
+                    SetSplitPosPixel( aPos.X() );
+                else
+                    SetSplitPosPixel( aPos.Y() );
+                mnLastSplitPos = nTemp;
+                Split();
+                EndSplit();
+
+                // Shift-Del deletes both splitters
+                if( aKeyCode.IsShift() && pSibling )
+                    pSibling->KeyInput( rKEvt );
+
+                GrabFocusToDocument();
+            }
+            break;
+
+        case KEY_ESCAPE:
+            if( mbKbdSplitting )
+                ImplKbdTracking( aKeyCode );
+            else
+                GrabFocusToDocument();
+            break;
+
+        case KEY_RETURN:
+            ImplKbdTracking( aKeyCode );
+            GrabFocusToDocument();
+            break;
+        default:    // let any key input fix the splitter
+            Window::KeyInput( rKEvt );
+            GrabFocusToDocument();
+            break;
+    }
+    mbInKeyEvent = false;
+}
+
+void Splitter::DataChanged( const DataChangedEvent& rDCEvt )
+{
+    Window::DataChanged( rDCEvt );
+    if( rDCEvt.GetType() != DataChangedEventType::SETTINGS )
+        return;
+
+    const AllSettings* pOldSettings = rDCEvt.GetOldSettings();
+    if(!pOldSettings)
+        return;
+
+    Color oldFaceColor = pOldSettings->GetStyleSettings().GetFaceColor();
+    Color newFaceColor = Application::GetSettings().GetStyleSettings().GetFaceColor();
+    if( oldFaceColor.IsDark() != newFaceColor.IsDark() )
+    {
+        if( newFaceColor.IsDark() )
+            SetBackground( ImplWhiteWall() );
+        else
+            SetBackground( ImplBlackWall() );
+    }
+}
+
+void Splitter::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rPaintRect)
+{
+    rRenderContext.DrawRect(rPaintRect);
+
+    tools::Polygon aPoly(rPaintRect);
+    tools::PolyPolygon aPolyPoly(aPoly);
+    rRenderContext.DrawTransparent(aPolyPoly, 85);
+
+    if (mbKbdSplitting)
+    {
+        LineInfo aInfo( LineStyle::Dash );
+        //aInfo.SetDashLen( 2 );
+        //aInfo.SetDashCount( 1 );
+        aInfo.SetDistance( 1 );
+        aInfo.SetDotLen( 2 );
+        aInfo.SetDotCount( 3 );
+
+        rRenderContext.DrawPolyLine( aPoly, aInfo );
+    }
+    else
+    {
+        rRenderContext.DrawRect(rPaintRect);
+    }
+}
+
+Size Splitter::GetOptimalSize() const
+{
+    return LogicToPixel(Size(3, 3), MapMode(MapUnit::MapAppFont));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */