LCOV - code coverage report
Current view: top level - vcl/inc/unx - saldisp.hxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 55 0.0 %
Date: 2014-04-14 Functions: 0 44 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : #ifndef INCLUDED_VCL_INC_UNX_SALDISP_HXX
      21             : #define INCLUDED_VCL_INC_UNX_SALDISP_HXX
      22             : 
      23             : class   SalDisplay;
      24             : class   SalColormap;
      25             : class   SalVisual;
      26             : class   SalXLib;
      27             : 
      28             : #include <unx/salunx.h>
      29             : #include <unx/saltype.h>
      30             : #include <vcl/salgtype.hxx>
      31             : #include <vcl/ptrstyle.hxx>
      32             : #include <sal/types.h>
      33             : #include <osl/mutex.h>
      34             : #include <vector>
      35             : #include <list>
      36             : #include <boost/unordered_map.hpp>
      37             : #include <tools/gen.hxx>
      38             : #include <salwtype.hxx>
      39             : #include <generic/gendisp.hxx>
      40             : 
      41             : #include <vclpluginapi.h>
      42             : 
      43             : class   BitmapPalette;
      44             : class   SalFrame;
      45             : class   ColorMask;
      46             : 
      47             : namespace vcl_sal { class WMAdaptor; }
      48             : 
      49             : #define PROPERTY_SUPPORT_WM_Parent_Pixmap_None  0x00000004
      50             : #define PROPERTY_SUPPORT_WM_ClientPos           0x00000008
      51             : #define PROPERTY_SUPPORT_3ButtonMouse           0x00000020
      52             : 
      53             : #define PROPERTY_BUG_XCopyArea_GXxor            0x00002000  // from window
      54             : #define PROPERTY_BUG_Tile                       0x00008000  // Recreate the
      55             :                                             // dither brush each time
      56             : #define PROPERTY_BUG_FillPolygon_Tile           0x00010000  // always Toggle Fillstyle
      57             : #define PROPERTY_BUG_DrawLine                   0x00020000  // a DrawLine is one point to short
      58             : #define PROPERTY_BUG_Bitmap_Bit_Order           0x00100000
      59             : 
      60             : #define PROPERTY_FEATURE_SharedMemory           0x02000000
      61             : #define PROPERTY_FEATURE_TrustedSolaris         0x04000000
      62             : 
      63             : #define PROPERTY_DEFAULT                        0x00000FCB
      64             : 
      65             : // server vendor
      66             : 
      67             : typedef enum  {
      68             :     vendor_none = 0,
      69             :     vendor_sun,
      70             :     vendor_unknown
      71             : } srv_vendor_t;
      72             : 
      73             : extern "C" srv_vendor_t sal_GetServerVendor( Display *p_display );
      74             : 
      75             : // MSB/Bigendian view (SalColor == RGB, r=0xFF0000, g=0xFF00, b=0xFF)
      76             : 
      77             : enum SalRGB { RGB,  RBG,
      78             :               GBR,  GRB,
      79             :               BGR,  BRG,
      80             :               RGBA, RBGA,
      81             :               GBRA, GRBA,
      82             :               BGRA, BRGA,
      83             :               otherSalRGB };
      84             : 
      85             : class SalVisual : public XVisualInfo
      86             : {
      87             :     SalRGB          eRGBMode_;
      88             :     int             nRedShift_;
      89             :     int             nGreenShift_;
      90             :     int             nBlueShift_;
      91             :     int             nRedBits_;
      92             :     int             nGreenBits_;
      93             :     int             nBlueBits_;
      94             : public:
      95             :                             SalVisual();
      96             :                             ~SalVisual();
      97             :                             SalVisual( const XVisualInfo* pXVI );
      98             : 
      99           0 :     inline  VisualID        GetVisualId() const { return visualid; }
     100           0 :     inline  Visual         *GetVisual() const { return visual; }
     101           0 :     inline  int             GetClass() const { return c_class; }
     102           0 :     inline  int             GetDepth() const { return depth; }
     103             :     inline  SalRGB          GetMode() const { return eRGBMode_; }
     104             : 
     105             :             Pixel           GetTCPixel( SalColor nColor ) const;
     106             :             SalColor        GetTCColor( Pixel nPixel ) const;
     107             : };
     108             : 
     109           0 : class SalColormap
     110             : {
     111             :     const SalDisplay*       m_pDisplay;
     112             :     Colormap                m_hColormap;
     113             :     std::vector<SalColor>   m_aPalette;         // Pseudocolor
     114             :     SalVisual               m_aVisual;
     115             :     std::vector<sal_uInt16>     m_aLookupTable;     // Pseudocolor: 12bit reduction
     116             :     Pixel                   m_nWhitePixel;
     117             :     Pixel                   m_nBlackPixel;
     118             :     Pixel                   m_nUsed;            // Pseudocolor
     119             :     SalX11Screen            m_nXScreen;
     120             : 
     121             :     void            GetPalette();
     122             :     void            GetLookupTable();
     123             : public:
     124             :     SalColormap( const SalDisplay*  pSalDisplay,
     125             :                  Colormap           hColormap,
     126             :                  SalX11Screen       nXScreen );
     127             :     SalColormap( sal_uInt16         nDepth );
     128             :     SalColormap();
     129             :     ~SalColormap();
     130             : 
     131           0 :     inline  Colormap            GetXColormap() const { return m_hColormap; }
     132           0 :     inline  const SalDisplay*   GetDisplay() const { return m_pDisplay; }
     133             :     inline  Display*            GetXDisplay() const;
     134           0 :     inline  const SalVisual&    GetVisual() const { return m_aVisual; }
     135           0 :     inline  Visual*             GetXVisual() const { return m_aVisual.GetVisual(); }
     136           0 :     inline  Pixel               GetWhitePixel() const { return m_nWhitePixel; }
     137           0 :     inline  Pixel               GetBlackPixel() const { return m_nBlackPixel; }
     138           0 :     inline  Pixel               GetUsed() const { return m_nUsed; }
     139             :     inline  int                 GetClass() const { return m_aVisual.GetClass(); }
     140             : 
     141             :     bool            GetXPixels( XColor  &rColor,
     142             :                                     int      r,
     143             :                                     int      g,
     144             :                                     int      b ) const;
     145             :     inline  bool            GetXPixel( XColor  &rColor,
     146             :                                            int      r,
     147             :                                            int      g,
     148             :                                            int      b ) const;
     149             :     Pixel           GetPixel( SalColor nColor ) const;
     150             :     SalColor        GetColor( Pixel nPixel ) const;
     151             : };
     152             : 
     153             : typedef int(*YieldFunc)(int fd, void* data);
     154             : 
     155             : class VCLPLUG_GEN_PUBLIC SalXLib
     156             : {
     157             : protected:
     158             :     timeval         m_aTimeout;
     159             :     sal_uLong       m_nTimeoutMS;
     160             :     int             m_pTimeoutFDS[2];
     161             : 
     162             :     int             nFDs_;
     163             :     fd_set          aReadFDS_;
     164             :     fd_set          aExceptionFDS_;
     165             : 
     166             : public:
     167             :     SalXLib();
     168             :     virtual         ~SalXLib();
     169             :     virtual void    Init();
     170             : 
     171             :     virtual void    Yield( bool bWait, bool bHandleAllCurrentEvents );
     172             :     virtual void    Wakeup();
     173             :     virtual void    PostUserEvent();
     174             : 
     175             :     virtual void    Insert( int fd, void* data,
     176             :                             YieldFunc   pending,
     177             :                             YieldFunc   queued,
     178             :                             YieldFunc   handle );
     179             :     virtual void    Remove( int fd );
     180             : 
     181             :     virtual void    StartTimer( sal_uLong nMS );
     182             :     virtual void    StopTimer();
     183             : 
     184             :     bool            CheckTimeout( bool bExecuteTimers = true );
     185             : };
     186             : 
     187             : class SalI18N_InputMethod;
     188             : class SalI18N_KeyboardExtension;
     189             : class AttributeProvider;
     190             : 
     191             : extern "C" {
     192             :     typedef Bool(*X_if_predicate)(Display*,XEvent*,XPointer);
     193             : }
     194             : 
     195             : class VCLPLUG_GEN_PUBLIC SalDisplay : public SalGenericDisplay
     196             : {
     197             : public:
     198             :     struct RenderEntry
     199             :     {
     200             :         Pixmap      m_aPixmap;
     201             :         Picture     m_aPicture;
     202             : 
     203           0 :         RenderEntry() : m_aPixmap( 0 ), m_aPicture( 0 ) {}
     204             :     };
     205             : 
     206             :     typedef boost::unordered_map<int,RenderEntry> RenderEntryMap;
     207             : 
     208           0 :     struct ScreenData
     209             :     {
     210             :         bool                m_bInit;
     211             : 
     212             :         XLIB_Window         m_aRoot;
     213             :         XLIB_Window         m_aRefWindow;
     214             :         Size                m_aSize;
     215             :         SalVisual           m_aVisual;
     216             :         SalColormap         m_aColormap;
     217             :         GC                  m_aMonoGC;
     218             :         GC                  m_aCopyGC;
     219             :         GC                  m_aAndInvertedGC;
     220             :         GC                  m_aAndGC;
     221             :         GC                  m_aOrGC;
     222             :         GC                  m_aStippleGC;
     223             :         Pixmap              m_hInvert50;
     224             :         mutable RenderEntryMap m_aRenderData;
     225             : 
     226           0 :         ScreenData() :
     227             :         m_bInit( false ),
     228             :         m_aRoot( None ),
     229             :         m_aRefWindow( None ),
     230             :         m_aMonoGC( None ),
     231             :         m_aCopyGC( None ),
     232             :         m_aAndInvertedGC( None ),
     233             :         m_aAndGC( None ),
     234             :         m_aOrGC( None ),
     235             :         m_aStippleGC( None ),
     236             :         m_hInvert50( None ),
     237           0 :         m_aRenderData( 1 )
     238           0 :         {}
     239             :     };
     240             : 
     241             : protected:
     242             :     SalXLib        *pXLib_;
     243             :     SalI18N_InputMethod         *mpInputMethod;
     244             :     SalI18N_KeyboardExtension   *mpKbdExtension;
     245             : 
     246             :     AttributeProvider           *mpFactory;
     247             : 
     248             :     Display        *pDisp_;             // X Display
     249             : 
     250             :     SalX11Screen                 m_nXDefaultScreen;
     251             :     std::vector< ScreenData >    m_aScreens;
     252             :     ScreenData      m_aInvalidScreenData;
     253             :     Pair            aResolution_;       // [dpi]
     254             :     sal_uLong       nMaxRequestSize_;   // [byte]
     255             : 
     256             :     srv_vendor_t    meServerVendor;
     257             : 
     258             :     // until x bytes
     259             : 
     260             :     XLIB_Cursor     aPointerCache_[POINTER_COUNT];
     261             : 
     262             :     // Keyboard
     263             :     bool        bNumLockFromXS_;    // Num Lock handled by X Server
     264             :     int             nNumLockIndex_;     // modifier index in modmap
     265             :     int             nNumLockMask_;      // keyevent state mask for
     266             :     KeySym          nShiftKeySym_;      // first shift modifier
     267             :     KeySym          nCtrlKeySym_;       // first control modifier
     268             :     KeySym          nMod1KeySym_;       // first mod1 modifier
     269             : 
     270             :     vcl_sal::WMAdaptor* m_pWMAdaptor;
     271             : 
     272             :     bool            m_bXinerama;
     273             :     std::vector< Rectangle > m_aXineramaScreens;
     274             :     std::vector< int > m_aXineramaScreenIndexMap;
     275             :     std::list<SalObject*> m_aSalObjects;
     276             : 
     277             :     bool            m_bUseRandRWrapper; // don't use randr on gtk, use gdk signals there
     278             : 
     279             :     mutable XLIB_Time  m_nLastUserEventTime; // mutable because changed on first access
     280             : 
     281             :     virtual bool    Dispatch( XEvent *pEvent ) = 0;
     282             :     void            InitXinerama();
     283             :     void            InitRandR( XLIB_Window aRoot ) const;
     284             :     void            DeInitRandR();
     285             :     int             processRandREvent( XEvent* );
     286             : 
     287             :     void            doDestruct();
     288             :     void            addXineramaScreenUnique( int i, long i_nX, long i_nY, long i_nWidth, long i_nHeight );
     289             : public:
     290             :     static SalDisplay *GetSalDisplay( Display* display );
     291             :     static bool BestVisual( Display     *pDisp,
     292             :                                 int          nScreen,
     293             :                                 XVisualInfo &rVI );
     294             : 
     295             :                     SalDisplay( Display* pDisp );
     296             : 
     297             :     virtual        ~SalDisplay();
     298             : 
     299             :     void            Init();
     300             : 
     301             : #ifdef DBG_UTIL
     302             :     void            PrintInfo() const;
     303             :     void            DbgPrintDisplayEvent(const char *pComment, XEvent *pEvent) const;
     304             : #endif
     305             : 
     306             :     void            Beep() const;
     307             : 
     308             :     void            ModifierMapping();
     309             :     void            SimulateKeyPress( sal_uInt16 nKeyCode );
     310             :     sal_uInt16          GetIndicatorState() const;
     311             :     OUString          GetKeyNameFromKeySym( KeySym keysym ) const;
     312             :     OUString       GetKeyName( sal_uInt16 nKeyCode ) const;
     313             :     sal_uInt16          GetKeyCode( KeySym keysym, char*pcPrintable ) const;
     314             :     KeySym          GetKeySym( XKeyEvent      *pEvent,
     315             :                                unsigned char  *pPrintable,
     316             :                                int            *pLen,
     317             :                                KeySym         *pUnmodifiedKeySym,
     318             :                                Status         *pStatus,
     319             :                                XIC = NULL ) const;
     320             : 
     321             :     XLIB_Cursor           GetPointer( int ePointerStyle );
     322             :     virtual int           CaptureMouse( SalFrame *pCapture );
     323             : 
     324             :     void                  Remove( XEvent   *pEvent );
     325             :     virtual ScreenData   *initScreen( SalX11Screen nXScreen ) const;
     326           0 :     const ScreenData&     getDataForScreen( SalX11Screen nXScreen ) const
     327             :     {
     328           0 :         if( nXScreen.getXScreen() >= m_aScreens.size() )
     329           0 :             return m_aInvalidScreenData;
     330           0 :         if( ! m_aScreens[nXScreen.getXScreen()].m_bInit )
     331           0 :             initScreen( nXScreen );
     332           0 :         return m_aScreens[nXScreen.getXScreen()];
     333             :     }
     334             : 
     335           0 :     XLIB_Window     GetDrawable( SalX11Screen nXScreen ) const { return getDataForScreen( nXScreen ).m_aRefWindow; }
     336           0 :     Display        *GetDisplay() const { return pDisp_; }
     337           0 :     SalX11Screen    GetDefaultXScreen() const { return m_nXDefaultScreen; }
     338           0 :     const Size&     GetScreenSize( SalX11Screen nXScreen ) const { return getDataForScreen( nXScreen ).m_aSize; }
     339           0 :     srv_vendor_t    GetServerVendor() const { return meServerVendor; }
     340           0 :     void            SetServerVendor() { meServerVendor = sal_GetServerVendor(pDisp_); }
     341           0 :     bool        IsDisplay() const { return !!pXLib_; }
     342             :     GC              GetMonoGC( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aMonoGC; }
     343           0 :     GC              GetCopyGC( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aCopyGC; }
     344             :     GC              GetAndInvertedGC( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aAndInvertedGC; }
     345             :     GC              GetAndGC( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aAndGC; }
     346             :     GC              GetOrGC( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aOrGC; }
     347             :     GC              GetStippleGC( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aStippleGC; }
     348             :     GC              GetGC( sal_uInt16 nDepth, SalX11Screen nXScreen ) const;
     349           0 :     Pixmap          GetInvert50( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_hInvert50; }
     350           0 :     const SalColormap&    GetColormap( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aColormap; }
     351           0 :     const SalVisual&      GetVisual( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aVisual; }
     352           0 :     RenderEntryMap&       GetRenderEntries( SalX11Screen nXScreen ) const { return getDataForScreen(nXScreen).m_aRenderData; }
     353           0 :     const Pair     &GetResolution() const { return aResolution_; }
     354           0 :     sal_uLong       GetProperties() const { return PROPERTY_DEFAULT; }
     355           0 :     sal_uLong       GetMaxRequestSize() const { return nMaxRequestSize_; }
     356             :     XLIB_Time       GetLastUserEventTime( bool bAlwaysReget = false ) const;
     357             : 
     358             :     bool            XIfEventWithTimeout( XEvent*, XPointer, X_if_predicate, long i_nTimeout = 1000 ) const;
     359             :     SalXLib*        GetXLib() const { return pXLib_; }
     360             : 
     361           0 :     SalI18N_InputMethod*        GetInputMethod()  const { return mpInputMethod;  }
     362           0 :     SalI18N_KeyboardExtension*  GetKbdExtension() const { return mpKbdExtension; }
     363           0 :     void            SetInputMethod( SalI18N_InputMethod *pInputMethod )
     364           0 :     { mpInputMethod = pInputMethod; }
     365           0 :     void            SetKbdExtension(SalI18N_KeyboardExtension *pKbdExtension)
     366           0 :     { mpKbdExtension = pKbdExtension; }
     367           0 :     ::vcl_sal::WMAdaptor* getWMAdaptor() const { return m_pWMAdaptor; }
     368           0 :     bool            IsXinerama() const { return m_bXinerama; }
     369           0 :     const std::vector< Rectangle >& GetXineramaScreens() const { return m_aXineramaScreens; }
     370           0 :     XLIB_Window     GetRootWindow( SalX11Screen nXScreen ) const
     371           0 :             { return getDataForScreen( nXScreen ).m_aRoot; }
     372             :     const std::vector< ScreenData >& GetScreenData() { return m_aScreens; }
     373           0 :     unsigned int GetXScreenCount() const { return m_aScreens.size(); }
     374             : 
     375           0 :     const std::list< SalFrame* >& getFrames() const { return m_aFrames; }
     376           0 :     bool            IsNumLockFromXS() const { return bNumLockFromXS_; }
     377             : 
     378           0 :     std::list< SalObject* >& getSalObjects() { return m_aSalObjects; }
     379             : 
     380             :     virtual void    PostUserEvent() SAL_OVERRIDE = 0;
     381             : };
     382             : 
     383             : inline GC SalDisplay::GetGC( sal_uInt16 nDepth, SalX11Screen nXScreen ) const
     384             : { return 1 == nDepth
     385             :          ? GetMonoGC( nXScreen )
     386             :          : getDataForScreen(nXScreen).m_aVisual.GetDepth() == nDepth
     387             :            ? GetCopyGC( nXScreen )
     388             :            : None; }
     389             : 
     390           0 : inline  Display *SalColormap::GetXDisplay() const
     391           0 : { return m_pDisplay->GetDisplay(); }
     392             : 
     393             : class VCLPLUG_GEN_PUBLIC SalX11Display : public SalDisplay
     394             : {
     395             : public:
     396             :              SalX11Display( Display* pDisp );
     397             :     virtual ~SalX11Display();
     398             : 
     399             :     virtual bool        Dispatch( XEvent *pEvent ) SAL_OVERRIDE;
     400             :     virtual void        Yield();
     401             :     virtual void        PostUserEvent() SAL_OVERRIDE;
     402             : 
     403             :     bool            IsEvent();
     404             :     void                SetupInput( SalI18N_InputMethod *pInputMethod );
     405             : };
     406             : 
     407             : // get foreign key names
     408             : namespace vcl_sal {
     409             :     OUString getKeysymReplacementName(
     410             :         const OUString& pLang,
     411             :         KeySym nSymbol );
     412             : }
     413             : 
     414             : #endif // INCLUDED_VCL_INC_UNX_SALDISP_HXX
     415             : 
     416             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10