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