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