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