Reset bigscreen on changed groups, not just changed tournaments.
[ccbs] / bigscreen / tinyptc / xshm.c
1 /*
2  * TinyPTC x11 v0.7.3 X Shared Memory Extension 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/XShm.h>
28 #include <sys/ipc.h>
29 #include <sys/shm.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <limits.h>
34 #include "tinyptc.h"
35
36 #ifdef __PTC_XSHM__
37
38 #define __PTC_FROM_SOURCE
39
40 #include "xshm.h"
41
42 /* Open the screen */
43
44 int
45 ptc_open (char *title, int width, int height)
46 {
47   /* Open a display on the current root window */
48   ptc_display = XOpenDisplay (NULL);
49   if (ptc_display == NULL)
50     {
51       return PTC_FAILURE;
52     }
53   /* Get the default screen associated with the previously opened display */
54   ptc_screen = DefaultScreen (ptc_display);
55   /* Get the default visual */
56   ptc_visual = DefaultVisual (ptc_display, ptc_screen);
57   /* Get screen bitdepth */
58   ptc_depth = DefaultDepth (ptc_display, ptc_screen);
59   /* Get a pointer to the supported pixmap formats */
60   ptc_pixmap_formats =
61     XListPixmapFormats (ptc_display, &ptc_pixmap_format_count);
62   /* Check if there's one that's suitable */
63   for (ptc_pixmap_counter = 0; ptc_pixmap_counter < ptc_pixmap_format_count;
64        ptc_pixmap_counter++)
65     {
66       if (ptc_depth == ptc_pixmap_formats[ptc_pixmap_counter].depth)
67         {
68           /* Set the right value */
69           ptc_converter_depth =
70             ptc_pixmap_formats[ptc_pixmap_counter].bits_per_pixel;
71         }
72     }
73   XFree (ptc_pixmap_formats);
74 #ifdef __PTC_ENABLE_CONVERSIONS__
75   /* Check if a converter is avaliable */
76   ptc_convert =
77     ptc_request_converter (ptc_converter_depth, ptc_visual->red_mask,
78                            ptc_visual->green_mask, ptc_visual->blue_mask);
79   if (!ptc_convert)
80     {
81       /* Close the display */
82       XCloseDisplay (ptc_display);
83       return 0;
84     }
85   /* Get the actual bytes-per-pixel value */
86   switch (ptc_converter_depth)
87     {
88     case 8:
89       ptc_output_pitch = 1;
90       break;
91     case 15:
92       ptc_output_pitch = 2;
93       break;
94     case 16:
95       ptc_output_pitch = 2;
96       break;
97     case 24:
98       ptc_output_pitch = 3;
99       break;
100     case 32:
101       ptc_output_pitch = 4;
102       break;
103     }
104   /* Allocate the temporary buffer */
105   ptc_buffer = (char *) malloc (width * height * ptc_output_pitch);
106   if (ptc_buffer == NULL)
107     {
108       XCloseDisplay (ptc_display);
109       return PTC_FAILURE;
110     }
111 #else
112   /* It runs only on a 32bpp display if no conversions were activated */
113   if (ptc_converter_depth != 32)
114     {
115       XCloseDisplay (ptc_display);
116       return PTC_FAILURE;
117     }
118 #endif /* __PTC_ENABLE_CONVERSIONS__ */
119   /* Check for XShm extension */
120   if (!XShmQueryExtension (ptc_display))
121     {
122       XCloseDisplay (ptc_display);
123       return PTC_FAILURE;
124     }
125   /* Get screen dimensions */
126   ptc_screen_width = DisplayWidth (ptc_display, ptc_screen);
127   ptc_screen_height = DisplayHeight (ptc_display, ptc_screen);
128   /* Get the default root window */
129   ptc_root_window = DefaultRootWindow (ptc_display);
130   /* Initialize window's attribute structure */
131   ptc_window_attributes.border_pixel = BlackPixel (ptc_display, ptc_screen);
132   ptc_window_attributes.background_pixel =
133     BlackPixel (ptc_display, ptc_screen);
134   ptc_window_attributes.backing_store = NotUseful;
135 #ifdef __PTC_CENTER_WINDOW__
136   /* Center the window on the screen */
137   ptc_x_position = (ptc_screen_width - width) / 2;
138   ptc_y_position = (ptc_screen_height - height) / 2;
139 #else
140   /* Dock the window on the top-left corner */
141   ptc_x_position = 0;
142   ptc_y_position = 0;
143 #endif /* __PTC_CENTER_WINDOW__ */
144   /* Create the window */
145   ptc_window =
146     XCreateWindow (ptc_display, ptc_root_window, ptc_x_position,
147                    ptc_y_position, width, height, 0, ptc_depth, InputOutput,
148                    ptc_visual, CWBackPixel | CWBorderPixel | CWBackingStore,
149                    &ptc_window_attributes);
150   /* Set the window's name */
151   XStoreName (ptc_display, ptc_window, title);
152   /* Tell the server to report only keypress-related events */
153   XSelectInput (ptc_display, ptc_window, KeyPressMask | KeyReleaseMask);
154   /* Initialize window's sizehint definition structure */
155   ptc_window_sizehints.flags = PPosition | PMinSize | PMaxSize;
156   ptc_window_sizehints.x = 0;
157   ptc_window_sizehints.y = 0;
158   ptc_window_sizehints.min_width = width;
159   ptc_window_sizehints.max_width = width;
160   ptc_window_sizehints.min_height = height;
161   ptc_window_sizehints.max_height = height;
162   /* Set the window's sizehint */
163   XSetWMNormalHints (ptc_display, ptc_window, &ptc_window_sizehints);
164   /* Clear the window */
165   XClearWindow (ptc_display, ptc_window);
166   /* Put the window on top of the others */
167   XMapRaised (ptc_display, ptc_window);
168   /* Clear event queue */
169   XFlush (ptc_display);
170   /* Get the default graphic context */
171   ptc_window_gc = DefaultGC (ptc_display, ptc_screen);
172   /* Create an XShmImage */
173   ptc_ximage =
174     XShmCreateImage (ptc_display, ptc_visual, ptc_depth, ZPixmap, 0,
175                      &ptc_shm_segment, width, height);
176   /* Get a shared segment */
177   ptc_shm_segment.shmid =
178     shmget (IPC_PRIVATE, ptc_ximage->bytes_per_line * ptc_ximage->height,
179             IPC_CREAT | 0777);
180   /* Initialize XShmImage data buffer pointer */
181   ptc_ximage->data = (char *)shmat (ptc_shm_segment.shmid, 0, 0);
182   /* Save buffer address */
183   ptc_shm_segment.shmaddr = ptc_ximage->data;
184   /* Put the segment in read/write */
185   ptc_shm_segment.readOnly = False;
186   /* Attach the segment to the display */
187   if (!XShmAttach (ptc_display, &ptc_shm_segment))
188     {
189       /* Destroy the image */
190       XDestroyImage (ptc_ximage);
191       /* Detach the buffer from the segment */
192       shmdt (ptc_shm_segment.shmaddr);
193       /* Remove the segment */
194       shmctl (ptc_shm_segment.shmid, IPC_RMID, 0);
195       /* Destroy the window */
196       XDestroyWindow (ptc_display, ptc_window);
197       /* Close the display */
198       XCloseDisplay (ptc_display);
199       return PTC_FAILURE;
200     }
201   /* Save windowsize values */
202   ptc_viewport_width = width;
203   ptc_viewport_height = height;
204   return PTC_SUCCESS;
205 }
206
207 /* Update the screen */
208
209 int
210 ptc_update (void *buffer)
211
212   char *ptc_buffer;
213                 
214   ptc_buffer=(char *)buffer;
215   /* Copy buffer data into the XShmImage */
216 #ifdef __PTC_ENABLE_CONVERSIONS__
217   ptc_source_index = 0;
218   ptc_destination_index = 0;
219   /* Convert the image line by line */
220   for (ptc_blitcounter = 0; ptc_blitcounter < ptc_viewport_height;
221        ptc_blitcounter++)
222     {
223       /* Conversion */
224       ptc_convert (ptc_buffer + ptc_source_index,
225                    (ptc_ximage->data) + ptc_destination_index,
226                    ptc_viewport_width);
227       /* Pointers update */
228       ptc_source_index += ptc_viewport_width * sizeof (int);
229       ptc_destination_index += ptc_viewport_width * ptc_output_pitch;
230     }
231 #else
232   /* Blit the image */
233   memcpy (ptc_ximage->data, buffer,
234           ptc_viewport_width * ptc_viewport_height * sizeof (int));
235 #endif /* __PTC_ENABLE_CONVERSIONS__ */
236   /* Synchronize the event queue */
237   XSync (ptc_display, 0);
238   /* Put the buffer on the window */
239   XShmPutImage (ptc_display, ptc_window, ptc_window_gc, ptc_ximage, 0, 0, 0,
240                 0, ptc_viewport_width, ptc_viewport_height, False);
241   /* Process incoming events */
242   if (ptc_process_events ())
243     {
244 #ifdef __PTC_CLEANUP_CALLBACK__
245       ptc_cleanup_callback ();
246 #endif /* __PTC_CLEANUP_CALLBACK__ */
247       ptc_close ();
248       exit (0);
249     }
250   return PTC_SUCCESS;
251 }
252
253 /* Process events */
254
255 int
256 ptc_process_events (void)
257 {
258   XEvent ptc_xevent;
259   KeySym ptc_keysym;
260   /* Check if there are events waiting in the display's queue */
261   if (XPending (ptc_display))
262     {
263       /* Get the next event in queue */
264       XNextEvent (ptc_display, &ptc_xevent);
265       /* Check if it's a keypress event */
266       if (ptc_xevent.type == KeyPress)
267         {
268           /* Get the keysym */
269           ptc_keysym = XLookupKeysym (&ptc_xevent.xkey, 0);
270           /* Check if the key pressed was a function one */
271           if ((ptc_keysym >> 8) == __PTC_FUNCTION_KEY__)
272             {
273               /* Check if it was the escape key */
274               if ((ptc_keysym & 0xFF) == __PTC_ESCAPE_KEY__)
275                 {
276                   return PTC_SUCCESS;
277                 }
278             }
279         }
280     }
281   return PTC_FAILURE;
282 }
283
284 /* Close the screen */
285
286 void
287 ptc_close (void)
288 {
289   /* Detach the segment from the display */
290   XShmDetach (ptc_display, &ptc_shm_segment);
291   /* Destroy the XShmImage */
292   XDestroyImage (ptc_ximage);
293   /* Detach the buffer from the segment */
294   shmdt (ptc_shm_segment.shmaddr);
295   /* Remove the segment */
296   shmctl (ptc_shm_segment.shmid, IPC_RMID, 0);
297   /* Close the window */
298   XDestroyWindow (ptc_display, ptc_window);
299   /* Close the display */
300   XCloseDisplay (ptc_display);
301   /* Deallocate the buffer */
302   if (ptc_buffer)
303     {
304       free (ptc_buffer);
305     }
306 }
307
308 #endif /* __PTC_XSHM__ */