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

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