← Back to branch summary

~3v1n0/compiz/unity-lowgfx-profile

« back to all changes in this revision

Viewing changes to gtk/window-decorator/events.c

  • Committer: Bileto Bot
  • Author(s): Alberts Muktupāvels
  • Date: 2016-06-02 01:29:12 UTC
  • mfrom: (4044.2.4 gwd-remove-2d)
  • Revision ID: ci-train-bot@canonical.com-20160602012912-pscipqlbwa43uuij
gtk-window-decorator: remove broken 2D decoration mode.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk/window-decorator/events.c
117
117
    if (use_tooltips)
118
118
        handle_tooltip_event (win, gtkwd_event, gtkwd_type, state, tooltip);
119
119
 
120
 
    if (d->frame_window && gtkwd_type == GEnterNotify)
121
 
    {
122
 
        GdkCursor* cursor;
123
 
        cursor = gdk_cursor_new (GDK_LEFT_PTR);
124
 
        gdk_window_set_cursor (d->frame_window, cursor);
125
 
        g_object_unref (cursor);
126
 
    }
127
 
 
128
120
    switch (gtkwd_type) {
129
121
    case GButtonPress:
130
122
        if (gtkwd_event->button <= max)
487
479
    static Time   last_button_time = 0;
488
480
    gint          titlebar_action = 0;
489
481
 
490
 
    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
491
 
 
492
 
    if (d->frame_window && gtkwd_type == GEnterNotify)
493
 
    {
494
 
        GdkCursor* cursor = gdk_cursor_new (GDK_LEFT_PTR);
495
 
        gdk_window_set_cursor (d->frame_window, cursor);
496
 
        g_object_unref (cursor);
497
 
    }
498
 
 
499
482
    if (gtkwd_type != GButtonPress)
500
483
        return;
501
484
 
560
543
{
561
544
    GWDSettings *settings = gwd_theme_get_settings (gwd_theme);
562
545
    gint    titlebar_action = 0;
563
 
    decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
564
 
 
565
 
    if (d->frame_window && gtkwd_type == GEnterNotify)
566
 
    {
567
 
        GdkCursor *cursor = NULL;
568
 
 
569
 
        switch (direction)
570
 
        {
571
 
            case WM_MOVERESIZE_SIZE_TOPLEFT:
572
 
                cursor = gdk_cursor_new (GDK_TOP_LEFT_CORNER);
573
 
                break;
574
 
            case WM_MOVERESIZE_SIZE_LEFT:
575
 
                cursor = gdk_cursor_new (GDK_LEFT_SIDE);
576
 
                break;
577
 
            case WM_MOVERESIZE_SIZE_BOTTOMLEFT:
578
 
                cursor = gdk_cursor_new (GDK_BOTTOM_LEFT_CORNER);
579
 
                break;
580
 
            case WM_MOVERESIZE_SIZE_BOTTOM:
581
 
                cursor = gdk_cursor_new (GDK_BOTTOM_SIDE);
582
 
                break;
583
 
            case WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
584
 
                cursor = gdk_cursor_new (GDK_BOTTOM_RIGHT_CORNER);
585
 
                break;
586
 
            case WM_MOVERESIZE_SIZE_RIGHT:
587
 
                cursor = gdk_cursor_new (GDK_RIGHT_SIDE);
588
 
                break;
589
 
            case WM_MOVERESIZE_SIZE_TOPRIGHT:
590
 
                cursor = gdk_cursor_new (GDK_TOP_RIGHT_CORNER);
591
 
                break;
592
 
            case WM_MOVERESIZE_SIZE_TOP:
593
 
                cursor = gdk_cursor_new (GDK_TOP_SIDE);
594
 
                break;
595
 
            default:
596
 
                break;
597
 
        }
598
 
 
599
 
        if (cursor)
600
 
        {
601
 
            gdk_window_set_cursor (d->frame_window, cursor);
602
 
            g_object_unref (cursor);
603
 
        }
604
 
    }
605
546
 
606
547
    if (gtkwd_type != GButtonPress)
607
548
        return;
696
637
                        gtkwd_event, gtkwd_type);
697
638
}
698
639
 
699
 
void
700
 
frame_window_realized (GtkWidget *widget,
701
 
                       gpointer  data)
702
 
{
703
 
    decor_t *d = (decor_t *) data;
704
 
 
705
 
    if (d)
706
 
    {
707
 
        GdkWindow *gdk_frame_window = gtk_widget_get_window (d->decor_window);
708
 
        gdk_window_reparent (gdk_frame_window, d->frame_window, 0, 0);
709
 
        gdk_window_lower (gdk_frame_window);
710
 
 
711
 
    }
712
 
}
713
 
 
714
 
static event_callback
715
 
find_event_callback_for_point (decor_t *d,
716
 
                               int     x,
717
 
                               int     y,
718
 
                               Bool    *enter,
719
 
                               Bool    *leave,
720
 
                               BoxPtr  *entered_box)
721
 
{
722
 
    int    i, j;
723
 
    BoxPtr box;
724
 
 
725
 
    for (i = 0; i < BUTTON_NUM; ++i)
726
 
    {
727
 
        box = &d->button_windows[i].pos;
728
 
        if (x >= box->x1 && x <= box->x2 &&
729
 
            y >= box->y1 && y <= box->y2)
730
 
        {
731
 
            if (d->last_pos_entered != box)
732
 
            {
733
 
                if (enter)
734
 
                    *enter = TRUE;
735
 
                if (leave && d->last_pos_entered)
736
 
                    *leave = TRUE;
737
 
                if (entered_box)
738
 
                    *entered_box = box;
739
 
            }
740
 
            return d->button_windows[i].callback;
741
 
        }
742
 
    }
743
 
 
744
 
    for (i = 0; i < 3; ++i)
745
 
    {
746
 
        for (j = 0; j < 3; ++j)
747
 
        {
748
 
            box = &d->event_windows[i][j].pos;
749
 
            if (x >= box->x1 && x <= box->x2 &&
750
 
                y >= box->y1 && y <= box->y2)
751
 
            {
752
 
                if (d->last_pos_entered != box)
753
 
                {
754
 
                    if (enter)
755
 
                        *enter = TRUE;
756
 
                    if (leave && d->last_pos_entered)
757
 
                        *leave = TRUE;
758
 
                    if (entered_box)
759
 
                        *entered_box = box;
760
 
                }
761
 
                return d->event_windows[i][j].callback;
762
 
            }
763
 
        }
764
 
    }
765
 
 
766
 
    return NULL;
767
 
}
768
 
 
769
 
static event_callback
770
 
find_leave_event_callback (decor_t *d)
771
 
{
772
 
    int i, j;
773
 
 
774
 
    for (i = 0; i < BUTTON_NUM; ++i)
775
 
    {
776
 
        if (d->last_pos_entered == &d->button_windows[i].pos)
777
 
            return d->button_windows[i].callback;
778
 
    }
779
 
 
780
 
    for (i = 0; i < 3; ++i)
781
 
    {
782
 
        for (j = 0; j < 3; ++j)
783
 
        {
784
 
            if (d->last_pos_entered == &d->event_windows[i][j].pos)
785
 
                return d->event_windows[i][j].callback;
786
 
        }
787
 
    }
788
 
 
789
 
    return NULL;
790
 
}
791
 
 
792
 
void
793
 
frame_handle_button_press (GtkWidget      *widget,
794
 
                           GdkEventButton *event,
795
 
                           gpointer       user_data)
796
 
{
797
 
    decor_t *d = (decor_t *) user_data;
798
 
 
799
 
    if (d)
800
 
    {
801
 
        /* Check to see where the event happened and fill out an appropriate
802
 
         * struct
803
 
         */
804
 
        event_callback cb;
805
 
 
806
 
        cb = find_event_callback_for_point (d, event->x, event->y,
807
 
                                            NULL, NULL, NULL);
808
 
 
809
 
        if (cb && d->decorated)
810
 
        {
811
 
            decor_event gtkwd_event;
812
 
 
813
 
            gtkwd_event.window = GDK_WINDOW_XID (d->frame_window);
814
 
            gtkwd_event.button = event->button;
815
 
            gtkwd_event.x      = event->x;
816
 
            gtkwd_event.y      = event->y;
817
 
            gtkwd_event.x_root = event->x_root;
818
 
            gtkwd_event.y_root = event->y_root;
819
 
            gtkwd_event.time   = event->time;
820
 
 
821
 
            (*cb) (d->win, &gtkwd_event, GButtonPress);
822
 
        }
823
 
    }
824
 
}
825
 
 
826
 
void
827
 
frame_handle_button_release (GtkWidget      *widget,
828
 
                             GdkEventButton *event,
829
 
                             gpointer       user_data)
830
 
{
831
 
    decor_t *d = (decor_t *) user_data;
832
 
 
833
 
    if (d)
834
 
    {
835
 
        event_callback cb;
836
 
 
837
 
        cb = find_event_callback_for_point (d, event->x, event->y,
838
 
                                            NULL, NULL, NULL);
839
 
 
840
 
        if (cb && d->decorated)
841
 
        {
842
 
            decor_event gtkwd_event;
843
 
 
844
 
            gtkwd_event.window = GDK_WINDOW_XID (d->frame_window);
845
 
            gtkwd_event.button = event->button;
846
 
            gtkwd_event.x      = event->x;
847
 
            gtkwd_event.y      = event->y;
848
 
            gtkwd_event.x_root = event->x_root;
849
 
            gtkwd_event.y_root = event->y_root;
850
 
            gtkwd_event.time   = event->time;
851
 
 
852
 
            (*cb) (d->win, &gtkwd_event, GButtonRelease);
853
 
        }
854
 
    }
855
 
}
856
 
 
857
 
void
858
 
frame_handle_motion (GtkWidget      *widget,
859
 
                     GdkEventMotion *event,
860
 
                     gpointer       user_data)
861
 
{
862
 
    decor_t *d = (decor_t *) user_data;
863
 
 
864
 
    if (d)
865
 
    {
866
 
        event_callback cb = NULL;
867
 
        Bool           send_enter = FALSE;
868
 
        Bool           send_leave = FALSE;
869
 
        BoxPtr         entered_box;
870
 
 
871
 
        cb = find_event_callback_for_point (d, event->x, event->y,
872
 
                                            &send_enter, &send_leave,
873
 
                                            &entered_box);
874
 
 
875
 
        if (cb && d->decorated)
876
 
        {
877
 
            decor_event gtkwd_event;
878
 
 
879
 
            gtkwd_event.window = GDK_WINDOW_XID (d->frame_window);
880
 
            gtkwd_event.x      = event->x;
881
 
            gtkwd_event.y      = event->y;
882
 
            gtkwd_event.x_root = event->x_root;
883
 
            gtkwd_event.y_root = event->y_root;
884
 
            gtkwd_event.time   = event->time;
885
 
 
886
 
            if (send_enter)
887
 
                (*cb) (d->win, &gtkwd_event, GEnterNotify);
888
 
 
889
 
            if (send_leave)
890
 
            {
891
 
                event_callback leave_cb;
892
 
 
893
 
                leave_cb = find_leave_event_callback (d);
894
 
 
895
 
                if (leave_cb)
896
 
                    (*leave_cb) (d->win, &gtkwd_event, GLeaveNotify);
897
 
 
898
 
            }
899
 
 
900
 
            if (send_enter)
901
 
                d->last_pos_entered = entered_box;
902
 
        }
903
 
        else if (d->last_pos_entered && d->decorated)
904
 
        {
905
 
            /* We are not in an event / button window but last_pos_entered
906
 
             * is still set, so send a GLeaveNotify to last_pos_entered
907
 
             * and set it to NULL
908
 
             */
909
 
 
910
 
            event_callback leave_cb;
911
 
 
912
 
            leave_cb = find_leave_event_callback (d);
913
 
 
914
 
            if (leave_cb)
915
 
            {
916
 
                decor_event    gtkwd_event;
917
 
 
918
 
                gtkwd_event.window = GDK_WINDOW_XID (d->frame_window);
919
 
                gtkwd_event.x      = event->x;
920
 
                gtkwd_event.y      = event->y;
921
 
                gtkwd_event.x_root = event->x_root;
922
 
                gtkwd_event.y_root = event->y_root;
923
 
                gtkwd_event.time   = event->time;
924
 
 
925
 
                (*leave_cb) (d->win, &gtkwd_event, GLeaveNotify);
926
 
            }
927
 
 
928
 
            d->last_pos_entered = NULL;
929
 
        }
930
 
    }
931
 
}
932
 
 
933
640
GdkFilterReturn
934
641
event_filter_func (GdkXEvent *gdkxevent,
935
642
                   GdkEvent  *event,
997
704
                if (!get_window_prop (xid, select_window_atom, &select))
998
705
                {
999
706
                    if (get_window_prop (xid, frame_input_window_atom, &frame))
1000
 
                        add_frame_window (win, frame, FALSE);
1001
 
                    else
1002
 
                        remove_frame_window (win);
1003
 
                }
1004
 
            }
1005
 
        }
1006
 
        if (xevent->xproperty.atom == frame_output_window_atom)
1007
 
        {
1008
 
            WnckWindow *win;
1009
 
 
1010
 
            xid = xevent->xproperty.window;
1011
 
 
1012
 
            win = wnck_window_get (xid);
1013
 
            if (win)
1014
 
            {
1015
 
                Window frame;
1016
 
 
1017
 
                if (!get_window_prop (xid, select_window_atom, &select))
1018
 
                {
1019
 
                    if (get_window_prop (xid, frame_output_window_atom, &frame))
1020
 
                        add_frame_window (win, frame, TRUE);
 
707
                        add_frame_window (win, frame);
1021
708
                    else
1022
709
                        remove_frame_window (win);
1023
710
                }