dbghelp: While loading MSC debug info, don't handle public symbol at once, but delay...
[wine] / dlls / winex11.drv / xinerama.c
1 /*
2  * Xinerama support
3  *
4  * Copyright 2006 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdarg.h>
25 #include <stdlib.h>
26 #include <X11/Xlib.h>
27 #ifdef HAVE_X11_EXTENSIONS_XINERAMA_H
28 #include <X11/extensions/Xinerama.h>
29 #endif
30 #include "wine/library.h"
31 #include "x11drv.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
35
36 static MONITORINFOEXW default_monitor =
37 {
38     sizeof(default_monitor),    /* cbSize */
39     { 0, 0, 0, 0 },             /* rcMonitor */
40     { 0, 0, 0, 0 },             /* rcWork */
41     MONITORINFOF_PRIMARY,       /* dwFlags */
42     { '\\','\\','.','\\','D','I','S','P','L','A','Y','1',0 }   /* szDevice */
43 };
44
45 static MONITORINFOEXW *monitors;
46 static int nb_monitors;
47
48 static inline MONITORINFOEXW *get_primary(void)
49 {
50     /* default to 0 if specified primary is invalid */
51     int idx = primary_monitor;
52     if (idx >= nb_monitors) idx = 0;
53     return &monitors[idx];
54 }
55
56 static inline HMONITOR index_to_monitor( int index )
57 {
58     return (HMONITOR)(UINT_PTR)(index + 1);
59 }
60
61 static inline int monitor_to_index( HMONITOR handle )
62 {
63     UINT_PTR index = (UINT_PTR)handle;
64     if (index < 1 || index > nb_monitors) return -1;
65     return index - 1;
66 }
67
68
69 #ifdef SONAME_LIBXINERAMA
70
71 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
72
73 MAKE_FUNCPTR(XineramaQueryExtension);
74 MAKE_FUNCPTR(XineramaQueryScreens);
75
76 static void load_xinerama(void)
77 {
78     void *handle;
79
80     if (!(handle = wine_dlopen(SONAME_LIBXINERAMA, RTLD_NOW, NULL, 0)))
81     {
82         WARN( "failed to open %s\n", SONAME_LIBXINERAMA );
83         return;
84     }
85     pXineramaQueryExtension = wine_dlsym( handle, "XineramaQueryExtension", NULL, 0 );
86     if (!pXineramaQueryExtension) WARN( "XineramaQueryScreens not found\n" );
87     pXineramaQueryScreens = wine_dlsym( handle, "XineramaQueryScreens", NULL, 0 );
88     if (!pXineramaQueryScreens) WARN( "XineramaQueryScreens not found\n" );
89 }
90
91 static int query_screens(void)
92 {
93     int i, count, event_base, error_base;
94     XineramaScreenInfo *screens;
95
96     if (!monitors)  /* first time around */
97         load_xinerama();
98
99     if (!pXineramaQueryExtension || !pXineramaQueryScreens ||
100         !pXineramaQueryExtension( gdi_display, &event_base, &error_base ) ||
101         !(screens = pXineramaQueryScreens( gdi_display, &count ))) return 0;
102
103     if (monitors != &default_monitor) HeapFree( GetProcessHeap(), 0, monitors );
104     if ((monitors = HeapAlloc( GetProcessHeap(), 0, count * sizeof(*monitors) )))
105     {
106         nb_monitors = count;
107         for (i = 0; i < nb_monitors; i++)
108         {
109             monitors[i].cbSize = sizeof( monitors[i] );
110             monitors[i].rcMonitor.left   = screens[i].x_org;
111             monitors[i].rcMonitor.top    = screens[i].y_org;
112             monitors[i].rcMonitor.right  = screens[i].x_org + screens[i].width;
113             monitors[i].rcMonitor.bottom = screens[i].y_org + screens[i].height;
114             monitors[i].rcWork           = monitors[i].rcMonitor;
115             monitors[i].dwFlags          = 0;
116             /* FIXME: using the same device name for all monitors for now */
117             lstrcpyW( monitors[i].szDevice, default_monitor.szDevice );
118         }
119
120         get_primary()->dwFlags |= MONITORINFOF_PRIMARY;
121     }
122     else count = 0;
123
124     XFree( screens );
125     return count;
126 }
127
128 #else  /* SONAME_LIBXINERAMA */
129
130 static inline int query_screens(void)
131 {
132     return 0;
133 }
134
135 #endif  /* SONAME_LIBXINERAMA */
136
137 void xinerama_init( unsigned int width, unsigned int height )
138 {
139     MONITORINFOEXW *primary;
140     int i;
141     RECT rect;
142
143     wine_tsx11_lock();
144
145     SetRect( &rect, 0, 0, width, height );
146
147     if (root_window != DefaultRootWindow( gdi_display ) || !query_screens())
148     {
149         default_monitor.rcWork = default_monitor.rcMonitor = rect;
150         nb_monitors = 1;
151         monitors = &default_monitor;
152     }
153
154     primary = get_primary();
155
156     /* coordinates (0,0) have to point to the primary monitor origin */
157     OffsetRect( &rect, -primary->rcMonitor.left, -primary->rcMonitor.top );
158     for (i = 0; i < nb_monitors; i++)
159     {
160         OffsetRect( &monitors[i].rcMonitor, rect.left, rect.top );
161         OffsetRect( &monitors[i].rcWork, rect.left, rect.top );
162         TRACE( "monitor %p: %s%s\n",
163                index_to_monitor(i), wine_dbgstr_rect(&monitors[i].rcMonitor),
164                (monitors[i].dwFlags & MONITORINFOF_PRIMARY) ? " (primary)" : "" );
165     }
166
167     virtual_screen_rect = rect;
168     screen_width = primary->rcMonitor.right - primary->rcMonitor.left;
169     screen_height = primary->rcMonitor.bottom - primary->rcMonitor.top;
170     TRACE( "virtual size: %s primary size: %dx%d\n",
171            wine_dbgstr_rect(&rect), screen_width, screen_height );
172
173     wine_tsx11_unlock();
174     ClipCursor( NULL );  /* reset the cursor clip rectangle */
175 }
176
177
178 /***********************************************************************
179  *              X11DRV_GetMonitorInfo  (X11DRV.@)
180  */
181 BOOL X11DRV_GetMonitorInfo( HMONITOR handle, LPMONITORINFO info )
182 {
183     int i = monitor_to_index( handle );
184
185     if (i == -1)
186     {
187         SetLastError( ERROR_INVALID_HANDLE );
188         return FALSE;
189     }
190     info->rcMonitor = monitors[i].rcMonitor;
191     info->rcWork = monitors[i].rcWork;
192     info->dwFlags = monitors[i].dwFlags;
193     if (info->cbSize >= sizeof(MONITORINFOEXW))
194         lstrcpyW( ((MONITORINFOEXW *)info)->szDevice, monitors[i].szDevice );
195     return TRUE;
196 }
197
198
199 /***********************************************************************
200  *              X11DRV_EnumDisplayMonitors  (X11DRV.@)
201  */
202 BOOL X11DRV_EnumDisplayMonitors( HDC hdc, LPRECT rect, MONITORENUMPROC proc, LPARAM lp )
203 {
204     int i;
205
206     if (hdc)
207     {
208         POINT origin;
209         RECT limit;
210
211         if (!GetDCOrgEx( hdc, &origin )) return FALSE;
212         if (GetClipBox( hdc, &limit ) == ERROR) return FALSE;
213
214         if (rect && !IntersectRect( &limit, &limit, rect )) return TRUE;
215
216         for (i = 0; i < nb_monitors; i++)
217         {
218             RECT monrect = monitors[i].rcMonitor;
219             OffsetRect( &monrect, -origin.x, -origin.y );
220             if (IntersectRect( &monrect, &monrect, &limit ))
221                 if (!proc( index_to_monitor(i), hdc, &monrect, lp ))
222                     return FALSE;
223         }
224     }
225     else
226     {
227         for (i = 0; i < nb_monitors; i++)
228         {
229             RECT unused;
230             if (!rect || IntersectRect( &unused, &monitors[i].rcMonitor, rect ))
231                 if (!proc( index_to_monitor(i), 0, &monitors[i].rcMonitor, lp ))
232                     return FALSE;
233         }
234     }
235     return TRUE;
236 }