vcl/unx/generic/gdi/salvd.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/sysdata.hxx>
  21
  22 #include <X11/Xlib.h>
  23 #include <X11/extensions/Xrender.h>
  24
  25 #include <unx/saldisp.hxx>
  26 #include <unx/salinst.h>
  27 #include <unx/salgdi.h>
  28 #include <unx/salvd.h>
  29 #include <unx/x11/xlimits.hxx>
  30
  31 #include <vcl/opengl/OpenGLHelper.hxx>
  32 #include <opengl/x11/salvd.hxx>
  33
  34 #include <config_features.h>
  35 #include <vcl/skia/SkiaHelper.hxx>
  36 #if HAVE_FEATURE_SKIA
  37 #include <skia/x11/salvd.hxx>
  38 #endif
  39
  40 std::unique_ptr<SalVirtualDevice> X11SalInstance::CreateX11VirtualDevice(SalGraphics const * pGraphics,
  41         tools::Long &nDX, tools::Long &nDY, DeviceFormat eFormat, const SystemGraphicsData *pData,
  42         std::unique_ptr<X11SalGraphics> pNewGraphics)
  43 {
  44     assert(pNewGraphics);
  45 #if HAVE_FEATURE_SKIA
  46     if (SkiaHelper::isVCLSkiaEnabled())
  47         return std::unique_ptr<SalVirtualDevice>(new X11SkiaSalVirtualDevice( pGraphics, nDX, nDY, pData, std::move(pNewGraphics) ));
  48     else
  49 #endif
  50     if (OpenGLHelper::isVCLOpenGLEnabled())
  51         return std::unique_ptr<SalVirtualDevice>(new X11OpenGLSalVirtualDevice( pGraphics, nDX, nDY, pData, std::move(pNewGraphics) ));
  52     else
  53         return std::unique_ptr<SalVirtualDevice>(new X11SalVirtualDevice(pGraphics, nDX, nDY, eFormat, pData, std::move(pNewGraphics)));
  54 }
  55
  56 std::unique_ptr<SalVirtualDevice> X11SalInstance::CreateVirtualDevice(SalGraphics* pGraphics,
  57         tools::Long &nDX, tools::Long &nDY, DeviceFormat eFormat, const SystemGraphicsData *pData)
  58 {
  59     return CreateX11VirtualDevice(pGraphics, nDX, nDY, eFormat, pData, std::make_unique<X11SalGraphics>());
  60 }
  61
  62 void X11SalGraphics::Init( X11SalVirtualDevice *pDevice, cairo_surface_t* pPreExistingTarget, SalColormap* pColormap,
  63                            bool bDeleteColormap )
  64 {
  65     SalDisplay *pDisplay  = pDevice->GetDisplay();
  66     m_nXScreen = pDevice->GetXScreenNumber();
  67
  68     int nVisualDepth = pDisplay->GetColormap( m_nXScreen ).GetVisual().GetDepth();
  69     int nDeviceDepth = pDevice->GetDepth();
  70
  71     if( pColormap )
  72     {
  73         m_pColormap = pColormap;
  74         if( bDeleteColormap )
  75             m_pDeleteColormap.reset(pColormap);
  76     }
  77     else if( nDeviceDepth == nVisualDepth )
  78         m_pColormap = &pDisplay->GetColormap( m_nXScreen );
  79     else if( nDeviceDepth == 1 )
  80     {
  81         m_pDeleteColormap.reset(new SalColormap());
  82         m_pColormap = m_pDeleteColormap.get();
  83     }
  84
  85     m_pVDev      = pDevice;
  86     m_pFrame     = nullptr;
  87
  88     bWindow_     = pDisplay->IsDisplay();
  89     bVirDev_     = true;
  90
  91     SetDrawable(pDevice->GetDrawable(), pPreExistingTarget, m_nXScreen);
  92     mxImpl->Init();
  93 }
  94
  95 X11SalVirtualDevice::X11SalVirtualDevice(SalGraphics const * pGraphics, tools::Long &nDX, tools::Long &nDY,
  96                                          DeviceFormat eFormat, const SystemGraphicsData *pData,
  97                                          std::unique_ptr<X11SalGraphics> pNewGraphics) :
  98     pGraphics_(std::move(pNewGraphics)),
  99     m_nXScreen(0),
 100     bGraphics_(false)
 101 {
 102     SalColormap* pColormap = nullptr;
 103     bool bDeleteColormap = false;
 104
 105     sal_uInt16 nBitCount;
 106     switch (eFormat)
 107     {
 108         case DeviceFormat::BITMASK:
 109             nBitCount = 1;
 110             break;
 111         default:
 112             nBitCount = pGraphics->GetBitCount();
 113             break;
 114
 115     }
 116
 117     pDisplay_               = vcl_sal::getSalDisplay(GetGenericUnixSalData());
 118     nDepth_                 = nBitCount;
 119
 120     if( pData && pData->hDrawable != None )
 121     {
 122         ::Window aRoot;
 123         int x, y;
 124         unsigned int w = 0, h = 0, bw, d;
 125         Display* pDisp = pDisplay_->GetDisplay();
 126         XGetGeometry( pDisp, pData->hDrawable,
 127                       &aRoot, &x, &y, &w, &h, &bw, &d );
 128         int nScreen = 0;
 129         while( nScreen < ScreenCount( pDisp ) )
 130         {
 131             if( RootWindow( pDisp, nScreen ) == aRoot )
 132                 break;
 133             nScreen++;
 134         }
 135         nDX_ = static_cast<tools::Long>(w);
 136         nDY_ = static_cast<tools::Long>(h);
 137         nDX = nDX_;
 138         nDY = nDY_;
 139         m_nXScreen = SalX11Screen( nScreen );
 140         hDrawable_ = pData->hDrawable;
 141         bExternPixmap_ = true;
 142     }
 143     else
 144     {
 145         nDX_ = nDX;
 146         nDY_ = nDY;
 147         m_nXScreen = pGraphics ? static_cast<X11SalGraphics const *>(pGraphics)->GetScreenNumber() :
 148                                  vcl_sal::getSalDisplay(GetGenericUnixSalData())->GetDefaultXScreen();
 149         hDrawable_ = limitXCreatePixmap( GetXDisplay(),
 150                                          pDisplay_->GetDrawable( m_nXScreen ),
 151                                          nDX_, nDY_,
 152                                          GetDepth() );
 153         bExternPixmap_ = false;
 154     }
 155
 156     XRenderPictFormat* pXRenderFormat = pData ? static_cast<XRenderPictFormat*>(pData->pXRenderFormat) : nullptr;
 157     if( pXRenderFormat )
 158     {
 159         pGraphics_->SetXRenderFormat( pXRenderFormat );
 160         if( pXRenderFormat->colormap )
 161             pColormap = new SalColormap( pDisplay_, pXRenderFormat->colormap, m_nXScreen );
 162         else
 163             pColormap = new SalColormap( nBitCount );
 164         bDeleteColormap = true;
 165     }
 166     else if( nBitCount != pDisplay_->GetVisual( m_nXScreen ).GetDepth() )
 167     {
 168         pColormap = new SalColormap( nBitCount );
 169         bDeleteColormap = true;
 170     }
 171
 172     pGraphics_->SetLayout( SalLayoutFlags::NONE ); // by default no! mirroring for VirtualDevices, can be enabled with EnableRTL()
 173
 174     // tdf#127529 see SvpSalInstance::CreateVirtualDevice for the rare case of a non-null pPreExistingTarget
 175     cairo_surface_t* pPreExistingTarget = pData ? static_cast<cairo_surface_t*>(pData->pSurface) : nullptr;
 176
 177     pGraphics_->Init( this, pPreExistingTarget, pColormap, bDeleteColormap );
 178 }
 179
 180 X11SalVirtualDevice::~X11SalVirtualDevice()
 181 {
 182     pGraphics_.reset();
 183
 184     if( GetDrawable() && !bExternPixmap_ )
 185         XFreePixmap( GetXDisplay(), GetDrawable() );
 186 }
 187
 188 SalGraphics* X11SalVirtualDevice::AcquireGraphics()
 189 {
 190     if( bGraphics_ )
 191         return nullptr;
 192
 193     if( pGraphics_ )
 194         bGraphics_ = true;
 195
 196     return pGraphics_.get();
 197 }
 198
 199 void X11SalVirtualDevice::ReleaseGraphics( SalGraphics* )
 200 { bGraphics_ = false; }
 201
 202 bool X11SalVirtualDevice::SetSize( tools::Long nDX, tools::Long nDY )
 203 {
 204     if( bExternPixmap_ )
 205         return false;
 206
 207     if( !nDX ) nDX = 1;
 208     if( !nDY ) nDY = 1;
 209
 210     Pixmap h = limitXCreatePixmap( GetXDisplay(),
 211                               pDisplay_->GetDrawable( m_nXScreen ),
 212                               nDX, nDY, nDepth_ );
 213
 214     if( !h )
 215     {
 216         if( !GetDrawable() )
 217         {
 218             hDrawable_ = limitXCreatePixmap( GetXDisplay(),
 219                                         pDisplay_->GetDrawable( m_nXScreen ),
 220                                         1, 1, nDepth_ );
 221             nDX_ = 1;
 222             nDY_ = 1;
 223         }
 224         return false;
 225     }
 226
 227     if( GetDrawable() )
 228         XFreePixmap( GetXDisplay(), GetDrawable() );
 229     hDrawable_ = h;
 230
 231     nDX_ = nDX;
 232     nDY_ = nDY;
 233
 234     if( pGraphics_ )
 235         pGraphics_->Init( this );
 236
 237     return true;
 238 }
 239
 240 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */