gesture/gesture.c

   1 /**************************************************************************\r
   2 \r
   3 xorg-server/gesture/gesture.c\r
   4 \r
   5 Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved\r
   6 \r
   7 Contact: Sung-Jin Park <sj76.park@samsung.com>\r
   8          Sangjin LEE <lsj119@samsung.com>\r
   9 \r
  10 Permission is hereby granted, free of charge, to any person obtaining a\r
  11 copy of this software and associated documentation files (the\r
  12 "Software"), to deal in the Software without restriction, including\r
  13 without limitation the rights to use, copy, modify, merge, publish,\r
  14 distribute, sub license, and/or sell copies of the Software, and to\r
  15 permit persons to whom the Software is furnished to do so, subject to\r
  16 the following conditions:\r
  17 \r
  18 The above copyright notice and this permission notice (including the\r
  19 next paragraph) shall be included in all copies or substantial portions\r
  20 of the Software.\r
  21 \r
  22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS\r
  23 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
  24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.\r
  25 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR\r
  26 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\r
  27 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\r
  28 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  29 \r
  30 **************************************************************************/\r
  31 \r
  32 #ifdef HAVE_DIX_CONFIG_H\r
  33 #include <dix-config.h>\r
  34 #endif\r
  35 \r
  36 #include "misc.h"\r
  37 #include "dixstruct.h"\r
  38 #include "globals.h"\r
  39 #include "extnsionst.h"\r
  40 #include "windowstr.h"\r
  41 #include "servermd.h"\r
  42 #include "swaprep.h"\r
  43 #include <X11/extensions/gestureproto.h>\r
  44 #include "gestureext.h"\r
  45 #include "protocol-versions.h"\r
  46 #include "inputstr.h"\r
  47 \r
  48 //#define __DEBUG_GESTURE_EXT__\r
  49 \r
  50 DevPrivateKeyRec gestureWindowPrivateKeyRec;\r
  51 #define gestureWindowPrivateKey (&gestureWindowPrivateKeyRec)\r
  52 \r
  53 static Mask grabbed_events_mask = 0;\r
  54 static int max_num_finger = 0;\r
  55 static GestureGrabEventRec grabbed_events[GestureNumberEvents];\r
  56 \r
  57 extern CallbackListPtr ResourceStateCallback;\r
  58 \r
  59 static unsigned char GestureReqCode = 0;\r
  60 static int GestureEventBase = 0;\r
  61 static int GestureErrorBase;\r
  62 \r
  63 static GestureProcsPtr GestureProcs;\r
  64 static GestureProcsRec GestureExtProcs = {\r
  65 };\r
  66 \r
  67 static DISPATCH_PROC(ProcGestureDispatch);\r
  68 static DISPATCH_PROC(ProcGestureQueryVersion);\r
  69 static DISPATCH_PROC(ProcGestureSelectEvents);\r
  70 static DISPATCH_PROC(ProcGestureGetSelectedEvents);\r
  71 static DISPATCH_PROC(ProcGestureGrabEvent);\r
  72 static DISPATCH_PROC(ProcGestureUngrabEvent);\r
  73 static DISPATCH_PROC(SProcGestureDispatch);\r
  74 static DISPATCH_PROC(SProcGestureQueryVersion);\r
  75 static DISPATCH_PROC(SProcGestureSelectEvents);\r
  76 static DISPATCH_PROC(SProcGestureGetSelectedEvents);\r
  77 static DISPATCH_PROC(SProcGestureGrabEvent);\r
  78 static DISPATCH_PROC(SProcGestureUngrabEvent);\r
  79 \r
  80 //event swap functions\r
  81 static void SGestureNotifyGroupEvent(xGestureNotifyGroupEvent *from, xGestureNotifyGroupEvent *to);\r
  82 static void SGestureNotifyFlickEvent(xGestureNotifyFlickEvent *from, xGestureNotifyFlickEvent *to);\r
  83 static void SGestureNotifyPanEvent(xGestureNotifyPanEvent *from, xGestureNotifyPanEvent *to);\r
  84 static void SGestureNotifyPinchRotationEvent(xGestureNotifyPinchRotationEvent *from, xGestureNotifyPinchRotationEvent *to);\r
  85 static void SGestureNotifyTapEvent(xGestureNotifyTapEvent *from, xGestureNotifyTapEvent *to);\r
  86 static void SGestureNotifyTapNHoldEvent(xGestureNotifyTapNHoldEvent *from, xGestureNotifyTapNHoldEvent *to);\r
  87 static void SGestureNotifyHoldEvent(xGestureNotifyHoldEvent *from, xGestureNotifyHoldEvent *to);\r
  88 static void SGestureNotifyEvent(xEvent * from, xEvent * to);\r
  89 \r
  90 void GestureExtInit(void)\r
  91 {\r
  92     GestureExtensionInit();\r
  93 }\r
  94 \r
  95 Bool\r
  96 GestureExtensionInit(void)\r
  97 {\r
  98     ExtensionEntry* extEntry;\r
  99 \r
 100     if (extEntry = AddExtension(GESTURE_EXT_NAME,\r
 101                                  GestureNumberEvents,\r
 102                                  GestureNumberErrors,\r
 103                                  ProcGestureDispatch,\r
 104                                  SProcGestureDispatch,\r
 105                                  NULL,\r
 106                                  StandardMinorOpcode))\r
 107     {\r
 108         GestureReqCode = (unsigned char)extEntry->base;\r
 109         GestureErrorBase = extEntry->errorBase;\r
 110         GestureEventBase = extEntry->eventBase;\r
 111         EventSwapVector[GestureEventBase] = (EventSwapPtr) SGestureNotifyEvent;\r
 112 \r
 113         if (!dixRegisterPrivateKey(&gestureWindowPrivateKeyRec, PRIVATE_WINDOW, 0))\r
 114          {\r
 115                 ErrorF("[X11][GestureExtensionInit] Failed to register private key object !\n");\r
 116                 return FALSE;\r
 117          }\r
 118 \r
 119         memset(grabbed_events, 0, sizeof(GestureGrabEventRec)*GestureNumberEvents);\r
 120         return TRUE;\r
 121     }\r
 122 \r
 123     return FALSE;\r
 124 }\r
 125 \r
 126 /*\r
 127  * functions for gesture driver\r
 128  */ \r
 129 Bool GestureSetMaxNumberOfFingers(int num_finger)\r
 130 {\r
 131         int i;\r
 132 \r
 133         if( !grabbed_events )\r
 134                 return FALSE;\r
 135 \r
 136         max_num_finger = num_finger + 1;\r
 137 #ifdef __DEBUG_GESTURE_EXT__\r
 138         ErrorF("[X11][GestureSetMaxNumberOfFingers] num_finger=%d, max_num_finger=%d\n", num_finger, max_num_finger);\r
 139 #endif//__DEBUG_GESTURE_EXT__\r
 140 \r
 141         for( i = 0 ;  i < GestureNumberEvents ;  i++ )\r
 142         {\r
 143                 grabbed_events[i].pGestureGrabWinInfo = malloc(sizeof(GestureGrabWinInfoRec)*max_num_finger);\r
 144                 if( !grabbed_events[i].pGestureGrabWinInfo )\r
 145                 {\r
 146                         ErrorF("[X11][GestureSetMaxNumberOfFingers] Failed to allocate memory for grabbed_events[%d].pGestureGrabWinInfo !\n", i);\r
 147                         return FALSE;\r
 148                 }\r
 149                 memset(grabbed_events[i].pGestureGrabWinInfo, 0, sizeof(GestureGrabWinInfoRec)*max_num_finger);\r
 150         }\r
 151 \r
 152         return TRUE;\r
 153 }\r
 154 \r
 155 Bool GestureUnsetMaxNumberOfFingers(void)\r
 156 {\r
 157         int i;\r
 158 \r
 159         if( !grabbed_events )\r
 160                 return FALSE;\r
 161 \r
 162         for( i = 0 ;  i < GestureNumberEvents ;  i++ )\r
 163         {\r
 164                 if( grabbed_events[i].pGestureGrabWinInfo )\r
 165                 {\r
 166                         free(grabbed_events[i].pGestureGrabWinInfo);\r
 167                 }\r
 168         }\r
 169         max_num_finger = 0;\r
 170 \r
 171 #ifdef __DEBUG_GESTURE_EXT__\r
 172         ErrorF("[X11][GestureUnsetMaxNumberOfFingers] max_num_finger=%d\n", max_num_finger);\r
 173 #endif//__DEBUG_GESTURE_EXT__\r
 174 \r
 175         return TRUE;\r
 176 }\r
 177 \r
 178 Bool GestureHasGrabbedEvents(Mask *pGrabMask, GestureGrabEventPtr *pGrabEvent)\r
 179 {\r
 180         int i, j;\r
 181 \r
 182         if( !pGrabEvent || !pGrabMask )\r
 183         {\r
 184                 ErrorF("[X11][GestureHasGrabbedEvents] pGrabEvent or pGrabMask is NULL !\n");\r
 185                 return FALSE;\r
 186         }\r
 187 \r
 188         *pGrabMask = grabbed_events_mask;\r
 189         *pGrabEvent = grabbed_events;\r
 190 \r
 191         if( !grabbed_events_mask )\r
 192         {\r
 193 #ifdef __DEBUG_GESTURE_EXT__\r
 194                 ErrorF("[X11][GestureHasGrabbedEvents] grabbed_events_mask is zero !\n");\r
 195 #endif//__DEBUG_GESTURE_EXT__\r
 196                 return FALSE;\r
 197         }\r
 198 #ifdef __DEBUG_GESTURE_EXT__\r
 199         else\r
 200         {\r
 201                 ErrorF("[X11][GestureHasGrabbedEvents] grabbed_events_mask=0x%x\n", *pGrabMask);\r
 202         }\r
 203 #endif//__DEBUG_GESTURE_EXT__\r
 204 \r
 205         return TRUE;\r
 206 }\r
 207 \r
 208 Bool GestureHasSelectedEvents(WindowPtr pWin, Mask *pEventMask)\r
 209 {\r
 210         int rc;\r
 211         GestureWindowPrivatePtr pPriv;\r
 212 \r
 213         if( !pWin || !pEventMask )\r
 214         {\r
 215                 ErrorF("[X11][GestureHasSelectedEvents] pWin or pEventMask is NULL !\n");\r
 216                 return FALSE;\r
 217         }\r
 218 \r
 219         pPriv = dixLookupPrivate(&pWin->devPrivates, gestureWindowPrivateKey);\r
 220 \r
 221          if( !pPriv )\r
 222         {\r
 223 #ifdef __DEBUG_GESTURE_EXT__\r
 224                 ErrorF("[X11][GestureHasSelectedEvents] no mask exist on window(0x%x)\n", pWin->drawable.id);\r
 225 #endif//__DEBUG_GESTURE_EXT__\r
 226                 *pEventMask = 0;\r
 227                 return FALSE;\r
 228         }\r
 229 \r
 230 #ifdef __DEBUG_GESTURE_EXT__\r
 231         ErrorF("[X11][GestureHasSelectedEvents] mask=0x%x on window(0x%x)\n", pPriv->mask, pWin->drawable.id);\r
 232 #endif//__DEBUG_GESTURE_EXT__\r
 233 \r
 234         *pEventMask = pPriv->mask;\r
 235 \r
 236         return TRUE;\r
 237 }\r
 238 \r
 239 /*\r
 240   * Hooking functions for tracing destroy of grab window(s)\r
 241   */\r
 242 static void GestureResourceStateCallback(CallbackListPtr *pcbl, pointer closure, pointer calldata)\r
 243 {\r
 244         int i, j, none_win_count;\r
 245         GestureWindowPrivatePtr pPriv;\r
 246         ResourceStateInfoRec *rec = calldata;\r
 247         WindowPtr pWin = (WindowPtr)rec->value;\r
 248 \r
 249         if (rec->type != RT_WINDOW)\r
 250                 return;\r
 251         if (rec->state != ResourceStateFreeing)\r
 252                 return;\r
 253         if( !grabbed_events_mask )\r
 254                 return;\r
 255 \r
 256 #ifdef __DEBUG_GESTURE_EXT__\r
 257         ErrorF("[X11][GestureResourceStateCallback] rec->id=0x%x, pWin->drawable.id=0x%x\n", rec->id, pWin->drawable.id);\r
 258         ErrorF("[X11][GestureResourceStateCallback][start] grabbed_events_mask=0x%x\n", grabbed_events_mask);\r
 259 #endif//__DEBUG_GESTURE_EXT__\r
 260 \r
 261         for( i = 0 ; i < GestureNumberEvents ; i++ )\r
 262         {\r
 263                 none_win_count = 0;\r
 264                 for( j = 0 ; j < max_num_finger ; j++ )\r
 265                 {\r
 266                         if( grabbed_events[i].pGestureGrabWinInfo[j].window == pWin->drawable.id )\r
 267                         {\r
 268 #ifdef __DEBUG_GESTURE_EXT__\r
 269                 ErrorF("[X11][GestureResourceStateCallback][1.5] i=%d, j=%d\n", i, j);\r
 270 #endif//__DEBUG_GESTURE_EXT__\r
 271                                 grabbed_events[i].pGestureGrabWinInfo[j].window = None;\r
 272                                 grabbed_events[i].pGestureGrabWinInfo[j].pWin = NULL;\r
 273                         }\r
 274 \r
 275                         if( None == grabbed_events[i].pGestureGrabWinInfo[j].window )\r
 276                         {\r
 277                                 none_win_count++;\r
 278                         }\r
 279                 }\r
 280 \r
 281                 if( none_win_count == max_num_finger )\r
 282                 {\r
 283 #ifdef __DEBUG_GESTURE_EXT__\r
 284                         ErrorF("[X11][GestureResourceStateCallback][before] grabbed_events_mask=0x%x\n", grabbed_events_mask);\r
 285 #endif//__DEBUG_GESTURE_EXT__\r
 286                         grabbed_events_mask = grabbed_events_mask & ~(1 << i);\r
 287 #ifdef __DEBUG_GESTURE_EXT__\r
 288                         ErrorF("[X11][GestureResourceStateCallback][after] grabbed_events_mask=0x%x\n", grabbed_events_mask);\r
 289 #endif//__DEBUG_GESTURE_EXT__\r
 290                 }               \r
 291         }\r
 292 \r
 293 #ifdef __DEBUG_GESTURE_EXT__\r
 294         ErrorF("[X11][GestureResourceStateCallback][end] grabbed_events_mask=0x%x\n", grabbed_events_mask);\r
 295 #endif//__DEBUG_GESTURE_EXT__\r
 296 \r
 297         return;\r
 298 }\r
 299 \r
 300 Bool\r
 301 GestureInstallResourceStateHooks(void)\r
 302 {\r
 303         Bool res = TRUE;\r
 304 \r
 305         res = AddCallback(&ResourceStateCallback, GestureResourceStateCallback, NULL);\r
 306 \r
 307         if(!res)\r
 308         {\r
 309                 ErrorF("[X11][GestureInstallResourceStateHooks] Failed to register one or more callbacks ! (res=%d)\n", res);\r
 310                 return FALSE;\r
 311         }\r
 312 \r
 313 #ifdef __DEBUG_GESTURE_EXT__\r
 314         ErrorF("[X11][GestureInstallResourceStateHooks] AddCallback result = %d\n", res);\r
 315 #endif//__DEBUG_GESTURE_EXT__\r
 316         return TRUE;\r
 317 }\r
 318 \r
 319 Bool\r
 320 GestureUninstallResourceStateHooks(void)\r
 321 {\r
 322         Bool res;\r
 323 \r
 324         res = DeleteCallback(&ResourceStateCallback, GestureResourceStateCallback, NULL);\r
 325 \r
 326 #ifdef __DEBUG_GESTURE_EXT__\r
 327         ErrorF("[X11][GestureUninstallResourceStateHooks] DeleteCallback result = %d\n", res);\r
 328 #endif//__DEBUG_GESTURE_EXT__\r
 329         return res;\r
 330 }\r
 331 \r
 332 /*\r
 333  * deliver the event\r
 334  */\r
 335 void\r
 336 GestureSendEvent (WindowPtr pWin, int type, unsigned int mask, xGestureCommonEvent *gce)\r
 337 {\r
 338     int rc;\r
 339     Mask access_mode = 0;\r
 340     GestureWindowPrivatePtr pPriv;\r
 341     WindowPtr pTmp = NULL;\r
 342 \r
 343     if( NULL == pWin )\r
 344     {\r
 345         access_mode |= DixReceiveAccess;\r
 346         rc = dixLookupWindow(&pWin, gce->any.window, serverClient, access_mode);\r
 347         if( rc != Success || !pWin )\r
 348        {\r
 349                 ErrorF("[X11][GestureSendEvent] Failed to lookup window !\n");\r
 350         return;\r
 351        }\r
 352 \r
 353        pPriv = dixLookupPrivate(&pWin->devPrivates, gestureWindowPrivateKey);\r
 354 \r
 355        if( !pPriv )\r
 356        {\r
 357 #ifdef __DEBUG_GESTURE_EXT__\r
 358                 ErrorF("[X11][GestureSendEvent] no mask exist on win(0x%x)\n", pWin->drawable.id);\r
 359 #endif//__DEBUG_GESTURE_EXT__\r
 360                 return;\r
 361        }\r
 362 \r
 363 #ifdef __DEBUG_GESTURE_EXT__\r
 364        ErrorF("[X11][GestureSendEvent] type=%d, mask=%d\n", type, mask);\r
 365 #endif//__DEBUG_GESTURE_EXT__\r
 366 \r
 367        if( !(pPriv->mask & mask) )\r
 368        {\r
 369 #ifdef __DEBUG_GESTURE_EXT__\r
 370         ErrorF("[X11][GestureSendEvent] selected window doesn't have valid event mask ! (pPriv->mask=0x%x, mask=0x%x)\n", pPriv->mask, mask);\r
 371 #endif//__DEBUG_GESTURE_EXT__       \r
 372         return;\r
 373        }\r
 374     }\r
 375 \r
 376     gce->any.type = type + GestureEventBase;\r
 377     gce->any.time = currentTime.milliseconds;\r
 378     WriteEventsToClient(wClient(pWin), 1, (xEvent *) gce);\r
 379 #ifdef __DEBUG_GESTURE_EXT__\r
 380     ErrorF("[X11][GestureSendEvent] Send gesture event(type:%x) to win(0x%x)\n", type, pWin->drawable.id);\r
 381 #endif//__DEBUG_GESTURE_EXT__\r
 382 }\r
 383 \r
 384 static void\r
 385 SGestureNotifyGroupEvent(xGestureNotifyGroupEvent *from, xGestureNotifyGroupEvent *to)\r
 386 {\r
 387         to->type = from->type;\r
 388         to->kind = from->kind;\r
 389         cpswaps(from->sequenceNumber, to->sequenceNumber);\r
 390         cpswapl(from->window, to->window);\r
 391         cpswapl(from->time, to->time);\r
 392         to->groupid = from->groupid;\r
 393         to->num_group = from->num_group;\r
 394         /* pad1 */\r
 395         /* pad2 */\r
 396         /* pad3 */\r
 397         /* pad4 */\r
 398         /* pad5 */\r
 399 }\r
 400 \r
 401 static void\r
 402 SGestureNotifyFlickEvent(xGestureNotifyFlickEvent *from, xGestureNotifyFlickEvent *to)\r
 403 {\r
 404         to->type = from->type;\r
 405         to->kind = from->kind;\r
 406         cpswaps(from->sequenceNumber, to->sequenceNumber);\r
 407         cpswapl(from->window, to->window);\r
 408         cpswapl(from->time, to->time);\r
 409         to->num_finger = from->num_finger;\r
 410         to->direction = from->direction;\r
 411         cpswaps(from->distance, to->distance);\r
 412         cpswapl(from->duration, to->duration);\r
 413         cpswapl(from->angle, to->angle);\r
 414         /* pad1 */\r
 415         /* pad2 */\r
 416 }\r
 417 \r
 418 static void\r
 419 SGestureNotifyPanEvent(xGestureNotifyPanEvent *from, xGestureNotifyPanEvent *to)\r
 420 {\r
 421         to->type = from->type;\r
 422         to->kind = from->kind;\r
 423         cpswaps(from->sequenceNumber, to->sequenceNumber);\r
 424         cpswapl(from->window, to->window);\r
 425         cpswapl(from->time, to->time);\r
 426         to->num_finger = from->num_finger;\r
 427         to->direction = from->direction;\r
 428         cpswaps(from->distance, to->distance);\r
 429         cpswapl(from->duration, to->duration);\r
 430         cpswaps(from->dx, to->dx);\r
 431         cpswaps(from->dy, to->dy);\r
 432         /* pad1 */\r
 433         /* pad2 */\r
 434 }\r
 435 \r
 436 static void\r
 437 SGestureNotifyPinchRotationEvent(xGestureNotifyPinchRotationEvent *from, xGestureNotifyPinchRotationEvent *to)\r
 438 {\r
 439         to->type = from->type;\r
 440         to->kind = from->kind;\r
 441         cpswaps(from->sequenceNumber, to->sequenceNumber);\r
 442         cpswapl(from->window, to->window);\r
 443         cpswapl(from->time, to->time);\r
 444         to->num_finger = from->num_finger;\r
 445         /* pad1 */\r
 446         cpswaps(from->distance, to->distance);\r
 447         cpswaps(from->cx, to->cx);\r
 448         cpswaps(from->cy, to->cy);\r
 449         cpswapl(from->zoom, to->zoom);\r
 450         cpswapl(from->angle, to->angle);\r
 451         /* pad2 */\r
 452 }\r
 453 \r
 454 static void\r
 455 SGestureNotifyTapEvent(xGestureNotifyTapEvent *from, xGestureNotifyTapEvent *to)\r
 456 {\r
 457         to->type = from->type;\r
 458         to->kind = from->kind;\r
 459         cpswaps(from->sequenceNumber, to->sequenceNumber);\r
 460         cpswapl(from->window, to->window);\r
 461         cpswapl(from->time, to->time);\r
 462         to->num_finger = from->num_finger;\r
 463         /* pad1 */\r
 464         cpswaps(from->cx, to->cx);\r
 465         cpswaps(from->cy, to->cy);\r
 466         to->tap_repeat = from->tap_repeat;\r
 467         /* pad2 */\r
 468         cpswapl(from->interval, to->interval);\r
 469         /* pad3 */\r
 470         /* pad4 */\r
 471 }\r
 472 \r
 473 static void\r
 474 SGestureNotifyTapNHoldEvent(xGestureNotifyTapNHoldEvent *from, xGestureNotifyTapNHoldEvent *to)\r
 475 {\r
 476         to->type = from->type;\r
 477         to->kind = from->kind;\r
 478         cpswaps(from->sequenceNumber, to->sequenceNumber);\r
 479         cpswapl(from->window, to->window);\r
 480         cpswapl(from->time, to->time);\r
 481         to->num_finger = from->num_finger;\r
 482         /* pad1 */\r
 483         cpswaps(from->cx, to->cx);\r
 484         cpswaps(from->cy, to->cy);\r
 485         /* pad2 */\r
 486         cpswapl(from->interval, to->interval);\r
 487         cpswapl(from->holdtime, to->holdtime);\r
 488         /* pad3 */\r
 489 }\r
 490 \r
 491 static void\r
 492 SGestureNotifyHoldEvent(xGestureNotifyHoldEvent *from, xGestureNotifyHoldEvent *to)\r
 493 {\r
 494         to->type = from->type;\r
 495         to->kind = from->kind;\r
 496         cpswaps(from->sequenceNumber, to->sequenceNumber);\r
 497         cpswapl(from->window, to->window);\r
 498         cpswapl(from->time, to->time);\r
 499         to->num_finger = from->num_finger;\r
 500         /* pad1 */\r
 501         cpswaps(from->cx, to->cx);\r
 502         cpswaps(from->cy, to->cy);\r
 503         /* pad2 */\r
 504         cpswapl(from->holdtime, to->holdtime);\r
 505         /* pad3 */\r
 506         /* pad4 */\r
 507 }\r
 508 \r
 509 static void\r
 510 SGestureNotifyEvent(xEvent * from, xEvent * to)\r
 511 {\r
 512     switch (from->u.u.detail) {\r
 513         case GestureNotifyGroup:\r
 514                 SGestureNotifyGroupEvent((xGestureNotifyGroupEvent *)from,\r
 515                         (xGestureNotifyGroupEvent *)to);\r
 516                 break;\r
 517         case GestureNotifyFlick:\r
 518                 SGestureNotifyFlickEvent((xGestureNotifyFlickEvent *)from,\r
 519                         (xGestureNotifyFlickEvent *)to);\r
 520                 break;\r
 521         case GestureNotifyPan:\r
 522                 SGestureNotifyPanEvent((xGestureNotifyPanEvent *)from,\r
 523                         (xGestureNotifyPanEvent *)to);\r
 524                 break;\r
 525         case GestureNotifyPinchRotation:\r
 526                 SGestureNotifyPinchRotationEvent((xGestureNotifyPinchRotationEvent *)from,\r
 527                         (xGestureNotifyPinchRotationEvent *)to);\r
 528                 break;\r
 529         case GestureNotifyTap:\r
 530                 SGestureNotifyTapEvent((xGestureNotifyTapEvent *)from,\r
 531                         (xGestureNotifyTapEvent *)to);\r
 532                 break;\r
 533         case GestureNotifyTapNHold:\r
 534                 SGestureNotifyTapNHoldEvent((xGestureNotifyTapNHoldEvent *)from,\r
 535                         (xGestureNotifyTapNHoldEvent *)to);\r
 536                 break;\r
 537         case GestureNotifyHold:\r
 538                 SGestureNotifyHoldEvent((xGestureNotifyHoldEvent *)from,\r
 539                         (xGestureNotifyHoldEvent *)to);\r
 540                 break;\r
 541     }\r
 542 #ifdef __DEBUG_GESTURE_EXT__\r
 543     ErrorF("[X11][SGestureNotifyEvent] ...\n");\r
 544 #endif//__DEBUG_GESTURE_EXT__\r
 545 }\r
 546 \r
 547 static int\r
 548 ProcGestureQueryVersion(register ClientPtr client)\r
 549 {\r
 550     xGestureQueryVersionReply rep;\r
 551     register int n;\r
 552 \r
 553     REQUEST_SIZE_MATCH(xGestureQueryVersionReq);\r
 554     rep.type = X_Reply;\r
 555     rep.length = 0;\r
 556     rep.sequenceNumber = client->sequence;\r
 557     rep.majorVersion = SERVER_GESTURE_MAJOR_VERSION;\r
 558     rep.minorVersion = SERVER_GESTURE_MINOR_VERSION;\r
 559     rep.patchVersion = SERVER_GESTURE_PATCH_VERSION;\r
 560     if (client->swapped)\r
 561     {\r
 562         swaps(&rep.sequenceNumber, n);\r
 563         swapl(&rep.length, n);\r
 564          swaps(&rep.majorVersion, n);\r
 565          swaps(&rep.minorVersion, n);\r
 566          swapl(&rep.patchVersion, n);\r
 567     }\r
 568     WriteToClient(client, sizeof(xGestureQueryVersionReply), (char *)&rep);\r
 569 \r
 570 #ifdef __DEBUG_GESTURE_EXT__\r
 571     ErrorF("[X11][ProcGestureQueryVersion] return Success !\n");\r
 572 #endif//__DEBUG_GESTURE_EXT__\r
 573 \r
 574     return Success;\r
 575 }\r
 576 \r
 577 static int\r
 578 SProcGestureQueryVersion(register ClientPtr  client)\r
 579 {\r
 580     register int n;\r
 581     REQUEST(xGestureQueryVersionReq);\r
 582     swaps(&stuff->length, n);\r
 583     return ProcGestureQueryVersion(client);\r
 584 }\r
 585 \r
 586 static int\r
 587 SProcGestureSelectEvents(register ClientPtr client)\r
 588 {\r
 589     register int n;\r
 590     REQUEST(xGestureSelectEventsReq);\r
 591     swaps(&stuff->length, n);\r
 592     swapl(&stuff->window, n);\r
 593     swapl(&stuff->mask, n);\r
 594     return ProcGestureSelectEvents(client);\r
 595 }\r
 596 \r
 597 static int\r
 598 ProcGestureSelectEvents (register ClientPtr client)\r
 599 {\r
 600     int rc;\r
 601     WindowPtr pWin;\r
 602     Mask access_mode = 0;\r
 603     GestureWindowPrivatePtr pPriv;\r
 604 \r
 605     REQUEST(xGestureSelectEventsReq);\r
 606     REQUEST_SIZE_MATCH (xGestureSelectEventsReq);\r
 607 \r
 608 #ifdef __DEBUG_GESTURE_EXT__\r
 609     ErrorF("[X11][ProcGestureSelectEvents] after REQUEST_SIZE_MATCH !\n");\r
 610 #endif//__DEBUG_GESTURE_EXT__\r
 611 \r
 612     access_mode |= DixReceiveAccess;\r
 613     rc = dixLookupWindow(&pWin, stuff->window, client, access_mode);\r
 614     if( rc != Success || !pWin )\r
 615     {\r
 616          ErrorF("[X11][ProcGestureSelectEvents] Failed to lookup window !\n");\r
 617         return BadWindow;\r
 618     }\r
 619 \r
 620 #ifdef __DEBUG_GESTURE_EXT__\r
 621     ErrorF("[X11][ProcGestureSelectEvents] pWin->drawable.id=0x%x\n", pWin->drawable.id);\r
 622 #endif//__DEBUG_GESTURE_EXT__\r
 623 \r
 624     pPriv = dixLookupPrivate(&pWin->devPrivates, gestureWindowPrivateKey);\r
 625 \r
 626     if( NULL == pPriv )//no mask was set\r
 627     {\r
 628         if( stuff->mask != 0 )\r
 629         {\r
 630                 pPriv = malloc(sizeof *pPriv);\r
 631                 if( !pPriv )\r
 632                 {\r
 633                         ErrorF("[X11][ProcGestureSelectEvents] Failed to allocate memory !\n");\r
 634                         return BadAlloc;\r
 635                 }\r
 636 \r
 637                 pPriv->mask = stuff->mask;\r
 638                 dixSetPrivate(&pWin->devPrivates, gestureWindowPrivateKey, pPriv);\r
 639 #ifdef __DEBUG_GESTURE_EXT__\r
 640                 ErrorF("[X11][ProcGestureSelectEvents] mask(0x%x) was addded on win(0x%x) !\n", stuff->mask, stuff->window);\r
 641 #endif//__DEBUG_GESTURE_EXT__\r
 642         }\r
 643     }\r
 644     else//mask was set already\r
 645     {\r
 646         if( stuff->mask == 0 )\r
 647         {\r
 648                 free(pPriv);\r
 649                 dixSetPrivate(&pWin->devPrivates, gestureWindowPrivateKey, NULL);\r
 650 #ifdef __DEBUG_GESTURE_EXT__\r
 651                 ErrorF("[X11][ProcGestureSelectEvents] mask was removed on win(0x%x) !\n", stuff->window);\r
 652 #endif//__DEBUG_GESTURE_EXT__\r
 653         }\r
 654         else\r
 655         {\r
 656                 pPriv->mask = stuff->mask;\r
 657                 dixSetPrivate(&pWin->devPrivates, gestureWindowPrivateKey, pPriv);\r
 658 #ifdef __DEBUG_GESTURE_EXT__\r
 659                 ErrorF("[X11][ProcGestureSelectEvents] mask(0x%x) was updated on win(0x%x) !\n", stuff->mask, stuff->window);\r
 660 #endif//__DEBUG_GESTURE_EXT__\r
 661         }\r
 662     }\r
 663 \r
 664 #ifdef __DEBUG_GESTURE_EXT__\r
 665     ErrorF("[X11][ProcGestureSelectEvents] Success !\n");\r
 666 #endif//__DEBUG_GESTURE_EXT__\r
 667 \r
 668     return Success;\r
 669 }\r
 670 \r
 671 static int\r
 672 SProcGestureGetSelectedEvents(register ClientPtr client)\r
 673 {\r
 674     register int n;\r
 675     REQUEST(xGestureGetSelectedEventsReq);\r
 676     swaps(&stuff->length, n);\r
 677     swapl(&stuff->window, n);\r
 678     return ProcGestureGetSelectedEvents(client);\r
 679 }\r
 680 \r
 681 static int\r
 682 ProcGestureGetSelectedEvents (register ClientPtr client)\r
 683 {\r
 684     register int n;\r
 685     int rc, ret = Success;\r
 686     WindowPtr pWin;\r
 687     Mask access_mode = 0;\r
 688     Mask mask_out = 0;\r
 689     GestureWindowPrivatePtr pPriv;\r
 690     xGestureGetSelectedEventsReply rep;\r
 691 \r
 692     REQUEST(xGestureGetSelectedEventsReq);\r
 693     REQUEST_SIZE_MATCH (xGestureGetSelectedEventsReq);\r
 694 \r
 695 #ifdef __DEBUG_GESTURE_EXT__\r
 696     ErrorF("[X11][ProcGestureGetSelectedEvents] after REQUEST_SIZE_MATCH !\n");\r
 697 #endif//__DEBUG_GESTURE_EXT__\r
 698 \r
 699     rep.type = X_Reply;\r
 700     rep.length = 0;\r
 701     rep.sequenceNumber = client->sequence;\r
 702 \r
 703     access_mode |= DixReceiveAccess;\r
 704     rc = dixLookupWindow(&pWin, stuff->window, client, access_mode);\r
 705     if( rc != Success || !pWin )\r
 706     {\r
 707          ErrorF("[X11][ProcGestureGetSelectedEvents] Failed to lookup window !\n");\r
 708          ret = BadWindow;\r
 709         goto failed;\r
 710     }\r
 711 \r
 712 #ifdef __DEBUG_GESTURE_EXT__\r
 713     ErrorF("[X11][ProcGestureGetSelectedEvents] pWin->drawable.id=0x%x\n", pWin->drawable.id);\r
 714 #endif//__DEBUG_GESTURE_EXT__\r
 715 \r
 716     pPriv = dixLookupPrivate(&pWin->devPrivates, gestureWindowPrivateKey);\r
 717 \r
 718     if( NULL == pPriv )//no mask was set\r
 719     {\r
 720         mask_out = 0;\r
 721     }\r
 722     else//mask was set already\r
 723     {\r
 724         mask_out = pPriv->mask;\r
 725     }\r
 726 \r
 727     rep.mask = mask_out;\r
 728     if (client->swapped)\r
 729     {\r
 730         swaps(&rep.sequenceNumber, n);\r
 731         swapl(&rep.length, n);\r
 732          swapl(&rep.mask, n);\r
 733     }\r
 734     WriteToClient(client, sizeof(xGestureGetSelectedEventsReply), (char *)&rep);\r
 735 \r
 736 #ifdef __DEBUG_GESTURE_EXT__\r
 737     ErrorF("[X11][ProcGestureGetSelectedEvents] Success !\n");\r
 738 #endif//__DEBUG_GESTURE_EXT__\r
 739 \r
 740     return ret;\r
 741 \r
 742 failed:\r
 743 \r
 744     rep.mask = 0;\r
 745     if (client->swapped)\r
 746     {\r
 747         swaps(&rep.sequenceNumber, n);\r
 748         swapl(&rep.length, n);\r
 749          swapl(&rep.mask, n);\r
 750     }\r
 751     WriteToClient(client, sizeof(xGestureGetSelectedEventsReply), (char *)&rep);\r
 752 \r
 753 #ifdef __DEBUG_GESTURE_EXT__\r
 754     ErrorF("[X11][ProcGestureGetSelectedEvents] Failed !\n");\r
 755 #endif//__DEBUG_GESTURE_EXT__\r
 756 \r
 757     return ret; \r
 758 }\r
 759 \r
 760 static int\r
 761 SProcGestureGrabEvent(register ClientPtr client)\r
 762 {\r
 763     register int n;\r
 764     REQUEST(xGestureGrabEventReq);\r
 765     swaps(&stuff->length, n);\r
 766     swapl(&stuff->window, n);\r
 767     swapl(&stuff->eventType, n);\r
 768     swapl(&stuff->num_finger, n);\r
 769     swapl(&stuff->time, n);\r
 770     return ProcGestureGrabEvent(client);\r
 771 }\r
 772 \r
 773 static int\r
 774 ProcGestureGrabEvent (register ClientPtr client)\r
 775 {\r
 776     register int n;\r
 777     int i, rc, ret = Success;\r
 778     TimeStamp ctime;\r
 779     WindowPtr pWin;\r
 780     Mask eventmask;\r
 781     Mask access_mode = 0;\r
 782     GestureWindowPrivatePtr pPriv;\r
 783     xGestureGrabEventReply rep;\r
 784 \r
 785     REQUEST(xGestureGrabEventReq);\r
 786     REQUEST_SIZE_MATCH (xGestureGrabEventReq);\r
 787 \r
 788     eventmask = (1L << stuff->eventType);\r
 789 \r
 790 #ifdef __DEBUG_GESTURE_EXT__\r
 791     ErrorF("[X11][ProcGestureGrabEvent] after REQUEST_SIZE_MATCH !\n");\r
 792     ErrorF("[X11][ProcGestureGrabEvent] stuff->window=0x%x, stuff->eventType=%d, stuff->num_finger=%d\n", stuff->window, stuff->eventType, stuff->num_finger);\r
 793 #endif//__DEBUG_GESTURE_EXT__\r
 794 \r
 795     //prepare to reply\r
 796     rep.type = X_Reply;\r
 797     rep.length = 0;\r
 798     rep.sequenceNumber = client->sequence;\r
 799 \r
 800     if( stuff->eventType >= GestureNumberEvents )\r
 801     {\r
 802         ErrorF("[X11][ProcGestureGrabEvent] GestureGrabAbnormal !(eventType(%d) >= GestureNumberEvents(%d))\n", stuff->eventType, (int)GestureNumberEvents);\r
 803         rep.status = GestureGrabAbnormal;\r
 804         ret = BadValue;\r
 805         goto grab_failed;\r
 806     }\r
 807 \r
 808     if( stuff->num_finger >= max_num_finger )\r
 809     {\r
 810         ErrorF("[X11][ProcGestureGrabEvent] GestureGrabAbnormal !(num_finger(%d) >= max num finger(%d))\n", stuff->num_finger, max_num_finger);\r
 811         rep.status = GestureGrabAbnormal;\r
 812         ret = BadValue;\r
 813         goto grab_failed;\r
 814     }\r
 815 \r
 816     ctime = ClientTimeToServerTime((CARD32)stuff->time);\r
 817 #if 1\r
 818     if ( CompareTimeStamps(ctime, currentTime) == LATER )\r
 819 #else\r
 820     if ( (CompareTimeStamps(ctime, currentTime) == LATER ) ||\r
 821     (CompareTimeStamps(ctime, grabInfo->grabTime) == EARLIER) )\r
 822 #endif\r
 823     {\r
 824         ErrorF("[X11][ProcGestureGrabEvent] GestureGrabInvalidTime !(ctime=%d, currentTime=%d)\n", ctime, currentTime);\r
 825         rep.status = GestureGrabInvalidTime;\r
 826         ret = BadAccess;\r
 827         goto grab_failed;\r
 828     }\r
 829 \r
 830     //check the event was grabbed already\r
 831     if( grabbed_events_mask & eventmask )\r
 832     {\r
 833         if( grabbed_events[stuff->eventType].pGestureGrabWinInfo[stuff->num_finger].window != None &&\r
 834                 grabbed_events[stuff->eventType].pGestureGrabWinInfo[stuff->num_finger].window != stuff->window )\r
 835         {\r
 836                 ErrorF("[X11][ProcGestureGrabEvent] GestureGrabbedAlready ! (org_mask=0x%x, eventmask=0x%x)\n",\r
 837                                 grabbed_events_mask, eventmask);\r
 838                 rep.status = GestureGrabbedAlready;\r
 839                 ret = BadAccess;\r
 840                 goto grab_failed;\r
 841         }\r
 842     }\r
 843 \r
 844 #ifdef __DEBUG_GESTURE_EXT__\r
 845     ErrorF("[X11][ProcGestureGrabEvent] Gesture(s) are available ! (org_mask=0x%x, eventmask=0x%x, eventType=%d, num_finger=%d)\n",\r
 846                         grabbed_events_mask, eventmask, stuff->eventType, stuff->num_finger);\r
 847 #endif//__DEBUG_GESTURE_EXT__\r
 848 \r
 849     access_mode |= DixReceiveAccess;\r
 850     rc = dixLookupWindow(&pWin, stuff->window, client, access_mode);\r
 851     if( rc != Success || !pWin )\r
 852     {\r
 853          ErrorF("[X11][ProcGestureGrabEvent] Failed to lookup window !\n");\r
 854          rep.status = GestureGrabAbnormal;\r
 855          ret = BadWindow;\r
 856         goto grab_failed;\r
 857     }\r
 858 \r
 859 #ifdef __DEBUG_GESTURE_EXT__\r
 860     ErrorF("[X11][ProcGestureGrabEvent] pWin->drawable.id=0x%x\n", pWin->drawable.id);\r
 861     ErrorF("[X11][ProcGestureGrabEvent][before] grabbed_events_mask=0x%x\n", grabbed_events_mask);\r
 862 #endif//__DEBUG_GESTURE_EXT__\r
 863 \r
 864     //set to grab\r
 865     grabbed_events_mask |= eventmask;\r
 866     grabbed_events[stuff->eventType].pGestureGrabWinInfo[stuff->num_finger].pWin = pWin;\r
 867     grabbed_events[stuff->eventType].pGestureGrabWinInfo[stuff->num_finger].window = stuff->window;\r
 868 \r
 869 #ifdef __DEBUG_GESTURE_EXT__\r
 870     ErrorF("[X11][ProcGestureGrabEvent][after] grabbed_events_mask=0x%x\n", grabbed_events_mask);\r
 871 #endif//__DEBUG_GESTURE_EXT__\r
 872 \r
 873     rep.status = GestureGrabSuccess;\r
 874 \r
 875     if (client->swapped)\r
 876     {\r
 877         swaps(&rep.sequenceNumber, n);\r
 878         swapl(&rep.length, n);\r
 879     }\r
 880     WriteToClient(client, sizeof(xGestureGrabEventReply), (char *)&rep);\r
 881 \r
 882 #ifdef __DEBUG_GESTURE_EXT__\r
 883     ErrorF("[X11][ProcGestureGrabEvent] Success !\n");\r
 884 #endif//__DEBUG_GESTURE_EXT__\r
 885 \r
 886     return Success;\r
 887 \r
 888 grab_failed:\r
 889 \r
 890     if (client->swapped)\r
 891     {\r
 892         swaps(&rep.sequenceNumber, n);\r
 893         swapl(&rep.length, n);\r
 894     }\r
 895 \r
 896     WriteToClient(client, sizeof(xGestureGrabEventReply), (char *)&rep);\r
 897 \r
 898 #ifdef __DEBUG_GESTURE_EXT__\r
 899     ErrorF("[X11][ProcGestureGrabEvent] Failed !\n");\r
 900 #endif//__DEBUG_GESTURE_EXT__\r
 901 \r
 902     return ret;\r
 903 }\r
 904 \r
 905 static int\r
 906 SProcGestureUngrabEvent(register ClientPtr client)\r
 907 {\r
 908     register int n;\r
 909     REQUEST(xGestureUngrabEventReq);\r
 910     swaps(&stuff->length, n);\r
 911     swapl(&stuff->window, n);\r
 912     swapl(&stuff->eventType, n);\r
 913     swapl(&stuff->num_finger, n);\r
 914     swapl(&stuff->time, n);\r
 915     return ProcGestureUngrabEvent(client);\r
 916 }\r
 917 \r
 918 static int\r
 919 ProcGestureUngrabEvent (register ClientPtr client)\r
 920 {\r
 921     register int n;\r
 922     int i, none_win_count, rc, ret = Success;\r
 923     TimeStamp ctime;\r
 924     WindowPtr pWin;\r
 925     Mask eventmask;\r
 926     Mask access_mode = 0;\r
 927     GestureWindowPrivatePtr pPriv;\r
 928     xGestureUngrabEventReply rep;\r
 929 \r
 930     REQUEST(xGestureUngrabEventReq);\r
 931     REQUEST_SIZE_MATCH (xGestureUngrabEventReq);\r
 932 \r
 933     eventmask = (1L << stuff->eventType);\r
 934 \r
 935 #ifdef __DEBUG_GESTURE_EXT__\r
 936     ErrorF("[X11][ProcGestureUngrabEvent] after REQUEST_SIZE_MATCH !\n");\r
 937 #endif//__DEBUG_GESTURE_EXT__\r
 938 \r
 939     //prepare to reply\r
 940     rep.type = X_Reply;\r
 941     rep.length = 0;\r
 942     rep.sequenceNumber = client->sequence;\r
 943     rep.status = GestureUngrabNotGrabbed;\r
 944 \r
 945     if( stuff->eventType >= GestureNumberEvents )\r
 946     {\r
 947         ErrorF("[X11][ProcGestureUngrabEvent] GestureGrabAbnormal !(eventType(%d) >= GestureNumberEvents(%d))\n", stuff->eventType, (int)GestureNumberEvents);\r
 948         rep.status = GestureUngrabAbnormal;\r
 949         ret = BadValue;\r
 950         goto ungrab_failed;\r
 951     }\r
 952 \r
 953     if( stuff->num_finger >= max_num_finger )\r
 954     {\r
 955         ErrorF("[X11][ProcGestureUngrabEvent] GestureGrabAbnormal !(num_finger(%d) >= max num finger(%d))\n", stuff->num_finger, max_num_finger);\r
 956         rep.status = GestureUngrabAbnormal;\r
 957         ret = BadValue;\r
 958         goto ungrab_failed;\r
 959     }\r
 960 \r
 961     ctime = ClientTimeToServerTime((CARD32)stuff->time);\r
 962 #if 1\r
 963     if ( CompareTimeStamps(ctime, currentTime) == LATER )\r
 964 #else\r
 965     if ( (CompareTimeStamps(ctime, currentTime) == LATER ) ||\r
 966     (CompareTimeStamps(ctime, grabInfo->grabTime) == EARLIER) )\r
 967 #endif\r
 968     {\r
 969         ErrorF("[X11][ProcGestureUngrabEvent] GestureGrabInvalidTime !(ctime=%d, currentTime=%d)\n", ctime, currentTime);\r
 970         rep.status = GestureGrabInvalidTime;\r
 971         ret = BadAccess;\r
 972         goto ungrab_failed;\r
 973     }\r
 974 \r
 975     if( grabbed_events_mask & eventmask )\r
 976     {\r
 977         if( grabbed_events[stuff->eventType].pGestureGrabWinInfo[stuff->num_finger].window == stuff->window )\r
 978         {\r
 979                 grabbed_events[stuff->eventType].pGestureGrabWinInfo[stuff->num_finger].window = None;\r
 980                 grabbed_events[stuff->eventType].pGestureGrabWinInfo[stuff->num_finger].pWin = NULL;\r
 981         }\r
 982 \r
 983         none_win_count = 0;\r
 984         for( i = 0 ; i < max_num_finger ; i++ )\r
 985         {\r
 986                 if( None == grabbed_events[stuff->eventType].pGestureGrabWinInfo[i].window )\r
 987                 {\r
 988                         none_win_count++;\r
 989                 }\r
 990         }\r
 991 \r
 992         if( none_win_count == max_num_finger )\r
 993         {\r
 994 #ifdef __DEBUG_GESTURE_EXT__\r
 995                 ErrorF("[X11][ProcGestureUngrabEvent][before] grabbed_events_mask=0x%x\n", grabbed_events_mask);\r
 996 #endif//__DEBUG_GESTURE_EXT__\r
 997                 grabbed_events_mask = grabbed_events_mask & ~(1<< stuff->eventType);\r
 998 #ifdef __DEBUG_GESTURE_EXT__\r
 999                 ErrorF("[X11][ProcGestureUngrabEvent][after] grabbed_events_mask=0x%x\n", grabbed_events_mask);\r
1000 #endif//__DEBUG_GESTURE_EXT__\r
1001         }       \r
1002         rep.status = GestureUngrabSuccess;\r
1003     }\r
1004 \r
1005     if( rep.status == GestureUngrabNotGrabbed )\r
1006     {\r
1007         ErrorF("[X11][ProcGestureUngrabEvent] No event(s) were grabbed by window(0x%x) !\n", stuff->window);\r
1008         ret = BadAccess;\r
1009         goto ungrab_failed;\r
1010     }\r
1011 \r
1012     //rep.status == GestureUngrabSuccess )\r
1013 #ifdef __DEBUG_GESTURE_EXT__\r
1014     ErrorF("[X11][ProcGestureUngrabEvent] Event(s) were grabbed by window(0x%x) exist !\n", stuff->window);\r
1015 #endif//__DEBUG_GESTURE_EXT__\r
1016 \r
1017     access_mode |= DixReceiveAccess;\r
1018     rc = dixLookupWindow(&pWin, stuff->window, client, access_mode);\r
1019     if( rc != Success || !pWin )\r
1020     {\r
1021          ErrorF("[X11][ProcGestureUngrabEvent] Failed to lookup window !\n");\r
1022          rep.status = GestureUngrabAbnormal;\r
1023          ret = BadWindow;\r
1024         goto ungrab_failed;\r
1025     }\r
1026 \r
1027 #ifdef __DEBUG_GESTURE_EXT__\r
1028     ErrorF("[X11][ProcGestureUngrabEvent] pWin->drawable.id=0x%x\n", pWin->drawable.id);\r
1029 #endif//__DEBUG_GESTURE_EXT__\r
1030 \r
1031     rep.status = GestureUngrabSuccess;\r
1032 \r
1033     if (client->swapped)\r
1034     {\r
1035         swaps(&rep.sequenceNumber, n);\r
1036         swapl(&rep.length, n);\r
1037     }\r
1038     WriteToClient(client, sizeof(xGestureUngrabEventReply), (char *)&rep);\r
1039 \r
1040 #ifdef __DEBUG_GESTURE_EXT__\r
1041     ErrorF("[X11][ProcGestureUngrabEvent] Success !\n");\r
1042 #endif//__DEBUG_GESTURE_EXT__\r
1043 \r
1044     return Success;\r
1045 \r
1046 ungrab_failed:\r
1047 \r
1048     if (client->swapped)\r
1049     {\r
1050         swaps(&rep.sequenceNumber, n);\r
1051         swapl(&rep.length, n);\r
1052     }\r
1053     WriteToClient(client, sizeof(xGestureUngrabEventReply), (char *)&rep);\r
1054 \r
1055 #ifdef __DEBUG_GESTURE_EXT__\r
1056     ErrorF("[X11][ProcGestureUngrabEvent] Failed !\n");\r
1057 #endif//__DEBUG_GESTURE_EXT__\r
1058 \r
1059     return ret;\r
1060 }\r
1061 \r
1062 /* dispatch */\r
1063 static int\r
1064 ProcGestureDispatch(register ClientPtr  client)\r
1065 {\r
1066     REQUEST(xReq);\r
1067 \r
1068     switch (stuff->data)\r
1069     {\r
1070             case X_GestureQueryVersion:\r
1071                 return ProcGestureQueryVersion(client);\r
1072     }\r
1073 \r
1074 #ifdef _F_GESTURE_DENY_REMOTE_CLIENT_\r
1075     if (!LocalClient(client))\r
1076         return GestureErrorBase + GestureClientNotLocal;\r
1077 #endif//_F_GESTURE_DENY_REMOTE_CLIENT_\r
1078 \r
1079     switch (stuff->data)\r
1080     {\r
1081             case X_GestureSelectEvents:\r
1082                 return ProcGestureSelectEvents(client);\r
1083             case X_GestureGetSelectedEvents:\r
1084                 return ProcGestureGetSelectedEvents(client);\r
1085             case X_GestureGrabEvent:\r
1086                 return ProcGestureGrabEvent(client);\r
1087             case X_GestureUngrabEvent:\r
1088                 return ProcGestureUngrabEvent(client);\r
1089             default:\r
1090                 return BadRequest;\r
1091     }\r
1092 }\r
1093 \r
1094 \r
1095 static int\r
1096 SProcGestureDispatch (register ClientPtr  client)\r
1097 {\r
1098     REQUEST(xReq);\r
1099 \r
1100     switch (stuff->data)\r
1101     {\r
1102     case X_GestureQueryVersion:\r
1103         return SProcGestureQueryVersion(client);\r
1104     }\r
1105 \r
1106 #ifdef _F_GESTURE_DENY_REMOTE_CLIENT_\r
1107     /* It is bound to be non-local when there is byte swapping */\r
1108     if (!LocalClient(client))\r
1109         return GestureErrorBase + GestureClientNotLocal;\r
1110 #endif//_F_GESTURE_DENY_REMOTE_CLIENT_\r
1111 \r
1112     /* only local clients are allowed Gesture access */\r
1113     switch (stuff->data)\r
1114     {\r
1115     case X_GestureSelectEvents:\r
1116         return SProcGestureSelectEvents(client);\r
1117     case X_GestureGetSelectedEvents:\r
1118         return SProcGestureGetSelectedEvents(client);\r
1119     case X_GestureGrabEvent:\r
1120         return SProcGestureGrabEvent(client);\r
1121     case X_GestureUngrabEvent:\r
1122         return SProcGestureUngrabEvent(client);\r
1123     default:\r
1124         return BadRequest;\r
1125     }\r
1126 }\r
1127 \r