Reset bigscreen on changed groups, not just changed tournaments.
[ccbs] / bigscreen / tinyptc / xdga1.c
1 /*
2  * TinyPTC x11 v0.7.3 X Direct Graphics Access Extension v1 target
3  * Copyright (C) 2000-2002 Alessandro Gatti <a.gatti@tiscali.it>
4  * 
5  * http://www.sourceforge.net/projects/tinyptc/
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 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  *
21  */
22
23 /* #includes */
24
25 #include <X11/Xlib.h>
26 #include <X11/Xutil.h>
27 #include <X11/extensions/xf86dga.h>
28 #include <X11/extensions/xf86vmode.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <limits.h>
33 #include <unistd.h>
34 #include <sys/types.h>
35 #include "tinyptc.h"
36
37 #ifdef __PTC_XDGA1__
38
39 #define __PTC_FROM_SOURCE
40
41 #include "xdga1.h"
42
43 /* Open the screen */
44
45 int
46 ptc_open (char *title, int width, int height)
47 {
48   /* Check for the effective UID of the running process */
49   if (geteuid ())
50     {
51       return PTC_FAILURE;
52     }
53   /* Open a display on the current root window */
54   ptc_display = XOpenDisplay (NULL);
55   if (ptc_display == NULL)
56     {
57       return PTC_FAILURE;
58     }
59   /* Get the default screen associated with the previously opened display */
60   ptc_screen = DefaultScreen (ptc_display);
61   /* Get the default visual */
62   ptc_visual = DefaultVisual (ptc_display, ptc_screen);
63   /* Get screen bitdepth */
64   ptc_depth = DefaultDepth (ptc_display, ptc_screen);
65   /* Get a pointer to the supported pixmap formats */
66   ptc_pixmap_formats =
67     XListPixmapFormats (ptc_display, &ptc_pixmap_format_count);
68   /* Check if there's one that's suitable */
69   for (ptc_pixmap_counter = 0; ptc_pixmap_counter < ptc_pixmap_format_count;
70        ptc_pixmap_counter++)
71     {
72       if (ptc_depth == ptc_pixmap_formats[ptc_pixmap_counter].depth)
73         {
74           /* Set the right value */
75           ptc_converter_depth =
76             ptc_pixmap_formats[ptc_pixmap_counter].bits_per_pixel;
77         }
78     }
79   XFree (ptc_pixmap_formats);
80 #ifdef __PTC_ENABLE_CONVERSIONS__
81   /* Check if a converter is avaliable */
82   ptc_convert =
83     ptc_request_converter (ptc_converter_depth, ptc_visual->red_mask,
84                            ptc_visual->green_mask, ptc_visual->blue_mask);
85   if (!ptc_convert)
86     {
87       /* Close the display */
88       XCloseDisplay (ptc_display);
89       return 0;
90     }
91   /* Get the actual bytes-per-pixel value */
92   switch (ptc_converter_depth)
93     {
94     case 8:
95       ptc_output_pitch = 1;
96       break;
97     case 15:
98       ptc_output_pitch = 2;
99       break;
100     case 16:
101       ptc_output_pitch = 2;
102       break;
103     case 24:
104       ptc_output_pitch = 3;
105       break;
106     case 32:
107       ptc_output_pitch = 4;
108       break;
109     }
110   /* Allocate the temporary buffer */
111   ptc_buffer = (char *) malloc (width * height * ptc_output_pitch);
112   if (ptc_buffer == NULL)
113     {
114       XCloseDisplay (ptc_display);
115       return PTC_FAILURE;
116     }
117 #else
118   /* It runs only on a 32bpp display if no conversions were activated */
119   if (ptc_converter_depth != 32)
120     {
121       XCloseDisplay (ptc_display);
122       return PTC_FAILURE;
123     }
124   ptc_output_pitch = sizeof (int);
125 #endif /* __PTC_ENABLE_CONVERSIONS__ */
126   /* Check for DGA extension avaliability */
127   if (!XF86DGAQueryExtension (ptc_display, &ptc_event_base, &ptc_error_base))
128     {
129       XCloseDisplay (ptc_display);
130       return PTC_FAILURE;
131     }
132   /* Get framebuffer parameters */
133   XF86DGAGetVideo (ptc_display, ptc_screen, &ptc_framebuffer_address,
134                    &ptc_framebuffer_width, &ptc_framebuffer_banksize,
135                    &ptc_framebuffer_memory);
136   /* Check if the mode is banked */
137   if (ptc_framebuffer_banksize < ptc_framebuffer_memory)
138     {
139       XCloseDisplay (ptc_display);
140       return PTC_FAILURE;
141     }
142   /* Check for VidMode extension avaliability */
143   if (!XF86VidModeQueryExtension
144       (ptc_display, &ptc_event_base, &ptc_error_base))
145     {
146       XCloseDisplay (ptc_display);
147       return PTC_FAILURE;
148     }
149   /* Get all the mode parameters */
150   XF86VidModeGetAllModeLines (ptc_display, ptc_screen, &ptc_totalmodes,
151                               &ptc_modeinfodata);
152   /* Get current mode parameters */
153   XF86VidModeGetModeLine (ptc_display, ptc_screen, &ptc_dotclock,
154                           &ptc_currentmodeline);
155   /* Search for current mode in parameter list */
156   for (ptc_modecounter = 0; ptc_modecounter < ptc_totalmodes;
157        ptc_modecounter++)
158     {
159       if ((ptc_currentmodeline.hdisplay ==
160            ptc_modeinfodata[ptc_modecounter]->hdisplay)
161           && (ptc_currentmodeline.vdisplay ==
162               ptc_modeinfodata[ptc_modecounter]->vdisplay))
163         {
164           /* Save the parameters */
165           ptc_previousmode_number = ptc_modecounter;
166           ptc_screen_width = ptc_currentmodeline.hdisplay;
167           ptc_screen_height = ptc_currentmodeline.vdisplay;
168           break;
169         }
170     }
171   ptc_emulate_fullscreen = True;
172   /* Search for desired mode in parameter list */
173   for (ptc_modecounter = 0; ptc_modecounter < ptc_totalmodes;
174        ptc_modecounter++)
175     {
176       if ((ptc_modeinfodata[ptc_modecounter]->hdisplay == width)
177           && (ptc_modeinfodata[ptc_modecounter]->vdisplay == height))
178         {
179           /* Try to switch mode */
180           if (!XF86VidModeSwitchToMode
181               (ptc_display, ptc_screen, ptc_modeinfodata[ptc_modecounter]))
182             {
183               XFree (ptc_modeinfodata);
184               XCloseDisplay (ptc_display);
185               return PTC_FAILURE;
186             }
187           ptc_emulate_fullscreen = False;
188           break;
189         }
190     }
191 #ifdef __PTC_BEST_VIDEOMODE__
192   /* It works for fullscreen emulation only */
193   if (ptc_emulate_fullscreen)
194     {
195       /* Set up loop */
196       ptc_best_delta = INT_MAX;
197       ptc_best_videomode = 0;
198       /* Check for all avaliable modes */
199       for (ptc_modecounter = 0; ptc_modecounter < ptc_totalmodes;
200            ptc_modecounter++)
201         {
202           if ((ptc_modeinfodata[ptc_modecounter]->hdisplay >= width)
203               && (ptc_modeinfodata[ptc_modecounter]->vdisplay >= height))
204             {
205               /* If it fits, get delta parameters */
206               ptc_best_x_delta =
207                 ptc_modeinfodata[ptc_modecounter]->hdisplay - width;
208               ptc_best_x_delta *= ptc_best_x_delta;
209               ptc_best_y_delta =
210                 ptc_modeinfodata[ptc_modecounter]->vdisplay - height;
211               ptc_best_y_delta *= ptc_best_y_delta;
212               /* Check if the mode was fitting better than the previous one */
213               if (ptc_best_x_delta + ptc_best_y_delta < ptc_best_delta)
214                 {
215                   /* Set up next iteration */
216                   ptc_best_delta = ptc_best_x_delta + ptc_best_y_delta;
217                   ptc_best_videomode = ptc_modecounter;
218                 }
219             }
220         }
221       /* Try to switch mode */
222       if (!XF86VidModeSwitchToMode
223           (ptc_display, ptc_screen, ptc_modeinfodata[ptc_best_videomode]))
224         {
225           XFree (ptc_modeinfodata);
226           XCloseDisplay (ptc_display);
227           return PTC_FAILURE;
228         }
229     }
230 #endif /* __PTC_BEST_VIDEOMODE__ */
231   /* Clear event queue */
232   XFlush (ptc_display);
233   /* Get the root window */
234   ptc_root_window = XRootWindow (ptc_display, ptc_screen);
235   /* Get exclusive keyboard access */
236   XGrabKeyboard (ptc_display, ptc_root_window, False, GrabModeAsync,
237                  GrabModeAsync, CurrentTime);
238   /* Get exclusive mouse access */
239   XGrabPointer (ptc_display, ptc_root_window, True,
240                 PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
241                 GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
242   /* Leave root mode */
243   setuid (getuid ());
244   /* Get viewport parameters */
245   XF86DGAGetViewPortSize (ptc_display, ptc_screen,
246                           (int *) (&ptc_screen_width),
247                           (int *) (&ptc_screen_height));
248   /* Set fullscreen emulation up */
249   if (ptc_emulate_fullscreen)
250     {
251       /* Get effective framebuffer address */
252 #ifdef __PTC_ENABLE_CONVERSIONS__
253       ptc_framebuffer_start =
254         ptc_framebuffer_width * ((ptc_screen_height - height) / 2) *
255         ptc_output_pitch +
256         ((ptc_screen_width - width) / 2) * ptc_output_pitch;
257 #else
258       ptc_framebuffer_start =
259         ptc_framebuffer_width * ((ptc_screen_height - height) / 2) *
260         sizeof (int) + ((ptc_screen_width - width) / 2) * sizeof (int);
261 #endif /* __PTC_ENABLE_CONVERSIONS__ */
262     }
263   else
264     {
265       /* Ignore offsets */
266       ptc_framebuffer_start = 0;
267     }
268   /* Get the pitch value */
269   ptc_framebuffer_pitch = ptc_framebuffer_width * ptc_output_pitch;
270   /* Do a safety fork */
271   if (XF86DGAForkApp (ptc_screen))
272     {
273       /* Exit DGA mode */
274       XF86DGADirectVideo (ptc_display, ptc_screen, False);
275       /* Switch back to the previous video mode */
276       XF86VidModeSwitchToMode (ptc_display, ptc_screen,
277                                ptc_modeinfodata[ptc_previousmode_number]);
278       /* Free modeinfo data */
279       XFree (ptc_modeinfodata);
280       /* Leave exclusive keyboard access */
281       XUngrabKeyboard (ptc_display, CurrentTime);
282       /* Leave exclusive mouse access */
283       XUngrabPointer (ptc_display, CurrentTime);
284       /* Close the display */
285       XCloseDisplay (ptc_display);
286       return PTC_FAILURE;
287     }
288   /* Initialize DGA video access */
289   XF86DGADirectVideo (ptc_display, ptc_screen,
290                       XF86DGADirectGraphics | XF86DGADirectKeyb |
291                       XF86DGADirectMouse);
292   /* Clear the screen */
293   memset (ptc_framebuffer_address, 0x00,
294           ptc_framebuffer_width * ptc_screen_height * ptc_output_pitch);
295   /* Select the input events that should be reported */
296   XSelectInput (ptc_display, DefaultRootWindow (ptc_display),
297                 KeyPressMask | KeyReleaseMask);
298   /* Set the final viewport */
299   XF86DGASetViewPort (ptc_display, ptc_screen, 0, 0);
300   /* Clear event queue */
301   XFlush (ptc_display);
302   /* Save the buffer size */
303   ptc_viewport_width = width;
304   ptc_viewport_height = height;
305   return PTC_SUCCESS;
306 }
307
308 /* Update the screen */
309
310 int
311 ptc_update (void *buffer)
312 {
313   char *ptc_buffer;
314
315   ptc_buffer=(char *)buffer;
316   ptc_framebuffer_index = 0;
317 #ifdef __PTC_ENABLE_CONVERSIONS__
318   ptc_source_index = 0;
319   ptc_destination_index = 0;
320 #endif /* __PTC_ENABLE_CONVERSIONS__ */
321   /* Do the blit line by line */
322   for (ptc_blitcounter = 0; ptc_blitcounter < ptc_viewport_height;
323        ptc_blitcounter++)
324     {
325 #ifdef __PTC_ENABLE_CONVERSIONS__
326       /* Conversion */
327       ptc_convert (ptc_buffer + ptc_source_index,
328                    ptc_framebuffer_address + ptc_framebuffer_start +
329                    ptc_destination_index, ptc_viewport_width);
330       /* Pointers update */
331       ptc_source_index += ptc_viewport_width * sizeof (int);
332       ptc_destination_index += ptc_framebuffer_pitch;
333 #else
334       /* Copy the data */
335       memcpy (ptc_framebuffer_address + ptc_framebuffer_start +
336               ptc_framebuffer_index, ptc_buffer,
337               ptc_viewport_width * sizeof (int));
338       ptc_buffer += ptc_viewport_width * sizeof (int);
339       /* Set up offsets */
340       ptc_framebuffer_index += ptc_framebuffer_pitch;
341 #endif /* __PTC_ENABLE_CONVERSIONS__ */
342     }
343   /* Process incoming events */
344   if (ptc_process_events ())
345     {
346 #ifdef __PTC_CLEANUP_CALLBACK__
347       ptc_cleanup_callback ();
348 #endif /* __PTC_CLEANUP_CALLBACK__ */
349       ptc_close ();
350       exit (0);
351     }
352   return PTC_SUCCESS;
353 }
354
355 /* Process events */
356
357 int
358 ptc_process_events (void)
359 {
360   XEvent ptc_xevent;
361   KeySym ptc_keysym;
362   /* Check if there are events waiting in the display's queue */
363   if (XPending (ptc_display))
364     {
365       /* Get the next event in queue */
366       XNextEvent (ptc_display, &ptc_xevent);
367       /* Check if it's a keypress event */
368       if (ptc_xevent.type == KeyPress)
369         {
370           /* Get the keysym */
371           ptc_keysym = XLookupKeysym (&ptc_xevent.xkey, 0);
372           /* Check if the key pressed was a function one */
373           if ((ptc_keysym >> 8) == __PTC_FUNCTION_KEY__)
374             {
375               /* Check if it was the escape key */
376               if ((ptc_keysym & 0xFF) == __PTC_ESCAPE_KEY__)
377                 {
378                   return PTC_SUCCESS;
379                 }
380             }
381         }
382     }
383   return PTC_FAILURE;
384 }
385
386 /* Close the screen */
387
388 void
389 ptc_close (void)
390 {
391   /* Exit from DGA mode */
392   XF86DGADirectVideo (ptc_display, ptc_screen, False);
393   /* Switch back to the previous video mode */
394   XF86VidModeSwitchToMode (ptc_display, ptc_screen,
395                            ptc_modeinfodata[ptc_previousmode_number]);
396   /* Free modeinfo data */
397   XFree (ptc_modeinfodata);
398   /* Leave exclusive keyboard access */
399   XUngrabKeyboard (ptc_display, CurrentTime);
400   /* Leave exclusive mouse access */
401   XUngrabPointer (ptc_display, CurrentTime);
402   /* Close the display */
403   XCloseDisplay (ptc_display);
404   /* Deallocate the buffer */
405   if (ptc_buffer)
406     {
407       free (ptc_buffer);
408     }
409 }
410
411 #endif /* __PTC_XDGA1__ */