vcl/unx/generic/app/salinst.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 <stdlib.h>
  21
  22 #include <config_features.h>
  23 #include <vcl/skia/SkiaHelper.hxx>
  24 #include <config_skia.h>
  25 #if HAVE_FEATURE_SKIA
  26 #include <skia/x11/gdiimpl.hxx>
  27 #include <skia/salbmp.hxx>
  28 #endif
  29
  30 #include <unx/saldata.hxx>
  31 #include <unx/saldisp.hxx>
  32 #include <unx/salinst.h>
  33 #include <unx/geninst.h>
  34 #include <unx/genpspgraphics.h>
  35 #include <unx/salframe.h>
  36 #include <unx/sm.hxx>
  37 #include <unx/i18n_im.hxx>
  38 #include <unx/salbmp.h>
  39
  40 #include <vcl/inputtypes.hxx>
  41
  42 #include <salwtype.hxx>
  43
  44 // plugin factory function
  45 extern "C"
  46 {
  47     VCLPLUG_GEN_PUBLIC SalInstance* create_SalInstance()
  48     {
  49         /* #i92121# workaround deadlocks in the X11 implementation
  50         */
  51         static const char* pNoXInitThreads = getenv( "SAL_NO_XINITTHREADS" );
  52         /* #i90094#
  53            from now on we know that an X connection will be
  54            established, so protect X against itself
  55         */
  56         if( ! ( pNoXInitThreads && *pNoXInitThreads ) )
  57             XInitThreads();
  58
  59         X11SalInstance* pInstance = new X11SalInstance( std::make_unique<SalYieldMutex>() );
  60
  61         // initialize SalData
  62         X11SalData *pSalData = new X11SalData();
  63
  64         pSalData->Init();
  65         pInstance->SetLib( pSalData->GetLib() );
  66
  67         return pInstance;
  68     }
  69 }
  70
  71 X11SalInstance::X11SalInstance(std::unique_ptr<SalYieldMutex> pMutex)
  72     : SalGenericInstance(std::move(pMutex))
  73     , mpXLib(nullptr)
  74 {
  75     ImplSVData* pSVData = ImplGetSVData();
  76     pSVData->maAppData.mxToolkitName = OUString("x11");
  77     m_bSupportsOpenGL = true;
  78 #if HAVE_FEATURE_SKIA
  79     X11SkiaSalGraphicsImpl::prepareSkia();
  80 #if SKIA_USE_BITMAP32
  81     if (SkiaHelper::isVCLSkiaEnabled())
  82         m_bSupportsBitmap32 = true;
  83 #endif
  84 #endif
  85 }
  86
  87 X11SalInstance::~X11SalInstance()
  88 {
  89     // close session management
  90     SessionManagerClient::close();
  91
  92     // dispose SalDisplay list from SalData
  93     // would be done in a static destructor else which is
  94     // a little late
  95     GetGenericUnixSalData()->Dispose();
  96
  97 #if HAVE_FEATURE_SKIA
  98     SkiaHelper::cleanup();
  99 #endif
 100 }
 101
 102 SalX11Display* X11SalInstance::CreateDisplay() const
 103 {
 104     return new SalX11Display( mpXLib->GetDisplay() );
 105 }
 106
 107 // AnyInput from sv/mow/source/app/svapp.cxx
 108
 109 namespace {
 110
 111 struct PredicateReturn
 112 {
 113     VclInputFlags nType;
 114     bool          bRet;
 115 };
 116
 117 }
 118
 119 extern "C" {
 120 static Bool ImplPredicateEvent( Display *, XEvent *pEvent, char *pData )
 121 {
 122     PredicateReturn *pPre = reinterpret_cast<PredicateReturn *>(pData);
 123
 124     if ( pPre->bRet )
 125         return False;
 126
 127     VclInputFlags nType;
 128
 129     switch( pEvent->type )
 130     {
 131         case ButtonPress:
 132         case ButtonRelease:
 133         case MotionNotify:
 134         case EnterNotify:
 135         case LeaveNotify:
 136             nType = VclInputFlags::MOUSE;
 137             break;
 138
 139         case KeyPress:
 140         //case KeyRelease:
 141             nType = VclInputFlags::KEYBOARD;
 142             break;
 143         case Expose:
 144         case GraphicsExpose:
 145         case NoExpose:
 146             nType = VclInputFlags::PAINT;
 147             break;
 148         default:
 149             nType = VclInputFlags::NONE;
 150     }
 151
 152     if ( (nType & pPre->nType) || ( nType == VclInputFlags::NONE && (pPre->nType & VclInputFlags::OTHER) ) )
 153         pPre->bRet = true;
 154
 155     return False;
 156 }
 157 }
 158
 159 bool X11SalInstance::AnyInput(VclInputFlags nType)
 160 {
 161     GenericUnixSalData *pData = GetGenericUnixSalData();
 162     Display *pDisplay  = vcl_sal::getSalDisplay(pData)->GetDisplay();
 163     bool bRet = false;
 164
 165     if( (nType & VclInputFlags::TIMER) && (mpXLib && mpXLib->CheckTimeout(false)) )
 166         bRet = true;
 167
 168     if( !bRet && XPending(pDisplay) )
 169     {
 170         PredicateReturn aInput;
 171         XEvent          aEvent;
 172
 173         aInput.bRet     = false;
 174         aInput.nType    = nType;
 175
 176         XCheckIfEvent(pDisplay, &aEvent, ImplPredicateEvent,
 177                       reinterpret_cast<char *>(&aInput) );
 178
 179         bRet = aInput.bRet;
 180     }
 181 #if OSL_DEBUG_LEVEL > 1
 182     SAL_INFO("vcl.app", "AnyInput "
 183             << std::showbase << std::hex
 184             << static_cast<unsigned int>(nType)
 185             << " = " << (bRet ? "true" : "false"));
 186 #endif
 187     return bRet;
 188 }
 189
 190 bool X11SalInstance::DoYield(bool bWait, bool bHandleAllCurrentEvents)
 191 {
 192     return mpXLib->Yield( bWait, bHandleAllCurrentEvents );
 193 }
 194
 195 OUString X11SalInstance::GetConnectionIdentifier()
 196 {
 197     static const char* pDisplay = getenv( "DISPLAY" );
 198     return pDisplay ? OUString::createFromAscii(pDisplay) : OUString();
 199 }
 200
 201 SalFrame *X11SalInstance::CreateFrame( SalFrame *pParent, SalFrameStyleFlags nSalFrameStyle )
 202 {
 203     SalFrame *pFrame = new X11SalFrame( pParent, nSalFrameStyle );
 204
 205     return pFrame;
 206 }
 207
 208 SalFrame* X11SalInstance::CreateChildFrame( SystemParentData* pParentData, SalFrameStyleFlags nStyle )
 209 {
 210     SalFrame* pFrame = new X11SalFrame( nullptr, nStyle, pParentData );
 211
 212     return pFrame;
 213 }
 214
 215 void X11SalInstance::DestroyFrame( SalFrame* pFrame )
 216 {
 217     delete pFrame;
 218 }
 219
 220 void X11SalInstance::AfterAppInit()
 221 {
 222     assert( mpXLib->GetDisplay() );
 223     assert( mpXLib->GetInputMethod() );
 224
 225     SalX11Display *pSalDisplay = CreateDisplay();
 226     mpXLib->GetInputMethod()->CreateMethod( mpXLib->GetDisplay() );
 227     pSalDisplay->SetupInput();
 228 }
 229
 230 void X11SalInstance::AddToRecentDocumentList(const OUString&, const OUString&, const OUString&) {}
 231
 232 void X11SalInstance::PostPrintersChanged()
 233 {
 234     SalDisplay* pDisp = vcl_sal::getSalDisplay(GetGenericUnixSalData());
 235     for (auto pSalFrame : pDisp->getFrames() )
 236         pDisp->PostEvent( pSalFrame, nullptr, SalEvent::PrinterChanged );
 237 }
 238
 239 std::unique_ptr<GenPspGraphics> X11SalInstance::CreatePrintGraphics()
 240 {
 241     return std::make_unique<GenPspGraphics>();
 242 }
 243
 244 std::shared_ptr<SalBitmap> X11SalInstance::CreateSalBitmap()
 245 {
 246 #if HAVE_FEATURE_SKIA
 247     if (SkiaHelper::isVCLSkiaEnabled())
 248         return std::make_shared<SkiaSalBitmap>();
 249     else
 250 #endif
 251         return std::make_shared<X11SalBitmap>();
 252 }
 253
 254 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */