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

   1 /*
   2     Copyright © 1995-2009, 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
  10 #include <proto/exec.h>
  11 #include <proto/oop.h>
  12 #include <proto/utility.h>
  13
  14 #define size_t aros_size_t
  15 #include <hidd/unixio.h>
  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 #define DEBUG 0
  53 #include <aros/debug.h>
  54
  55 /****************************************************************************************/
  56
  57 #define NOUNIXIO                1
  58 #define BETTER_REPEAT_HANDLING  1
  59
  60 #define XTASK_NAME "x11hidd task"
  61
  62 /* We need to have highest priotity for this task, because we
  63 are simulating an interrupt. Ie. an "interrupt handler" called
  64 but this task should NEVER be interrupted by a task (for example input.device),
  65 otherwize it will give strange effects, especially in the circular-buffer handling
  66 in gameport/keyboard. (Writing to the buffer is not atomic even
  67 from within the IRQ handler!)
  68
  69  Instead of calling
  70 the irq handler directly from the task, we should instead
  71 Cause() a software irq, but Cause() does not work at the moment..
  72 */
  73
  74 #define XTASK_PRIORITY  50
  75
  76 #define XTASK_STACKSIZE (AROS_STACKSIZE)
  77
  78 #undef XSD
  79 #define XSD(cl) xsd
  80
  81 /****************************************************************************************/
  82
  83 #if NOUNIXIO
  84
  85 /****************************************************************************************/
  86
  87 AROS_UFH4(ULONG, x11VBlank,
  88     AROS_UFHA(ULONG, dummy, A0),
  89     AROS_UFHA(void *, data, A1),
  90     AROS_UFHA(ULONG, dummy2, A5),
  91     AROS_UFHA(struct ExecBase *, SysBase, A6))
  92 {
  93     AROS_USERFUNC_INIT
  94
  95     Signal((struct Task *)data, SIGBREAKF_CTRL_D);
  96
  97     return 0;
  98
  99     AROS_USERFUNC_EXIT
 100 }
 101
 102 /****************************************************************************************/
 103
 104 #else
 105
 106 /****************************************************************************************/
 107
 108 static int unixio_callback(int displayfd, struct x11_staticdata *xsd)
 109 {
 110     int pending;
 111
 112     LOCK_X11
 113     pending = XCALL(XPending, xsd->display);
 114     UNLOCK_X11
 115
 116     return pending;
 117 }
 118
 119 /****************************************************************************************/
 120
 121 #endif
 122
 123 /****************************************************************************************/
 124
 125 VOID x11task_entry(struct x11task_params *xtpparam)
 126 {
 127     struct x11_staticdata   *xsd;
 128     struct MinList           nmsg_list;
 129     struct MinList           xwindowlist;
 130     struct x11task_params    xtp;
 131     ULONG                    hostclipboardmask;
 132     BOOL                     f12_down = FALSE;
 133     KeySym                   ks;
 134
 135 #if NOUNIXIO
 136     struct Interrupt         myint;
 137 #else
 138     struct MsgPort          *unixio_port = NULL;
 139     HIDD                    *unixio = NULL;
 140     IPTR                     ret;
 141     ULONG                    unixiosig;
 142     BOOL                     domouse = FALSE;
 143     LONG                     last_mouse_x;
 144     LONG                     last_mouse_y;
 145     BOOL                     dounixio = TRUE;
 146 #endif
 147
 148     /* We must copy the parameter struct because they are allocated
 149      on the parent's stack */
 150     xtp = *xtpparam;
 151     xsd = xtp.xsd;
 152
 153
 154     xsd->x11task_notify_port = CreateMsgPort();
 155     if (NULL == xsd->x11task_notify_port)
 156         goto failexit;
 157
 158     NEWLIST(&nmsg_list);
 159     NEWLIST(&xwindowlist);
 160
 161 #if NOUNIXIO
 162
 163     myint.is_Code         = (APTR)&x11VBlank;
 164     myint.is_Data         = FindTask(NULL);
 165     myint.is_Node.ln_Name = "X11 VBlank server";
 166     myint.is_Node.ln_Pri  = 0;
 167     myint.is_Node.ln_Type = NT_INTERRUPT;
 168
 169     AddIntServer(INTB_TIMERTICK, &myint);
 170
 171
 172     Signal(xtp.parent, xtp.ok_signal);
 173
 174 #else
 175
 176     unixio = (HIDD)New_UnixIO(OOPBase, SysBase);
 177     if (unixio)
 178     {
 179         unixio_port = CreateMsgPort();
 180         if (unixio_port)
 181         {
 182             unixiosig = 1L << unixio_port->mp_SigBit;
 183             Signal(xtp.parent, xtp.ok_signal);
 184
 185         }
 186         else goto failexit;
 187     }
 188     else goto failexit;
 189 #endif
 190
 191     hostclipboardmask = x11clipboard_init(xsd);
 192
 193     for (;;)
 194     {
 195         XEvent               event;
 196     #if BETTER_REPEAT_HANDLING
 197         XEvent               keyrelease_event;
 198         BOOL                 keyrelease_pending = FALSE;
 199     #endif
 200         struct notify_msg   *nmsg;
 201         ULONG                notifysig = 1L << xsd->x11task_notify_port->mp_SigBit;
 202         ULONG                sigs;
 203
 204 #if NOUNIXIO
 205
 206         sigs = Wait(SIGBREAKF_CTRL_D | notifysig | xtp.kill_signal | hostclipboardmask);
 207
 208 #else
 209
 210
 211     #if 0
 212
 213
 214         ret = (int)Hidd_UnixIO_Wait(unixio,
 215                                     ConnectionNumber( xsd->display ),
 216                                     vHidd_UnixIO_Read,
 217                                     unixio_callback,
 218                                     (APTR)xsd,
 219                                     xtp.kill_signal | notifysig | hostclipboardmask);
 220
 221
 222     #else
 223
 224         if (dounixio)
 225         {
 226             ret = Hidd_UnixIO_AsyncIO(unixio,
 227                                        ConnectionNumber(xsd->display),  vHidd_UnixIO_Terminal,
 228                                        unixio_port, vHidd_UnixIO_Read, SysBase);
 229
 230             if (ret)
 231             {
 232
 233                 kprintf("ERROR WHEN CALLING UNIXIO: %d\n", ret);
 234                 dounixio = TRUE;
 235
 236                 continue;
 237             }
 238             else
 239             {
 240                 dounixio = FALSE;
 241             }
 242         }
 243
 244         sigs = Wait(notifysig | unixiosig | xtp.kill_signal | hostclipboardmask);
 245 D(bug("Got input from unixio\n"));
 246 /*
 247         if (ret != 0)
 248         {
 249             continue;
 250         }
 251
 252
 253 */
 254
 255         if (sigs & unixiosig)
 256         {
 257              struct uioMessage *uiomsg;
 258              int                result;
 259
 260              uiomsg = (struct uioMessage *)GetMsg(unixio_port);
 261              result = uiomsg->result;
 262
 263              FreeMem(uiomsg, sizeof (struct uioMessage));
 264
 265              dounixio = TRUE;
 266
 267              if (result)
 268                 continue;
 269         }
 270
 271     #endif
 272
 273
 274 #endif
 275         if (sigs & xtp.kill_signal)
 276             goto failexit;
 277
 278         if (sigs & notifysig)
 279         {
 280
 281             while ((nmsg = (struct notify_msg *)GetMsg(xsd->x11task_notify_port)))
 282             {
 283                 /* Add the messages to an internal list */
 284
 285                 switch (nmsg->notify_type)
 286                 {
 287                     case NOTY_WINCREATE:
 288                     {
 289                         struct xwinnode * node;
 290                         /* Maintain a list of open windows for the X11 event handler in x11.c */
 291
 292                         node = AllocMem(sizeof (struct xwinnode), MEMF_CLEAR);
 293
 294                         if (NULL != node)
 295                         {
 296
 297                             node->xwindow = nmsg->xwindow;
 298                             node->bmobj   = nmsg->bmobj;
 299                             AddTail( (struct List *)&xwindowlist, (struct Node *)node );
 300                         }
 301                         else
 302                         {
 303                             kprintf("!!!! CANNOT GET MEMORY FOR X11 WIN NODE\n");
 304                             CCALL(raise, 19);
 305                         }
 306
 307                         ReplyMsg((struct Message *)nmsg);
 308                         break;
 309                     }
 310
 311                     case NOTY_MAPWINDOW:
 312                         LOCK_X11
 313                         XCALL(XMapWindow, nmsg->xdisplay, nmsg->xwindow);
 314                     #if ADJUST_XWIN_SIZE
 315                         XCALL(XMapRaised, nmsg->xdisplay, nmsg->masterxwindow);
 316                     #endif
 317                         UNLOCK_X11
 318
 319                         AddTail((struct List *)&nmsg_list, (struct Node *)nmsg);
 320
 321                         /* Do not reply message yet */
 322                         break;
 323
 324                     case NOTY_RESIZEWINDOW:
 325                     {
 326                         XWindowChanges xwc;
 327                         BOOL replymsg = TRUE;
 328                         struct xwinnode *node;
 329
 330                         xwc.width  = nmsg->width;
 331                         xwc.height = nmsg->height;
 332
 333                         LOCK_X11
 334                         if (xsd->fullscreen)
 335                         {
 336                             x11_fullscreen_switchmode(nmsg->xdisplay, &xwc.width, &xwc.height);
 337                         }
 338                         XCALL(XConfigureWindow, nmsg->xdisplay
 339                             , nmsg->masterxwindow
 340                             , CWWidth | CWHeight
 341                             , &xwc
 342                         );
 343                         XCALL(XFlush, nmsg->xdisplay);
 344                         UNLOCK_X11
 345
 346                     #if DELAY_XWIN_MAPPING
 347                         ForeachNode(&xwindowlist, node)
 348                         {
 349                             if (node->xwindow == nmsg->xwindow)
 350                             {
 351                                 if (!node->window_mapped)
 352                                 {
 353                                     LOCK_X11
 354                                     XCALL(XMapWindow, nmsg->xdisplay, nmsg->xwindow);
 355                                 #if ADJUST_XWIN_SIZE
 356                                     XCALL(XMapRaised, nmsg->xdisplay, nmsg->masterxwindow);
 357                                 #endif
 358                                     if (xsd->fullscreen)
 359                                     {
 360                                         XCALL(XGrabKeyboard, nmsg->xdisplay,nmsg->xwindow,False,GrabModeAsync,GrabModeAsync,CurrentTime);
 361                                         XCALL(XGrabPointer, nmsg->xdisplay,nmsg->xwindow, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
 362                                                       GrabModeAsync, GrabModeAsync, nmsg->xwindow, None, CurrentTime);
 363                                     }
 364                                     XCALL(XFlush, nmsg->xdisplay);
 365                                     UNLOCK_X11
 366
 367                                     nmsg->notify_type = NOTY_MAPWINDOW;
 368                                     AddTail((struct List *)&nmsg_list, (struct Node *)nmsg);
 369
 370                                     /* Do not reply message yet */
 371                                     replymsg = FALSE;
 372
 373                                     break;
 374                                 }
 375                             }
 376                         }
 377                     #endif
 378
 379                         if (replymsg) ReplyMsg((struct Message *)nmsg);
 380
 381                         break;
 382                     }
 383
 384                     case NOTY_WINDISPOSE:
 385                     {
 386                         struct xwinnode *node, *safe;
 387
 388
 389                         ForeachNodeSafe(&xwindowlist, node, safe)
 390                         {
 391                             if (node->xwindow == nmsg->xwindow)
 392                             {
 393                                  Remove((struct Node *)node);
 394                                  FreeMem(node, sizeof (struct xwinnode));
 395                             }
 396                         }
 397
 398                         ReplyMsg((struct Message *)nmsg);
 399
 400                         break;
 401                     }
 402
 403                 } /* switch() */
 404
 405             } /* while () */
 406
 407             //continue;
 408
 409         } /* if (message from notify port) */
 410
 411         if (sigs & hostclipboardmask)
 412         {
 413             x11clipboard_handle_commands(xsd);
 414         }
 415
 416         for (;;)
 417         {
 418             struct xwinnode *node;
 419             int              pending;
 420             BOOL             window_found = FALSE;
 421
 422             LOCK_X11
 423             XCALL(XFlush, xsd->display);
 424             XCALL(XSync, xsd->display, FALSE);
 425             pending = XCALL(XEventsQueued, xsd->display, QueuedAlready);
 426             UNLOCK_X11
 427
 428             if (pending == 0)
 429             {
 430             #if BETTER_REPEAT_HANDLING
 431                 if (keyrelease_pending)
 432                 {
 433                     if (XCALL(XLookupKeysym, (XKeyEvent *)&keyrelease_event, 0) == XK_F12)
 434                     {
 435                         f12_down = FALSE;
 436                     }
 437
 438                     ObtainSemaphoreShared( &xsd->sema );
 439                     if (xsd->kbdhidd)
 440                     {
 441                         Hidd_X11Kbd_HandleEvent(xsd->kbdhidd, &keyrelease_event);
 442                     }
 443                     ReleaseSemaphore( &xsd->sema );
 444                     keyrelease_pending = FALSE;
 445                 }
 446             #endif
 447
 448                 /* Get out of for(;;) loop */
 449                 break;
 450             }
 451
 452             LOCK_X11
 453             XCALL(XNextEvent, xsd->display, &event);
 454             UNLOCK_X11
 455
 456             D(bug("Got Event for X=%d\n", event.xany.window));
 457
 458         #if BETTER_REPEAT_HANDLING
 459             if (keyrelease_pending)
 460             {
 461                 BOOL repeated_key = FALSE;
 462
 463                 /* Saw this in SDL/X11 code, where a comment says that
 464                    the idea for this was coming from GII, whatever that
 465                    is. */
 466
 467                 if ((event.xany.window == keyrelease_event.xany.window) &&
 468                     (event.type == KeyPress) &&
 469                     (event.xkey.keycode == keyrelease_event.xkey.keycode) &&
 470                     ((event.xkey.time - keyrelease_event.xkey.time) < 2))
 471                 {
 472                     repeated_key = TRUE;
 473                 }
 474
 475                 keyrelease_pending = FALSE;
 476
 477                 if (repeated_key)
 478                 {
 479                     /* Drop both previous keyrelease and this keypress event. */
 480                     continue;
 481                 }
 482
 483                 LOCK_X11
 484                 if (XCALL(XLookupKeysym, (XKeyEvent *)&keyrelease_event, 0) == XK_F12)
 485                 {
 486                     f12_down = FALSE;
 487                 }
 488                 UNLOCK_X11
 489
 490                 ObtainSemaphoreShared( &xsd->sema );
 491                 if (xsd->kbdhidd)
 492                 {
 493                     Hidd_X11Kbd_HandleEvent(xsd->kbdhidd, &keyrelease_event);
 494                 }
 495                 ReleaseSemaphore( &xsd->sema );
 496             }
 497         #endif
 498
 499             if (event.type == MappingNotify)
 500             {
 501                 LOCK_X11
 502                 XCALL(XRefreshKeyboardMapping, (XMappingEvent*)&event);
 503                 UNLOCK_X11
 504
 505                 continue;
 506             }
 507
 508         #if ADJUST_XWIN_SIZE
 509             /* Must check this here, because below only the inner
 510                window events are recognized */
 511
 512             if ((event.type == ClientMessage) &&
 513                 (event.xclient.data.l[0] == xsd->delete_win_atom))
 514             {
 515                 CCALL(raise, SIGINT);
 516             }
 517         #endif
 518
 519             ForeachNode( &xwindowlist, node)
 520             {
 521                 if (node->xwindow == event.xany.window)
 522                 {
 523                     window_found = TRUE;
 524                     break;
 525                 }
 526             }
 527
 528             if (x11clipboard_want_event(&event))
 529             {
 530                 x11clipboard_handle_event(xsd, &event);
 531             }
 532
 533             if (window_found)
 534             {
 535                 D(bug("Got event for window %x\n", event.xany.window));
 536                 switch (event.type)
 537                 {
 538                     case GraphicsExpose:
 539                     case Expose:
 540                         break;
 541
 542                     case ConfigureRequest:
 543                         kprintf("!!! CONFIGURE REQUEST !!\n");
 544                         break;
 545
 546                 #if 0
 547                     /* stegerg: not needed */
 548                     case ConfigureNotify:
 549                     {
 550                         /* The window has been resized */
 551
 552                         XConfigureEvent     *me;
 553                         struct notify_msg   *nmsg, *safe;
 554
 555                         me = (XConfigureEvent *)&event;
 556                         ForeachNodeSafe(&nmsg_list, nmsg, safe)
 557                         {
 558                             if (    me->window == nmsg->xwindow
 559                                  && nmsg->notify_type == NOTY_RESIZEWINDOW)
 560                             {
 561                                  /*  The window has now been mapped.
 562                                      Send reply to app */
 563
 564                                  Remove((struct Node *)nmsg);
 565                                  ReplyMsg((struct Message *)nmsg);
 566                             }
 567                         }
 568
 569
 570
 571                         break;
 572                     }
 573                 #endif
 574
 575                     case ButtonPress:
 576                         xsd->x_time = event.xbutton.time;
 577                         D(bug("ButtonPress event\n"));
 578
 579                         ObtainSemaphoreShared( &xsd->sema );
 580                         if (xsd->mousehidd)
 581                             Hidd_X11Mouse_HandleEvent(xsd->mousehidd, &event);
 582                         ReleaseSemaphore( &xsd->sema );
 583                         break;
 584
 585                     case ButtonRelease:
 586                         xsd->x_time = event.xbutton.time;
 587                         D(bug("ButtonRelease event\n"));
 588
 589                         ObtainSemaphoreShared( &xsd->sema );
 590                         if (xsd->mousehidd)
 591                             Hidd_X11Mouse_HandleEvent(xsd->mousehidd, &event);
 592                         ReleaseSemaphore( &xsd->sema );
 593                         break;
 594
 595                     case MotionNotify:
 596                         xsd->x_time = event.xmotion.time;
 597                         D(bug("Motionnotify event\n"));
 598
 599                         ObtainSemaphoreShared( &xsd->sema );
 600                         if (xsd->mousehidd)
 601                             Hidd_X11Mouse_HandleEvent(xsd->mousehidd, &event);
 602                         ReleaseSemaphore( &xsd->sema );
 603                         break;
 604
 605                     case FocusOut:
 606                     #if !BETTER_REPEAT_HANDLING
 607                         LOCK_X11
 608                         XCALL(XAutoRepeatOn, xsd->display);
 609                         UNLOCK_X11
 610                     #endif
 611
 612                     #if 0
 613                         ObtainSemaphoreShared(&xsd->sema);
 614                         /* Call the user supplied callback func, if supplied */
 615                         if (NULL != xsd->activecallback)
 616                         {
 617                             xsd->activecallback(xsd->callbackdata, node->bmobj, FALSE);
 618                         }
 619                         ReleaseSemaphore(&xsd->sema);
 620                     #endif
 621                         break;
 622
 623                     case FocusIn:
 624                     #if 0
 625                         ObtainSemaphoreShared(&xsd->sema);
 626                         /* Call the user supplied callback func, if supplied */
 627                         if (NULL != xsd->activecallback)
 628                         {
 629                             xsd->activecallback(xsd->callbackdata, node->bmobj, TRUE);
 630                         }
 631                         ReleaseSemaphore(&xsd->sema);
 632                     #endif
 633                         break;
 634
 635                     case KeyPress:
 636                         xsd->x_time = event.xkey.time;
 637
 638                         LOCK_X11
 639                     #if !BETTER_REPEAT_HANDLING
 640                         XCALL(XAutoRepeatOff, XSD(cl)->display);
 641                     #endif
 642                         ks = XCALL(XLookupKeysym, (XKeyEvent *)&event, 0);
 643                         if (ks == XK_F12)
 644                         {
 645                             f12_down = TRUE;
 646                         }
 647                         else if (f12_down && ((ks == XK_Q) || (ks == XK_q)))
 648                         {
 649                             CCALL(raise, SIGINT);
 650                         }
 651                         UNLOCK_X11
 652
 653                         ObtainSemaphoreShared( &xsd->sema );
 654                         if (xsd->kbdhidd)
 655                         {
 656                             Hidd_X11Kbd_HandleEvent(xsd->kbdhidd, &event);
 657                         }
 658                         ReleaseSemaphore( &xsd->sema );
 659                         break;
 660
 661
 662                     case KeyRelease:
 663                         xsd->x_time = event.xkey.time;
 664
 665                     #if BETTER_REPEAT_HANDLING
 666                         keyrelease_pending = TRUE;
 667                         keyrelease_event = event;
 668                     #else
 669                         LOCK_X11
 670                         if (XCALL(XLookupKeysym, &event, 0) == XK_F12)
 671                         {
 672                             f12_down = FALSE;
 673                         }
 674                         XCALL(XAutoRepeatOn, XSD(cl)->display);
 675                         UNLOCK_X11
 676
 677                         ObtainSemaphoreShared( &xsd->sema );
 678                         if (xsd->kbdhidd)
 679                         {
 680                             Hidd_X11Kbd_HandleEvent(xsd->kbdhidd, &event);
 681                         }
 682                         ReleaseSemaphore( &xsd->sema );
 683                     #endif
 684                         break;
 685
 686                     case EnterNotify:
 687                         break;
 688
 689                     case LeaveNotify:
 690                         break;
 691
 692                     case MapNotify:
 693                     {
 694
 695                         XMapEvent           *me;
 696                         struct notify_msg   *nmsg, *safe;
 697                         struct xwinnode     *node;
 698                         BOOL                 found = FALSE;
 699
 700                         me = (XMapEvent *)&event;
 701
 702                         ForeachNodeSafe(&nmsg_list, nmsg, safe)
 703                         {
 704                             if (me->window == nmsg->xwindow
 705                                 && nmsg->notify_type == NOTY_MAPWINDOW)
 706                             {
 707                                  /*  The window has now been mapped.
 708                                      Send reply to app */
 709
 710                                  found = TRUE;
 711                                  Remove((struct Node *)nmsg);
 712                                  ReplyMsg((struct Message *)nmsg);
 713                             }
 714                         }
 715
 716                         /* Find it in thw window list and mark it as mapped */
 717
 718                         ForeachNode(&xwindowlist, node)
 719                         {
 720                             if (node->xwindow == me->window)
 721                             {
 722                                 node->window_mapped = TRUE;
 723                             }
 724                         }
 725
 726
 727                         break;
 728                     }
 729
 730                 #if !ADJUST_XWIN_SIZE
 731                     case ClientMessage:
 732                         if (event.xclient.data.l[0] == xsd->delete_win_atom)
 733                         {
 734                             CCALL(raise, SIGINT);
 735                         }
 736                         break;
 737                 #endif
 738
 739                 } /* switch (X11 event type) */
 740
 741             } /* if (is event for HIDD window) */
 742
 743         } /* while (events from X)  */
 744
 745     } /* Forever */
 746
 747 failexit:
 748     #warning "Also try to free window node list ?"
 749
 750     if (xsd->x11task_notify_port)
 751     {
 752         DeleteMsgPort(xsd->x11task_notify_port);
 753     }
 754
 755
 756 #if (!NOUNIXIO)
 757     if (NULL != unixio_port)
 758     {
 759         DeleteMsgPort(unixio_port);
 760     }
 761
 762     if (NULL != unixio)
 763     {
 764         OOP_DisposeObject(unixio);
 765     }
 766 #endif
 767
 768     Signal(xtp.parent, xtp.fail_signal);
 769
 770 }
 771
 772 /****************************************************************************************/
 773
 774 struct Task *create_x11task( struct x11task_params *params)
 775 {
 776     struct Task *task;
 777     APTR         stack;
 778
 779     task = AllocMem(sizeof (struct Task), MEMF_PUBLIC|MEMF_CLEAR);
 780     if (task)
 781     {
 782         NEWLIST(&task->tc_MemEntry);
 783         task->tc_Node.ln_Type =NT_TASK;
 784         task->tc_Node.ln_Name = XTASK_NAME;
 785         task->tc_Node.ln_Pri  = XTASK_PRIORITY;
 786
 787         stack = AllocMem(XTASK_STACKSIZE, MEMF_PUBLIC);
 788         if(stack != NULL)
 789         {
 790             struct TagItem tags[] =
 791             {
 792                  {TASKTAG_ARG1, (IPTR)params},
 793                  {TAG_DONE                  }
 794             };
 795
 796             task->tc_SPLower = stack;
 797             task->tc_SPUpper = (UBYTE *)stack + XTASK_STACKSIZE;
 798
 799         #if AROS_STACK_GROWS_DOWNWARDS
 800             task->tc_SPReg = (UBYTE *)task->tc_SPUpper-SP_OFFSET;
 801         #else
 802             task->tc_SPReg = (UBYTE *)task->tc_SPLower+SP_OFFSET;
 803         #endif
 804
 805             /* You have to clear signals first. */
 806             SetSignal(0, params->ok_signal | params->fail_signal);
 807
 808             if(NewAddTask(task, x11task_entry, NULL, tags) != NULL)
 809             {
 810                 /* Everything went OK. Wait for task to initialize */
 811                 ULONG sigset;
 812
 813
 814                 sigset = Wait( params->ok_signal | params->fail_signal );
 815                 if (sigset & params->ok_signal)
 816                 {
 817                     return task;
 818                 }
 819
 820             }
 821             FreeMem(stack, XTASK_STACKSIZE);
 822
 823         }
 824         FreeMem(task,sizeof(struct Task));
 825
 826     }
 827     return NULL;
 828 }
 829
 830 /****************************************************************************************/