probe_event/gesture.cpp

   1 /*
   2  *  DA probe
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  *
   8  * Jaewon Lim <jaewon81.lim@samsung.com>
   9  * Woojin Jung <woojin2.jung@samsung.com>
  10  * Juyoung Kim <j0.kim@samsung.com>
  11  * Anastasia Lyupa <a.lyupa@samsung.com>
  12  *
  13  * This library is free software; you can redistribute it and/or modify it under
  14  * the terms of the GNU Lesser General Public License as published by the
  15  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  16  * any later version.
  17  *
  18  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  19  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  20  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  21  * License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  25  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  26  *
  27  * Contributors:
  28  * - S-Core Co., Ltd
  29  * - Samsung RnD Institute Russia
  30  *
  31  */
  32
  33 #include "daprobe.h"
  34 #include "dahelper.h"
  35 #include "probeinfo.h"
  36 #include "osp_probe.h"
  37 #include "dacollection.h"
  38 #include "da_event.h"
  39 #include "gesture.h"
  40 #include "binproto.h"
  41
  42 #define PACK_GESTURE_EVENT(_GESTURETYPE, _X, _Y, _INFO1, _INFO2, _ARGDETECTOR)  \
  43         do {                                                                                                                                            \
  44                 char info1_str[16];                                                                                                             \
  45                 setProbePoint(&probeInfo);                                                                                              \
  46                 PREPARE_LOCAL_BUF();                                                                                                    \
  47                 PACK_COMMON_BEGIN(MSG_PROBE_UIEVENT, LC_UIEVENT, "p", _ARGDETECTOR);    \
  48                 PACK_COMMON_END(0, 0, 0);                                                                                               \
  49                 sprintf(info1_str, "%d", _INFO1);                                                                               \
  50                 PACK_UIEVENT(_EVENT_GESTURE, _GESTURETYPE, _X, _Y, info1_str, _INFO2);  \
  51                 FLUSH_LOCAL_BUF();                                                                                                              \
  52         } while (0)
  53
  54 GestureEventListener GestureEventListener::rInstance;
  55
  56 GestureEventListener::GestureEventListener()
  57 {
  58
  59 }
  60
  61 GestureEventListener::~GestureEventListener()
  62 {
  63
  64 }
  65
  66 void GestureEventListener::OnCustomGestureCanceled (TouchGestureDetector &gestureDetector)
  67 {
  68         probeInfo_t     probeInfo;
  69
  70         if(isOptionEnabled(OPT_EVENT))
  71         {
  72                 probeBlockStart();
  73                 PACK_GESTURE_EVENT(_GESTURE_CUSTOM, 0, 0, 0, 0, &gestureDetector);
  74                 probeBlockEnd();
  75         }
  76 }
  77
  78 void GestureEventListener::OnCustomGestureChanged (TouchGestureDetector &gestureDetector)
  79 {
  80         probeInfo_t     probeInfo;
  81
  82         if(isOptionEnabled(OPT_EVENT))
  83         {
  84                 probeBlockStart();
  85                 PACK_GESTURE_EVENT(_GESTURE_CUSTOM, 0, 0, 0, 0, &gestureDetector);
  86                 probeBlockEnd();
  87         }
  88 }
  89
  90 void GestureEventListener::OnCustomGestureFinished (TouchGestureDetector &gestureDetector)
  91 {
  92         probeInfo_t     probeInfo;
  93
  94         if(isOptionEnabled(OPT_EVENT))
  95         {
  96                 probeBlockStart();
  97                 PACK_GESTURE_EVENT(_GESTURE_CUSTOM, 0, 0, 0, 0, &gestureDetector);
  98                 probeBlockEnd();
  99         }
 100 }
 101
 102 void GestureEventListener::OnCustomGestureStarted (TouchGestureDetector &gestureDetector)
 103 {
 104         probeInfo_t     probeInfo;
 105
 106         if(isOptionEnabled(OPT_EVENT))
 107         {
 108                 probeBlockStart();
 109                 PACK_GESTURE_EVENT(_GESTURE_CUSTOM, 0, 0, 0, 0, &gestureDetector);
 110                 probeBlockEnd();
 111         }
 112 }
 113
 114 void GestureEventListener::OnFlickGestureCanceled (TouchFlickGestureDetector &gestureDetector)
 115 {
 116         probeInfo_t     probeInfo;
 117
 118         if(isOptionEnabled(OPT_EVENT))
 119         {
 120                 probeBlockStart();
 121                 {
 122                         int x = 0, y = 0, dur = 0;
 123                         FlickDirection direction = FLICK_DIRECTION_NONE;
 124
 125                         gestureDetector.GetDistance(x, y);
 126                         dur = gestureDetector.GetDuration();
 127                         direction = gestureDetector.GetDirection();
 128                         PACK_GESTURE_EVENT(_GESTURE_FLICK, x, y, dur, (int)direction, &gestureDetector);
 129                 }
 130                 probeBlockEnd();
 131         }
 132 }
 133
 134 void GestureEventListener::OnFlickGestureDetected (TouchFlickGestureDetector &gestureDetector)
 135 {
 136         probeInfo_t     probeInfo;
 137
 138         if(isOptionEnabled(OPT_EVENT))
 139         {
 140                 probeBlockStart();
 141                 {
 142                         int x = 0, y = 0, dur = 0;
 143                         FlickDirection direction = FLICK_DIRECTION_NONE;
 144
 145                         gestureDetector.GetDistance(x, y);
 146                         dur = gestureDetector.GetDuration();
 147                         direction = gestureDetector.GetDirection();
 148                         PACK_GESTURE_EVENT(_GESTURE_FLICK, x, y, dur, (int)direction, &gestureDetector);
 149                 }
 150                 probeBlockEnd();
 151         }
 152 }
 153
 154 void GestureEventListener::OnLongPressGestureCanceled (TouchLongPressGestureDetector &gestureDetector)
 155 {
 156         probeInfo_t     probeInfo;
 157
 158         if(isOptionEnabled(OPT_EVENT))
 159         {
 160                 probeBlockStart();
 161                 {
 162                         int moveallow = 0, tcount = 0, dur = 0;
 163
 164                         moveallow = gestureDetector.GetMoveAllowance();
 165                         dur = gestureDetector.GetDuration();
 166                         tcount = gestureDetector.GetTouchCount();
 167                         PACK_GESTURE_EVENT(_GESTURE_LONGPRESS, moveallow, 0, dur, tcount, &gestureDetector);
 168                 }
 169                 probeBlockEnd();
 170         }
 171 }
 172
 173 void GestureEventListener::OnLongPressGestureDetected (TouchLongPressGestureDetector &gestureDetector)
 174 {
 175         probeInfo_t     probeInfo;
 176
 177         if(isOptionEnabled(OPT_EVENT))
 178         {
 179                 probeBlockStart();
 180                 {
 181                         int moveallow = 0, tcount = 0, dur = 0;
 182
 183                         moveallow = gestureDetector.GetMoveAllowance();
 184                         dur = gestureDetector.GetDuration();
 185                         tcount = gestureDetector.GetTouchCount();
 186                         PACK_GESTURE_EVENT(_GESTURE_LONGPRESS, moveallow, 0, dur, tcount, &gestureDetector);
 187                 }
 188                 probeBlockEnd();
 189         }
 190 }
 191
 192 void GestureEventListener::OnPanningGestureCanceled (TouchPanningGestureDetector &gestureDetector)
 193 {
 194         probeInfo_t     probeInfo;
 195
 196         if(isOptionEnabled(OPT_EVENT))
 197         {
 198                 probeBlockStart();
 199                 {
 200                         int tcount = 0;
 201
 202                         tcount = gestureDetector.GetTouchCount();
 203                         PACK_GESTURE_EVENT(_GESTURE_PANNING, 0, 0, 0, tcount, &gestureDetector);
 204                 }
 205                 probeBlockEnd();
 206         }
 207 }
 208
 209 void GestureEventListener::OnPanningGestureChanged (TouchPanningGestureDetector &gestureDetector)
 210 {
 211         probeInfo_t     probeInfo;
 212
 213         if(isOptionEnabled(OPT_EVENT))
 214         {
 215                 probeBlockStart();
 216                 {
 217                         int tcount = 0;
 218
 219                         tcount = gestureDetector.GetTouchCount();
 220                         PACK_GESTURE_EVENT(_GESTURE_PANNING, 0, 0, 0, tcount, &gestureDetector);
 221                 }
 222                 probeBlockEnd();
 223         }
 224 }
 225
 226 void GestureEventListener::OnPanningGestureFinished (TouchPanningGestureDetector &gestureDetector)
 227 {
 228         probeInfo_t     probeInfo;
 229
 230         if(isOptionEnabled(OPT_EVENT))
 231         {
 232                 probeBlockStart();
 233                 {
 234                         int tcount = 0;
 235
 236                         tcount = gestureDetector.GetTouchCount();
 237                         PACK_GESTURE_EVENT(_GESTURE_PANNING, 0, 0, 0, tcount, &gestureDetector);
 238                 }
 239                 probeBlockEnd();
 240         }
 241 }
 242
 243 void GestureEventListener::OnPanningGestureStarted (TouchPanningGestureDetector &gestureDetector)
 244 {
 245         probeInfo_t     probeInfo;
 246
 247         if(isOptionEnabled(OPT_EVENT))
 248         {
 249                 probeBlockStart();
 250                 {
 251                         int tcount = 0;
 252
 253                         tcount = gestureDetector.GetTouchCount();
 254                         PACK_GESTURE_EVENT(_GESTURE_PANNING, 0, 0, 0, tcount, &gestureDetector);
 255                 }
 256                 probeBlockEnd();
 257         }
 258 }
 259
 260 void GestureEventListener::OnPinchGestureCanceled (TouchPinchGestureDetector &gestureDetector)
 261 {
 262         probeInfo_t     probeInfo;
 263
 264         if(isOptionEnabled(OPT_EVENT))
 265         {
 266                 probeBlockStart();
 267                 {
 268                         Tizen::Graphics::Point point;
 269                         int scale = 0;
 270
 271                         point = gestureDetector.GetCenterPoint();
 272                         scale = gestureDetector.GetScale();
 273                         PACK_GESTURE_EVENT(_GESTURE_PINCH, point.x, point.y, scale, 0, &gestureDetector);
 274                 }
 275                 probeBlockEnd();
 276         }
 277 }
 278
 279 void GestureEventListener::OnPinchGestureChanged (TouchPinchGestureDetector &gestureDetector)
 280 {
 281         probeInfo_t     probeInfo;
 282
 283         if(isOptionEnabled(OPT_EVENT))
 284         {
 285                 probeBlockStart();
 286                 {
 287                         Tizen::Graphics::Point point;
 288                         int scale = 0;
 289
 290                         point = gestureDetector.GetCenterPoint();
 291                         scale = gestureDetector.GetScale();
 292                         PACK_GESTURE_EVENT(_GESTURE_PINCH, point.x, point.y, scale, 0, &gestureDetector);
 293                 }
 294                 probeBlockEnd();
 295         }
 296 }
 297
 298 void GestureEventListener::OnPinchGestureFinished (TouchPinchGestureDetector &gestureDetector)
 299 {
 300         probeInfo_t     probeInfo;
 301
 302         if(isOptionEnabled(OPT_EVENT))
 303         {
 304                 probeBlockStart();
 305                 {
 306                         Tizen::Graphics::Point point;
 307                         int scale = 0;
 308
 309                         point = gestureDetector.GetCenterPoint();
 310                         scale = gestureDetector.GetScale();
 311                         PACK_GESTURE_EVENT(_GESTURE_PINCH, point.x, point.y, scale, 0, &gestureDetector);
 312                 }
 313                 probeBlockEnd();
 314         }
 315 }
 316
 317 void GestureEventListener::OnPinchGestureStarted (TouchPinchGestureDetector &gestureDetector)
 318 {
 319         probeInfo_t     probeInfo;
 320
 321         if(isOptionEnabled(OPT_EVENT))
 322         {
 323                 probeBlockStart();
 324                 {
 325                         Tizen::Graphics::Point point;
 326                         int scale = 0;
 327
 328                         point = gestureDetector.GetCenterPoint();
 329                         scale = gestureDetector.GetScale();
 330                         PACK_GESTURE_EVENT(_GESTURE_PINCH, point.x, point.y, scale, 0, &gestureDetector);
 331                 }
 332                 probeBlockEnd();
 333         }
 334 }
 335
 336 void GestureEventListener::OnRotationGestureCanceled (TouchRotationGestureDetector &gestureDetector)
 337 {
 338         probeInfo_t     probeInfo;
 339
 340         if(isOptionEnabled(OPT_EVENT))
 341         {
 342                 probeBlockStart();
 343                 {
 344                         int distance = 0;
 345                         float angle = 0.0f;
 346
 347                         distance = gestureDetector.GetDistance();
 348                         angle = gestureDetector.GetAngle();
 349                         PACK_GESTURE_EVENT(_GESTURE_ROTATION, 0, 0, distance, static_cast<int>(angle), &gestureDetector);
 350                 }
 351                 probeBlockEnd();
 352         }
 353 }
 354
 355 void GestureEventListener::OnRotationGestureChanged (TouchRotationGestureDetector &gestureDetector)
 356 {
 357         probeInfo_t     probeInfo;
 358
 359         if(isOptionEnabled(OPT_EVENT))
 360         {
 361                 probeBlockStart();
 362                 {
 363                         int distance = 0;
 364                         float angle = 0.0f;
 365
 366                         distance = gestureDetector.GetDistance();
 367                         angle = gestureDetector.GetAngle();
 368                         PACK_GESTURE_EVENT(_GESTURE_ROTATION, 0, 0, distance, static_cast<int>(angle), &gestureDetector);
 369                 }
 370                 probeBlockEnd();
 371         }
 372 }
 373
 374 void GestureEventListener::OnRotationGestureFinished (TouchRotationGestureDetector &gestureDetector)
 375 {
 376         probeInfo_t     probeInfo;
 377
 378         if(isOptionEnabled(OPT_EVENT))
 379         {
 380                 probeBlockStart();
 381                 {
 382                         int distance = 0;
 383                         float angle = 0.0f;
 384
 385                         distance = gestureDetector.GetDistance();
 386                         angle = gestureDetector.GetAngle();
 387                         PACK_GESTURE_EVENT(_GESTURE_ROTATION, 0, 0, distance, static_cast<int>(angle), &gestureDetector);
 388                 }
 389                 probeBlockEnd();
 390         }
 391 }
 392
 393 void GestureEventListener::OnRotationGestureStarted (TouchRotationGestureDetector &gestureDetector)
 394 {
 395         probeInfo_t     probeInfo;
 396
 397         if(isOptionEnabled(OPT_EVENT))
 398         {
 399                 probeBlockStart();
 400                 {
 401                         int distance = 0;
 402                         float angle = 0.0f;
 403
 404                         distance = gestureDetector.GetDistance();
 405                         angle = gestureDetector.GetAngle();
 406                         PACK_GESTURE_EVENT(_GESTURE_ROTATION, 0, 0, distance, static_cast<int>(angle), &gestureDetector);
 407                 }
 408                 probeBlockEnd();
 409         }
 410 }
 411
 412 void GestureEventListener::OnTapGestureCanceled (TouchTapGestureDetector &gestureDetector)
 413 {
 414         probeInfo_t     probeInfo;
 415
 416         if(isOptionEnabled(OPT_EVENT))
 417         {
 418                 probeBlockStart();
 419                 {
 420                         int move = 0, tapcount = 0, touchcount = 0, interval = 0;
 421
 422                         move = gestureDetector.GetMoveAllowance();
 423                         tapcount = gestureDetector.GetTapCount();
 424                         interval = gestureDetector.GetTapInterval();
 425                         touchcount = gestureDetector.GetTouchCount();
 426                         PACK_GESTURE_EVENT(_GESTURE_TAP, move, tapcount, interval, touchcount, &gestureDetector);
 427                 }
 428                 probeBlockEnd();
 429         }
 430 }
 431
 432 void GestureEventListener::OnTapGestureDetected (TouchTapGestureDetector &gestureDetector)
 433 {
 434         probeInfo_t     probeInfo;
 435
 436         if(isOptionEnabled(OPT_EVENT))
 437         {
 438                 probeBlockStart();
 439                 {
 440                         int move = 0, tapcount = 0, touchcount = 0, interval = 0;
 441
 442                         move = gestureDetector.GetMoveAllowance();
 443                         tapcount = gestureDetector.GetTapCount();
 444                         interval = gestureDetector.GetTapInterval();
 445                         touchcount = gestureDetector.GetTouchCount();
 446                         PACK_GESTURE_EVENT(_GESTURE_TAP, move, tapcount, interval, touchcount, &gestureDetector);
 447                 }
 448                 probeBlockEnd();
 449         }
 450 }
 451
 452 GestureEventListener& GestureEventListener::GetInstance()
 453 {
 454         return rInstance;
 455 }
 456
 457
 458 namespace Tizen { namespace Ui {
 459
 460 result TouchFlickGestureDetector::AddFlickGestureEventListener(ITouchFlickGestureEventListener& listener)
 461 {
 462         typedef result (TouchFlickGestureDetector::*methodType)(ITouchFlickGestureEventListener& listener);
 463         static methodType addflickgestureeventlistenerp;
 464         result iret;
 465
 466         GET_REAL_FUNC_OSP(_ZN5Tizen2Ui25TouchFlickGestureDetector28AddFlickGestureEventListenerERNS0_31ITouchFlickGestureEventListenerE,
 467                         LIBOSP_UIFW, addflickgestureeventlistenerp);
 468
 469         probeBlockStart();
 470         GestureEventListener& mylistener = GestureEventListener::GetInstance();
 471         if(add_detector_hash(static_cast<void*>(this), static_cast<void*>(&mylistener)) <= 0)
 472         {
 473                 iret = (this->*addflickgestureeventlistenerp)(static_cast<ITouchFlickGestureEventListener&>(mylistener));
 474                 if(likely(iret == E_SUCCESS))
 475                 {
 476                         // do nothing
 477                 }
 478                 else
 479                 {
 480                         del_detector_hash(static_cast<void*>(this));
 481                 }
 482         }
 483         probeBlockEnd();
 484
 485         return (this->*addflickgestureeventlistenerp)(listener);
 486 }
 487
 488 result TouchLongPressGestureDetector::AddLongPressGestureEventListener(ITouchLongPressGestureEventListener& listener)
 489 {
 490         typedef result (TouchLongPressGestureDetector::*methodType)(ITouchLongPressGestureEventListener& listener);
 491         static methodType addlongpressgestureeventlistenerp;
 492         result iret;
 493
 494         GET_REAL_FUNC_OSP(_ZN5Tizen2Ui29TouchLongPressGestureDetector32AddLongPressGestureEventListenerERNS0_35ITouchLongPressGestureEventListenerE,
 495                         LIBOSP_UIFW, addlongpressgestureeventlistenerp);
 496
 497         probeBlockStart();
 498         GestureEventListener& mylistener = GestureEventListener::GetInstance();
 499         if(add_detector_hash(static_cast<void*>(this), static_cast<void*>(&mylistener)) <= 0)
 500         {
 501                 iret = (this->*addlongpressgestureeventlistenerp)(static_cast<ITouchLongPressGestureEventListener&>(mylistener));
 502                 if(likely(iret == E_SUCCESS))
 503                 {
 504                         // do nothing
 505                 }
 506                 else
 507                 {
 508                         del_detector_hash(static_cast<void*>(this));
 509                 }
 510         }
 511         probeBlockEnd();
 512
 513         return (this->*addlongpressgestureeventlistenerp)(listener);
 514 }
 515
 516 result TouchPanningGestureDetector::AddPanningGestureEventListener(ITouchPanningGestureEventListener& listener)
 517 {
 518         typedef result (TouchPanningGestureDetector::*methodType)(ITouchPanningGestureEventListener& listener);
 519         static methodType addpanninggestureeventlistenerp;
 520         result iret;
 521
 522         GET_REAL_FUNC_OSP(_ZN5Tizen2Ui27TouchPanningGestureDetector30AddPanningGestureEventListenerERNS0_33ITouchPanningGestureEventListenerE,
 523                         LIBOSP_UIFW, addpanninggestureeventlistenerp);
 524
 525         probeBlockStart();
 526         GestureEventListener& mylistener = GestureEventListener::GetInstance();
 527         if(add_detector_hash(static_cast<void*>(this), static_cast<void*>(&mylistener)) <= 0)
 528         {
 529                 iret = (this->*addpanninggestureeventlistenerp)(static_cast<ITouchPanningGestureEventListener&>(mylistener));
 530                 if(likely(iret == E_SUCCESS))
 531                 {
 532                         // do nothing
 533                 }
 534                 else
 535                 {
 536                         del_detector_hash(static_cast<void*>(this));
 537                 }
 538         }
 539         probeBlockEnd();
 540
 541         return (this->*addpanninggestureeventlistenerp)(listener);
 542 }
 543
 544 result TouchPinchGestureDetector::AddPinchGestureEventListener(ITouchPinchGestureEventListener& listener)
 545 {
 546         typedef result (TouchPinchGestureDetector::*methodType)(ITouchPinchGestureEventListener& listener);
 547         static methodType addpinchgestureeventlistenerp;
 548         result iret;
 549
 550         GET_REAL_FUNC_OSP(_ZN5Tizen2Ui25TouchPinchGestureDetector28AddPinchGestureEventListenerERNS0_31ITouchPinchGestureEventListenerE,
 551                         LIBOSP_UIFW, addpinchgestureeventlistenerp);
 552
 553         probeBlockStart();
 554         GestureEventListener& mylistener = GestureEventListener::GetInstance();
 555         if(add_detector_hash(static_cast<void*>(this), static_cast<void*>(&mylistener)) <= 0)
 556         {
 557                 iret = (this->*addpinchgestureeventlistenerp)(static_cast<ITouchPinchGestureEventListener&>(mylistener));
 558                 if(likely(iret == E_SUCCESS))
 559                 {
 560                         // do nothing
 561                 }
 562                 else
 563                 {
 564                         del_detector_hash(static_cast<void*>(this));
 565                 }
 566         }
 567         probeBlockEnd();
 568
 569         return (this->*addpinchgestureeventlistenerp)(listener);
 570 }
 571
 572 result TouchRotationGestureDetector::AddRotationGestureEventListener(ITouchRotationGestureEventListener& listener)
 573 {
 574         typedef result (TouchRotationGestureDetector::*methodType)(ITouchRotationGestureEventListener& listener);
 575         static methodType addrotationgestureeventlistenerp;
 576         result iret;
 577
 578         GET_REAL_FUNC_OSP(_ZN5Tizen2Ui28TouchRotationGestureDetector31AddRotationGestureEventListenerERNS0_34ITouchRotationGestureEventListenerE,
 579                         LIBOSP_UIFW, addrotationgestureeventlistenerp);
 580
 581         probeBlockStart();
 582         GestureEventListener& mylistener = GestureEventListener::GetInstance();
 583         if(add_detector_hash(static_cast<void*>(this), static_cast<void*>(&mylistener)) <= 0)
 584         {
 585                 iret = (this->*addrotationgestureeventlistenerp)(static_cast<ITouchRotationGestureEventListener&>(mylistener));
 586                 if(likely(iret == E_SUCCESS))
 587                 {
 588                         // do nothing
 589                 }
 590                 else
 591                 {
 592                         del_detector_hash(static_cast<void*>(this));
 593                 }
 594         }
 595         probeBlockEnd();
 596
 597         return (this->*addrotationgestureeventlistenerp)(listener);
 598 }
 599
 600 result TouchTapGestureDetector::AddTapGestureEventListener(ITouchTapGestureEventListener& listener)
 601 {
 602         typedef result (TouchTapGestureDetector::*methodType)(ITouchTapGestureEventListener& listener);
 603         static methodType addtapgestureeventlistenerp;
 604         result iret;
 605
 606         GET_REAL_FUNC_OSP(_ZN5Tizen2Ui23TouchTapGestureDetector26AddTapGestureEventListenerERNS0_29ITouchTapGestureEventListenerE,
 607                         LIBOSP_UIFW, addtapgestureeventlistenerp);
 608
 609         probeBlockStart();
 610         GestureEventListener& mylistener = GestureEventListener::GetInstance();
 611         if(add_detector_hash(static_cast<void*>(this), static_cast<void*>(&mylistener)) <= 0)
 612         {
 613                 iret = (this->*addtapgestureeventlistenerp)(static_cast<ITouchTapGestureEventListener&>(mylistener));
 614                 if(likely(iret == E_SUCCESS))
 615                 {
 616                         // do nothing
 617                 }
 618                 else
 619                 {
 620                         del_detector_hash(static_cast<void*>(this));
 621                 }
 622         }
 623         probeBlockEnd();
 624
 625         return (this->*addtapgestureeventlistenerp)(listener);
 626 }
 627
 628 result TouchGestureDetector::AddGestureEventListener(ITouchGestureEventListener& listener)
 629 {
 630         typedef result (TouchGestureDetector::*methodType)(ITouchGestureEventListener& listener);
 631         static methodType addgestureeventlistenerp;
 632         result iret;
 633
 634         GET_REAL_FUNC_OSP(_ZN5Tizen2Ui20TouchGestureDetector23AddGestureEventListenerERNS0_26ITouchGestureEventListenerE,
 635                         LIBOSP_UIFW, addgestureeventlistenerp);
 636
 637         probeBlockStart();
 638         GestureEventListener& mylistener = GestureEventListener::GetInstance();
 639         if(add_detector_hash(static_cast<void*>(this), static_cast<void*>(&mylistener)) <= 0)
 640         {
 641                 iret = (this->*addgestureeventlistenerp)(static_cast<ITouchGestureEventListener&>(mylistener));
 642                 if(likely(iret == E_SUCCESS))
 643                 {
 644                         // do nothing
 645                 }
 646                 else
 647                 {
 648                         del_detector_hash(static_cast<void*>(this));
 649                 }
 650         }
 651         probeBlockEnd();
 652
 653         return (this->*addgestureeventlistenerp)(listener);
 654 }
 655
 656
 657 } }     // end of namespace
 658
 659
 660