chart2/source/controller/main/ChartWindow.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 <ChartWindow.hxx>
  21 #include <ChartController.hxx>
  22 #include <helpids.h>
  23 #include <uiobject.hxx>
  24
  25 #include <vcl/help.hxx>
  26 #include <vcl/settings.hxx>
  27
  28 #include <sfx2/ipclient.hxx>
  29 #include <sfx2/viewsh.hxx>
  30 #include <sfx2/lokhelper.hxx>
  31 #include <comphelper/lok.hxx>
  32
  33 #define TWIPS_PER_PIXEL 15
  34
  35 using namespace ::com::sun::star;
  36
  37 namespace
  38 {
  39 ::tools::Rectangle lcl_AWTRectToVCLRect( const css::awt::Rectangle & rAWTRect )
  40 {
  41     ::tools::Rectangle aResult;
  42     aResult.setX( rAWTRect.X );
  43     aResult.setY( rAWTRect.Y );
  44     aResult.setWidth( rAWTRect.Width );
  45     aResult.setHeight( rAWTRect.Height );
  46     return aResult;
  47 }
  48 } // anonymous namespace
  49
  50 namespace chart
  51 {
  52
  53 ChartWindow::ChartWindow( ChartController* pController, vcl::Window* pParent, WinBits nStyle )
  54         : Window(pParent, nStyle)
  55         , m_pWindowController( pController )
  56         , m_bInPaint(false)
  57         , m_pViewShellWindow( nullptr )
  58 {
  59     set_id("chart_window");
  60     SetHelpId( HID_SCH_WIN_DOCUMENT );
  61     SetMapMode( MapMode(MapUnit::Map100thMM) );
  62     adjustHighContrastMode();
  63     // chart does not depend on exact pixel painting => enable antialiased drawing
  64     SetAntialiasing( AntialiasingFlags::EnableB2dDraw | GetAntialiasing() );
  65     EnableRTL( false );
  66     if( pParent )
  67         pParent->EnableRTL( false );// #i96215# necessary for a correct position of the context menu in rtl mode
  68 }
  69
  70 ChartWindow::~ChartWindow()
  71 {
  72     disposeOnce();
  73 }
  74
  75 void ChartWindow::dispose()
  76 {
  77     m_pViewShellWindow.clear();
  78     vcl::Window::dispose();
  79 }
  80
  81 void ChartWindow::PrePaint(vcl::RenderContext& )
  82 {
  83     // forward VCLs PrePaint window event to DrawingLayer
  84     if (m_pWindowController)
  85     {
  86        m_pWindowController->PrePaint();
  87     }
  88 }
  89
  90 void ChartWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
  91 {
  92     if (comphelper::LibreOfficeKit::isActive() && !rRenderContext.IsVirtual())
  93         return;
  94
  95     m_bInPaint = true;
  96     if (m_pWindowController)
  97     {
  98         m_pWindowController->execute_Paint(rRenderContext, rRect);
  99     }
 100     else
 101     {
 102         Window::Paint(rRenderContext, rRect);
 103     }
 104     m_bInPaint = false;
 105 }
 106
 107 void ChartWindow::MouseButtonDown(const MouseEvent& rMEvt)
 108 {
 109     if( m_pWindowController )
 110         m_pWindowController->execute_MouseButtonDown(rMEvt);
 111     else
 112         Window::MouseButtonDown(rMEvt);
 113 }
 114
 115 void ChartWindow::MouseMove( const MouseEvent& rMEvt )
 116 {
 117     if( m_pWindowController )
 118         m_pWindowController->execute_MouseMove( rMEvt );
 119     else
 120         Window::MouseMove( rMEvt );
 121 }
 122
 123 void ChartWindow::Tracking( const TrackingEvent& rTEvt )
 124 {
 125     if( !m_pWindowController )
 126         Window::Tracking( rTEvt );
 127 }
 128
 129 void ChartWindow::MouseButtonUp( const MouseEvent& rMEvt )
 130 {
 131     if( m_pWindowController )
 132         m_pWindowController->execute_MouseButtonUp( rMEvt );
 133     else
 134         Window::MouseButtonUp( rMEvt );
 135 }
 136
 137 void ChartWindow::Resize()
 138 {
 139     if( m_pWindowController )
 140         m_pWindowController->execute_Resize();
 141     else
 142         Window::Resize();
 143 }
 144
 145 void ChartWindow::Activate()
 146 {
 147     if( !m_pWindowController )
 148         Window::Activate();
 149 }
 150 void ChartWindow::Deactivate()
 151 {
 152     if( !m_pWindowController )
 153         Window::Deactivate();
 154 }
 155 void ChartWindow::GetFocus()
 156 {
 157     if( !m_pWindowController )
 158         Window::GetFocus();
 159 }
 160 void ChartWindow::LoseFocus()
 161 {
 162     if( !m_pWindowController )
 163         Window::LoseFocus();
 164 }
 165
 166 void ChartWindow::Command( const CommandEvent& rCEvt )
 167 {
 168     if( m_pWindowController )
 169         m_pWindowController->execute_Command( rCEvt );
 170     else
 171         Window::Command( rCEvt );
 172 }
 173
 174 void ChartWindow::KeyInput( const KeyEvent& rKEvt )
 175 {
 176     if( m_pWindowController )
 177     {
 178         if( !m_pWindowController->execute_KeyInput(rKEvt) )
 179             Window::KeyInput(rKEvt);
 180     }
 181     else
 182         Window::KeyInput( rKEvt );
 183 }
 184
 185 uno::Reference< css::accessibility::XAccessible > ChartWindow::CreateAccessible()
 186 {
 187     if( m_pWindowController )
 188         return m_pWindowController->CreateAccessible();
 189     else
 190         return Window::CreateAccessible();
 191 }
 192
 193 void ChartWindow::DataChanged( const DataChangedEvent& rDCEvt )
 194 {
 195     vcl::Window::DataChanged( rDCEvt );
 196
 197     if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
 198          (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
 199     {
 200         adjustHighContrastMode();
 201     }
 202 }
 203
 204 void ChartWindow::RequestHelp( const HelpEvent& rHEvt )
 205 {
 206     bool bHelpHandled = false;
 207     if( ( rHEvt.GetMode() & HelpEventMode::QUICK ) &&
 208         m_pWindowController )
 209     {
 210 //         Point aLogicHitPos = PixelToLogic( rHEvt.GetMousePosPixel()); // old chart: GetPointerPosPixel()
 211         Point aLogicHitPos = PixelToLogic( GetPointerPosPixel());
 212         OUString aQuickHelpText;
 213         awt::Rectangle aHelpRect;
 214         bool bIsBalloonHelp( Help::IsBalloonHelpEnabled() );
 215         bHelpHandled = m_pWindowController->requestQuickHelp( aLogicHitPos, bIsBalloonHelp, aQuickHelpText, aHelpRect );
 216
 217         if( bHelpHandled )
 218         {
 219             if( bIsBalloonHelp )
 220                 Help::ShowBalloon(
 221                     this, rHEvt.GetMousePosPixel(), lcl_AWTRectToVCLRect( aHelpRect ), aQuickHelpText );
 222             else
 223                 Help::ShowQuickHelp(
 224                     this, lcl_AWTRectToVCLRect( aHelpRect ), aQuickHelpText );
 225         }
 226     }
 227
 228     if( !bHelpHandled )
 229         vcl::Window::RequestHelp( rHEvt );
 230 }
 231
 232 void ChartWindow::LogicMouseButtonDown(const MouseEvent& rEvent)
 233 {
 234     MouseButtonDown(rEvent);
 235 }
 236
 237 void ChartWindow::LogicMouseButtonUp(const MouseEvent& rEvent)
 238 {
 239     MouseButtonUp(rEvent);
 240 }
 241
 242 void ChartWindow::LogicMouseMove(const MouseEvent& rEvent)
 243 {
 244     MouseMove(rEvent);
 245 }
 246
 247 void ChartWindow::adjustHighContrastMode()
 248 {
 249     static const DrawModeFlags nContrastMode =
 250         DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill |
 251         DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient;
 252
 253     bool bUseContrast = GetSettings().GetStyleSettings().GetHighContrastMode();
 254     SetDrawMode( bUseContrast ? nContrastMode : DrawModeFlags::Default );
 255 }
 256
 257 void ChartWindow::ForceInvalidate()
 258 {
 259     vcl::Window::Invalidate();
 260 }
 261 void ChartWindow::Invalidate( InvalidateFlags nFlags )
 262 {
 263     if( m_bInPaint ) // #i101928# superfluous paint calls while entering and editing charts"
 264         return;
 265     vcl::Window::Invalidate( nFlags );
 266 }
 267 void ChartWindow::Invalidate( const tools::Rectangle& rRect, InvalidateFlags nFlags )
 268 {
 269     if( m_bInPaint ) // #i101928# superfluous paint calls while entering and editing charts"
 270         return;
 271     vcl::Window::Invalidate( rRect, nFlags );
 272 }
 273 void ChartWindow::Invalidate( const vcl::Region& rRegion, InvalidateFlags nFlags )
 274 {
 275     if( m_bInPaint ) // #i101928# superfluous paint calls while entering and editing charts"
 276         return;
 277     vcl::Window::Invalidate( rRegion, nFlags );
 278 }
 279
 280 void ChartWindow::LogicInvalidate(const tools::Rectangle* pRectangle)
 281 {
 282     SfxViewShell* pCurrentShell = SfxViewShell::Current();
 283     if ( nullptr == pCurrentShell )
 284         return;
 285     OString sRectangle;
 286     if (!pRectangle)
 287     {
 288         // we have to invalidate the whole chart area not the whole document
 289         sRectangle = GetBoundingBox().toString();
 290     }
 291     else
 292     {
 293         tools::Rectangle aRectangle(*pRectangle);
 294         // When dragging shapes the map mode is disabled.
 295         if (IsMapModeEnabled())
 296         {
 297             if (GetMapMode().GetMapUnit() == MapUnit::Map100thMM)
 298                 aRectangle = OutputDevice::LogicToLogic(aRectangle, MapMode(MapUnit::Map100thMM), MapMode(MapUnit::MapTwip));
 299         }
 300         else
 301         {
 302             aRectangle = PixelToLogic(aRectangle, MapMode(MapUnit::MapTwip));
 303         }
 304
 305         vcl::Window* pEditWin = GetParentEditWin();
 306         if (pEditWin)
 307         {
 308             MapMode aCWMapMode = GetMapMode();
 309             double fXScale( aCWMapMode.GetScaleX() );
 310             double fYScale( aCWMapMode.GetScaleY() );
 311
 312             if (!IsMapModeEnabled())
 313             {
 314                 aRectangle.SetLeft( aRectangle.Left() / fXScale );
 315                 aRectangle.SetRight( aRectangle.Right() / fXScale );
 316                 aRectangle.SetTop( aRectangle.Top() / fYScale );
 317                 aRectangle.SetBottom( aRectangle.Bottom() / fYScale );
 318             }
 319
 320             Point aOffset = this->GetOffsetPixelFrom(*pEditWin);
 321             aOffset.setX( aOffset.X() * (TWIPS_PER_PIXEL / fXScale) );
 322             aOffset.setY( aOffset.Y() * (TWIPS_PER_PIXEL / fYScale) );
 323
 324             aRectangle = tools::Rectangle(aRectangle.TopLeft() + aOffset, aRectangle.GetSize());
 325         }
 326
 327         sRectangle = aRectangle.toString();
 328     }
 329     SfxLokHelper::notifyInvalidation(pCurrentShell, sRectangle);
 330 }
 331
 332 FactoryFunction ChartWindow::GetUITestFactory() const
 333 {
 334     return ChartWindowUIObject::create;
 335 }
 336
 337 ChartController* ChartWindow::GetController()
 338 {
 339     return m_pWindowController;
 340 }
 341
 342 vcl::Window* ChartWindow::GetParentEditWin()
 343 {
 344     if (m_pViewShellWindow)
 345         return m_pViewShellWindow.get();
 346
 347     // So, you are thinking, why do not invoke pCurrentShell->GetWindow() ?
 348     // Because in Impress the parent edit win is not view shell window.
 349     SfxViewShell* pCurrentShell = SfxViewShell::Current();
 350     if( pCurrentShell )
 351     {
 352         SfxInPlaceClient* pIPClient = pCurrentShell->GetIPClient();
 353         if (pIPClient)
 354         {
 355             vcl::Window* pRootWin = pIPClient->GetEditWin();
 356             if(pRootWin && pRootWin->IsAncestorOf(*this))
 357             {
 358                 m_pViewShellWindow = pRootWin;
 359                 return m_pViewShellWindow.get();
 360             }
 361         }
 362     }
 363     return nullptr;
 364 }
 365
 366 tools::Rectangle ChartWindow::GetBoundingBox()
 367 {
 368     tools::Rectangle aBBox;
 369
 370     vcl::Window* pRootWin = GetParentEditWin();
 371     if (pRootWin)
 372     {
 373         // In all cases, the following code fragment
 374         // returns the chart bounding box in twips.
 375         MapMode aCWMapMode = GetMapMode();
 376         double fXScale( aCWMapMode.GetScaleX() );
 377         double fYScale( aCWMapMode.GetScaleY() );
 378         Point aOffset = GetOffsetPixelFrom(*pRootWin);
 379         aOffset.setX( aOffset.X() * (TWIPS_PER_PIXEL / fXScale) );
 380         aOffset.setY( aOffset.Y() * (TWIPS_PER_PIXEL / fYScale) );
 381         Size aSize = GetSizePixel();
 382         aSize.setWidth( aSize.Width() * (TWIPS_PER_PIXEL / fXScale) );
 383         aSize.setHeight( aSize.Height() * (TWIPS_PER_PIXEL / fYScale) );
 384         aBBox = tools::Rectangle(aOffset, aSize);
 385     }
 386     return aBBox;
 387 }
 388
 389 } //namespace chart
 390
 391 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */