src/unix/displayx11.cpp

   1 ///////////////////////////////////////////////////////////////////////////
   2 // Name:        src/unix/displayx11.cpp
   3 // Purpose:     Unix/X11 implementation of wxDisplay class
   4 // Author:      Brian Victor, Vadim Zeitlin
   5 // Modified by:
   6 // Created:     12/05/02
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24   #pragma hdrstop
  25 #endif
  26
  27 #include "wx/display.h"
  28 #include "wx/display_impl.h"
  29 #include "wx/intl.h"
  30 #include "wx/log.h"
  31
  32 #ifndef WX_PRECOMP
  33   #include "wx/dynarray.h"
  34   #include "wx/gdicmn.h"
  35   #include "wx/string.h"
  36   #include "wx/utils.h"
  37 #endif /* WX_PRECOMP */
  38
  39 #if wxUSE_DISPLAY
  40
  41 /* These must be included after the wx files.  Otherwise the Data macro in
  42  * Xlibint.h conflicts with a function declaration in wx/list.h.  */
  43 extern "C"
  44 {
  45     #include <X11/Xlib.h>
  46     #include <X11/Xlibint.h>
  47
  48     #include <X11/extensions/Xinerama.h>
  49     #ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
  50         #include <X11/extensions/xf86vmode.h>
  51     #endif
  52 }
  53
  54 // ----------------------------------------------------------------------------
  55 // helper class to automatically free XineramaQueryScreens() return value
  56 // ----------------------------------------------------------------------------
  57
  58 class ScreensInfo
  59 {
  60 public:
  61     ScreensInfo()
  62     {
  63         m_screens = XineramaQueryScreens((Display *)wxGetDisplay(), &m_num);
  64     }
  65
  66     ~ScreensInfo()
  67     {
  68         XFree(m_screens);
  69     }
  70
  71     operator const XineramaScreenInfo *() const { return m_screens; }
  72
  73     size_t GetCount() const { return wx_static_cast(size_t, m_num); }
  74
  75 private:
  76     XineramaScreenInfo *m_screens;
  77     int m_num;
  78 };
  79
  80 // ----------------------------------------------------------------------------
  81 // display and display factory classes
  82 // ----------------------------------------------------------------------------
  83
  84 class WXDLLEXPORT wxDisplayImplX11 : public wxDisplayImpl
  85 {
  86 public:
  87     wxDisplayImplX11(const XineramaScreenInfo& info)
  88         : m_rect(info.x_org, info.y_org, info.width, info.height)
  89     {
  90     }
  91
  92     virtual wxRect GetGeometry() const { return m_rect; }
  93     virtual wxString GetName() const { return wxString(); }
  94
  95     virtual wxArrayVideoModes GetModes(const wxVideoMode& mode) const;
  96     virtual wxVideoMode GetCurrentMode() const;
  97     virtual bool ChangeMode(const wxVideoMode& mode);
  98
  99 private:
 100     wxRect m_rect;
 101     int m_depth;
 102
 103     DECLARE_NO_COPY_CLASS(wxDisplayImplX11)
 104 };
 105
 106 class wxDisplayFactoryX11 : public wxDisplayFactory
 107 {
 108 public:
 109     wxDisplayFactoryX11();
 110
 111     virtual wxDisplayImpl *CreateDisplay(size_t n);
 112     virtual size_t GetCount();
 113     virtual int GetFromPoint(const wxPoint& pt);
 114
 115 protected:
 116     DECLARE_NO_COPY_CLASS(wxDisplayFactoryX11)
 117 };
 118
 119 // ============================================================================
 120 // wxDisplayFactoryX11 implementation
 121 // ============================================================================
 122
 123 size_t wxDisplayFactoryX11::GetCount()
 124 {
 125     return ScreensInfo().GetCount();
 126 }
 127
 128 int wxDisplayFactoryX11::GetFromPoint(const wxPoint& p)
 129 {
 130     ScreensInfo screens;
 131
 132     const size_t numscreens(screens.GetCount());
 133     for ( size_t i = 0; i < numscreens; ++i )
 134     {
 135         const XineramaScreenInfo& s = screens[i];
 136         if ( p.x >= s.x_org && p.x < s.x_org + s.width &&
 137                 p.y >= s.y_org && p.y < s.y_org + s.height )
 138         {
 139             return i;
 140         }
 141     }
 142
 143     return wxNOT_FOUND;
 144 }
 145
 146 wxDisplayImpl *wxDisplayFactoryX11::CreateDisplay(size_t n)
 147 {
 148     ScreensInfo screens;
 149
 150     return n < screens.GetCount() ? new wxDisplayImplX11(screens[n]) : NULL;
 151 }
 152
 153 // ============================================================================
 154 // wxDisplayImplX11 implementation
 155 // ============================================================================
 156
 157 #ifdef HAVE_X11_EXTENSIONS_XF86VMODE_H
 158
 159 //
 160 //  See (http://www.xfree86.org/4.2.0/XF86VidModeDeleteModeLine.3.html) for more
 161 //  info about xf86 video mode extensions
 162 //
 163
 164 //free private data common to x (usually s3) servers
 165 #define wxClearXVM(vm)  if(vm.privsize) XFree(vm.c_private)
 166
 167 // Correct res rate from GLFW
 168 #define wxCRR2(v,dc) (int) (((1000.0f * (float) dc) /*PIXELS PER SECOND */) / ((float) v.htotal * v.vtotal /*PIXELS PER FRAME*/) + 0.5f)
 169 #define wxCRR(v) wxCRR2(v,v.dotclock)
 170 #define wxCVM2(v, dc) wxVideoMode(v.hdisplay, v.vdisplay, DefaultDepth((Display*)wxGetDisplay(), DefaultScreen((Display*)wxGetDisplay())), wxCRR2(v,dc))
 171 #define wxCVM(v) wxCVM2(v, v.dotclock)
 172
 173 wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& mode) const
 174 {
 175     //Convenience...
 176     Display* pDisplay = (Display*) wxGetDisplay(); //default display
 177     int nScreen = DefaultScreen(pDisplay); //default screen of (default) display...
 178
 179     //Some variables..
 180     XF86VidModeModeInfo** ppXModes; //Enumerated Modes (Don't forget XFree() :))
 181     int nNumModes; //Number of modes enumerated....
 182
 183     wxArrayVideoModes Modes; //modes to return...
 184
 185     if (XF86VidModeGetAllModeLines(pDisplay, nScreen, &nNumModes, &ppXModes) == TRUE)
 186     {
 187         for (int i = 0; i < nNumModes; ++i)
 188         {
 189             if (mode == wxDefaultVideoMode || //According to display.h All modes valid if dafault mode...
 190                 mode.Matches(wxCVM((*ppXModes[i]))) ) //...?
 191             {
 192                 Modes.Add(wxCVM((*ppXModes[i])));
 193             }
 194             wxClearXVM((*ppXModes[i]));
 195         //  XFree(ppXModes[i]); //supposed to free?
 196         }
 197         XFree(ppXModes);
 198     }
 199     else //OOPS!
 200     {
 201         wxLogSysError(_("Failed to enumerate video modes"));
 202     }
 203
 204     return Modes;
 205 }
 206
 207 wxVideoMode wxDisplay::GetCurrentMode() const
 208 {
 209   XF86VidModeModeLine VM;
 210   int nDotClock;
 211   XF86VidModeGetModeLine((Display*)wxGetDisplay(), DefaultScreen((Display*)wxGetDisplay()),
 212                          &nDotClock, &VM);
 213   wxClearXVM(VM);
 214   return wxCVM2(VM, nDotClock);
 215 }
 216
 217 bool wxDisplay::ChangeMode(const wxVideoMode& mode)
 218 {
 219     XF86VidModeModeInfo** ppXModes; //Enumerated Modes (Don't forget XFree() :))
 220     int nNumModes; //Number of modes enumerated....
 221
 222     if( !XF86VidModeGetAllModeLines((Display*)wxGetDisplay(), DefaultScreen((Display*)wxGetDisplay()), &nNumModes, &ppXModes) )
 223     {
 224         wxLogSysError(_("Failed to change video mode"));
 225         return false;
 226     }
 227
 228     bool bRet = false;
 229     if (mode == wxDefaultVideoMode)
 230     {
 231         bRet = XF86VidModeSwitchToMode((Display*)wxGetDisplay(), DefaultScreen((Display*)wxGetDisplay()),
 232                      ppXModes[0]) == TRUE;
 233
 234         for (int i = 0; i < nNumModes; ++i)
 235         {
 236             wxClearXVM((*ppXModes[i]));
 237         //  XFree(ppXModes[i]); //supposed to free?
 238         }
 239     }
 240     else
 241     {
 242         for (int i = 0; i < nNumModes; ++i)
 243         {
 244             if (!bRet &&
 245                 ppXModes[i]->hdisplay == mode.w &&
 246                 ppXModes[i]->vdisplay == mode.h &&
 247                 wxCRR((*ppXModes[i])) == mode.refresh)
 248             {
 249                 //switch!
 250                 bRet = XF86VidModeSwitchToMode((Display*)wxGetDisplay(), DefaultScreen((Display*)wxGetDisplay()),
 251                          ppXModes[i]) == TRUE;
 252             }
 253             wxClearXVM((*ppXModes[i]));
 254         //  XFree(ppXModes[i]); //supposed to free?
 255         }
 256     }
 257
 258     XFree(ppXModes);
 259
 260     return bRet;
 261 }
 262
 263
 264 #else // !HAVE_X11_EXTENSIONS_XF86VMODE_H
 265
 266 wxArrayVideoModes wxDisplay::GetModes(const wxVideoMode& mode) const
 267 {
 268     int count_return;
 269     int* depths = XListDepths((Display*)wxGetDisplay(), 0, &count_return);
 270     wxArrayVideoModes modes;
 271     if ( depths )
 272     {
 273         for ( int x = 0; x < count_return; ++x )
 274         {
 275             modes.Add(wxVideoMode(m_rect.GetWidth(), m_rect.GetHeight(), depths[x]));
 276         }
 277
 278         XFree(depths);
 279     }
 280     return modes;
 281 }
 282
 283 wxVideoMode wxDisplay::GetCurrentMode() const
 284 {
 285     // Not implemented
 286     return wxVideoMode();
 287 }
 288
 289 bool wxDisplay::ChangeMode(const wxVideoMode& mode)
 290 {
 291     // Not implemented
 292     return false;
 293 }
 294
 295 #endif // !HAVE_X11_EXTENSIONS_XF86VMODE_H
 296
 297 // ============================================================================
 298 // wxDisplay::CreateFactory()
 299 // ============================================================================
 300
 301 /* static */ wxDisplayFactory *wxDisplay::CreateFactory()
 302 {
 303     Display *disp = (Display*)wxGetDisplay();
 304
 305     return XineramaIsActive(disp) ? new wxDisplayFactoryX11
 306                                   : new wxDisplayFactorySingle;
 307 }
 308
 309 #endif /* wxUSE_DISPLAY */