vcl/unx/generic/gdi/salgdi.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 <config_features.h>
  21 #include <vcl/skia/SkiaHelper.hxx>
  22 #if HAVE_FEATURE_SKIA
  23 #include <skia/x11/gdiimpl.hxx>
  24 #include <skia/x11/textrender.hxx>
  25 #endif
  26
  27 #include <X11/Xlib.h>
  28 #include <X11/Xutil.h>
  29
  30 #include <basegfx/polygon/b2dpolygon.hxx>
  31 #include <basegfx/polygon/b2dpolypolygon.hxx>
  32 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  33 #include <basegfx/matrix/b2dhommatrix.hxx>
  34 #include <basegfx/curve/b2dcubicbezier.hxx>
  35
  36 #include <headless/svpgdi.hxx>
  37
  38 #include <vcl/sysdata.hxx>
  39 #include <vcl/virdev.hxx>
  40 #include <sal/log.hxx>
  41 #include <o3tl/string_view.hxx>
  42
  43 #include <unx/salunx.h>
  44 #include <unx/saldisp.hxx>
  45 #include <unx/salgdi.h>
  46 #include <unx/x11/xlimits.hxx>
  47
  48 #include <salframe.hxx>
  49 #include <salgdiimpl.hxx>
  50 #include <textrender.hxx>
  51 #include <salvd.hxx>
  52
  53 #include <unx/salframe.h>
  54 #include <unx/cairotextrender.hxx>
  55 #include "cairo_xlib_cairo.hxx"
  56 #include <cairo-xlib.h>
  57
  58 #include "X11CairoSalGraphicsImpl.hxx"
  59
  60
  61 // X11Common
  62
  63 X11Common::X11Common()
  64     : m_hDrawable(None)
  65     , m_pColormap(nullptr)
  66 {}
  67
  68 // X11SalGraphics
  69
  70 X11SalGraphics::X11SalGraphics():
  71     m_pFrame(nullptr),
  72     m_pVDev(nullptr),
  73     m_nXScreen( 0 )
  74 {
  75 #if HAVE_FEATURE_SKIA
  76     if (SkiaHelper::isVCLSkiaEnabled())
  77     {
  78         mxImpl.reset(new X11SkiaSalGraphicsImpl(*this));
  79         mxTextRenderImpl.reset(new SkiaTextRender);
  80     }
  81     else
  82 #endif
  83     {
  84         mxImpl.reset(new X11CairoSalGraphicsImpl(*this, maCairoCommon));
  85         mxTextRenderImpl.reset(new CairoTextRender(maCairoCommon));
  86     }
  87 }
  88
  89 X11SalGraphics::~X11SalGraphics() COVERITY_NOEXCEPT_FALSE
  90 {
  91     mxImpl->DeInit();
  92     SetDrawable(None, nullptr, m_nXScreen);
  93     ReleaseFonts();
  94     FreeColorMap();
  95 }
  96
  97 void X11SalGraphics::FreeColorMap()
  98 {
  99     if( m_pDeleteColormap )
 100     {
 101         m_pDeleteColormap.reset();
 102         maX11Common.m_pColormap = nullptr;
 103     }
 104 }
 105
 106 SalGraphicsImpl* X11SalGraphics::GetImpl() const
 107 {
 108     return mxImpl.get();
 109 }
 110
 111 void X11SalGraphics::SetDrawable(Drawable aDrawable, cairo_surface_t* pSurface, SalX11Screen nXScreen)
 112 {
 113     maCairoCommon.m_pSurface = pSurface;
 114     if (maCairoCommon.m_pSurface)
 115     {
 116         maCairoCommon.m_aFrameSize.setX(cairo_xlib_surface_get_width(pSurface));
 117         maCairoCommon.m_aFrameSize.setY(cairo_xlib_surface_get_height(pSurface));
 118         dl_cairo_surface_get_device_scale(pSurface, &maCairoCommon.m_fScale, nullptr);
 119     }
 120
 121     // shortcut if nothing changed
 122     if( maX11Common.m_hDrawable == aDrawable )
 123         return;
 124
 125     // free screen specific resources if needed
 126     if( nXScreen != m_nXScreen )
 127     {
 128         FreeColorMap();
 129         maX11Common.m_pColormap = &vcl_sal::getSalDisplay(GetGenericUnixSalData())->GetColormap( nXScreen );
 130         m_nXScreen = nXScreen;
 131     }
 132
 133     maX11Common.m_hDrawable = aDrawable;
 134 }
 135
 136 void X11SalGraphics::Init( X11SalFrame& rFrame, Drawable aTarget,
 137                            SalX11Screen nXScreen )
 138 {
 139     maX11Common.m_pColormap = &vcl_sal::getSalDisplay(GetGenericUnixSalData())->GetColormap(nXScreen);
 140     m_nXScreen  = nXScreen;
 141
 142     m_pFrame    = &rFrame;
 143     m_pVDev     = nullptr;
 144
 145     SetDrawable(aTarget, rFrame.GetSurface(), nXScreen);
 146     mxImpl->UpdateX11GeometryProvider();
 147 }
 148
 149 void X11SalGraphics::GetResolution( sal_Int32 &rDPIX, sal_Int32 &rDPIY ) // const
 150 {
 151     char* pForceDpi;
 152     if ((pForceDpi = getenv("SAL_FORCEDPI")))
 153     {
 154         rDPIX = rDPIY = o3tl::toInt32(std::string_view(pForceDpi));
 155         return;
 156     }
 157
 158     const SalDisplay *pDisplay = GetDisplay();
 159     if (!pDisplay)
 160     {
 161         SAL_WARN( "vcl", "Null display");
 162         rDPIX = rDPIY = 96;
 163         return;
 164     }
 165
 166     Pair dpi = pDisplay->GetResolution();
 167     rDPIX = dpi.A();
 168     rDPIY = dpi.B();
 169
 170     if ( rDPIY > 200 )
 171     {
 172         rDPIX = Divide( rDPIX * 200, rDPIY );
 173         rDPIY = 200;
 174     }
 175
 176     // #i12705# equalize x- and y-resolution if they are close enough
 177     if( rDPIX == rDPIY )
 178         return;
 179
 180     // different x- and y- resolutions are usually artifacts of
 181     // a wrongly calculated screen size.
 182 #if OSL_DEBUG_LEVEL >= 2
 183     SAL_INFO("vcl.gdi", "Forcing Resolution from "
 184         << std::hex << rDPIX
 185         << std::dec << rDPIX
 186         << " to "
 187         << std::hex << rDPIY
 188         << std::dec << rDPIY);
 189 #endif
 190     rDPIX = rDPIY; // y-resolution is more trustworthy
 191 }
 192
 193 SystemGraphicsData X11SalGraphics::GetGraphicsData() const
 194 {
 195     SystemGraphicsData aRes;
 196
 197     aRes.nSize = sizeof(aRes);
 198     aRes.pDisplay  = GetXDisplay();
 199     aRes.hDrawable = maX11Common.m_hDrawable;
 200     aRes.pVisual   = GetVisual().visual;
 201     aRes.nScreen   = m_nXScreen.getXScreen();
 202     return aRes;
 203 }
 204
 205 void X11SalGraphics::Flush()
 206 {
 207     if( X11GraphicsImpl* x11Impl = dynamic_cast< X11GraphicsImpl* >( mxImpl.get()))
 208         x11Impl->Flush();
 209 }
 210
 211 #if ENABLE_CAIRO_CANVAS
 212
 213 bool X11SalGraphics::SupportsCairo() const
 214 {
 215     return true;
 216 }
 217
 218 cairo::SurfaceSharedPtr X11SalGraphics::CreateSurface(const cairo::CairoSurfaceSharedPtr& rSurface) const
 219 {
 220     return std::make_shared<cairo::X11Surface>(rSurface);
 221 }
 222
 223 namespace
 224 {
 225     cairo::X11SysData getSysData( const vcl::Window& rWindow )
 226     {
 227         const SystemEnvData* pSysData = rWindow.GetSystemData();
 228
 229         if( !pSysData )
 230             return cairo::X11SysData();
 231         else
 232             return cairo::X11SysData(*pSysData, rWindow.ImplGetFrame());
 233     }
 234
 235     cairo::X11SysData getSysData( const VirtualDevice& rVirDev )
 236     {
 237         return cairo::X11SysData( rVirDev.GetSystemGfxData() );
 238     }
 239 }
 240
 241 cairo::SurfaceSharedPtr X11SalGraphics::CreateSurface( const OutputDevice& rRefDevice,
 242                                 int x, int y, int width, int height ) const
 243 {
 244     if( rRefDevice.GetOutDevType() == OUTDEV_WINDOW )
 245         return std::make_shared<cairo::X11Surface>(getSysData(*rRefDevice.GetOwnerWindow()),
 246                                                x,y,width,height);
 247     if( rRefDevice.IsVirtual() )
 248         return std::make_shared<cairo::X11Surface>(getSysData(static_cast<const VirtualDevice&>(rRefDevice)),
 249                                                x,y,width,height);
 250     return cairo::SurfaceSharedPtr();
 251 }
 252
 253 cairo::SurfaceSharedPtr X11SalGraphics::CreateBitmapSurface( const OutputDevice&     rRefDevice,
 254                                       const BitmapSystemData& rData,
 255                                       const Size&             rSize ) const
 256 {
 257     SAL_INFO("vcl", "requested size: " << rSize.Width() << " x " << rSize.Height()
 258               << " available size: " << rData.mnWidth << " x "
 259               << rData.mnHeight);
 260     if ( rData.mnWidth == rSize.Width() && rData.mnHeight == rSize.Height() )
 261     {
 262         if( rRefDevice.GetOutDevType() == OUTDEV_WINDOW )
 263             return std::make_shared<cairo::X11Surface>(getSysData(*rRefDevice.GetOwnerWindow()), rData );
 264         else if( rRefDevice.IsVirtual() )
 265             return std::make_shared<cairo::X11Surface>(getSysData(static_cast<const VirtualDevice&>(rRefDevice)), rData );
 266     }
 267
 268     return cairo::SurfaceSharedPtr();
 269 }
 270
 271 css::uno::Any X11SalGraphics::GetNativeSurfaceHandle(cairo::SurfaceSharedPtr& rSurface, const basegfx::B2ISize& /*rSize*/) const
 272 {
 273     cairo::X11Surface& rXlibSurface=dynamic_cast<cairo::X11Surface&>(*rSurface);
 274     css::uno::Sequence< css::uno::Any > args{
 275         css::uno::Any(false), // do not call XFreePixmap on it
 276         css::uno::Any(sal_Int64(rXlibSurface.getPixmap()->mhDrawable))
 277     };
 278     return css::uno::Any(args);
 279 }
 280
 281 #endif // ENABLE_CAIRO_CANVAS
 282
 283 SalGeometryProvider *X11SalGraphics::GetGeometryProvider() const
 284 {
 285     if (m_pFrame)
 286         return static_cast< SalGeometryProvider * >(m_pFrame);
 287     else
 288         return static_cast< SalGeometryProvider * >(m_pVDev);
 289 }
 290
 291 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */