?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use consistent hidd naming
[AROS.git] / arch / all-hosted / hidd / x11 / x11gfx.c
blob81a216bb748531d4d8b921cf4ae8e88de59a2283
1 /*
2 Copyright © 1995-2014, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: X11 gfx HIDD for AROS.
6 Lang: English.
7 */
8
9 #include "x11_debug.h"
10
11 #define __OOP_NOATTRBASES__
12
13 #include <stddef.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <unistd.h>
17
18 #include <X11/Xlib.h>
19 #include <X11/cursorfont.h>
20 #include <X11/Xutil.h>
21
22 #include <signal.h>
23 #include <string.h>
24
25 #include <exec/libraries.h>
26 #include <exec/types.h>
27 #include <exec/resident.h>
28 #include <exec/memory.h>
29 #include <aros/libcall.h>
30 #include <proto/exec.h>
31 #include <proto/oop.h>
32 #include <proto/utility.h>
33 #include <oop/oop.h>
34
35 #include <hidd/hidd.h>
36 #include <hidd/graphics.h>
37
38 #include <aros/symbolsets.h>
39
40 #include "bitmap_class.h"
41 #include "x11gfx_intern.h"
42 #include "x11.h"
43
44 #include LC_LIBDEFS_FILE
45
46 #define XFLUSH(x) XCALL(XFlush, x)
47 //#define XFLUSH(x)
48
49 /****************************************************************************************/
50
51 #define IS_X11GFX_ATTR(attr, idx) ( ( (idx) = (attr) - HiddX11GfxAB) < num_Hidd_X11BitMap_Attrs)
52
53 int xshm_major;
54
55 /* Some attrbases needed as global vars.
56 These are write-once read-many */
57
58 OOP_AttrBase HiddBitMapAttrBase;
59 OOP_AttrBase HiddX11BitMapAB;
60 OOP_AttrBase HiddSyncAttrBase;
61 OOP_AttrBase HiddPixFmtAttrBase;
62 OOP_AttrBase HiddGfxAttrBase;
63 OOP_AttrBase HiddAttrBase;
64
65 static const struct OOP_ABDescr attrbases[] =
66 {
67 { IID_Hidd_BitMap , &HiddBitMapAttrBase },
68 { IID_Hidd_BitMap_X11 , &HiddX11BitMapAB },
69 { IID_Hidd_Sync , &HiddSyncAttrBase },
70 { IID_Hidd_PixFmt , &HiddPixFmtAttrBase },
71 { IID_Hidd_Gfx , &HiddGfxAttrBase },
72 { IID_Hidd , &HiddAttrBase },
73 { NULL , NULL }
74 };
75
76 static VOID cleanupx11stuff(struct x11_staticdata *xsd);
77 static BOOL initx11stuff(struct x11_staticdata *xsd);
78
79 /****************************************************************************************/
80
81 OOP_Object *X11Cl__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
82 {
83 struct TagItem pftags[] =
84 {
85 { aHidd_PixFmt_RedShift , 0 }, /* 0 */
86 { aHidd_PixFmt_GreenShift , 0 }, /* 1 */
87 { aHidd_PixFmt_BlueShift , 0 }, /* 2 */
88 { aHidd_PixFmt_AlphaShift , 0 }, /* 3 */
89 { aHidd_PixFmt_RedMask , 0 }, /* 4 */
90 { aHidd_PixFmt_GreenMask , 0 }, /* 5 */
91 { aHidd_PixFmt_BlueMask , 0 }, /* 6 */
92 { aHidd_PixFmt_AlphaMask , 0 }, /* 7 */
93 { aHidd_PixFmt_ColorModel , 0 }, /* 8 */
94 { aHidd_PixFmt_Depth , 0 }, /* 9 */
95 { aHidd_PixFmt_BytesPerPixel, 0 }, /* 10 */
96 { aHidd_PixFmt_BitsPerPixel , 0 }, /* 11 */
97 { aHidd_PixFmt_StdPixFmt , 0 }, /* 12 */
98 { aHidd_PixFmt_CLUTShift , 0 }, /* 13 */
99 { aHidd_PixFmt_CLUTMask , 0 }, /* 14 */
100 { aHidd_PixFmt_BitMapType , 0 }, /* 15 */
101 { TAG_DONE , 0UL }
102 };
103
104 struct TagItem tags_160_160[] =
105 {
106 { aHidd_Sync_HDisp , 160 },
107 { aHidd_Sync_VDisp , 160 },
108 { aHidd_Sync_Description, (IPTR)"X11:160x160" },
109 { TAG_DONE , 0UL }
110 };
111
112 struct TagItem tags_240_320[] =
113 {
114 { aHidd_Sync_HDisp , 240 },
115 { aHidd_Sync_VDisp , 320 },
116 { aHidd_Sync_Description, (IPTR)"X11:240x320" },
117 { TAG_DONE , 0UL }
118 };
119
120 struct TagItem tags_320_240[] =
121 {
122 { aHidd_Sync_HDisp , 320 },
123 { aHidd_Sync_VDisp , 240 },
124 { aHidd_Sync_Description, (IPTR)"X11:320x240" },
125 { TAG_DONE , 0UL }
126 };
127
128 struct TagItem tags_512_384[] =
129 {
130 { aHidd_Sync_HDisp , 512 },
131 { aHidd_Sync_VDisp , 384 },
132 { aHidd_Sync_Description, (IPTR)"X11:512x384" },
133 { TAG_DONE , 0UL }
134 };
135
136 struct TagItem tags_640_480[] =
137 {
138 { aHidd_Sync_HDisp , 640 },
139 { aHidd_Sync_VDisp , 480 },
140 { aHidd_Sync_Description, (IPTR)"X11:640x480" },
141 { TAG_DONE , 0UL }
142 };
143
144 struct TagItem tags_800_600[] =
145 {
146 { aHidd_Sync_HDisp , 800 },
147 { aHidd_Sync_VDisp , 600 },
148 { aHidd_Sync_Description, (IPTR)"X11:800x600" },
149 { TAG_DONE , 0UL }
150 };
151
152 struct TagItem tags_1024_768[] =
153 {
154 { aHidd_Sync_HDisp , 1024 },
155 { aHidd_Sync_VDisp , 768 },
156 { aHidd_Sync_Description, (IPTR)"X11:1024x768" },
157 { TAG_DONE , 0UL }
158 };
159
160 struct TagItem tags_1152_864[] =
161 {
162 { aHidd_Sync_HDisp , 1152 },
163 { aHidd_Sync_VDisp , 864 },
164 { aHidd_Sync_Description, (IPTR)"X11:1152x864" },
165 { TAG_DONE , 0UL }
166 };
167
168 struct TagItem tags_1280_800[] =
169 {
170 { aHidd_Sync_HDisp , 1280 },
171 { aHidd_Sync_VDisp , 800 },
172 { aHidd_Sync_Description, (IPTR)"X11:1280x800" },
173 { TAG_DONE , 0UL }
174 };
175
176 struct TagItem tags_1280_960[] =
177 {
178 { aHidd_Sync_HDisp , 1280 },
179 { aHidd_Sync_VDisp , 960 },
180 { aHidd_Sync_Description, (IPTR)"X11:1280x960" },
181 { TAG_DONE , 0UL }
182 };
183
184 struct TagItem tags_1280_1024[] =
185 {
186 { aHidd_Sync_HDisp , 1280 },
187 { aHidd_Sync_VDisp , 1024 },
188 { aHidd_Sync_Description, (IPTR)"X11:1280x1024" },
189 { TAG_DONE , 0UL }
190 };
191
192 struct TagItem tags_1400_1050[] =
193 {
194 { aHidd_Sync_HDisp , 1400 },
195 { aHidd_Sync_VDisp , 1050 },
196 { aHidd_Sync_Description, (IPTR)"X11:1400x1050" },
197 { TAG_DONE , 0UL }
198 };
199
200 struct TagItem tags_1600_1200[] =
201 {
202 { aHidd_Sync_HDisp , 1600 },
203 { aHidd_Sync_VDisp , 1200 },
204 { aHidd_Sync_Description, (IPTR)"X11:1600x1200" },
205 { TAG_DONE , 0UL }
206 };
207
208 struct TagItem tags_1680_1050[] =
209 {
210 { aHidd_Sync_HDisp , 1680 },
211 { aHidd_Sync_VDisp , 1050 },
212 { aHidd_Sync_Description, (IPTR)"X11:1680x1050" },
213 { TAG_DONE , 0UL }
214 };
215
216 struct TagItem tags_1920_1080[] =
217 {
218 { aHidd_Sync_HDisp , 1920 },
219 { aHidd_Sync_VDisp , 1080 },
220 { aHidd_Sync_Description, (IPTR)"X11:1920x1080" },
221 { TAG_DONE , 0UL }
222 };
223
224 struct TagItem tags_1920_1200[] =
225 {
226 { aHidd_Sync_HDisp , 1920 },
227 { aHidd_Sync_VDisp , 1200 },
228 { aHidd_Sync_Description, (IPTR)"X11:1920x1200" },
229 { TAG_DONE , 0UL }
230 };
231
232 /* Default display modes. Used on displays which do not support Free86-VidModeExtension */
233 struct TagItem default_mode_tags[] =
234 {
235 { aHidd_Gfx_PixFmtTags , (IPTR)pftags },
236 { aHidd_Gfx_SyncTags , (IPTR)tags_160_160 },
237 { aHidd_Gfx_SyncTags , (IPTR)tags_240_320 },
238 { aHidd_Gfx_SyncTags , (IPTR)tags_320_240 },
239 { aHidd_Gfx_SyncTags , (IPTR)tags_512_384 },
240 { aHidd_Gfx_SyncTags , (IPTR)tags_640_480 },
241 { aHidd_Gfx_SyncTags , (IPTR)tags_800_600 },
242 { aHidd_Gfx_SyncTags , (IPTR)tags_1024_768 },
243 { aHidd_Gfx_SyncTags , (IPTR)tags_1152_864 },
244 { aHidd_Gfx_SyncTags , (IPTR)tags_1280_800 },
245 { aHidd_Gfx_SyncTags , (IPTR)tags_1280_960 },
246 { aHidd_Gfx_SyncTags , (IPTR)tags_1280_1024 },
247 { aHidd_Gfx_SyncTags , (IPTR)tags_1400_1050 },
248 { aHidd_Gfx_SyncTags , (IPTR)tags_1600_1200 },
249 { aHidd_Gfx_SyncTags , (IPTR)tags_1680_1050 },
250 { aHidd_Gfx_SyncTags , (IPTR)tags_1920_1080 },
251 { aHidd_Gfx_SyncTags , (IPTR)tags_1920_1200 },
252 { TAG_DONE , 0UL }
253 };
254
255 struct TagItem *mode_tags = NULL;
256
257 struct TagItem mytags[] =
258 {
259 { aHidd_Gfx_ModeTags , (IPTR)default_mode_tags },
260 { aHidd_Name , (IPTR)"x11_1.monitor" },
261 { aHidd_HardwareName , (IPTR)"X Window system" },
262 { aHidd_ProducerName , (IPTR)"X.Org Foundation" },
263 { TAG_MORE , (IPTR)msg->attrList }
264 };
265
266 struct pRoot_New mymsg = { msg->mID, mytags };
267
268 struct TagItem *resolution = NULL;
269 XF86VidModeModeInfo** modes = NULL;
270 static int modeNum = 0;
271 ULONG realmode = 0;
272
273 ULONG i, screen;
274 Display *disp;
275
276 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
277
278 /* Do GfxHidd initalization here */
279 if (!initx11stuff(XSD(cl)))
280 {
281 D(bug("[X11Gfx] %s: initialisation failed!\n", __PRETTY_FUNCTION__));
282 return NULL;
283 }
284
285 /* Get supported X11 resolution from RandR resources */
286
287 disp = XCALL(XOpenDisplay, NULL);
288 screen = XCALL(XDefaultScreen, disp);
289 // rootwin = XCALL(XRootWindow, disp, screen);
290
291 if (!(XSD(cl)->options & OPTION_FORCESTDMODES))
292 {
293 XVMCALL(XF86VidModeGetAllModeLines, disp, screen, &modeNum, &modes);
294 D(bug("[X11Gfx] Found %u modes, table at 0x%P\n", modeNum, modes));
295
296 if (modeNum)
297 {
298 /* Got XF86VidMode data, use it */
299 if ((resolution = AllocMem(modeNum * sizeof(struct TagItem) * 4, MEMF_PUBLIC)) == NULL)
300 {
301 D(bug("[X11] failed to allocate memory for %d modes: %d !!!\n", modeNum, XSD(cl)->vi.class));
302
303 XCALL(XCloseDisplay, disp);
304 cleanupx11stuff(XSD(cl));
305
306 return NULL;
307 }
308
309 for(i = 0; i < modeNum; i++)
310 {
311 ULONG j;
312 BOOL insert;
313 insert = TRUE;
314
315 /* avoid duplicated resolution */
316 for(j = 0; j < realmode; j++)
317 {
318 if(resolution[j * 4].ti_Data == modes[i]->hdisplay && resolution[j * 4 + 1].ti_Data == modes[i]->vdisplay)
319 { /* Found a matching resolution. Don't insert ! */
320 insert = FALSE;
321 }
322 }
323
324 if(insert)
325 {
326 resolution[realmode * 4 + 0].ti_Tag = aHidd_Sync_HDisp;
327 resolution[realmode * 4 + 0].ti_Data = modes[i]->hdisplay;
328
329 resolution[realmode * 4 + 1].ti_Tag = aHidd_Sync_VDisp;
330 resolution[realmode * 4 + 1].ti_Data = modes[i]->vdisplay;
331
332 resolution[realmode * 4 + 2].ti_Tag = aHidd_Sync_Description;
333 resolution[realmode * 4 + 2].ti_Data = (IPTR)"X11: %hx%v";
334
335 resolution[realmode * 4 + 3].ti_Tag = TAG_DONE;
336 resolution[realmode * 4 + 3].ti_Data = 0UL;
337
338 realmode++;
339 }
340 }
341
342 if((mode_tags = AllocMem(sizeof(struct TagItem) * (realmode + 2), MEMF_PUBLIC)) == NULL)
343 {
344 D(bug("[X11] failed to allocate memory for mode tag's: %d !!!\n", XSD(cl)->vi.class));
345
346 FreeMem(resolution, modeNum * sizeof(struct TagItem) * 4);
347 XCALL(XCloseDisplay, disp);
348 cleanupx11stuff(XSD(cl));
349
350 return NULL;
351 }
352
353 mode_tags[0].ti_Tag = aHidd_Gfx_PixFmtTags;
354 mode_tags[0].ti_Data = (IPTR)pftags;
355
356 /* The different screenmode from XF86VMODE */
357 for(i=0; i < realmode; i++)
358 {
359 mode_tags[1 + i].ti_Tag = aHidd_Gfx_SyncTags;
360 mode_tags[1 + i].ti_Data = (IPTR)(resolution + i*4);
361 }
362
363 mode_tags[1 + i].ti_Tag = TAG_DONE;
364 mode_tags[1 + i].ti_Data = 0UL;
365
366 /* Use our new mode tags instead of default ones */
367 mytags[0].ti_Data = (IPTR)mode_tags;
368 }
369 }
370
371 /* Register gfxmodes */
372 pftags[0].ti_Data = XSD(cl)->red_shift;
373 pftags[1].ti_Data = XSD(cl)->green_shift;
374 pftags[2].ti_Data = XSD(cl)->blue_shift;
375 pftags[3].ti_Data = 0;
376
377 pftags[4].ti_Data = XSD(cl)->vi.red_mask;
378 pftags[5].ti_Data = XSD(cl)->vi.green_mask;
379 pftags[6].ti_Data = XSD(cl)->vi.blue_mask;
380 pftags[7].ti_Data = 0x00000000;
381
382 if (XSD(cl)->vi.class == TrueColor)
383 {
384 pftags[8].ti_Data = vHidd_ColorModel_TrueColor;
385 }
386 else if (XSD(cl)->vi.class == PseudoColor)
387 {
388 pftags[8].ti_Data = vHidd_ColorModel_Palette;
389 pftags[13].ti_Data = XSD(cl)->clut_shift;
390 pftags[14].ti_Data = XSD(cl)->clut_mask;
391 }
392 else
393 {
394 D(bug("[X11Gfx] unsupported color model: %d\n", XSD(cl)->vi.class));
395 if (resolution)
396 {
397 FreeMem(resolution, modeNum * sizeof(struct TagItem) * 4);
398 FreeMem(mode_tags, sizeof(struct TagItem) * (realmode + 2));
399 }
400 XCALL(XCloseDisplay, disp);
401 cleanupx11stuff(XSD(cl));
402
403 return NULL;
404 }
405
406 pftags[9].ti_Data = XSD(cl)->depth;
407 pftags[10].ti_Data = XSD(cl)->bytes_per_pixel;
408 pftags[11].ti_Data = XSD(cl)->depth;
409 pftags[12].ti_Data = vHidd_StdPixFmt_Native;
410
411 /* FIXME: Do better than this */
412
413 /* We assume chunky */
414 pftags[15].ti_Data = vHidd_BitMapType_Chunky;
415
416 D(bug("Calling super method\n"));
417
418 o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)&mymsg);
419
420 D(bug("Super method returned\n"));
421
422 FreeMem(resolution, modeNum * sizeof(struct TagItem) * 4);
423 FreeMem(mode_tags, sizeof(struct TagItem) * (realmode + 2));
424 XCALL(XCloseDisplay, disp);
425
426 if (NULL != o)
427 {
428 XColor bg, fg;
429 struct gfx_data *data = OOP_INST_DATA(cl, o);
430
431 LOCK_X11
432 data->display = XSD(cl)->display;
433 data->screen = DefaultScreen( data->display );
434 data->depth = DisplayPlanes( data->display, data->screen );
435 data->colmap = DefaultColormap( data->display, data->screen );
436 D(bug("x11_func.XCreateFontCursor(%x), display(%x)\n", x11_func.XCreateFontCursor, data->display));
437 /* Create cursor */
438 data->cursor = XCALL(XCreateFontCursor, data->display, XC_top_left_arrow);
439
440 fg.pixel = BlackPixel(data->display, data->screen);
441 fg.red = 0x0000; fg.green = 0x0000; fg.blue = 0x0000;
442 fg.flags = (DoRed | DoGreen | DoBlue);
443 bg.pixel = WhitePixel(data->display, data->screen);
444 bg.red = 0xFFFF; bg.green = 0xFFFF; bg.blue = 0xFFFF;
445 bg.flags = (DoRed | DoGreen | DoBlue);
446
447 XCALL(XRecolorCursor, data->display, data->cursor, &fg, &bg);
448
449 if (XSD(cl)->options & OPTION_BACKINGSTORE)
450 {
451 switch(DoesBackingStore(ScreenOfDisplay(data->display, data->screen)))
452 {
453 case WhenMapped:
454 case Always:
455 break;
456
457 case NotUseful:
458 bug("\n"
459 "+----------------------------------------------------------+\n"
460 "| Your X Server seems to have backing store disabled! |\n"
461 "| =================================================== |\n"
462 "| |\n"
463 "| If possible you should try to switch it on, otherwise |\n"
464 "| AROS will have problems with its display. When the AROS |\n"
465 "| X window is hidden by other X windows, or is dragged |\n"
466 "| off screen, then the graphics in those parts will get |\n"
467 "| lost, unless backing store support is enabled. |\n"
468 "| |\n"
469 "| In case your X11 Server is XFree 4.x then switching on |\n"
470 "| backingstore support can be done by starting the X11 |\n"
471 "| server with something like \"startx -- +bs\". Depending |\n"
472 "| on what X driver you use it might also be possible |\n"
473 "| to turn it on by adding |\n"
474 "| |\n"
475 "| Option \"Backingstore\" |\n"
476 "| |\n"
477 "| to the Device Section of your X Window config file, |\n"
478 "| which usually is \"/etc/X11/xorg.conf\" |\n"
479 "| or \"/etc/X11/XFree86Config\" |\n"
480 "+----------------------------------------------------------+\n"
481 "\n");
482 break;
483 }
484 }
485
486 UNLOCK_X11
487
488 D(bug("[X11Gfx] Got object from super\n"));
489
490 data->display = XSD(cl)->display;
491 }
492
493 ReturnPtr("X11Gfx::New", OOP_Object *, o);
494 }
495
496 /********** GfxHidd::Dispose() ******************************/
497 VOID X11Cl__Root__Dispose(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
498 {
499 D(bug("[X11Gfx] %s(0x%p)\n", __PRETTY_FUNCTION__, o));
500
501 cleanupx11stuff(XSD(cl));
502
503 D(bug("X11Gfx::Dispose: calling super\n"));
504 OOP_DoSuperMethod(cl, o, msg);
505
506 }
507
508 /****************************************************************************************/
509
510 OOP_Object *X11Cl__Hidd_Gfx__NewBitMap(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_NewBitMap *msg)
511 {
512 struct pHidd_Gfx_NewBitMap p;
513 OOP_Object *newbm;
514 HIDDT_ModeID modeid;
515 struct gfx_data *data;
516 struct TagItem tags[] =
517 {
518 { aHidd_X11BitMap_SysDisplay , 0 }, /* 0 */
519 { aHidd_X11BitMap_SysScreen , 0 }, /* 1 */
520 { aHidd_X11BitMap_SysCursor , 0 }, /* 2 */
521 { aHidd_X11BitMap_ColorMap , 0 }, /* 3 */
522 { aHidd_X11BitMap_VisualClass , 0 }, /* 4 */
523 { TAG_IGNORE , 0 }, /* 5 */
524 { TAG_MORE , 0 } /* 6 */
525 };
526
527 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
528
529 data = OOP_INST_DATA(cl, o);
530
531 tags[0].ti_Data = (IPTR)data->display;
532 tags[1].ti_Data = data->screen;
533 tags[2].ti_Data = (IPTR)data->cursor;
534 tags[3].ti_Data = data->colmap;
535 tags[4].ti_Data = XSD(cl)->vi.class;
536 tags[6].ti_Data = (IPTR)msg->attrList;
537
538 /* Displayable bitmap ? */
539 modeid = GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList);
540
541 if (modeid != vHidd_ModeID_Invalid)
542 {
543 /* ModeID supplied, it's for sure X11 bitmap */
544 tags[5].ti_Tag = aHidd_BitMap_ClassPtr;
545 tags[5].ti_Data = (IPTR)XSD(cl)->bmclass;
546 }
547
548 /* !!! IMPORTANT !!! */
549 p.mID = msg->mID;
550 p.attrList = tags;
551
552 newbm = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)&p);
553
554 ReturnPtr("X11Gfx::NewBitMap", OOP_Object *, newbm);
555 }
556
557 /****************************************************************************************/
558
559 VOID X11Cl__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg)
560 {
561 ULONG idx;
562
563 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
564
565 if (IS_GFX_ATTR(msg->attrID, idx))
566 {
567 switch (idx)
568 {
569 case aoHidd_Gfx_IsWindowed:
570 *msg->storage = TRUE;
571 return;
572
573 case aoHidd_Gfx_HWSpriteTypes:
574 #if X11SOFTMOUSE
575 *msg->storage = 0;
576 #else
577 *msg->storage = vHidd_SpriteType_DirectColor;
578 #endif
579 return;
580
581 case aoHidd_Gfx_DriverName:
582 *msg->storage = (IPTR) "X11";
583 return;
584 }
585 }
586 OOP_DoSuperMethod(cl, o, (OOP_Msg) msg);
587 }
588
589 /****************************************************************************************/
590
591 VOID X11Cl__Root__Set(OOP_Class *cl, OOP_Object *obj, struct pRoot_Set *msg)
592 {
593 struct TagItem *tag, *tstate;
594 ULONG idx;
595 struct x11_staticdata *data = XSD(cl);
596
597 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
598
599 tstate = msg->attrList;
600 while ((tag = NextTagItem(&tstate)))
601 {
602 if (IS_GFX_ATTR(tag->ti_Tag, idx))
603 {
604 switch (idx)
605 {
606 case aoHidd_Gfx_ActiveCallBack:
607 data->activecallback = (void *) tag->ti_Data;
608 break;
609
610 case aoHidd_Gfx_ActiveCallBackData:
611 data->callbackdata = (void *) tag->ti_Data;
612 break;
613 }
614 }
615 }
616 OOP_DoSuperMethod(cl, obj, &msg->mID);
617 }
618
619 /****************************************************************************************/
620
621 VOID X11Cl__Hidd_Gfx__CopyBox(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_CopyBox *msg)
622 {
623 ULONG mode;
624 Drawable src = 0, dest = 0;
625 GC gc = 0;
626
627 struct gfx_data *data = OOP_INST_DATA(cl, o);
628
629 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
630
631 mode = GC_DRMD(msg->gc);
632
633 OOP_GetAttr(msg->src, aHidd_X11BitMap_Drawable, (IPTR *) &src);
634 OOP_GetAttr(msg->dest, aHidd_X11BitMap_Drawable, (IPTR *) &dest);
635
636 if (0 == dest || 0 == src)
637 {
638 /*
639 * One of objects is not an X11 bitmap.
640 * Let the superclass do the copying in a more general way
641 */
642 OOP_DoSuperMethod(cl, o, &msg->mID);
643 return;
644 }
645
646 OOP_GetAttr(msg->src, aHidd_X11BitMap_GC, (IPTR *) &gc);
647
648 HostLib_Lock();
649
650 XCALL(XSetFunction, data->display, gc, mode);
651 XCALL(XCopyArea,
652 data->display, src, dest, gc, msg->srcX, msg->srcY, msg->width, msg->height, msg->destX, msg->destY);
653
654 HostLib_Unlock();
655 }
656
657 /****************************************************************************************/
658
659 BOOL X11Cl__Hidd_Gfx__SetCursorShape(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
660 {
661 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
662
663 /* Dummy implementation */
664 return TRUE;
665 }
666
667 /****************************************************************************************/
668
669 BOOL X11Cl__Hidd_Gfx__SetCursorPos(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
670 {
671 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
672
673 /* Dummy implementation */
674 return TRUE;
675 }
676
677 /****************************************************************************************/
678
679 VOID X11Cl__Hidd_Gfx__SetCursorVisible(OOP_Class *cl, OOP_Object *o, OOP_Msg msg)
680 {
681 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
682
683 /* Dummy implementation */
684 return;
685 }
686
687 /****************************************************************************************/
688
689 static ULONG mask_to_shift(ULONG mask)
690 {
691 ULONG i;
692
693 for (i = 32; mask; i--)
694 {
695 mask >>= 1;
696 }
697
698 if (mask == 32)
699 {
700 i = 0;
701 }
702
703 return i;
704 }
705
706 /****************************************************************************************/
707
708 #undef XSD
709 #define XSD(cl) xsd
710
711 /*
712 Inits sysdisplay, sysscreen, colormap, etc.. */
713 static BOOL initx11stuff(struct x11_staticdata *xsd)
714 {
715 /* XColor fg, bg; */
716 BOOL ok = TRUE;
717 XVisualInfo template;
718 XVisualInfo *visinfo;
719 int template_mask;
720 int numvisuals;
721 XImage *testimage;
722
723 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
724
725 if (!X11_Init(xsd))
726 return FALSE;
727
728 LOCK_X11
729
730 /* Get some info on the display */
731 template.visualid = XCALL(XVisualIDFromVisual, DefaultVisual(xsd->display, DefaultScreen(xsd->display)));
732 template_mask = VisualIDMask;
733
734 visinfo = XCALL(XGetVisualInfo, xsd->display, template_mask, &template, &numvisuals);
735
736 if (numvisuals > 1)
737 {
738 D(bug("[X11Gfx] %s: got %d visualinfo from X\n", __PRETTY_FUNCTION__, numvisuals));
739
740 // CCALL(raise, SIGSTOP);
741 }
742
743 if (NULL == visinfo)
744 {
745 D(bug("[X11Gfx] %s: no visualinfo available!\n", __PRETTY_FUNCTION__));
746
747 CCALL(raise, SIGSTOP);
748
749 ok = FALSE;
750 }
751 else
752 {
753 /* Store the visual info structure */
754
755 memcpy(&xsd->vi, visinfo, sizeof(XVisualInfo));
756
757 XCALL(XFree, visinfo);
758
759 visinfo = &xsd->vi;
760
761 /* We only support TrueColor for now */
762
763 switch (visinfo->class)
764 {
765 case TrueColor:
766 /* Get the pixel masks */
767 xsd->red_shift = mask_to_shift(xsd->vi.red_mask);
768 xsd->green_shift = mask_to_shift(xsd->vi.green_mask);
769 xsd->blue_shift = mask_to_shift(xsd->vi.blue_mask);
770 break;
771
772 case PseudoColor:
773 /* stegerg */
774 xsd->vi.red_mask = ((1 << xsd->vi.bits_per_rgb) - 1) << (xsd->vi.bits_per_rgb * 2);
775 xsd->vi.green_mask = ((1 << xsd->vi.bits_per_rgb) - 1) << (xsd->vi.bits_per_rgb * 1);
776 xsd->vi.blue_mask = ((1 << xsd->vi.bits_per_rgb) - 1);
777 xsd->red_shift = mask_to_shift(xsd->vi.red_mask);
778 xsd->green_shift = mask_to_shift(xsd->vi.green_mask);
779 xsd->blue_shift = mask_to_shift(xsd->vi.blue_mask);
780 /* end stegerg */
781 break;
782
783 default:
784 D(bug("[X11Gfx] %s: unsupported display mode!\n", __PRETTY_FUNCTION__));
785
786 CCALL(raise, SIGSTOP);
787 }
788
789 xsd->depth = 0;
790
791 /* stegerg: based on xwininfo source */
792
793 {
794 XWindowAttributes win_attributes;
795
796 if (!XCALL(XGetWindowAttributes, xsd->display,
797 RootWindow(xsd->display, DefaultScreen(xsd->display)),
798 &win_attributes))
799 {
800 D(bug("[X11Gfx] %s: failed to obtain bits per pixel\n", __PRETTY_FUNCTION__));
801
802 CCALL(raise, SIGSTOP);
803 }
804 xsd->depth = win_attributes.depth;
805 D(
806 bug("\n");
807 bug("[X11Gfx] %s: Display Depth = %dbit (Default = %dbit)\n", __PRETTY_FUNCTION__, DisplayPlanes(xsd->display, DefaultScreen(xsd->display)), DefaultDepth(xsd->display, DefaultScreen(xsd->display)));
808 #if (0)
809 bug("[X11Gfx] %s: %d Bits per Pixel\n", __PRETTY_FUNCTION__, xsd->depth);
810 #endif
811 )
812 }
813
814 /* Create a dummy X image to get bits per pixel */
815 testimage = XCALL(XGetImage, xsd->display, RootWindow(xsd->display,
816 DefaultScreen(xsd->display)), 0, 0, 1, 1,
817 AllPlanes, ZPixmap);
818
819 if (NULL != testimage)
820 {
821 xsd->bytes_per_pixel = (testimage->bits_per_pixel + 7) >> 3;
822 XDestroyImage(testimage);
823 }
824 else
825 {
826 D(bug("[X11Gfx] %s: failed to create query image\n", __PRETTY_FUNCTION__));
827 CCALL(raise, SIGSTOP);
828 }
829
830 if (PseudoColor == xsd->vi.class)
831 {
832 xsd->clut_mask = (1L << xsd->depth) - 1;
833 xsd->clut_shift = 0;
834 }
835 }
836
837 /* Create a dummy window for pixmaps */
838 xsd->dummy_window_for_creating_pixmaps = XCALL(XCreateSimpleWindow, xsd->display,
839 DefaultRootWindow(xsd->display),
840 0, 0, 100, 100,
841 0,
842 BlackPixel(xsd->display, DefaultScreen(xsd->display)),
843 BlackPixel(xsd->display, DefaultScreen(xsd->display)));
844 if (0 == xsd->dummy_window_for_creating_pixmaps)
845 {
846 D(bug("[X11Gfx] %s: failed to create pixmap window\n", __PRETTY_FUNCTION__));
847 ok = FALSE;
848 }
849
850 #if USE_XSHM
851 {
852 char *displayname = XCALL(XDisplayName, NULL);
853
854 if ((strncmp(displayname, ":", 1) == 0) ||
855 (strncmp(displayname, "unix:", 5) == 0))
856 {
857 /* Display is local, not remote. XSHM is possible */
858
859 /* Do we have Xshm support ? */
860 xsd->xshm_info = init_shared_mem(xsd->display);
861
862 if (NULL == xsd->xshm_info)
863 {
864 /* ok = FALSE; */
865 D(bug("INITIALIZATION OF XSHM FAILED !!\n"));
866 }
867 else
868 {
869 int a, b;
870
871 InitSemaphore(&xsd->shm_sema);
872 xsd->use_xshm = TRUE;
873
874 XCALL(XQueryExtension, xsd->display, "MIT-SHM", &xshm_major, &a, &b);
875 }
876 }
877 }
878 #endif
879
880 UNLOCK_X11
881
882 ReturnBool("initx11stuff", ok);
883
884 }
885
886 /****************************************************************************************/
887
888 static VOID cleanupx11stuff(struct x11_staticdata *xsd)
889 {
890 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
891
892 LOCK_X11
893
894 /* Do nothing for now */
895 if (0 != xsd->dummy_window_for_creating_pixmaps)
896 {
897 XCALL(XDestroyWindow, xsd->display, xsd->dummy_window_for_creating_pixmaps);
898 }
899
900 #if USE_XSHM
901 cleanup_shared_mem(xsd->display, xsd->xshm_info);
902 #endif
903
904 UNLOCK_X11
905 }
906
907 /****************************************************************************************/
908
909 //#define xsd (&LIBBASE->xsd)
910 /****************************************************************************************/
911
912 static int x11gfx_init(LIBBASETYPEPTR LIBBASE)
913 {
914 D(bug("[X11Gfx] %s: initialising semaphore @ 0x%p\n", __PRETTY_FUNCTION__, &LIBBASE->xsd.sema));
915
916 InitSemaphore(&LIBBASE->xsd.sema);
917
918 return OOP_ObtainAttrBases(attrbases);
919 }
920
921 /****************************************************************************************/
922
923 static int x11gfx_expunge(LIBBASETYPEPTR LIBBASE)
924 {
925 D(bug("[X11Gfx] %s()\n", __PRETTY_FUNCTION__));
926
927 OOP_ReleaseAttrBases(attrbases);
928 return TRUE;
929 }
930
931 /****************************************************************************************/
932
933 ADD2INITLIB(x11gfx_init, 0);
934 ADD2EXPUNGELIB(x11gfx_expunge, 0);
935
936 /****************************************************************************************/
Mirror of AROS' svn.