libgrip

Merge lp:~jpakkane/libgrip/deduplicate into lp:libgrip

  1. deduplicate
  2. Merge into trunk
Proposed by Jussi Pakkanen
Status: Merged
Merged at revision: 42
Proposed branch: lp:~jpakkane/libgrip/deduplicate
Merge into: lp:libgrip
Diff against target: 488 lines (+124/-333)
1 file modified
src/gripgesturemanager.c (+124/-333)
To merge this branch: bzr merge lp:~jpakkane/libgrip/deduplicate
Reviewer Review Type Date Requested Status
Chase Douglas (community) Approve
Review via email: mp+64676@code.launchpad.net

Description of the change

Gesture_start, gesture_update and gesture_end are identical except for one parameter. This branch deduplicates these into one common function.

To post a comment you must log in.
Revision history for this message
Jussi Pakkanen (jpakkane) wrote :

Whoops, theres an extra thingy there. I'll push a fixed version.

lp:~jpakkane/libgrip/deduplicate updated
42. By Jussi Pakkanen

Removed useless duplication with a common function.

43. By Jussi Pakkanen

Put braces according to coding standards.

Revision history for this message
Jussi Pakkanen (jpakkane) wrote :

Fixed.

Revision history for this message
Chase Douglas (chasedouglas) wrote :

/me loves code simplification :).

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
=== modified file 'src/gripgesturemanager.c'
--- src/gripgesturemanager.c 2011-05-19 11:11:35 +0000
+++ src/gripgesturemanager.c 2011-06-15 12:53:25 +0000
@@ -489,6 +489,127 @@
489 return (x >= ax && x < ax + alloc.width && y >= ay && y < ay + alloc.height);489 return (x >= ax && x < ax + alloc.width && y >= ay && y < ay + alloc.height);
490}490}
491491
492
493static void process_gesture (void *cookie,
494 GeisGestureType type,
495 GeisGestureId id,
496 GeisSize attr_count,
497 GeisGestureAttr *attrs,
498 GripTimeType time_type)
499{
500 GripGestureRegistration *reg = (GripGestureRegistration *)cookie;
501 GList *l = NULL;
502
503 for (l = reg->bindings; l != NULL; l = l->next)
504 {
505 GripGestureBinding *binding = (GripGestureBinding *)l->data;
506
507 if (binding->type == type)
508 {
509 GripGestureEvent *event = grip_gesture_event_new (type);
510
511 if (type == GRIP_GESTURE_DRAG)
512 {
513 GripEventGestureDrag *drag = (GripEventGestureDrag *)event;
514
515 drag->type = type;
516 drag->id = id;
517 drag->fingers = drag_gesture_handle_properties (drag,
518 attr_count,
519 attrs);
520
521 if (drag->fingers == binding->touches)
522 {
523 if (matches_widget (binding->widget,
524 gtk_widget_get_window(GTK_WIDGET (reg->window)),
525 (gint)drag->focus_x,
526 (gint)drag->focus_y))
527 {
528 binding->callback (binding->widget,
529 time_type,
530 event,
531 binding->data);
532 }
533 }
534 }
535 else if (type == GRIP_GESTURE_PINCH)
536 {
537 GripEventGesturePinch *pinch = (GripEventGesturePinch *)event;
538
539 pinch->type = type;
540 pinch->id = id;
541 pinch->fingers = pinch_gesture_handle_properties (pinch,
542 attr_count,
543 attrs);
544
545 if (pinch->fingers == binding->touches)
546 {
547 if (matches_widget (binding->widget,
548 gtk_widget_get_window(GTK_WIDGET(reg->window)),
549 (gint)pinch->focus_x,
550 (gint)pinch->focus_y))
551 {
552 binding->callback (binding->widget,
553 time_type,
554 event,
555 binding->data);
556 }
557 }
558 }
559 else if (type == GRIP_GESTURE_ROTATE)
560 {
561 GripEventGestureRotate *rotate = (GripEventGestureRotate *)event;
562
563 rotate->type = type;
564 rotate->id = id;
565 rotate->fingers = rotate_gesture_handle_properties (rotate,
566 attr_count,
567 attrs);
568
569 if (rotate->fingers == binding->touches)
570 {
571 if (matches_widget (binding->widget,
572 gtk_widget_get_window(GTK_WIDGET (reg->window)),
573 (gint)rotate->focus_x,
574 (gint)rotate->focus_y))
575 {
576 binding->callback (binding->widget,
577 time_type,
578 event,
579 binding->data);
580 }
581 }
582 }
583 else if (type == GRIP_GESTURE_TAP)
584 {
585 GripEventGestureTap *tap = (GripEventGestureTap *)event;
586
587 tap->type = type;
588 tap->id = id;
589 tap->fingers = tap_gesture_handle_properties (tap,
590 attr_count,
591 attrs);
592
593 if (tap->fingers == binding->touches)
594 {
595 if (matches_widget (binding->widget,
596 gtk_widget_get_window(GTK_WIDGET (reg->window)),
597 (gint)tap->focus_x,
598 (gint)tap->focus_y))
599 {
600 binding->callback (binding->widget,
601 time_type,
602 event,
603 binding->data);
604 }
605 }
606 }
607
608 grip_gesture_event_free (event);
609 }
610 }
611}
612
492static void613static void
493gesture_start (void *cookie,614gesture_start (void *cookie,
494 GeisGestureType type,615 GeisGestureType type,
@@ -496,117 +617,7 @@
496 GeisSize attr_count,617 GeisSize attr_count,
497 GeisGestureAttr *attrs)618 GeisGestureAttr *attrs)
498{619{
499 GripGestureRegistration *reg = (GripGestureRegistration *)cookie;620 process_gesture(cookie, type, id, attr_count, attrs, GRIP_TIME_START);
500 GList *l = NULL;
501
502 for (l = reg->bindings; l != NULL; l = l->next)
503 {
504 GripGestureBinding *binding = (GripGestureBinding *)l->data;
505
506 if (binding->type == type)
507 {
508 GripGestureEvent *event = grip_gesture_event_new (type);
509
510 if (type == GRIP_GESTURE_DRAG)
511 {
512 GripEventGestureDrag *drag = (GripEventGestureDrag *)event;
513
514 drag->type = type;
515 drag->id = id;
516 drag->fingers = drag_gesture_handle_properties (drag,
517 attr_count,
518 attrs);
519
520 if (drag->fingers == binding->touches)
521 {
522 if (matches_widget (binding->widget,
523 gtk_widget_get_window(GTK_WIDGET (reg->window)),
524 (gint)drag->focus_x,
525 (gint)drag->focus_y))
526 {
527 binding->callback (binding->widget,
528 GRIP_TIME_START,
529 event,
530 binding->data);
531 }
532 }
533 }
534 else if (type == GRIP_GESTURE_PINCH)
535 {
536 GripEventGesturePinch *pinch = (GripEventGesturePinch *)event;
537
538 pinch->type = type;
539 pinch->id = id;
540 pinch->fingers = pinch_gesture_handle_properties (pinch,
541 attr_count,
542 attrs);
543
544 if (pinch->fingers == binding->touches)
545 {
546 if (matches_widget (binding->widget,
547 gtk_widget_get_window(GTK_WIDGET(reg->window)),
548 (gint)pinch->focus_x,
549 (gint)pinch->focus_y))
550 {
551 binding->callback (binding->widget,
552 GRIP_TIME_START,
553 event,
554 binding->data);
555 }
556 }
557 }
558 else if (type == GRIP_GESTURE_ROTATE)
559 {
560 GripEventGestureRotate *rotate = (GripEventGestureRotate *)event;
561
562 rotate->type = type;
563 rotate->id = id;
564 rotate->fingers = rotate_gesture_handle_properties (rotate,
565 attr_count,
566 attrs);
567
568 if (rotate->fingers == binding->touches)
569 {
570 if (matches_widget (binding->widget,
571 gtk_widget_get_window(GTK_WIDGET (reg->window)),
572 (gint)rotate->focus_x,
573 (gint)rotate->focus_y))
574 {
575 binding->callback (binding->widget,
576 GRIP_TIME_START,
577 event,
578 binding->data);
579 }
580 }
581 }
582 else if (type == GRIP_GESTURE_TAP)
583 {
584 GripEventGestureTap *tap = (GripEventGestureTap *)event;
585
586 tap->type = type;
587 tap->id = id;
588 tap->fingers = tap_gesture_handle_properties (tap,
589 attr_count,
590 attrs);
591
592 if (tap->fingers == binding->touches)
593 {
594 if (matches_widget (binding->widget,
595 gtk_widget_get_window(GTK_WIDGET (reg->window)),
596 (gint)tap->focus_x,
597 (gint)tap->focus_y))
598 {
599 binding->callback (binding->widget,
600 GRIP_TIME_START,
601 event,
602 binding->data);
603 }
604 }
605 }
606
607 grip_gesture_event_free (event);
608 }
609 }
610}621}
611622
612static void623static void
@@ -616,117 +627,7 @@
616 GeisSize attr_count,627 GeisSize attr_count,
617 GeisGestureAttr *attrs)628 GeisGestureAttr *attrs)
618{629{
619 GripGestureRegistration *reg = (GripGestureRegistration *)cookie;630 process_gesture(cookie, type, id, attr_count, attrs, GRIP_TIME_UPDATE);
620 GList *l = NULL;
621
622 for (l = reg->bindings; l != NULL; l = l->next)
623 {
624 GripGestureBinding *binding = (GripGestureBinding *)l->data;
625
626 if (binding->type == type)
627 {
628 GripGestureEvent *event = grip_gesture_event_new (type);
629
630 if (type == GRIP_GESTURE_DRAG)
631 {
632 GripEventGestureDrag *drag = (GripEventGestureDrag *)event;
633
634 drag->type = type;
635 drag->id = id;
636 drag->fingers = drag_gesture_handle_properties (drag,
637 attr_count,
638 attrs);
639
640 if (drag->fingers == binding->touches)
641 {
642 if (matches_widget (binding->widget,
643 gtk_widget_get_window(GTK_WIDGET (reg->window)),
644 (gint)drag->focus_x,
645 (gint)drag->focus_y))
646 {
647 binding->callback (binding->widget,
648 GRIP_TIME_UPDATE,
649 event,
650 binding->data);
651 }
652 }
653 }
654 else if (type == GRIP_GESTURE_PINCH)
655 {
656 GripEventGesturePinch *pinch = (GripEventGesturePinch *)event;
657
658 pinch->type = type;
659 pinch->id = id;
660 pinch->fingers = pinch_gesture_handle_properties (pinch,
661 attr_count,
662 attrs);
663
664 if (pinch->fingers == binding->touches)
665 {
666 if (matches_widget (binding->widget,
667 gtk_widget_get_window(GTK_WIDGET (reg->window)),
668 (gint)pinch->focus_x,
669 (gint)pinch->focus_y))
670 {
671 binding->callback (binding->widget,
672 GRIP_TIME_UPDATE,
673 event,
674 binding->data);
675 }
676 }
677 }
678 else if (type == GRIP_GESTURE_ROTATE)
679 {
680 GripEventGestureRotate *rotate = (GripEventGestureRotate *)event;
681
682 rotate->type = type;
683 rotate->id = id;
684 rotate->fingers = rotate_gesture_handle_properties (rotate,
685 attr_count,
686 attrs);
687
688 if (rotate->fingers == binding->touches)
689 {
690 if (matches_widget (binding->widget,
691 gtk_widget_get_window(GTK_WIDGET (reg->window)),
692 (gint)rotate->focus_x,
693 (gint)rotate->focus_y))
694 {
695 binding->callback (binding->widget,
696 GRIP_TIME_UPDATE,
697 event,
698 binding->data);
699 }
700 }
701 }
702 else if (type == GRIP_GESTURE_TAP)
703 {
704 GripEventGestureTap *tap = (GripEventGestureTap *)event;
705
706 tap->type = type;
707 tap->id = id;
708 tap->fingers = tap_gesture_handle_properties (tap,
709 attr_count,
710 attrs);
711
712 if (tap->fingers == binding->touches)
713 {
714 if (matches_widget (binding->widget,
715 gtk_widget_get_window(GTK_WIDGET (reg->window)),
716 (gint)tap->focus_x,
717 (gint)tap->focus_y))
718 {
719 binding->callback (binding->widget,
720 GRIP_TIME_UPDATE,
721 event,
722 binding->data);
723 }
724 }
725 }
726
727 grip_gesture_event_free (event);
728 }
729 }
730}631}
731632
732static void633static void
@@ -736,117 +637,7 @@
736 GeisSize attr_count,637 GeisSize attr_count,
737 GeisGestureAttr *attrs)638 GeisGestureAttr *attrs)
738{639{
739 GripGestureRegistration *reg = (GripGestureRegistration *)cookie;640 process_gesture(cookie, type, id, attr_count, attrs, GRIP_TIME_END);
740 GList *l = NULL;
741
742 for (l = reg->bindings; l != NULL; l = l->next)
743 {
744 GripGestureBinding *binding = (GripGestureBinding *)l->data;
745
746 if (binding->type == type)
747 {
748 GripGestureEvent *event = grip_gesture_event_new (type);
749
750 if (type == GRIP_GESTURE_DRAG)
751 {
752 GripEventGestureDrag *drag = (GripEventGestureDrag *)event;
753
754 drag->type = type;
755 drag->id = id;
756 drag->fingers = drag_gesture_handle_properties (drag,
757 attr_count,
758 attrs);
759
760 if (drag->fingers == binding->touches)
761 {
762 if (matches_widget (binding->widget,
763 gtk_widget_get_window(GTK_WIDGET (reg->window)),
764 (gint)drag->focus_x,
765 (gint)drag->focus_y))
766 {
767 binding->callback (binding->widget,
768 GRIP_TIME_END,
769 event,
770 binding->data);
771 }
772 }
773 }
774 else if (type == GRIP_GESTURE_PINCH)
775 {
776 GripEventGesturePinch *pinch = (GripEventGesturePinch *)event;
777
778 pinch->type = type;
779 pinch->id = id;
780 pinch->fingers = pinch_gesture_handle_properties (pinch,
781 attr_count,
782 attrs);
783
784 if (pinch->fingers == binding->touches)
785 {
786 if (matches_widget (binding->widget,
787 gtk_widget_get_window(GTK_WIDGET (reg->window)),
788 (gint)pinch->focus_x,
789 (gint)pinch->focus_y))
790 {
791 binding->callback (binding->widget,
792 GRIP_TIME_END,
793 event,
794 binding->data);
795 }
796 }
797 }
798 else if (type == GRIP_GESTURE_ROTATE)
799 {
800 GripEventGestureRotate *rotate = (GripEventGestureRotate *)event;
801
802 rotate->type = type;
803 rotate->id = id;
804 rotate->fingers = rotate_gesture_handle_properties (rotate,
805 attr_count,
806 attrs);
807
808 if (rotate->fingers == binding->touches)
809 {
810 if (matches_widget (binding->widget,
811 gtk_widget_get_window(GTK_WIDGET (reg->window)),
812 (gint)rotate->focus_x,
813 (gint)rotate->focus_y))
814 {
815 binding->callback (binding->widget,
816 GRIP_TIME_END,
817 event,
818 binding->data);
819 }
820 }
821 }
822 else if (type == GRIP_GESTURE_TAP)
823 {
824 GripEventGestureTap *tap = (GripEventGestureTap *)event;
825
826 tap->type = type;
827 tap->id = id;
828 tap->fingers = tap_gesture_handle_properties (tap,
829 attr_count,
830 attrs);
831
832 if (tap->fingers == binding->touches)
833 {
834 if (matches_widget (binding->widget,
835 gtk_widget_get_window(GTK_WIDGET (reg->window)),
836 (gint)tap->focus_x,
837 (gint)tap->focus_y))
838 {
839 binding->callback (binding->widget,
840 GRIP_TIME_END,
841 event,
842 binding->data);
843 }
844 }
845 }
846
847 grip_gesture_event_free (event);
848 }
849 }
850}641}
851642
852static void643static void

Subscribers

People subscribed via source and target branches