opengl: Move wgl font code to winex11.drv.
[wine] / dlls / winex11.drv / x11drv_main.c
1 /*
2  * X11DRV initialization code
3  *
4  * Copyright 1998 Patrik Stridvall
5  * Copyright 2000 Alexandre Julliard
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include "config.h"
23
24 #include <fcntl.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #ifdef HAVE_SYS_TIME_H
30 # include <sys/time.h>
31 #endif
32 #ifdef HAVE_UNISTD_H
33 # include <unistd.h>
34 #endif
35 #include <X11/cursorfont.h>
36 #include <X11/Xlib.h>
37 #ifdef HAVE_XKB
38 #include <X11/XKBlib.h>
39 #endif
40 #ifdef HAVE_X11_EXTENSIONS_XRENDER_H
41 #include <X11/extensions/Xrender.h>
42 #endif
43
44 #include "windef.h"
45 #include "winbase.h"
46 #include "wine/winbase16.h"
47 #include "winreg.h"
48
49 #include "x11drv.h"
50 #include "xvidmode.h"
51 #include "xrandr.h"
52 #include "wine/server.h"
53 #include "wine/debug.h"
54
55 WINE_DEFAULT_DEBUG_CHANNEL(x11drv);
56 WINE_DECLARE_DEBUG_CHANNEL(synchronous);
57
58 static CRITICAL_SECTION X11DRV_CritSection;
59 static CRITICAL_SECTION_DEBUG critsect_debug =
60 {
61     0, 0, &X11DRV_CritSection,
62     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
63       0, 0, { (DWORD_PTR)(__FILE__ ": X11DRV_CritSection") }
64 };
65 static CRITICAL_SECTION X11DRV_CritSection = { &critsect_debug, -1, 0, 0, 0, 0 };
66
67 Screen *screen;
68 Visual *visual;
69 unsigned int screen_width;
70 unsigned int screen_height;
71 unsigned int screen_depth;
72 Window root_window;
73 int dxgrab = 0;
74 int usexvidmode = 1;
75 int usexrandr = 1;
76 int use_xkb = 1;
77 int use_take_focus = 1;
78 int use_primary_selection = 0;
79 int managed_mode = 1;
80 int private_color_map = 0;
81 int client_side_with_core = 1;
82 int client_side_with_render = 1;
83 int client_side_antialias_with_core = 1;
84 int client_side_antialias_with_render = 1;
85 int copy_default_colors = 128;
86 int alloc_system_colors = 256;
87 DWORD thread_data_tls_index = TLS_OUT_OF_INDEXES;
88 int xrender_error_base = 0;
89
90 static BOOL desktop_dbl_buf = TRUE;
91
92 static x11drv_error_callback err_callback;   /* current callback for error */
93 static Display *err_callback_display;        /* display callback is set for */
94 static void *err_callback_arg;               /* error callback argument */
95 static int err_callback_result;              /* error callback result */
96 static unsigned long err_serial;             /* serial number of first request */
97 static int (*old_error_handler)( Display *, XErrorEvent * );
98 static int use_xim = 1;
99 static char input_style[20];
100
101 #define IS_OPTION_TRUE(ch) \
102     ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
103 #define IS_OPTION_FALSE(ch) \
104     ((ch) == 'n' || (ch) == 'N' || (ch) == 'f' || (ch) == 'F' || (ch) == '0')
105
106 Atom X11DRV_Atoms[NB_XATOMS - FIRST_XATOM];
107
108 static const char * const atom_names[NB_XATOMS - FIRST_XATOM] =
109 {
110     "CLIPBOARD",
111     "COMPOUND_TEXT",
112     "MULTIPLE",
113     "SELECTION_DATA",
114     "TARGETS",
115     "TEXT",
116     "UTF8_STRING",
117     "RAW_ASCENT",
118     "RAW_DESCENT",
119     "RAW_CAP_HEIGHT",
120     "WM_PROTOCOLS",
121     "WM_DELETE_WINDOW",
122     "WM_TAKE_FOCUS",
123     "KWM_DOCKWINDOW",
124     "DndProtocol",
125     "DndSelection",
126     "_MOTIF_WM_HINTS",
127     "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR",
128     "_NET_SYSTEM_TRAY_OPCODE",
129     "_NET_SYSTEM_TRAY_S0",
130     "_NET_WM_MOVERESIZE",
131     "_NET_WM_NAME",
132     "_NET_WM_PID",
133     "_NET_WM_PING",
134     "_NET_WM_STATE",
135     "_NET_WM_STATE_FULLSCREEN",
136     "_NET_WM_WINDOW_TYPE",
137     "_NET_WM_WINDOW_TYPE_UTILITY",
138     "_XEMBED_INFO",
139     "XdndAware",
140     "XdndEnter",
141     "XdndPosition",
142     "XdndStatus",
143     "XdndLeave",
144     "XdndFinished",
145     "XdndDrop",
146     "XdndActionCopy",
147     "XdndActionMove",
148     "XdndActionLink",
149     "XdndActionAsk",
150     "XdndActionPrivate",
151     "XdndSelection",
152     "XdndTarget",
153     "XdndTypeList",
154     "WCF_DIB",
155     "image/gif",
156     "text/html",
157     "text/plain",
158     "text/rtf",
159     "text/richtext"
160 };
161
162 /***********************************************************************
163  *              ignore_error
164  *
165  * Check if the X error is one we can ignore.
166  */
167 static inline BOOL ignore_error( Display *display, XErrorEvent *event )
168 {
169     if (event->request_code == X_SetInputFocus && event->error_code == BadMatch) return TRUE;
170
171     /* ignore a number of errors on gdi display caused by creating/destroying windows */
172     if (display == gdi_display)
173     {
174         if (event->error_code == BadDrawable || event->error_code == BadGC) return TRUE;
175 #ifdef HAVE_X11_EXTENSIONS_XRENDER_H
176         if (xrender_error_base)  /* check for XRender errors */
177         {
178             if (event->error_code == xrender_error_base + BadPicture) return TRUE;
179         }
180 #endif
181     }
182     return FALSE;
183 }
184
185
186 /***********************************************************************
187  *              X11DRV_expect_error
188  *
189  * Setup a callback function that will be called on an X error.  The
190  * callback must return non-zero if the error is the one it expected.
191  * This function acquires the x11 lock; X11DRV_check_error must be
192  * called in all cases to release it.
193  */
194 void X11DRV_expect_error( Display *display, x11drv_error_callback callback, void *arg )
195 {
196     wine_tsx11_lock();
197     err_callback         = callback;
198     err_callback_display = display;
199     err_callback_arg     = arg;
200     err_callback_result  = 0;
201     err_serial           = NextRequest(display);
202 }
203
204
205 /***********************************************************************
206  *              X11DRV_check_error
207  *
208  * Check if an expected X11 error occurred; return non-zero if yes.
209  * Also release the x11 lock obtained in X11DRV_expect_error.
210  * The caller is responsible for calling XSync first if necessary.
211  */
212 int X11DRV_check_error(void)
213 {
214     int ret;
215     err_callback = NULL;
216     ret = err_callback_result;
217     wine_tsx11_unlock();
218     return ret;
219 }
220
221
222 /***********************************************************************
223  *              error_handler
224  */
225 static int error_handler( Display *display, XErrorEvent *error_evt )
226 {
227     if (err_callback && display == err_callback_display &&
228         (long)(error_evt->serial - err_serial) >= 0)
229     {
230         if ((err_callback_result = err_callback( display, error_evt, err_callback_arg )))
231         {
232             TRACE( "got expected error %d req %d\n",
233                    error_evt->error_code, error_evt->request_code );
234             return 0;
235         }
236     }
237     if (ignore_error( display, error_evt ))
238     {
239         TRACE( "got ignored error %d req %d\n",
240                error_evt->error_code, error_evt->request_code );
241         return 0;
242     }
243     if (TRACE_ON(synchronous))
244     {
245         ERR( "X protocol error: serial=%ld, request_code=%d - breaking into debugger\n",
246              error_evt->serial, error_evt->request_code );
247         DebugBreak();  /* force an entry in the debugger */
248     }
249     old_error_handler( display, error_evt );
250     return 0;
251 }
252
253 /***********************************************************************
254  *              wine_tsx11_lock   (X11DRV.@)
255  */
256 void wine_tsx11_lock(void)
257 {
258     EnterCriticalSection( &X11DRV_CritSection );
259 }
260
261 /***********************************************************************
262  *              wine_tsx11_unlock   (X11DRV.@)
263  */
264 void wine_tsx11_unlock(void)
265 {
266     LeaveCriticalSection( &X11DRV_CritSection );
267 }
268
269
270 /***********************************************************************
271  *              get_config_key
272  *
273  * Get a config key from either the app-specific or the default config
274  */
275 inline static DWORD get_config_key( HKEY defkey, HKEY appkey, const char *name,
276                                     char *buffer, DWORD size )
277 {
278     if (appkey && !RegQueryValueExA( appkey, name, 0, NULL, (LPBYTE)buffer, &size )) return 0;
279     if (defkey && !RegQueryValueExA( defkey, name, 0, NULL, (LPBYTE)buffer, &size )) return 0;
280     return ERROR_FILE_NOT_FOUND;
281 }
282
283
284 /***********************************************************************
285  *              setup_options
286  *
287  * Setup the x11drv options.
288  */
289 static void setup_options(void)
290 {
291     char buffer[MAX_PATH+16];
292     HKEY hkey, appkey = 0;
293     DWORD len;
294
295     /* @@ Wine registry key: HKCU\Software\Wine\X11 Driver */
296     if (RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\X11 Driver", &hkey )) hkey = 0;
297
298     /* open the app-specific key */
299
300     len = (GetModuleFileNameA( 0, buffer, MAX_PATH ));
301     if (len && len < MAX_PATH)
302     {
303         HKEY tmpkey;
304         char *p, *appname = buffer;
305         if ((p = strrchr( appname, '/' ))) appname = p + 1;
306         if ((p = strrchr( appname, '\\' ))) appname = p + 1;
307         strcat( appname, "\\X11 Driver" );
308         /* @@ Wine registry key: HKCU\Software\Wine\AppDefaults\app.exe\X11 Driver */
309         if (!RegOpenKeyA( HKEY_CURRENT_USER, "Software\\Wine\\AppDefaults", &tmpkey ))
310         {
311             if (RegOpenKeyA( tmpkey, appname, &appkey )) appkey = 0;
312             RegCloseKey( tmpkey );
313         }
314     }
315
316     if (!get_config_key( hkey, appkey, "Managed", buffer, sizeof(buffer) ))
317         managed_mode = IS_OPTION_TRUE( buffer[0] );
318
319     if (!get_config_key( hkey, appkey, "DXGrab", buffer, sizeof(buffer) ))
320         dxgrab = IS_OPTION_TRUE( buffer[0] );
321
322     if (!get_config_key( hkey, appkey, "UseXVidMode", buffer, sizeof(buffer) ))
323         usexvidmode = IS_OPTION_TRUE( buffer[0] );
324
325     if (!get_config_key( hkey, appkey, "UseXRandR", buffer, sizeof(buffer) ))
326         usexrandr = IS_OPTION_TRUE( buffer[0] );
327
328     if (!get_config_key( hkey, appkey, "UseTakeFocus", buffer, sizeof(buffer) ))
329         use_take_focus = IS_OPTION_TRUE( buffer[0] );
330
331     if (!get_config_key( hkey, appkey, "UsePrimarySelection", buffer, sizeof(buffer) ))
332         use_primary_selection = IS_OPTION_TRUE( buffer[0] );
333
334     screen_depth = 0;
335     if (!get_config_key( hkey, appkey, "ScreenDepth", buffer, sizeof(buffer) ))
336         screen_depth = atoi(buffer);
337
338     if (!get_config_key( hkey, appkey, "ClientSideWithCore", buffer, sizeof(buffer) ))
339         client_side_with_core = IS_OPTION_TRUE( buffer[0] );
340
341     if (!get_config_key( hkey, appkey, "ClientSideWithRender", buffer, sizeof(buffer) ))
342         client_side_with_render = IS_OPTION_TRUE( buffer[0] );
343
344     if (!get_config_key( hkey, appkey, "ClientSideAntiAliasWithCore", buffer, sizeof(buffer) ))
345         client_side_antialias_with_core = IS_OPTION_TRUE( buffer[0] );
346
347     if (!get_config_key( hkey, appkey, "ClientSideAntiAliasWithRender", buffer, sizeof(buffer) ))
348         client_side_antialias_with_render = IS_OPTION_TRUE( buffer[0] );
349
350     if (!get_config_key( hkey, appkey, "DesktopDoubleBuffered", buffer, sizeof(buffer) ))
351         desktop_dbl_buf = IS_OPTION_TRUE( buffer[0] );
352
353     if (!get_config_key( hkey, appkey, "UseXIM", buffer, sizeof(buffer) ))
354         use_xim = IS_OPTION_TRUE( buffer[0] );
355
356     if (!get_config_key( hkey, appkey, "PrivateColorMap", buffer, sizeof(buffer) ))
357         private_color_map = IS_OPTION_TRUE( buffer[0] );
358
359     if (!get_config_key( hkey, appkey, "CopyDefaultColors", buffer, sizeof(buffer) ))
360         copy_default_colors = atoi(buffer);
361
362     if (!get_config_key( hkey, appkey, "AllocSystemColors", buffer, sizeof(buffer) ))
363         alloc_system_colors = atoi(buffer);
364
365     get_config_key( hkey, appkey, "InputStyle", input_style, sizeof(input_style) );
366
367     if (appkey) RegCloseKey( appkey );
368     if (hkey) RegCloseKey( hkey );
369 }
370
371
372 /***********************************************************************
373  *           X11DRV process initialisation routine
374  */
375 static BOOL process_attach(void)
376 {
377     Display *display;
378     XVisualInfo *desktop_vi = NULL;
379
380     setup_options();
381
382     if ((thread_data_tls_index = TlsAlloc()) == TLS_OUT_OF_INDEXES) return FALSE;
383
384     /* Open display */
385
386     if (!(display = XOpenDisplay( NULL ))) return FALSE;
387
388     fcntl( ConnectionNumber(display), F_SETFD, 1 ); /* set close on exec flag */
389     screen = DefaultScreenOfDisplay( display );
390     visual = DefaultVisual( display, DefaultScreen(display) );
391     root_window = DefaultRootWindow( display );
392     gdi_display = display;
393     old_error_handler = XSetErrorHandler( error_handler );
394
395     /* Initialize screen depth */
396
397     if (screen_depth)  /* depth specified */
398     {
399         int depth_count, i;
400         int *depth_list = XListDepths(display, DefaultScreen(display), &depth_count);
401         for (i = 0; i < depth_count; i++)
402             if (depth_list[i] == screen_depth) break;
403         XFree( depth_list );
404         if (i >= depth_count)
405         {
406             WARN( "invalid depth %d, using default\n", screen_depth );
407             screen_depth = 0;
408         }
409     }
410     if (!screen_depth) screen_depth = DefaultDepthOfScreen( screen );
411
412     /* If OpenGL is available, change the default visual, etc as necessary */
413     if (desktop_dbl_buf && (desktop_vi = X11DRV_setup_opengl_visual( display )))
414     {
415         visual       = desktop_vi->visual;
416         screen       = ScreenOfDisplay(display, desktop_vi->screen);
417         screen_depth = desktop_vi->depth;
418         XFree(desktop_vi);
419     }
420
421     XInternAtoms( display, (char **)atom_names, NB_XATOMS - FIRST_XATOM, False, X11DRV_Atoms );
422
423     if (TRACE_ON(synchronous)) XSynchronize( display, True );
424
425     screen_width  = WidthOfScreen( screen );
426     screen_height = HeightOfScreen( screen );
427
428     X11DRV_Settings_Init();
429
430 #ifdef HAVE_LIBXXF86VM
431     /* initialize XVidMode */
432     X11DRV_XF86VM_Init();
433 #endif
434 #ifdef HAVE_LIBXRANDR
435     /* initialize XRandR */
436     X11DRV_XRandR_Init();
437 #endif
438
439     X11DRV_InitKeyboard();
440     X11DRV_InitClipboard();
441
442     return TRUE;
443 }
444
445
446 /***********************************************************************
447  *           X11DRV thread termination routine
448  */
449 static void thread_detach(void)
450 {
451     struct x11drv_thread_data *data = TlsGetValue( thread_data_tls_index );
452
453     if (data)
454     {
455         X11DRV_ResetSelectionOwner();
456         CloseHandle( data->display_fd );
457         wine_tsx11_lock();
458         XCloseDisplay( data->display );
459         /* if (data->xim) XCloseIM( data->xim ); */ /* crashes Xlib */
460         wine_tsx11_unlock();
461         HeapFree( GetProcessHeap(), 0, data );
462     }
463 }
464
465
466 /***********************************************************************
467  *           X11DRV process termination routine
468  */
469 static void process_detach(void)
470 {
471 #ifdef HAVE_LIBXXF86VM
472     /* cleanup XVidMode */
473     X11DRV_XF86VM_Cleanup();
474 #endif
475     if(using_client_side_fonts)
476         X11DRV_XRender_Finalize();
477
478     /* cleanup GDI */
479     X11DRV_GDI_Finalize();
480
481     DeleteCriticalSection( &X11DRV_CritSection );
482     TlsFree( thread_data_tls_index );
483 }
484
485
486 /***********************************************************************
487  *           X11DRV thread initialisation routine
488  */
489 struct x11drv_thread_data *x11drv_init_thread_data(void)
490 {
491     struct x11drv_thread_data *data;
492
493     if (!(data = HeapAlloc( GetProcessHeap(), 0, sizeof(*data) )))
494     {
495         ERR( "could not create data\n" );
496         ExitProcess(1);
497     }
498     wine_tsx11_lock();
499     if (!(data->display = XOpenDisplay(NULL)))
500     {
501         wine_tsx11_unlock();
502         MESSAGE( "x11drv: Can't open display: %s\n", XDisplayName(NULL) );
503         MESSAGE( "Please ensure that your X server is running and that $DISPLAY is set correctly.\n" );
504         ExitProcess(1);
505     }
506
507     fcntl( ConnectionNumber(data->display), F_SETFD, 1 ); /* set close on exec flag */
508
509 #ifdef HAVE_XKB
510     if (use_xkb)
511     {
512         use_xkb = XkbUseExtension( data->display, NULL, NULL );
513         if (use_xkb) XkbSetDetectableAutoRepeat( data->display, True, NULL );
514     }
515 #endif
516
517     if (TRACE_ON(synchronous)) XSynchronize( data->display, True );
518     wine_tsx11_unlock();
519
520     if (use_xim && !(data->xim = X11DRV_SetupXIM( data->display, input_style )))
521         WARN("Input Method is not available\n");
522
523     if (wine_server_fd_to_handle( ConnectionNumber(data->display), GENERIC_READ | SYNCHRONIZE,
524                                   0, &data->display_fd ))
525     {
526         MESSAGE( "x11drv: Can't allocate handle for display fd\n" );
527         ExitProcess(1);
528     }
529     data->process_event_count = 0;
530     data->cursor = None;
531     data->cursor_window = None;
532     data->grab_window = None;
533     data->last_focus = 0;
534     data->selection_wnd = 0;
535     TlsSetValue( thread_data_tls_index, data );
536     return data;
537 }
538
539
540 /***********************************************************************
541  *           X11DRV initialisation routine
542  */
543 BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
544 {
545     BOOL ret = TRUE;
546
547     switch(reason)
548     {
549     case DLL_PROCESS_ATTACH:
550         ret = process_attach();
551         break;
552     case DLL_THREAD_DETACH:
553         thread_detach();
554         break;
555     case DLL_PROCESS_DETACH:
556         process_detach();
557         break;
558     }
559     return ret;
560 }
561
562 /***********************************************************************
563  *              GetScreenSaveActive (X11DRV.@)
564  *
565  * Returns the active status of the screen saver
566  */
567 BOOL X11DRV_GetScreenSaveActive(void)
568 {
569     int timeout, temp;
570     wine_tsx11_lock();
571     XGetScreenSaver(gdi_display, &timeout, &temp, &temp, &temp);
572     wine_tsx11_unlock();
573     return timeout != 0;
574 }
575
576 /***********************************************************************
577  *              SetScreenSaveActive (X11DRV.@)
578  *
579  * Activate/Deactivate the screen saver
580  */
581 void X11DRV_SetScreenSaveActive(BOOL bActivate)
582 {
583     int timeout, interval, prefer_blanking, allow_exposures;
584     static int last_timeout = 15 * 60;
585
586     wine_tsx11_lock();
587     XGetScreenSaver(gdi_display, &timeout, &interval, &prefer_blanking,
588                     &allow_exposures);
589     if (timeout) last_timeout = timeout;
590
591     timeout = bActivate ? last_timeout : 0;
592     XSetScreenSaver(gdi_display, timeout, interval, prefer_blanking,
593                     allow_exposures);
594     wine_tsx11_unlock();
595 }