← Back to branch summary

~unity-api-team/hud/lp-1288025

« back to all changes in this revision

Viewing changes to src/window-menu.c

Tags: upstream-13.04.0
Import upstream version 13.04.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/window-menu.c
1
 
/*
2
 
 * Copyright © 2012 Canonical Limited
3
 
 *
4
 
 * This library is free software; you can redistribute it and/or
5
 
 * modify it under the terms of the GNU Lesser General Public
6
 
 * License as published by the Free Software Foundation; either
7
 
 * version 2 of the licence, or (at your option) any later version.
8
 
 *
9
 
 * This library is distributed in the hope that it will be useful,
10
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 
 * Lesser General Public License for more details.
13
 
 *
14
 
 * You should have received a copy of the GNU Lesser General Public
15
 
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
16
 
 *
17
 
 * Author: Ted Gould <ted.gould@canonical.com>
18
 
 */
19
 
 
20
 
#ifdef HAVE_CONFIG_H
21
 
#include "config.h"
22
 
#endif
23
 
 
24
 
#include "window-menu.h"
25
 
#include "indicator-appmenu-marshal.h"
26
 
 
27
 
#define WINDOW_MENU_GET_PRIVATE(o) \
28
 
(G_TYPE_INSTANCE_GET_PRIVATE ((o), WINDOW_MENU_TYPE, WindowMenuPrivate))
29
 
 
30
 
/* Signals */
31
 
 
32
 
enum {
33
 
        ENTRY_ADDED,
34
 
        ENTRY_REMOVED,
35
 
        ERROR_STATE,
36
 
        STATUS_CHANGED,
37
 
        SHOW_MENU,
38
 
        A11Y_UPDATE,
39
 
        LAST_SIGNAL
40
 
};
41
 
 
42
 
static guint signals[LAST_SIGNAL] = { 0 };
43
 
 
44
 
/* Prototypes */
45
 
 
46
 
static void window_menu_class_init (WindowMenuClass *klass);
47
 
static void window_menu_init       (WindowMenu *self);
48
 
static void window_menu_dispose    (GObject *object);
49
 
static void window_menu_finalize   (GObject *object);
50
 
 
51
 
G_DEFINE_TYPE (WindowMenu, window_menu, G_TYPE_OBJECT);
52
 
 
53
 
static void
54
 
window_menu_class_init (WindowMenuClass *klass)
55
 
{
56
 
        GObjectClass *object_class = G_OBJECT_CLASS (klass);
57
 
 
58
 
        object_class->dispose = window_menu_dispose;
59
 
        object_class->finalize = window_menu_finalize;
60
 
 
61
 
        /* Signals */
62
 
        signals[ENTRY_ADDED] =  g_signal_new(WINDOW_MENU_SIGNAL_ENTRY_ADDED,
63
 
                                              G_TYPE_FROM_CLASS(klass),
64
 
                                              G_SIGNAL_RUN_LAST,
65
 
                                              G_STRUCT_OFFSET (WindowMenuClass, entry_added),
66
 
                                              NULL, NULL,
67
 
                                              g_cclosure_marshal_VOID__POINTER,
68
 
                                              G_TYPE_NONE, 1, G_TYPE_POINTER);
69
 
        signals[ENTRY_REMOVED] =  g_signal_new(WINDOW_MENU_SIGNAL_ENTRY_REMOVED,
70
 
                                              G_TYPE_FROM_CLASS(klass),
71
 
                                              G_SIGNAL_RUN_LAST,
72
 
                                              G_STRUCT_OFFSET (WindowMenuClass, entry_removed),
73
 
                                              NULL, NULL,
74
 
                                              g_cclosure_marshal_VOID__POINTER,
75
 
                                              G_TYPE_NONE, 1, G_TYPE_POINTER);
76
 
        signals[ERROR_STATE] =   g_signal_new(WINDOW_MENU_SIGNAL_ERROR_STATE,
77
 
                                              G_TYPE_FROM_CLASS(klass),
78
 
                                              G_SIGNAL_RUN_LAST,
79
 
                                              G_STRUCT_OFFSET (WindowMenuClass, error_state),
80
 
                                              NULL, NULL,
81
 
                                              g_cclosure_marshal_VOID__BOOLEAN,
82
 
                                              G_TYPE_NONE, 1, G_TYPE_BOOLEAN, G_TYPE_NONE);
83
 
        signals[STATUS_CHANGED] = g_signal_new(WINDOW_MENU_SIGNAL_STATUS_CHANGED,
84
 
                                              G_TYPE_FROM_CLASS(klass),
85
 
                                              G_SIGNAL_RUN_LAST,
86
 
                                              G_STRUCT_OFFSET (WindowMenuClass, status_changed),
87
 
                                              NULL, NULL,
88
 
                                              g_cclosure_marshal_VOID__INT,
89
 
                                              G_TYPE_NONE, 1, G_TYPE_INT, G_TYPE_NONE);
90
 
        signals[SHOW_MENU] =     g_signal_new(WINDOW_MENU_SIGNAL_SHOW_MENU,
91
 
                                              G_TYPE_FROM_CLASS(klass),
92
 
                                              G_SIGNAL_RUN_LAST,
93
 
                                              G_STRUCT_OFFSET (WindowMenuClass, show_menu),
94
 
                                              NULL, NULL,
95
 
                                              _indicator_appmenu_marshal_VOID__POINTER_UINT,
96
 
                                              G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_UINT, G_TYPE_NONE);
97
 
        signals[A11Y_UPDATE] =   g_signal_new(WINDOW_MENU_SIGNAL_A11Y_UPDATE,
98
 
                                              G_TYPE_FROM_CLASS(klass),
99
 
                                              G_SIGNAL_RUN_LAST,
100
 
                                              G_STRUCT_OFFSET (WindowMenuClass, a11y_update),
101
 
                                              NULL, NULL,
102
 
                                              _indicator_appmenu_marshal_VOID__POINTER,
103
 
                                              G_TYPE_NONE, 1, G_TYPE_POINTER, G_TYPE_NONE);
104
 
 
105
 
        return;
106
 
}
107
 
 
108
 
static void
109
 
window_menu_init (WindowMenu *self)
110
 
{
111
 
 
112
 
 
113
 
        return;
114
 
}
115
 
 
116
 
static void
117
 
window_menu_dispose (GObject *object)
118
 
{
119
 
 
120
 
        G_OBJECT_CLASS (window_menu_parent_class)->dispose (object);
121
 
        return;
122
 
}
123
 
 
124
 
static void
125
 
window_menu_finalize (GObject *object)
126
 
{
127
 
 
128
 
        G_OBJECT_CLASS (window_menu_parent_class)->finalize (object);
129
 
        return;
130
 
}
131
 
 
132
 
 
133
 
/**************************
134
 
  API
135
 
 **************************/
136
 
GList *
137
 
window_menu_get_entries (WindowMenu * wm)
138
 
{
139
 
        WindowMenuClass * class = WINDOW_MENU_GET_CLASS(wm);
140
 
 
141
 
        if (class->get_entries != NULL) {
142
 
                return class->get_entries(wm);
143
 
        } else {
144
 
                return NULL;
145
 
        }
146
 
}
147
 
 
148
 
guint
149
 
window_menu_get_location (WindowMenu * wm, IndicatorObjectEntry * entry)
150
 
{
151
 
        WindowMenuClass * class = WINDOW_MENU_GET_CLASS(wm);
152
 
 
153
 
        if (class->get_location != NULL) {
154
 
                return class->get_location(wm, entry);
155
 
        } else {
156
 
                return 0;
157
 
        }
158
 
}
159
 
 
160
 
guint
161
 
window_menu_get_xid (WindowMenu * wm)
162
 
{
163
 
        WindowMenuClass * class = WINDOW_MENU_GET_CLASS(wm);
164
 
 
165
 
        if (class->get_xid != NULL) {
166
 
                return class->get_xid(wm);
167
 
        } else {
168
 
                return 0;
169
 
        }
170
 
}
171
 
 
172
 
gboolean
173
 
window_menu_get_error_state (WindowMenu * wm)
174
 
{
175
 
        WindowMenuClass * class = WINDOW_MENU_GET_CLASS(wm);
176
 
 
177
 
        if (class->get_error_state != NULL) {
178
 
                return class->get_error_state(wm);
179
 
        } else {
180
 
                return TRUE;
181
 
        }
182
 
}
183
 
 
184
 
WindowMenuStatus
185
 
window_menu_get_status (WindowMenu * wm)
186
 
{
187
 
        WindowMenuClass * class = WINDOW_MENU_GET_CLASS(wm);
188
 
 
189
 
        if (class->get_status != NULL) {
190
 
                return class->get_status(wm);
191
 
        } else {
192
 
                return WINDOW_MENU_STATUS_NORMAL;
193
 
        }
194
 
}
195
 
 
196
 
void
197
 
window_menu_entry_restore (WindowMenu * wm, IndicatorObjectEntry * entry)
198
 
{
199
 
        WindowMenuClass * class = WINDOW_MENU_GET_CLASS(wm);
200
 
 
201
 
        if (class->entry_restore != NULL) {
202
 
                return class->entry_restore(wm, entry);
203
 
        } else {
204
 
                return;
205
 
        }
206
 
}
207
 
 
208
 
void
209
 
window_menu_entry_activate (WindowMenu * wm, IndicatorObjectEntry * entry, guint timestamp)
210
 
{
211
 
        WindowMenuClass * class = WINDOW_MENU_GET_CLASS(wm);
212
 
 
213
 
        if (class->entry_activate != NULL) {
214
 
                return class->entry_activate(wm, entry, timestamp);
215
 
        } else {
216
 
                return;
217
 
        }
218
 
}