Exemple #1
0
    rx::observable<std::tuple<Touch*, TouchEventObservable>> touchEventObservable(Node* targetNode, std::function<bool(Touch*)> isBegan /* = nullptr */, bool isSwallow /* = shallow */) {

        RefPtr<Node> sharedTarget(targetNode);
        return rx::observable<>::defer(
                                       [sharedTarget, isSwallow, isBegan] () {
                                           auto subject = std::make_shared<rxsub::subject<std::tuple<Touch*, TouchEventObservable>>>();
                                           auto subscriber = subject->get_subscriber();
                                           
                                           auto listener = RefPtr<EventListenerTouchOneByOne>{EventListenerTouchOneByOne::create()};
                                           
                                           if (isSwallow) {
                                               listener->setSwallowTouches(isSwallow);
                                           }

                                           auto finalizer = Util::shared_finallizer([subject, subscriber]() {
                                               subscriber.on_completed();
                                           });

                                           listener->onTouchBegan = [isBegan, listener, subscriber, finalizer, subject](Touch* t, Event*) -> bool {
                                               if (isBegan) {
                                                   if (!isBegan(t)) {
                                                       return false;
                                                   }
                                               }
                                               rxsub::subject<Touch*> subj2{};
                                               auto subscriber2 = subj2.get_subscriber();
                                               listener->onTouchMoved = [=](Touch* t, Event*) {
                                                   subscriber2.on_next(t);
                                               };
                                               listener->onTouchEnded = [=](Touch* t, Event*) {
                                                   subscriber2.on_next(t);
                                                   subscriber2.on_completed();
                                               };
                                               listener->onTouchCancelled = [=](Touch* t, Event*) {
                                                   subscriber2.on_next(t);
                                                   subscriber2.on_completed();
                                               };
                                               
                                               auto ob = subj2.get_observable();
                                               subscriber.on_next(std::make_tuple(t, ob));
                                               return true;
                                           };
                                           
                                           
                                           Director::getInstance()->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener, sharedTarget.get());
                                           
                                           return subject->get_observable()
                                           .finally([=]() {
                                               subscriber.unsubscribe();
                                               Director::getInstance()->getEventDispatcher()->removeEventListener(listener);
                                           }).as_dynamic();
                                       }).as_dynamic();

    }
  bool CoverWidget::on_slideshowScroll(GdkEventScroll * s) {

    if (s->direction == GDK_SCROLL_DOWN) {
      on_next();
    } else if (s->direction == GDK_SCROLL_UP) {
      on_prev();
    }
  }
  bool CoverWidget::slideLeft() {
    if (slideshowStarted) {
      on_next();
      return true;
    } else {
      return false;
    }

  }
static gboolean on_key(GtkWidget *widget, GdkEventKey *event, Editor *e)
{
    switch(event->keyval)
    {
        case GDK_Up:
            on_prev(NULL, e);
            return TRUE;
        case GDK_Down: case GDK_Return:
            on_next(NULL, e);
            return TRUE;            
    }
    return FALSE;
}