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