vcl/source/outdev/nativecontrols.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 <cassert>
  21
  22 #include <vcl/outdev.hxx>
  23 #include <vcl/virdev.hxx>
  24 #include <vcl/window.hxx>
  25 #include <sal/log.hxx>
  26
  27 #include <vcl/salnativewidgets.hxx>
  28 #include <vcl/pdfextoutdevdata.hxx>
  29
  30 #include <salgdi.hxx>
  31
  32 static bool EnableNativeWidget( const OutputDevice& i_rDevice )
  33 {
  34     const OutDevType eType( i_rDevice.GetOutDevType() );
  35     switch ( eType )
  36     {
  37
  38     case OUTDEV_WINDOW:
  39         {
  40             const vcl::Window* pWindow = dynamic_cast< const vcl::Window* >( &i_rDevice );
  41             if (pWindow)
  42             {
  43                 return pWindow->IsNativeWidgetEnabled();
  44             }
  45             else
  46             {
  47                 SAL_WARN ("vcl.gdi", "Could not cast i_rDevice to Window");
  48                 assert (pWindow);
  49                 return false;
  50             }
  51         }
  52
  53     case OUTDEV_PDF:
  54         [[fallthrough]];
  55     case OUTDEV_VIRDEV:
  56     {
  57         const vcl::ExtOutDevData* pOutDevData( i_rDevice.GetExtOutDevData() );
  58         const vcl::PDFExtOutDevData* pPDFData( dynamic_cast< const vcl::PDFExtOutDevData* >( pOutDevData ) );
  59         return pPDFData == nullptr;
  60     }
  61
  62     default:
  63         return false;
  64     }
  65 }
  66
  67 ImplControlValue::~ImplControlValue()
  68 {
  69 }
  70
  71 ImplControlValue* ImplControlValue::clone() const
  72 {
  73     assert( typeid( const ImplControlValue ) == typeid( *this ));
  74     return new ImplControlValue( *this );
  75 }
  76
  77 ScrollbarValue::~ScrollbarValue()
  78 {
  79 }
  80
  81 ScrollbarValue* ScrollbarValue::clone() const
  82 {
  83     assert( typeid( const ScrollbarValue ) == typeid( *this ));
  84     return new ScrollbarValue( *this );
  85 }
  86
  87 SliderValue::~SliderValue()
  88 {
  89 }
  90
  91 SliderValue* SliderValue::clone() const
  92 {
  93     assert( typeid( const SliderValue ) == typeid( *this ));
  94     return new SliderValue( *this );
  95 }
  96
  97 int TabPaneValue::m_nOverlap = 0;
  98
  99 TabPaneValue* TabPaneValue::clone() const
 100 {
 101     assert(typeid(const TabPaneValue) == typeid(*this));
 102     return new TabPaneValue(*this);
 103 }
 104
 105 TabitemValue::~TabitemValue()
 106 {
 107 }
 108
 109 TabitemValue* TabitemValue::clone() const
 110 {
 111     assert( typeid( const TabitemValue ) == typeid( *this ));
 112     return new TabitemValue( *this );
 113 }
 114
 115 SpinbuttonValue::~SpinbuttonValue()
 116 {
 117 }
 118
 119 SpinbuttonValue* SpinbuttonValue::clone() const
 120 {
 121     assert( typeid( const SpinbuttonValue ) == typeid( *this ));
 122     return new SpinbuttonValue( *this );
 123 }
 124
 125 ToolbarValue::~ToolbarValue()
 126 {
 127 }
 128
 129 ToolbarValue* ToolbarValue::clone() const
 130 {
 131     assert( typeid( const ToolbarValue ) == typeid( *this ));
 132     return new ToolbarValue( *this );
 133 }
 134
 135 MenubarValue::~MenubarValue()
 136 {
 137 }
 138
 139 MenubarValue* MenubarValue::clone() const
 140 {
 141     assert( typeid( const MenubarValue ) == typeid( *this ));
 142     return new MenubarValue( *this );
 143 }
 144
 145 MenupopupValue::~MenupopupValue()
 146 {
 147 }
 148
 149 MenupopupValue* MenupopupValue::clone() const
 150 {
 151     assert( typeid( const MenupopupValue ) == typeid( *this ));
 152     return new MenupopupValue( *this );
 153 }
 154
 155 PushButtonValue::~PushButtonValue()
 156 {
 157 }
 158
 159 PushButtonValue* PushButtonValue::clone() const
 160 {
 161     assert( typeid( const PushButtonValue ) == typeid( *this ));
 162     return new PushButtonValue( *this );
 163 }
 164
 165 // These functions are mainly passthrough functions that allow access to
 166 // the SalFrame behind a Window object for native widget rendering purposes.
 167
 168 bool OutputDevice::IsNativeControlSupported( ControlType nType, ControlPart nPart ) const
 169 {
 170     if( !EnableNativeWidget( *this ) )
 171         return false;
 172
 173     if ( !mpGraphics && !AcquireGraphics() )
 174         return false;
 175
 176     return mpGraphics->IsNativeControlSupported(nType, nPart);
 177 }
 178
 179 bool OutputDevice::HitTestNativeScrollbar(
 180                               ControlPart nPart,
 181                               const tools::Rectangle& rControlRegion,
 182                               const Point& aPos,
 183                               bool& rIsInside ) const
 184 {
 185     if( !EnableNativeWidget( *this ) )
 186         return false;
 187
 188     if ( !mpGraphics && !AcquireGraphics() )
 189         return false;
 190
 191     Point aWinOffs( mnOutOffX, mnOutOffY );
 192     tools::Rectangle screenRegion( rControlRegion );
 193     screenRegion.Move( aWinOffs.X(), aWinOffs.Y());
 194
 195     return mpGraphics->HitTestNativeScrollbar( nPart, screenRegion, Point( aPos.X() + mnOutOffX, aPos.Y() + mnOutOffY ),
 196         rIsInside, this );
 197 }
 198
 199 static std::shared_ptr< ImplControlValue > TransformControlValue( const ImplControlValue& rVal, const OutputDevice& rDev )
 200 {
 201     std::shared_ptr< ImplControlValue > aResult;
 202     switch( rVal.getType() )
 203     {
 204     case ControlType::Slider:
 205         {
 206             const SliderValue* pSlVal = static_cast<const SliderValue*>(&rVal);
 207             SliderValue* pNew = new SliderValue( *pSlVal );
 208             aResult.reset( pNew );
 209             pNew->maThumbRect = rDev.ImplLogicToDevicePixel( pSlVal->maThumbRect );
 210         }
 211         break;
 212     case ControlType::Scrollbar:
 213         {
 214             const ScrollbarValue* pScVal = static_cast<const ScrollbarValue*>(&rVal);
 215             ScrollbarValue* pNew = new ScrollbarValue( *pScVal );
 216             aResult.reset( pNew );
 217             pNew->maThumbRect = rDev.ImplLogicToDevicePixel( pScVal->maThumbRect );
 218             pNew->maButton1Rect = rDev.ImplLogicToDevicePixel( pScVal->maButton1Rect );
 219             pNew->maButton2Rect = rDev.ImplLogicToDevicePixel( pScVal->maButton2Rect );
 220         }
 221         break;
 222     case ControlType::SpinButtons:
 223         {
 224             const SpinbuttonValue* pSpVal = static_cast<const SpinbuttonValue*>(&rVal);
 225             SpinbuttonValue* pNew = new SpinbuttonValue( *pSpVal );
 226             aResult.reset( pNew );
 227             pNew->maUpperRect = rDev.ImplLogicToDevicePixel( pSpVal->maUpperRect );
 228             pNew->maLowerRect = rDev.ImplLogicToDevicePixel( pSpVal->maLowerRect );
 229         }
 230         break;
 231     case ControlType::Toolbar:
 232         {
 233             const ToolbarValue* pTVal = static_cast<const ToolbarValue*>(&rVal);
 234             ToolbarValue* pNew = new ToolbarValue( *pTVal );
 235             aResult.reset( pNew );
 236             pNew->maGripRect = rDev.ImplLogicToDevicePixel( pTVal->maGripRect );
 237         }
 238         break;
 239     case ControlType::TabPane:
 240         {
 241             const TabPaneValue* pTIVal = static_cast<const TabPaneValue*>(&rVal);
 242             TabPaneValue* pNew = new TabPaneValue(*pTIVal);
 243             pNew->m_aTabHeaderRect = rDev.ImplLogicToDevicePixel(pTIVal->m_aTabHeaderRect);
 244             pNew->m_aSelectedTabRect = rDev.ImplLogicToDevicePixel(pTIVal->m_aSelectedTabRect);
 245             aResult.reset(pNew);
 246         }
 247         break;
 248     case ControlType::TabItem:
 249         {
 250             const TabitemValue* pTIVal = static_cast<const TabitemValue*>(&rVal);
 251             TabitemValue* pNew = new TabitemValue( *pTIVal );
 252             pNew->maContentRect = rDev.ImplLogicToDevicePixel(pTIVal->maContentRect);
 253             aResult.reset( pNew );
 254         }
 255         break;
 256     case ControlType::Menubar:
 257         {
 258             const MenubarValue* pMVal = static_cast<const MenubarValue*>(&rVal);
 259             MenubarValue* pNew = new MenubarValue( *pMVal );
 260             aResult.reset( pNew );
 261         }
 262         break;
 263     case ControlType::Pushbutton:
 264         {
 265             const PushButtonValue* pBVal = static_cast<const PushButtonValue*>(&rVal);
 266             PushButtonValue* pNew = new PushButtonValue( *pBVal );
 267             aResult.reset( pNew );
 268         }
 269         break;
 270     case ControlType::Generic:
 271             aResult = std::make_shared<ImplControlValue>( rVal );
 272             break;
 273     case ControlType::MenuPopup:
 274         {
 275             const MenupopupValue* pMVal = static_cast<const MenupopupValue*>(&rVal);
 276             MenupopupValue* pNew = new MenupopupValue( *pMVal );
 277             pNew->maItemRect = rDev.ImplLogicToDevicePixel( pMVal->maItemRect );
 278             aResult.reset( pNew );
 279         }
 280         break;
 281     default:
 282         std::abort();
 283         break;
 284     }
 285     return aResult;
 286 }
 287 bool OutputDevice::DrawNativeControl( ControlType nType,
 288                             ControlPart nPart,
 289                             const tools::Rectangle& rControlRegion,
 290                             ControlState nState,
 291                             const ImplControlValue& aValue,
 292                             const OUString& aCaption,
 293                             const Color& rBackgroundColor )
 294 {
 295     assert(!is_double_buffered_window());
 296
 297     if( !EnableNativeWidget( *this ) )
 298         return false;
 299
 300     // make sure the current clip region is initialized correctly
 301     if ( !mpGraphics && !AcquireGraphics() )
 302         return false;
 303
 304     if ( mbInitClipRegion )
 305         InitClipRegion();
 306     if ( mbOutputClipped )
 307         return true;
 308
 309     if ( mbInitLineColor )
 310         InitLineColor();
 311     if ( mbInitFillColor )
 312         InitFillColor();
 313
 314     // Convert the coordinates from relative to Window-absolute, so we draw
 315     // in the correct place in platform code
 316     std::shared_ptr< ImplControlValue > aScreenCtrlValue( TransformControlValue( aValue, *this ) );
 317     tools::Rectangle screenRegion( ImplLogicToDevicePixel( rControlRegion ) );
 318
 319     bool bRet = mpGraphics->DrawNativeControl(nType, nPart, screenRegion, nState, *aScreenCtrlValue, aCaption, this, rBackgroundColor );
 320
 321     return bRet;
 322 }
 323
 324 bool OutputDevice::GetNativeControlRegion(  ControlType nType,
 325                                 ControlPart nPart,
 326                                 const tools::Rectangle& rControlRegion,
 327                                 ControlState nState,
 328                                 const ImplControlValue& aValue,
 329                                 tools::Rectangle &rNativeBoundingRegion,
 330                                 tools::Rectangle &rNativeContentRegion ) const
 331 {
 332     if( !EnableNativeWidget( *this ) )
 333         return false;
 334
 335     if ( !mpGraphics && !AcquireGraphics() )
 336         return false;
 337
 338     // Convert the coordinates from relative to Window-absolute, so we draw
 339     // in the correct place in platform code
 340     std::shared_ptr< ImplControlValue > aScreenCtrlValue( TransformControlValue( aValue, *this ) );
 341     tools::Rectangle screenRegion( ImplLogicToDevicePixel( rControlRegion ) );
 342
 343     bool bRet = mpGraphics->GetNativeControlRegion(nType, nPart, screenRegion, nState, *aScreenCtrlValue,
 344                                 rNativeBoundingRegion,
 345                                 rNativeContentRegion, this );
 346     if( bRet )
 347     {
 348         // transform back native regions
 349         rNativeBoundingRegion = ImplDevicePixelToLogic( rNativeBoundingRegion );
 350         rNativeContentRegion = ImplDevicePixelToLogic( rNativeContentRegion );
 351     }
 352
 353     return bRet;
 354 }
 355
 356 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */