Separated several classes into header files from tool main.cpp
[synfig.git] / synfig-osx / launcher / appledri.c
1 /* $XFree86: xc/programs/Xserver/GL/dri/xf86dri.c,v 1.10 2000/12/07 20:26:14 dawes Exp $ */
2 /**************************************************************************
3
4 Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
5 Copyright 2000 VA Linux Systems, Inc.
6 Copyright (c) 2002 Apple Computer, Inc.
7 All Rights Reserved.
8
9 Permission is hereby granted, free of charge, to any person obtaining a
10 copy of this software and associated documentation files (the
11 "Software"), to deal in the Software without restriction, including
12 without limitation the rights to use, copy, modify, merge, publish,
13 distribute, sub license, and/or sell copies of the Software, and to
14 permit persons to whom the Software is furnished to do so, subject to
15 the following conditions:
16
17 The above copyright notice and this permission notice (including the
18 next paragraph) shall be included in all copies or substantial portions
19 of the Software.
20
21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
24 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
25 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
26 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
27 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28
29 **************************************************************************/
30
31 /*
32  * Authors:
33  *   Kevin E. Martin <martin@valinux.com>
34  *   Jens Owen <jens@valinux.com>
35  *   Rickard E. (Rik) Faith <faith@valinux.com>
36  *
37  */
38
39 #define NEED_REPLIES
40 #define NEED_EVENTS
41 #include "X.h"
42 #include "Xproto.h"
43 #include "misc.h"
44 #include "dixstruct.h"
45 #include "extnsionst.h"
46 #include "colormapst.h"
47 #include "cursorstr.h"
48 #include "scrnintstr.h"
49 #include "servermd.h"
50 #define _APPLEDRI_SERVER_
51 #include "appledristr.h"
52 #include "swaprep.h"
53 #include "dri.h"
54 #include "dri-surface.h"
55 #include "dristruct.h"
56 #include "rootless-common.h"
57 #include "X11Application.h"
58
59 static int DRIErrorBase;
60
61 static DISPATCH_PROC(ProcAppleDRIDispatch);
62 static DISPATCH_PROC(SProcAppleDRIDispatch);
63
64 static void AppleDRIResetProc(ExtensionEntry* extEntry);
65
66 static unsigned char DRIReqCode = 0;
67 static int DRIEventBase = 0;
68
69 extern void AppleDRIExtensionInit(void);
70
71 static void SNotifyEvent(xAppleDRINotifyEvent *from, xAppleDRINotifyEvent *to);
72
73 typedef struct _DRIEvent *DRIEventPtr;
74 typedef struct _DRIEvent {
75     DRIEventPtr     next;
76     ClientPtr       client;
77     XID             clientResource;
78     unsigned int    mask;
79 } DRIEventRec;
80
81 void
82 AppleDRIExtensionInit(void)
83 {
84     ExtensionEntry* extEntry;
85
86     if (DRIExtensionInit() &&
87         (extEntry = AddExtension(APPLEDRINAME,
88                                  AppleDRINumberEvents,
89                                  AppleDRINumberErrors,
90                                  ProcAppleDRIDispatch,
91                                  SProcAppleDRIDispatch,
92                                  AppleDRIResetProc,
93                                  StandardMinorOpcode))) {
94         DRIReqCode = (unsigned char)extEntry->base;
95         DRIErrorBase = extEntry->errorBase;
96         DRIEventBase = extEntry->eventBase;
97         EventSwapVector[DRIEventBase] = (EventSwapPtr) SNotifyEvent;
98     }
99 }
100
101 /*ARGSUSED*/
102 static void
103 AppleDRIResetProc (
104     ExtensionEntry* extEntry
105 )
106 {
107     DRIReset();
108 }
109
110 static int
111 ProcAppleDRIQueryVersion(
112     register ClientPtr client
113 )
114 {
115     xAppleDRIQueryVersionReply rep;
116     register int n;
117
118     REQUEST_SIZE_MATCH(xAppleDRIQueryVersionReq);
119     rep.type = X_Reply;
120     rep.length = 0;
121     rep.sequenceNumber = client->sequence;
122     rep.majorVersion = APPLE_DRI_MAJOR_VERSION;
123     rep.minorVersion = APPLE_DRI_MINOR_VERSION;
124     rep.patchVersion = APPLE_DRI_PATCH_VERSION;
125     if (client->swapped) {
126         swaps(&rep.sequenceNumber, n);
127         swapl(&rep.length, n);
128     }
129     WriteToClient(client, sizeof(xAppleDRIQueryVersionReply), (char *)&rep);
130     return (client->noClientException);
131 }
132
133 \f
134 /* surfaces */
135
136 static int
137 ProcAppleDRIQueryDirectRenderingCapable(
138     register ClientPtr client
139 )
140 {
141     xAppleDRIQueryDirectRenderingCapableReply   rep;
142     Bool isCapable;
143
144     REQUEST(xAppleDRIQueryDirectRenderingCapableReq);
145     REQUEST_SIZE_MATCH(xAppleDRIQueryDirectRenderingCapableReq);
146     rep.type = X_Reply;
147     rep.length = 0;
148     rep.sequenceNumber = client->sequence;
149
150     if (!DRIQueryDirectRenderingCapable( screenInfo.screens[stuff->screen], 
151                                          &isCapable)) {
152         return BadValue;
153     }
154     rep.isCapable = isCapable;
155
156     if (!LocalClient(client))
157         rep.isCapable = 0;
158
159     WriteToClient(client, 
160         sizeof(xAppleDRIQueryDirectRenderingCapableReply), (char *)&rep);
161     return (client->noClientException);
162 }
163
164 static int
165 ProcAppleDRIAuthConnection(
166     register ClientPtr client
167 )
168 {
169     xAppleDRIAuthConnectionReply rep;
170     
171     REQUEST(xAppleDRIAuthConnectionReq);
172     REQUEST_SIZE_MATCH(xAppleDRIAuthConnectionReq);
173
174     rep.type = X_Reply;
175     rep.length = 0;
176     rep.sequenceNumber = client->sequence;
177     rep.authenticated = 1;
178
179     if (!DRIAuthConnection( screenInfo.screens[stuff->screen], stuff->magic)) {
180         ErrorF("Failed to authenticate %u\n", stuff->magic);
181         rep.authenticated = 0;
182     }
183     WriteToClient(client, sizeof(xAppleDRIAuthConnectionReply), (char *)&rep);
184     return (client->noClientException);
185 }
186
187 static void surface_notify (void *_arg, void *data)
188 {
189     DRISurfaceNotifyArg *arg = _arg;
190     int client_index = (int) data;
191     ClientPtr client;
192     xAppleDRINotifyEvent se;
193
194     if (client_index < 0 || client_index >= currentMaxClients)
195         return;
196
197     client = clients[client_index];
198     if (client == NULL || client == serverClient || client->clientGone)
199         return;
200
201     se.type = DRIEventBase + AppleDRISurfaceNotify;
202     se.kind = arg->kind;
203     se.arg = arg->id;
204     se.sequenceNumber = client->sequence;
205     se.time = currentTime.milliseconds;
206     WriteEventsToClient (client, 1, (xEvent *) &se);
207 }
208
209 static int
210 ProcAppleDRICreateSurface(
211     ClientPtr client
212 )
213 {
214     xAppleDRICreateSurfaceReply rep;
215     DrawablePtr pDrawable;
216     xp_surface_id sid;
217     unsigned int key[2];
218
219     REQUEST(xAppleDRICreateSurfaceReq);
220     REQUEST_SIZE_MATCH(xAppleDRICreateSurfaceReq);
221     rep.type = X_Reply;
222     rep.length = 0;
223     rep.sequenceNumber = client->sequence;
224
225     if (!(pDrawable = (DrawablePtr)SecurityLookupDrawable(
226                                                 (Drawable)stuff->drawable,
227                                                 client, 
228                                                 SecurityReadAccess))) {
229         return BadValue;
230     }
231
232     rep.key_0 = rep.key_1 = rep.uid = 0;
233
234     if (!DRICreateSurface( screenInfo.screens[stuff->screen],
235                            (Drawable)stuff->drawable, pDrawable,
236                            stuff->client_id, &sid, key,
237                            surface_notify, (void *) client->index)) {
238         return BadValue;
239     }
240
241     rep.key_0 = key[0];
242     rep.key_1 = key[1];
243     rep.uid = sid;
244
245     WriteToClient(client, sizeof(xAppleDRICreateSurfaceReply), (char *)&rep);
246     return (client->noClientException);
247 }
248
249 static int
250 ProcAppleDRIDestroySurface(
251     register ClientPtr client
252 )
253 {
254     REQUEST(xAppleDRIDestroySurfaceReq);
255     DrawablePtr pDrawable;
256     REQUEST_SIZE_MATCH(xAppleDRIDestroySurfaceReq);
257
258     if (!(pDrawable = (DrawablePtr)SecurityLookupDrawable(
259                                                 (Drawable)stuff->drawable,
260                                                 client, 
261                                                 SecurityReadAccess))) {
262         return BadValue;
263     }
264
265     if (!DRIDestroySurface( screenInfo.screens[stuff->screen], 
266                             (Drawable)stuff->drawable,
267                             pDrawable, NULL, NULL)) {
268         return BadValue;
269     }
270
271     return (client->noClientException);
272 }
273
274 \f
275 /* dispatch */
276
277 static int
278 ProcAppleDRIDispatch (
279     register ClientPtr  client
280 )
281 {
282     REQUEST(xReq);
283
284     switch (stuff->data)
285     {
286     case X_AppleDRIQueryVersion:
287         return ProcAppleDRIQueryVersion(client);
288     case X_AppleDRIQueryDirectRenderingCapable:
289         return ProcAppleDRIQueryDirectRenderingCapable(client);
290     }
291
292     if (!LocalClient(client))
293         return DRIErrorBase + AppleDRIClientNotLocal;
294
295     switch (stuff->data)
296     {
297     case X_AppleDRIAuthConnection:
298         return ProcAppleDRIAuthConnection(client);
299     case X_AppleDRICreateSurface:
300         return ProcAppleDRICreateSurface(client);
301     case X_AppleDRIDestroySurface:
302         return ProcAppleDRIDestroySurface(client);
303     default:
304         return BadRequest;
305     }
306 }
307
308 static void
309 SNotifyEvent(from, to)
310     xAppleDRINotifyEvent *from, *to;
311 {
312     to->type = from->type;
313     to->kind = from->kind;
314     cpswaps (from->sequenceNumber, to->sequenceNumber);
315     cpswapl (from->time, to->time);
316     cpswapl (from->arg, to->arg);
317 }
318
319 static int
320 SProcAppleDRIQueryVersion(
321     register ClientPtr  client
322 )
323 {
324     register int n;
325     REQUEST(xAppleDRIQueryVersionReq);
326     swaps(&stuff->length, n);
327     return ProcAppleDRIQueryVersion(client);
328 }
329
330 static int
331 SProcAppleDRIDispatch (
332     register ClientPtr  client
333 )
334 {
335     REQUEST(xReq);
336
337     /* It is bound to be non-local when there is byte swapping */
338     if (!LocalClient(client))
339         return DRIErrorBase + AppleDRIClientNotLocal;
340
341     /* only local clients are allowed DRI access */
342     switch (stuff->data)
343     {
344     case X_AppleDRIQueryVersion:
345         return SProcAppleDRIQueryVersion(client);
346     default:
347         return BadRequest;
348     }
349 }