arch/all-hosted/hidd/x11/x11.c

   1 /*
   2     Copyright © 1995-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: X11 hidd. Connects to the X server and receives events.
   6     Lang: English.
   7 */
   8
   9 #include "x11_debug.h"
  10
  11 #include <proto/exec.h>
  12 #include <proto/oop.h>
  13 #include <proto/utility.h>
  14
  15 #define size_t aros_size_t
  16 #include <hidd/hidd.h>
  17
  18 #include <oop/ifmeta.h>
  19
  20 #include <dos/dos.h>
  21
  22 #include <exec/types.h>
  23 #include <exec/lists.h>
  24 #include <exec/memory.h>
  25 #include <exec/libraries.h>
  26 #include <exec/resident.h>
  27 #include <hardware/intbits.h>
  28 #include <utility/utility.h>
  29
  30 #include <aros/asmcall.h>
  31 #undef size_t
  32
  33 #define timeval sys_timevalinit_x11class
  34 #include <sys/types.h>
  35 #include <signal.h>
  36 #include <stddef.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #undef timeval
  42
  43 #include <X11/Xlib.h>
  44 #include <X11/Xutil.h>
  45 #include <X11/Xatom.h>
  46 #include <X11/keysym.h>
  47
  48 #include "x11.h"
  49 #include "fullscreen.h"
  50 #include "x11gfx_intern.h"
  51
  52 VOID X11BM_ExposeFB(APTR data, WORD x, WORD y, WORD width, WORD height);
  53
  54 /****************************************************************************************/
  55
  56 #define BETTER_REPEAT_HANDLING  1
  57
  58 #define XTASK_NAME "x11hidd task"
  59
  60 /* We need to have highest priority for this task, because we
  61  are simulating an interrupt. I.e. an "interrupt handler" called
  62  by this task should NEVER be interrupted by a task (for example input.device),
  63  otherwise it will give strange effects, especially in the circular-buffer
  64  handling in gameport/keyboard. (Writing to the buffer is not atomic even
  65  from within the IRQ handler!)
  66
  67  Instead of calling
  68  the irq handler directly from the task, we should instead
  69  Cause() a software irq, but Cause() does not work at the moment..
  70  */
  71
  72 #define XTASK_PRIORITY  50
  73
  74 #define XTASK_STACKSIZE (AROS_STACKSIZE)
  75
  76 #undef XSD
  77 #define XSD(cl) xsd
  78
  79 /****************************************************************************************/
  80
  81 AROS_INTH1(x11VBlank, struct Task *, task)
  82 {
  83     AROS_INTFUNC_INIT
  84
  85     DB2(bug("[X11] %s()\n", __PRETTY_FUNCTION__));
  86
  87     Signal(task, SIGBREAKF_CTRL_D);
  88
  89     return FALSE;
  90
  91     AROS_INTFUNC_EXIT
  92 }
  93
  94 /****************************************************************************************/
  95
  96 VOID x11task_entry(struct x11task_params *xtpparam)
  97 {
  98     ULONG notifysig;
  99     struct MinList nmsg_list;
 100     struct MinList xwindowlist;
 101     ULONG hostclipboardmask;
 102     BOOL f12_down = FALSE;
 103     KeySym ks;
 104
 105     /* copy needed parameter's because they are allocated on the parent's stack */
 106
 107     struct Task *task_Parent = xtpparam->parent;
 108     ULONG  task_SigKill = xtpparam->kill_signal;
 109     struct x11_staticdata *xsd = xtpparam->xsd;
 110
 111     struct Interrupt myint;
 112
 113     D(bug("[X11] %s()\n", __PRETTY_FUNCTION__));
 114
 115     xsd->x11task_notify_port = CreateMsgPort();
 116     if (NULL == xsd->x11task_notify_port)
 117     {
 118         D(bug("[X11] %s: failed to create notification port!\n", __PRETTY_FUNCTION__));
 119         Signal(task_Parent, xtpparam->fail_signal);
 120         return;
 121     }
 122
 123     D(bug("[X11] %s: notification port @ 0x%p\n", __PRETTY_FUNCTION__, xsd->x11task_notify_port));
 124
 125     notifysig = 1L << xsd->x11task_notify_port->mp_SigBit;
 126
 127     D(bug("[X11] %s: notification signal = %08x (bit %d)\n", __PRETTY_FUNCTION__, notifysig, xsd->x11task_notify_port->mp_SigBit));
 128
 129     NEWLIST(&nmsg_list);
 130     NEWLIST(&xwindowlist);
 131
 132     myint.is_Code = (VOID_FUNC) x11VBlank;
 133     myint.is_Data = FindTask(NULL);
 134     myint.is_Node.ln_Name = "X11 VBlank server";
 135     myint.is_Node.ln_Pri = 0;
 136     myint.is_Node.ln_Type = NT_INTERRUPT;
 137
 138     AddIntServer(INTB_VERTB, &myint);
 139
 140     Signal(task_Parent, xtpparam->ok_signal);
 141
 142     /* N.B : do not attempt to use xtpparam after this point! */
 143
 144     hostclipboardmask = x11clipboard_init(xsd);
 145
 146     for (;;)
 147     {
 148         XEvent event;
 149 #if BETTER_REPEAT_HANDLING
 150         XEvent keyrelease_event;
 151         BOOL keyrelease_pending = FALSE;
 152 #endif
 153         struct notify_msg *nmsg;
 154         ULONG sigs;
 155
 156         DB2(bug("[X11] %s: waiting for signals...\n", __PRETTY_FUNCTION__));
 157
 158         sigs = Wait(SIGBREAKF_CTRL_D | notifysig | task_SigKill| hostclipboardmask);
 159
 160         DB2(bug("[X11] %s: signal %08x received\n", __PRETTY_FUNCTION__, sigs));
 161
 162         if (sigs & task_SigKill)
 163         {
 164             D(bug("[X11] %s: kill signal received - exiting\n", __PRETTY_FUNCTION__));
 165             break;
 166         }
 167
 168         if (sigs & notifysig)
 169         {
 170             D(bug("[X11] %s: notification signal received\n", __PRETTY_FUNCTION__));
 171
 172             while ((nmsg = (struct notify_msg *) GetMsg(xsd->x11task_notify_port)))
 173             {
 174                 /* Add the messages to an internal list */
 175
 176                 switch (nmsg->notify_type)
 177                 {
 178                 case NOTY_WINCREATE:
 179                     {
 180                         struct xwinnode * node;
 181                         /* Maintain a list of open windows for the X11 event handler in x11.c */
 182
 183                         D(bug("[X11] %s: NOTY_WINCREATE\n", __PRETTY_FUNCTION__));
 184
 185                         node = AllocMem(sizeof(struct xwinnode), MEMF_CLEAR);
 186
 187                         if (NULL != node)
 188                         {
 189                             node->xwindow = nmsg->xwindow;
 190                             node->masterxwindow = nmsg->masterxwindow;
 191                             node->bmobj = nmsg->bmobj;
 192                             AddTail((struct List *) &xwindowlist, (struct Node *) node);
 193                         }
 194                         else
 195                         {
 196                             bug("!!!! CANNOT GET MEMORY FOR X11 WIN NODE\n");
 197                             CCALL(raise, 19);
 198                         }
 199
 200                         ReplyMsg((struct Message *) nmsg);
 201                         break;
 202                     }
 203                 case NOTY_MAPWINDOW:
 204                     {
 205                         D(bug("[X11] %s: NOTY_MAPWINDOW Window @ 0x%p (Display = 0x%p)\n", __PRETTY_FUNCTION__, nmsg->xwindow, nmsg->xdisplay));
 206
 207                         LOCK_X11
 208                         XCALL(XMapWindow, nmsg->xdisplay, nmsg->xwindow);
 209 #if ADJUST_XWIN_SIZE
 210                         XCALL(XMapRaised, nmsg->xdisplay, nmsg->masterxwindow);
 211 #endif
 212                         UNLOCK_X11
 213
 214                         AddTail((struct List *) &nmsg_list, (struct Node *) nmsg);
 215
 216                         /* Do not reply message yet */
 217                         break;
 218                     }
 219                 case NOTY_RESIZEWINDOW:
 220                     {
 221                         XWindowChanges xwc;
 222                         XSizeHints sizehint;
 223                         BOOL replymsg = TRUE;
 224
 225                         D(bug("[X11] %s: NOTY_RESIZEWINDOW\n", __PRETTY_FUNCTION__));
 226
 227                         xwc.width = nmsg->width;
 228                         xwc.height = nmsg->height;
 229
 230                         sizehint.flags = PMinSize | PMaxSize;
 231                         sizehint.min_width = nmsg->width;
 232                         sizehint.min_height = nmsg->height;
 233                         sizehint.max_width = nmsg->width;
 234                         sizehint.max_height = nmsg->height;
 235
 236                         LOCK_X11
 237                         if (xsd->options & OPTION_FULLSCREEN)
 238                         {
 239                             x11_fullscreen_switchmode(nmsg->xdisplay, &xwc.width, &xwc.height);
 240                         }
 241
 242                         XCALL(XSetWMNormalHints, nmsg->xdisplay, nmsg->masterxwindow, &sizehint);
 243                         XCALL(XConfigureWindow, nmsg->xdisplay, nmsg->masterxwindow, CWWidth | CWHeight, &xwc);
 244                         XCALL(XFlush, nmsg->xdisplay);
 245                         UNLOCK_X11
 246
 247                         if (xsd->options & OPTION_DELAYXWINMAPPING)
 248                         {
 249                             struct xwinnode *node;
 250                             ForeachNode(&xwindowlist, node)
 251                             {
 252                                 if (node->xwindow == nmsg->xwindow)
 253                                 {
 254                                     if (!node->window_mapped)
 255                                     {
 256                                         LOCK_X11
 257                                         XCALL(XMapWindow, nmsg->xdisplay, nmsg->xwindow);
 258 #if ADJUST_XWIN_SIZE
 259                                         XCALL(XMapRaised, nmsg->xdisplay, nmsg->masterxwindow);
 260 #endif
 261                                         if (xsd->options & OPTION_FULLSCREEN)
 262                                         {
 263                                             XCALL(XGrabKeyboard, nmsg->xdisplay, nmsg->xwindow, False, GrabModeAsync, GrabModeAsync, CurrentTime);
 264                                             XCALL(XGrabPointer, nmsg->xdisplay, nmsg->xwindow, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, nmsg->xwindow, None, CurrentTime);
 265                                         }
 266
 267                                         XCALL(XFlush, nmsg->xdisplay);
 268                                         UNLOCK_X11
 269
 270                                         nmsg->notify_type = NOTY_MAPWINDOW;
 271                                         AddTail((struct List *) &nmsg_list, (struct Node *) nmsg);
 272
 273                                         /* Do not reply message yet */
 274                                         replymsg = FALSE;
 275
 276                                         break;
 277                                     }
 278                                 }
 279                             }
 280                         }
 281
 282                         if (replymsg)
 283                             ReplyMsg((struct Message *) nmsg);
 284
 285                         break;
 286                     }
 287                 case NOTY_WINDISPOSE:
 288                     {
 289                         struct xwinnode *node, *safe;
 290
 291                         D(bug("[X11] %s: NOTY_WINDISPOSE\n", __PRETTY_FUNCTION__));
 292
 293                         ForeachNodeSafe(&xwindowlist, node, safe)
 294                         {
 295                             if (node->xwindow == nmsg->xwindow)
 296                             {
 297                                 Remove((struct Node *) node);
 298                                 FreeMem(node, sizeof(struct xwinnode));
 299                             }
 300                         }
 301                         ReplyMsg((struct Message *) nmsg);
 302                         break;
 303                     }
 304                 } /* switch() */
 305             } /* while () */
 306             //continue;
 307         } /* if (message from notify port) */
 308
 309         if (sigs & hostclipboardmask)
 310         {
 311             x11clipboard_handle_commands(xsd);
 312         }
 313
 314         for (;;)
 315         {
 316             struct xwinnode *node;
 317             int pending;
 318             BOOL window_found = FALSE;
 319
 320             LOCK_X11
 321             XCALL(XFlush, xsd->display);
 322             XCALL(XSync, xsd->display, FALSE);
 323             pending = XCALL(XEventsQueued, xsd->display, QueuedAlready);
 324             UNLOCK_X11
 325
 326             if (pending == 0)
 327             {
 328 #if BETTER_REPEAT_HANDLING
 329                 if (keyrelease_pending)
 330                 {
 331                     LOCK_X11
 332                     if (XCALL(XLookupKeysym, (XKeyEvent *)&keyrelease_event, 0)
 333                             == XK_F12)
 334                     {
 335                         f12_down = FALSE;
 336                     }
 337                     UNLOCK_X11
 338
 339                     ObtainSemaphoreShared(&xsd->sema);
 340                     if (xsd->kbdhidd)
 341                     {
 342                         Hidd_X11Kbd_HandleEvent(xsd->kbdhidd, &keyrelease_event);
 343                     }
 344                     ReleaseSemaphore(&xsd->sema);
 345                     keyrelease_pending = FALSE;
 346                 }
 347 #endif
 348
 349                 /* Get out of for(;;) loop */
 350                 break;
 351             }
 352
 353             LOCK_X11
 354             XCALL(XNextEvent, xsd->display, &event);
 355             UNLOCK_X11
 356
 357             D(bug("Got Event for X=%d\n", event.xany.window));
 358
 359 #if BETTER_REPEAT_HANDLING
 360             if (keyrelease_pending)
 361             {
 362                 BOOL repeated_key = FALSE;
 363
 364                 /* Saw this in SDL/X11 code, where a comment says that
 365                  the idea for this was coming from GII, whatever that
 366                  is. */
 367
 368                 if ((event.xany.window == keyrelease_event.xany.window)
 369                         && (event.type == KeyPress)
 370                         && (event.xkey.keycode == keyrelease_event.xkey.keycode)
 371                         && ((event.xkey.time - keyrelease_event.xkey.time) < 2))
 372                 {
 373                     repeated_key = TRUE;
 374                 }
 375
 376                 keyrelease_pending = FALSE;
 377
 378                 if (repeated_key)
 379                 {
 380                     /* Drop both previous keyrelease and this keypress event. */
 381                     continue;
 382                 }
 383
 384                 LOCK_X11
 385                 if (XCALL(XLookupKeysym, (XKeyEvent *)&keyrelease_event, 0)
 386                         == XK_F12)
 387                 {
 388                     f12_down = FALSE;
 389                 }
 390                 UNLOCK_X11
 391
 392                 ObtainSemaphoreShared(&xsd->sema);
 393                 if (xsd->kbdhidd)
 394                 {
 395                     Hidd_X11Kbd_HandleEvent(xsd->kbdhidd, &keyrelease_event);
 396                 }
 397                 ReleaseSemaphore(&xsd->sema);
 398             }
 399 #endif
 400
 401             if (event.type == MappingNotify)
 402             {
 403                 LOCK_X11
 404                 XCALL(XRefreshKeyboardMapping, (XMappingEvent*)&event);
 405                 UNLOCK_X11
 406
 407                 continue;
 408             }
 409
 410 #if ADJUST_XWIN_SIZE
 411             /* Must check this here, because below only the inner
 412              window events are recognized */
 413
 414             if ((event.type == ClientMessage) && (event.xclient.data.l[0] == xsd->delete_win_atom))
 415             {
 416                 D(bug("Shutting down AROS\n"));
 417                 CCALL(raise, SIGINT);
 418             }
 419
 420             /* Redirect focus from outer window to inner window. This allows
 421              keys to be seen without the mouse hovering over the window */
 422             if (event.type == FocusIn)
 423             {
 424                 ForeachNode(&xwindowlist, node)
 425                 {
 426                     if (node->masterxwindow == event.xfocus.window)
 427                     {
 428                         LOCK_X11
 429                         XCALL(XSetInputFocus, xsd->display, node->xwindow,
 430                             RevertToParent, CurrentTime);
 431                         UNLOCK_X11
 432                         break;
 433                     }
 434                 }
 435             }
 436 #endif
 437
 438             ForeachNode(&xwindowlist, node)
 439             {
 440                 if (node->xwindow == event.xany.window)
 441                 {
 442                     window_found = TRUE;
 443                     break;
 444                 }
 445             }
 446
 447             if (x11clipboard_want_event(&event))
 448             {
 449                 x11clipboard_handle_event(xsd, &event);
 450             }
 451
 452             if (window_found)
 453             {
 454                 D(bug("Got event for window %x\n", event.xany.window));
 455                 switch (event.type)
 456                 {
 457                 case GraphicsExpose:
 458                     break;
 459
 460                 case Expose:
 461                     LOCK_X11
 462                     X11BM_ExposeFB(OOP_INST_DATA(OOP_OCLASS(node->bmobj), node->bmobj), event.xexpose.x,
 463                             event.xexpose.y, event.xexpose.width, event.xexpose.height);
 464                     UNLOCK_X11
 465                     break;
 466
 467                 case ConfigureRequest:
 468                     bug("!!! CONFIGURE REQUEST !!\n");
 469                     break;
 470
 471 #if 0
 472                 /* stegerg: not needed */
 473                 case ConfigureNotify:
 474                 {
 475                     /* The window has been resized */
 476
 477                     XConfigureEvent *me;
 478                     struct notify_msg *nmsg, *safe;
 479
 480                     me = (XConfigureEvent *)&event;
 481                     ForeachNodeSafe(&nmsg_list, nmsg, safe)
 482                     {
 483                         if ( me->window == nmsg->xwindow
 484                                 && nmsg->notify_type == NOTY_RESIZEWINDOW)
 485                         {
 486                             /*  The window has now been mapped.
 487                              Send reply to app */
 488
 489                             Remove((struct Node *)nmsg);
 490                             ReplyMsg((struct Message *)nmsg);
 491                         }
 492                     }
 493
 494                     break;
 495                 }
 496 #endif
 497
 498                 case ButtonPress:
 499                     xsd->x_time = event.xbutton.time;
 500                     D(bug("ButtonPress event\n"));
 501
 502                     ObtainSemaphoreShared(&xsd->sema);
 503                     if (xsd->mousehidd)
 504                         Hidd_X11Mouse_HandleEvent(xsd->mousehidd, &event);
 505                     ReleaseSemaphore(&xsd->sema);
 506                     break;
 507
 508                 case ButtonRelease:
 509                     xsd->x_time = event.xbutton.time;
 510                     D(bug("ButtonRelease event\n"));
 511
 512                     ObtainSemaphoreShared(&xsd->sema);
 513                     if (xsd->mousehidd)
 514                         Hidd_X11Mouse_HandleEvent(xsd->mousehidd, &event);
 515                     ReleaseSemaphore(&xsd->sema);
 516                     break;
 517
 518                 case MotionNotify:
 519                     xsd->x_time = event.xmotion.time;
 520                     D(bug("Motionnotify event\n"));
 521
 522                     ObtainSemaphoreShared(&xsd->sema);
 523                     if (xsd->mousehidd)
 524                         Hidd_X11Mouse_HandleEvent(xsd->mousehidd, &event);
 525                     ReleaseSemaphore(&xsd->sema);
 526                     break;
 527
 528                 case FocusOut:
 529 #if !BETTER_REPEAT_HANDLING
 530                     LOCK_X11
 531                     XCALL(XAutoRepeatOn, xsd->display);
 532                     UNLOCK_X11
 533 #endif
 534                     break;
 535
 536                 case FocusIn:
 537                     /* Call the user supplied callback func, if supplied */
 538                     if (NULL != xsd->activecallback)
 539                     {
 540                         xsd->activecallback(xsd->callbackdata, NULL);
 541                     }
 542                     break;
 543
 544                 case KeyPress:
 545                     xsd->x_time = event.xkey.time;
 546
 547                     LOCK_X11
 548 #if !BETTER_REPEAT_HANDLING
 549                     XCALL(XAutoRepeatOff, XSD(cl)->display);
 550 #endif
 551                     ks = XCALL(XLookupKeysym, (XKeyEvent *)&event, 0);
 552                     if (ks == XK_F12)
 553                     {
 554                         f12_down = TRUE;
 555                     }
 556                     else if (f12_down && ((ks == XK_Q) || (ks == XK_q)))
 557                     {
 558                         CCALL(raise, SIGINT);
 559                     }
 560                     UNLOCK_X11
 561
 562                     ObtainSemaphoreShared(&xsd->sema);
 563                     if (xsd->kbdhidd)
 564                     {
 565                         Hidd_X11Kbd_HandleEvent(xsd->kbdhidd, &event);
 566                     }
 567                     ReleaseSemaphore(&xsd->sema);
 568                     break;
 569
 570                 case KeyRelease:
 571                     xsd->x_time = event.xkey.time;
 572
 573 #if BETTER_REPEAT_HANDLING
 574                     keyrelease_pending = TRUE;
 575                     keyrelease_event = event;
 576 #else
 577                     LOCK_X11
 578                     if (XCALL(XLookupKeysym, &event, 0) == XK_F12)
 579                     {
 580                         f12_down = FALSE;
 581                     }
 582                     XCALL(XAutoRepeatOn, XSD(cl)->display);
 583                     UNLOCK_X11
 584
 585                     ObtainSemaphoreShared( &xsd->sema );
 586                     if (xsd->kbdhidd)
 587                     {
 588                         Hidd_X11Kbd_HandleEvent(xsd->kbdhidd, &event);
 589                     }
 590                     ReleaseSemaphore( &xsd->sema );
 591 #endif
 592                     break;
 593
 594                 case EnterNotify:
 595                     break;
 596
 597                 case LeaveNotify:
 598                     break;
 599
 600                 case MapNotify:
 601                 {
 602
 603                     XMapEvent *me;
 604                     struct notify_msg *nmsg, *safe;
 605                     struct xwinnode *node;
 606
 607                     me = (XMapEvent *) &event;
 608
 609                     ForeachNodeSafe(&nmsg_list, nmsg, safe)
 610                     {
 611                         if (me->window == nmsg->xwindow && nmsg->notify_type == NOTY_MAPWINDOW)
 612                         {
 613                             /*  The window has now been mapped.
 614                              Send reply to app */
 615
 616                             Remove((struct Node *) nmsg);
 617                             ReplyMsg((struct Message *) nmsg);
 618                         }
 619                     }
 620
 621                     /* Find it in the window list and mark it as mapped */
 622
 623                     ForeachNode(&xwindowlist, node)
 624                     {
 625                         if (node->xwindow == me->window)
 626                         {
 627                             node->window_mapped = TRUE;
 628                         }
 629                     }
 630
 631                     break;
 632                 }
 633
 634 #if !ADJUST_XWIN_SIZE
 635                     case ClientMessage:
 636                     if (event.xclient.data.l[0] == xsd->delete_win_atom)
 637                     {
 638                         CCALL(raise, SIGINT);
 639                     }
 640                     break;
 641 #endif
 642
 643                 } /* switch (X11 event type) */
 644
 645             } /* if (is event for HIDD window) */
 646
 647         } /* while (events from X)  */
 648
 649     } /* Forever */
 650
 651     /* Also try to free window node list ? */
 652     if (xsd->x11task_notify_port)
 653     {
 654         DeleteMsgPort(xsd->x11task_notify_port);
 655     }
 656 }
 657
 658 /****************************************************************************************/
 659
 660 struct Task *create_x11task(struct x11task_params *params)
 661 {
 662     struct Task *task;
 663
 664     D(bug("[X11] %s()\n", __PRETTY_FUNCTION__));
 665
 666     task = NewCreateTask(TASKTAG_PC, x11task_entry, TASKTAG_STACKSIZE,
 667             XTASK_STACKSIZE, TASKTAG_NAME, XTASK_NAME, TASKTAG_PRI,
 668             XTASK_PRIORITY, TASKTAG_ARG1, params, TAG_DONE);
 669     if (task)
 670     {
 671         D(bug("[X11] %s: task @ 0x%p\n", __PRETTY_FUNCTION__, task));
 672
 673         /* Everything went OK. Wait for task to initialize */
 674         ULONG sigset;
 675
 676         sigset = Wait(params->ok_signal | params->fail_signal);
 677         if (sigset & params->ok_signal)
 678         {
 679             D(bug("[X11] %s: got ok signal\n", __PRETTY_FUNCTION__));
 680
 681             return task;
 682         }
 683     }
 684     return NULL;
 685 }
 686
 687 /****************************************************************************************/