← Back to branch summary

~ubuntu-branches/ubuntu/natty/libwnck/natty

« back to all changes in this revision

Viewing changes to libwnck/wnck-enum-types.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2009-06-30 12:37:25 UTC
  • mfrom: (1.1.45 upstream)
  • Revision ID: james.westby@ubuntu.com-20090630123725-hf3fiw6ercfdvqvj
Tags: 2.26.2-0ubuntu1
https://launchpad.net/bugs/393704
* New upstream release: (LP: #393704)
  - Fix wnck_application_get_icon_is_fallback() to actually work (Vincent)
  - Fix gtk-doc warning (Vincent)
  - Use shave to improve build log readability (Vincent)
  - Build system tweaks (Vincent)
* debian/patches/90_relibtoolize.patch:
  - Obsolete as upstream now uses libtool 2.2.6 which does not have the rpath
    issue

Show diffs side-by-side

added added

removed removed

Lines of Context:
libwnck/wnck-enum-types.c
4
4
#include <libwnck/libwnck.h>
5
5
 
6
6
/* enumerations from "pager.h" */
 
7
static const GEnumValue _wnck_pager_display_mode_values[] = {
 
8
  { WNCK_PAGER_DISPLAY_NAME, "WNCK_PAGER_DISPLAY_NAME", "name" },
 
9
  { WNCK_PAGER_DISPLAY_CONTENT, "WNCK_PAGER_DISPLAY_CONTENT", "content" },
 
10
  { 0, NULL, NULL }
 
11
};
 
12
 
7
13
GType
8
14
wnck_pager_display_mode_get_type (void)
9
15
{
10
 
  static GType etype = 0;
11
 
  if (etype == 0) {
12
 
    static const GEnumValue values[] = {
13
 
      { WNCK_PAGER_DISPLAY_NAME, "WNCK_PAGER_DISPLAY_NAME", "name" },
14
 
      { WNCK_PAGER_DISPLAY_CONTENT, "WNCK_PAGER_DISPLAY_CONTENT", "content" },
15
 
      { 0, NULL, NULL }
16
 
    };
17
 
    etype = g_enum_register_static ("WnckPagerDisplayMode", values);
18
 
  }
19
 
  return etype;
 
16
  static GType type = 0;
 
17
 
 
18
  if (!type)
 
19
    type = g_enum_register_static ("WnckPagerDisplayMode", _wnck_pager_display_mode_values);
 
20
 
 
21
  return type;
20
22
}
21
23
 
 
24
 
22
25
/* enumerations from "screen.h" */
 
26
static const GEnumValue _wnck_motion_direction_values[] = {
 
27
  { WNCK_MOTION_UP, "WNCK_MOTION_UP", "up" },
 
28
  { WNCK_MOTION_DOWN, "WNCK_MOTION_DOWN", "down" },
 
29
  { WNCK_MOTION_LEFT, "WNCK_MOTION_LEFT", "left" },
 
30
  { WNCK_MOTION_RIGHT, "WNCK_MOTION_RIGHT", "right" },
 
31
  { 0, NULL, NULL }
 
32
};
 
33
 
23
34
GType
24
35
wnck_motion_direction_get_type (void)
25
36
{
26
 
  static GType etype = 0;
27
 
  if (etype == 0) {
28
 
    static const GEnumValue values[] = {
29
 
      { WNCK_MOTION_UP, "WNCK_MOTION_UP", "up" },
30
 
      { WNCK_MOTION_DOWN, "WNCK_MOTION_DOWN", "down" },
31
 
      { WNCK_MOTION_LEFT, "WNCK_MOTION_LEFT", "left" },
32
 
      { WNCK_MOTION_RIGHT, "WNCK_MOTION_RIGHT", "right" },
33
 
      { 0, NULL, NULL }
34
 
    };
35
 
    etype = g_enum_register_static ("WnckMotionDirection", values);
36
 
  }
37
 
  return etype;
 
37
  static GType type = 0;
 
38
 
 
39
  if (!type)
 
40
    type = g_enum_register_static ("WnckMotionDirection", _wnck_motion_direction_values);
 
41
 
 
42
  return type;
38
43
}
 
44
 
 
45
static const GEnumValue __wncklayoutorientation___wnck_layout_orientation_values[] = {
 
46
  { WNCK_LAYOUT_ORIENTATION_HORIZONTAL, "WNCK_LAYOUT_ORIENTATION_HORIZONTAL", "horizontal" },
 
47
  { WNCK_LAYOUT_ORIENTATION_VERTICAL, "WNCK_LAYOUT_ORIENTATION_VERTICAL", "vertical" },
 
48
  { 0, NULL, NULL }
 
49
};
 
50
 
39
51
GType
40
52
_wncklayoutorientation___wnck_layout_orientation_get_type (void)
41
53
{
42
 
  static GType etype = 0;
43
 
  if (etype == 0) {
44
 
    static const GEnumValue values[] = {
45
 
      { WNCK_LAYOUT_ORIENTATION_HORIZONTAL, "WNCK_LAYOUT_ORIENTATION_HORIZONTAL", "horizontal" },
46
 
      { WNCK_LAYOUT_ORIENTATION_VERTICAL, "WNCK_LAYOUT_ORIENTATION_VERTICAL", "vertical" },
47
 
      { 0, NULL, NULL }
48
 
    };
49
 
    etype = g_enum_register_static ("_WnckLayoutOrientation", values);
50
 
  }
51
 
  return etype;
 
54
  static GType type = 0;
 
55
 
 
56
  if (!type)
 
57
    type = g_enum_register_static ("_WnckLayoutOrientation", __wncklayoutorientation___wnck_layout_orientation_values);
 
58
 
 
59
  return type;
52
60
}
 
61
 
 
62
static const GEnumValue __wncklayoutcorner___wnck_layout_corner_values[] = {
 
63
  { WNCK_LAYOUT_CORNER_TOPLEFT, "WNCK_LAYOUT_CORNER_TOPLEFT", "topleft" },
 
64
  { WNCK_LAYOUT_CORNER_TOPRIGHT, "WNCK_LAYOUT_CORNER_TOPRIGHT", "topright" },
 
65
  { WNCK_LAYOUT_CORNER_BOTTOMRIGHT, "WNCK_LAYOUT_CORNER_BOTTOMRIGHT", "bottomright" },
 
66
  { WNCK_LAYOUT_CORNER_BOTTOMLEFT, "WNCK_LAYOUT_CORNER_BOTTOMLEFT", "bottomleft" },
 
67
  { 0, NULL, NULL }
 
68
};
 
69
 
53
70
GType
54
71
_wncklayoutcorner___wnck_layout_corner_get_type (void)
55
72
{
56
 
  static GType etype = 0;
57
 
  if (etype == 0) {
58
 
    static const GEnumValue values[] = {
59
 
      { WNCK_LAYOUT_CORNER_TOPLEFT, "WNCK_LAYOUT_CORNER_TOPLEFT", "topleft" },
60
 
      { WNCK_LAYOUT_CORNER_TOPRIGHT, "WNCK_LAYOUT_CORNER_TOPRIGHT", "topright" },
61
 
      { WNCK_LAYOUT_CORNER_BOTTOMRIGHT, "WNCK_LAYOUT_CORNER_BOTTOMRIGHT", "bottomright" },
62
 
      { WNCK_LAYOUT_CORNER_BOTTOMLEFT, "WNCK_LAYOUT_CORNER_BOTTOMLEFT", "bottomleft" },
63
 
      { 0, NULL, NULL }
64
 
    };
65
 
    etype = g_enum_register_static ("_WnckLayoutCorner", values);
66
 
  }
67
 
  return etype;
 
73
  static GType type = 0;
 
74
 
 
75
  if (!type)
 
76
    type = g_enum_register_static ("_WnckLayoutCorner", __wncklayoutcorner___wnck_layout_corner_values);
 
77
 
 
78
  return type;
68
79
}
69
80
 
 
81
 
70
82
/* enumerations from "tasklist.h" */
 
83
static const GEnumValue _wnck_tasklist_grouping_type_values[] = {
 
84
  { WNCK_TASKLIST_NEVER_GROUP, "WNCK_TASKLIST_NEVER_GROUP", "never-group" },
 
85
  { WNCK_TASKLIST_AUTO_GROUP, "WNCK_TASKLIST_AUTO_GROUP", "auto-group" },
 
86
  { WNCK_TASKLIST_ALWAYS_GROUP, "WNCK_TASKLIST_ALWAYS_GROUP", "always-group" },
 
87
  { 0, NULL, NULL }
 
88
};
 
89
 
71
90
GType
72
91
wnck_tasklist_grouping_type_get_type (void)
73
92
{
74
 
  static GType etype = 0;
75
 
  if (etype == 0) {
76
 
    static const GEnumValue values[] = {
77
 
      { WNCK_TASKLIST_NEVER_GROUP, "WNCK_TASKLIST_NEVER_GROUP", "never-group" },
78
 
      { WNCK_TASKLIST_AUTO_GROUP, "WNCK_TASKLIST_AUTO_GROUP", "auto-group" },
79
 
      { WNCK_TASKLIST_ALWAYS_GROUP, "WNCK_TASKLIST_ALWAYS_GROUP", "always-group" },
80
 
      { 0, NULL, NULL }
81
 
    };
82
 
    etype = g_enum_register_static ("WnckTasklistGroupingType", values);
83
 
  }
84
 
  return etype;
 
93
  static GType type = 0;
 
94
 
 
95
  if (!type)
 
96
    type = g_enum_register_static ("WnckTasklistGroupingType", _wnck_tasklist_grouping_type_values);
 
97
 
 
98
  return type;
85
99
}
86
100
 
 
101
 
87
102
/* enumerations from "util.h" */
 
103
static const GEnumValue _wnck_client_type_values[] = {
 
104
  { WNCK_CLIENT_TYPE_APPLICATION, "WNCK_CLIENT_TYPE_APPLICATION", "application" },
 
105
  { WNCK_CLIENT_TYPE_PAGER, "WNCK_CLIENT_TYPE_PAGER", "pager" },
 
106
  { 0, NULL, NULL }
 
107
};
 
108
 
88
109
GType
89
110
wnck_client_type_get_type (void)
90
111
{
91
 
  static GType etype = 0;
92
 
  if (etype == 0) {
93
 
    static const GEnumValue values[] = {
94
 
      { WNCK_CLIENT_TYPE_APPLICATION, "WNCK_CLIENT_TYPE_APPLICATION", "application" },
95
 
      { WNCK_CLIENT_TYPE_PAGER, "WNCK_CLIENT_TYPE_PAGER", "pager" },
96
 
      { 0, NULL, NULL }
97
 
    };
98
 
    etype = g_enum_register_static ("WnckClientType", values);
99
 
  }
100
 
  return etype;
 
112
  static GType type = 0;
 
113
 
 
114
  if (!type)
 
115
    type = g_enum_register_static ("WnckClientType", _wnck_client_type_values);
 
116
 
 
117
  return type;
101
118
}
102
119
 
 
120
 
103
121
/* enumerations from "window.h" */
 
122
static const GEnumValue _wnck_window_state_values[] = {
 
123
  { WNCK_WINDOW_STATE_MINIMIZED, "WNCK_WINDOW_STATE_MINIMIZED", "minimized" },
 
124
  { WNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY, "WNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY", "maximized-horizontally" },
 
125
  { WNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY, "WNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY", "maximized-vertically" },
 
126
  { WNCK_WINDOW_STATE_SHADED, "WNCK_WINDOW_STATE_SHADED", "shaded" },
 
127
  { WNCK_WINDOW_STATE_SKIP_PAGER, "WNCK_WINDOW_STATE_SKIP_PAGER", "skip-pager" },
 
128
  { WNCK_WINDOW_STATE_SKIP_TASKLIST, "WNCK_WINDOW_STATE_SKIP_TASKLIST", "skip-tasklist" },
 
129
  { WNCK_WINDOW_STATE_STICKY, "WNCK_WINDOW_STATE_STICKY", "sticky" },
 
130
  { WNCK_WINDOW_STATE_HIDDEN, "WNCK_WINDOW_STATE_HIDDEN", "hidden" },
 
131
  { WNCK_WINDOW_STATE_FULLSCREEN, "WNCK_WINDOW_STATE_FULLSCREEN", "fullscreen" },
 
132
  { WNCK_WINDOW_STATE_DEMANDS_ATTENTION, "WNCK_WINDOW_STATE_DEMANDS_ATTENTION", "demands-attention" },
 
133
  { WNCK_WINDOW_STATE_URGENT, "WNCK_WINDOW_STATE_URGENT", "urgent" },
 
134
  { WNCK_WINDOW_STATE_ABOVE, "WNCK_WINDOW_STATE_ABOVE", "above" },
 
135
  { WNCK_WINDOW_STATE_BELOW, "WNCK_WINDOW_STATE_BELOW", "below" },
 
136
  { 0, NULL, NULL }
 
137
};
 
138
 
104
139
GType
105
140
wnck_window_state_get_type (void)
106
141
{
107
 
  static GType etype = 0;
108
 
  if (etype == 0) {
109
 
    static const GFlagsValue values[] = {
110
 
      { WNCK_WINDOW_STATE_MINIMIZED, "WNCK_WINDOW_STATE_MINIMIZED", "minimized" },
111
 
      { WNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY, "WNCK_WINDOW_STATE_MAXIMIZED_HORIZONTALLY", "maximized-horizontally" },
112
 
      { WNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY, "WNCK_WINDOW_STATE_MAXIMIZED_VERTICALLY", "maximized-vertically" },
113
 
      { WNCK_WINDOW_STATE_SHADED, "WNCK_WINDOW_STATE_SHADED", "shaded" },
114
 
      { WNCK_WINDOW_STATE_SKIP_PAGER, "WNCK_WINDOW_STATE_SKIP_PAGER", "skip-pager" },
115
 
      { WNCK_WINDOW_STATE_SKIP_TASKLIST, "WNCK_WINDOW_STATE_SKIP_TASKLIST", "skip-tasklist" },
116
 
      { WNCK_WINDOW_STATE_STICKY, "WNCK_WINDOW_STATE_STICKY", "sticky" },
117
 
      { WNCK_WINDOW_STATE_HIDDEN, "WNCK_WINDOW_STATE_HIDDEN", "hidden" },
118
 
      { WNCK_WINDOW_STATE_FULLSCREEN, "WNCK_WINDOW_STATE_FULLSCREEN", "fullscreen" },
119
 
      { WNCK_WINDOW_STATE_DEMANDS_ATTENTION, "WNCK_WINDOW_STATE_DEMANDS_ATTENTION", "demands-attention" },
120
 
      { WNCK_WINDOW_STATE_URGENT, "WNCK_WINDOW_STATE_URGENT", "urgent" },
121
 
      { WNCK_WINDOW_STATE_ABOVE, "WNCK_WINDOW_STATE_ABOVE", "above" },
122
 
      { WNCK_WINDOW_STATE_BELOW, "WNCK_WINDOW_STATE_BELOW", "below" },
123
 
      { 0, NULL, NULL }
124
 
    };
125
 
    etype = g_flags_register_static ("WnckWindowState", values);
126
 
  }
127
 
  return etype;
 
142
  static GType type = 0;
 
143
 
 
144
  if (!type)
 
145
    type = g_enum_register_static ("WnckWindowState", _wnck_window_state_values);
 
146
 
 
147
  return type;
128
148
}
 
149
 
 
150
static const GEnumValue _wnck_window_actions_values[] = {
 
151
  { WNCK_WINDOW_ACTION_MOVE, "WNCK_WINDOW_ACTION_MOVE", "move" },
 
152
  { WNCK_WINDOW_ACTION_RESIZE, "WNCK_WINDOW_ACTION_RESIZE", "resize" },
 
153
  { WNCK_WINDOW_ACTION_SHADE, "WNCK_WINDOW_ACTION_SHADE", "shade" },
 
154
  { WNCK_WINDOW_ACTION_STICK, "WNCK_WINDOW_ACTION_STICK", "stick" },
 
155
  { WNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY, "WNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY", "maximize-horizontally" },
 
156
  { WNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY, "WNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY", "maximize-vertically" },
 
157
  { WNCK_WINDOW_ACTION_CHANGE_WORKSPACE, "WNCK_WINDOW_ACTION_CHANGE_WORKSPACE", "change-workspace" },
 
158
  { WNCK_WINDOW_ACTION_CLOSE, "WNCK_WINDOW_ACTION_CLOSE", "close" },
 
159
  { WNCK_WINDOW_ACTION_UNMAXIMIZE_HORIZONTALLY, "WNCK_WINDOW_ACTION_UNMAXIMIZE_HORIZONTALLY", "unmaximize-horizontally" },
 
160
  { WNCK_WINDOW_ACTION_UNMAXIMIZE_VERTICALLY, "WNCK_WINDOW_ACTION_UNMAXIMIZE_VERTICALLY", "unmaximize-vertically" },
 
161
  { WNCK_WINDOW_ACTION_UNSHADE, "WNCK_WINDOW_ACTION_UNSHADE", "unshade" },
 
162
  { WNCK_WINDOW_ACTION_UNSTICK, "WNCK_WINDOW_ACTION_UNSTICK", "unstick" },
 
163
  { WNCK_WINDOW_ACTION_MINIMIZE, "WNCK_WINDOW_ACTION_MINIMIZE", "minimize" },
 
164
  { WNCK_WINDOW_ACTION_UNMINIMIZE, "WNCK_WINDOW_ACTION_UNMINIMIZE", "unminimize" },
 
165
  { WNCK_WINDOW_ACTION_MAXIMIZE, "WNCK_WINDOW_ACTION_MAXIMIZE", "maximize" },
 
166
  { WNCK_WINDOW_ACTION_UNMAXIMIZE, "WNCK_WINDOW_ACTION_UNMAXIMIZE", "unmaximize" },
 
167
  { WNCK_WINDOW_ACTION_FULLSCREEN, "WNCK_WINDOW_ACTION_FULLSCREEN", "fullscreen" },
 
168
  { WNCK_WINDOW_ACTION_ABOVE, "WNCK_WINDOW_ACTION_ABOVE", "above" },
 
169
  { WNCK_WINDOW_ACTION_BELOW, "WNCK_WINDOW_ACTION_BELOW", "below" },
 
170
  { 0, NULL, NULL }
 
171
};
 
172
 
129
173
GType
130
174
wnck_window_actions_get_type (void)
131
175
{
132
 
  static GType etype = 0;
133
 
  if (etype == 0) {
134
 
    static const GFlagsValue values[] = {
135
 
      { WNCK_WINDOW_ACTION_MOVE, "WNCK_WINDOW_ACTION_MOVE", "move" },
136
 
      { WNCK_WINDOW_ACTION_RESIZE, "WNCK_WINDOW_ACTION_RESIZE", "resize" },
137
 
      { WNCK_WINDOW_ACTION_SHADE, "WNCK_WINDOW_ACTION_SHADE", "shade" },
138
 
      { WNCK_WINDOW_ACTION_STICK, "WNCK_WINDOW_ACTION_STICK", "stick" },
139
 
      { WNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY, "WNCK_WINDOW_ACTION_MAXIMIZE_HORIZONTALLY", "maximize-horizontally" },
140
 
      { WNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY, "WNCK_WINDOW_ACTION_MAXIMIZE_VERTICALLY", "maximize-vertically" },
141
 
      { WNCK_WINDOW_ACTION_CHANGE_WORKSPACE, "WNCK_WINDOW_ACTION_CHANGE_WORKSPACE", "change-workspace" },
142
 
      { WNCK_WINDOW_ACTION_CLOSE, "WNCK_WINDOW_ACTION_CLOSE", "close" },
143
 
      { WNCK_WINDOW_ACTION_UNMAXIMIZE_HORIZONTALLY, "WNCK_WINDOW_ACTION_UNMAXIMIZE_HORIZONTALLY", "unmaximize-horizontally" },
144
 
      { WNCK_WINDOW_ACTION_UNMAXIMIZE_VERTICALLY, "WNCK_WINDOW_ACTION_UNMAXIMIZE_VERTICALLY", "unmaximize-vertically" },
145
 
      { WNCK_WINDOW_ACTION_UNSHADE, "WNCK_WINDOW_ACTION_UNSHADE", "unshade" },
146
 
      { WNCK_WINDOW_ACTION_UNSTICK, "WNCK_WINDOW_ACTION_UNSTICK", "unstick" },
147
 
      { WNCK_WINDOW_ACTION_MINIMIZE, "WNCK_WINDOW_ACTION_MINIMIZE", "minimize" },
148
 
      { WNCK_WINDOW_ACTION_UNMINIMIZE, "WNCK_WINDOW_ACTION_UNMINIMIZE", "unminimize" },
149
 
      { WNCK_WINDOW_ACTION_MAXIMIZE, "WNCK_WINDOW_ACTION_MAXIMIZE", "maximize" },
150
 
      { WNCK_WINDOW_ACTION_UNMAXIMIZE, "WNCK_WINDOW_ACTION_UNMAXIMIZE", "unmaximize" },
151
 
      { WNCK_WINDOW_ACTION_FULLSCREEN, "WNCK_WINDOW_ACTION_FULLSCREEN", "fullscreen" },
152
 
      { WNCK_WINDOW_ACTION_ABOVE, "WNCK_WINDOW_ACTION_ABOVE", "above" },
153
 
      { WNCK_WINDOW_ACTION_BELOW, "WNCK_WINDOW_ACTION_BELOW", "below" },
154
 
      { 0, NULL, NULL }
155
 
    };
156
 
    etype = g_flags_register_static ("WnckWindowActions", values);
157
 
  }
158
 
  return etype;
 
176
  static GType type = 0;
 
177
 
 
178
  if (!type)
 
179
    type = g_enum_register_static ("WnckWindowActions", _wnck_window_actions_values);
 
180
 
 
181
  return type;
159
182
}
 
183
 
 
184
static const GEnumValue _wnck_window_type_values[] = {
 
185
  { WNCK_WINDOW_NORMAL, "WNCK_WINDOW_NORMAL", "normal" },
 
186
  { WNCK_WINDOW_DESKTOP, "WNCK_WINDOW_DESKTOP", "desktop" },
 
187
  { WNCK_WINDOW_DOCK, "WNCK_WINDOW_DOCK", "dock" },
 
188
  { WNCK_WINDOW_DIALOG, "WNCK_WINDOW_DIALOG", "dialog" },
 
189
  { WNCK_WINDOW_TOOLBAR, "WNCK_WINDOW_TOOLBAR", "toolbar" },
 
190
  { WNCK_WINDOW_MENU, "WNCK_WINDOW_MENU", "menu" },
 
191
  { WNCK_WINDOW_UTILITY, "WNCK_WINDOW_UTILITY", "utility" },
 
192
  { WNCK_WINDOW_SPLASHSCREEN, "WNCK_WINDOW_SPLASHSCREEN", "splashscreen" },
 
193
  { 0, NULL, NULL }
 
194
};
 
195
 
160
196
GType
161
197
wnck_window_type_get_type (void)
162
198
{
163
 
  static GType etype = 0;
164
 
  if (etype == 0) {
165
 
    static const GEnumValue values[] = {
166
 
      { WNCK_WINDOW_NORMAL, "WNCK_WINDOW_NORMAL", "normal" },
167
 
      { WNCK_WINDOW_DESKTOP, "WNCK_WINDOW_DESKTOP", "desktop" },
168
 
      { WNCK_WINDOW_DOCK, "WNCK_WINDOW_DOCK", "dock" },
169
 
      { WNCK_WINDOW_DIALOG, "WNCK_WINDOW_DIALOG", "dialog" },
170
 
      { WNCK_WINDOW_TOOLBAR, "WNCK_WINDOW_TOOLBAR", "toolbar" },
171
 
      { WNCK_WINDOW_MENU, "WNCK_WINDOW_MENU", "menu" },
172
 
      { WNCK_WINDOW_UTILITY, "WNCK_WINDOW_UTILITY", "utility" },
173
 
      { WNCK_WINDOW_SPLASHSCREEN, "WNCK_WINDOW_SPLASHSCREEN", "splashscreen" },
174
 
      { 0, NULL, NULL }
175
 
    };
176
 
    etype = g_enum_register_static ("WnckWindowType", values);
177
 
  }
178
 
  return etype;
 
199
  static GType type = 0;
 
200
 
 
201
  if (!type)
 
202
    type = g_enum_register_static ("WnckWindowType", _wnck_window_type_values);
 
203
 
 
204
  return type;
179
205
}
 
206
 
 
207
static const GEnumValue _wnck_window_gravity_values[] = {
 
208
  { WNCK_WINDOW_GRAVITY_CURRENT, "WNCK_WINDOW_GRAVITY_CURRENT", "current" },
 
209
  { WNCK_WINDOW_GRAVITY_NORTHWEST, "WNCK_WINDOW_GRAVITY_NORTHWEST", "northwest" },
 
210
  { WNCK_WINDOW_GRAVITY_NORTH, "WNCK_WINDOW_GRAVITY_NORTH", "north" },
 
211
  { WNCK_WINDOW_GRAVITY_NORTHEAST, "WNCK_WINDOW_GRAVITY_NORTHEAST", "northeast" },
 
212
  { WNCK_WINDOW_GRAVITY_WEST, "WNCK_WINDOW_GRAVITY_WEST", "west" },
 
213
  { WNCK_WINDOW_GRAVITY_CENTER, "WNCK_WINDOW_GRAVITY_CENTER", "center" },
 
214
  { WNCK_WINDOW_GRAVITY_EAST, "WNCK_WINDOW_GRAVITY_EAST", "east" },
 
215
  { WNCK_WINDOW_GRAVITY_SOUTHWEST, "WNCK_WINDOW_GRAVITY_SOUTHWEST", "southwest" },
 
216
  { WNCK_WINDOW_GRAVITY_SOUTH, "WNCK_WINDOW_GRAVITY_SOUTH", "south" },
 
217
  { WNCK_WINDOW_GRAVITY_SOUTHEAST, "WNCK_WINDOW_GRAVITY_SOUTHEAST", "southeast" },
 
218
  { WNCK_WINDOW_GRAVITY_STATIC, "WNCK_WINDOW_GRAVITY_STATIC", "static" },
 
219
  { 0, NULL, NULL }
 
220
};
 
221
 
180
222
GType
181
223
wnck_window_gravity_get_type (void)
182
224
{
183
 
  static GType etype = 0;
184
 
  if (etype == 0) {
185
 
    static const GEnumValue values[] = {
186
 
      { WNCK_WINDOW_GRAVITY_CURRENT, "WNCK_WINDOW_GRAVITY_CURRENT", "current" },
187
 
      { WNCK_WINDOW_GRAVITY_NORTHWEST, "WNCK_WINDOW_GRAVITY_NORTHWEST", "northwest" },
188
 
      { WNCK_WINDOW_GRAVITY_NORTH, "WNCK_WINDOW_GRAVITY_NORTH", "north" },
189
 
      { WNCK_WINDOW_GRAVITY_NORTHEAST, "WNCK_WINDOW_GRAVITY_NORTHEAST", "northeast" },
190
 
      { WNCK_WINDOW_GRAVITY_WEST, "WNCK_WINDOW_GRAVITY_WEST", "west" },
191
 
      { WNCK_WINDOW_GRAVITY_CENTER, "WNCK_WINDOW_GRAVITY_CENTER", "center" },
192
 
      { WNCK_WINDOW_GRAVITY_EAST, "WNCK_WINDOW_GRAVITY_EAST", "east" },
193
 
      { WNCK_WINDOW_GRAVITY_SOUTHWEST, "WNCK_WINDOW_GRAVITY_SOUTHWEST", "southwest" },
194
 
      { WNCK_WINDOW_GRAVITY_SOUTH, "WNCK_WINDOW_GRAVITY_SOUTH", "south" },
195
 
      { WNCK_WINDOW_GRAVITY_SOUTHEAST, "WNCK_WINDOW_GRAVITY_SOUTHEAST", "southeast" },
196
 
      { WNCK_WINDOW_GRAVITY_STATIC, "WNCK_WINDOW_GRAVITY_STATIC", "static" },
197
 
      { 0, NULL, NULL }
198
 
    };
199
 
    etype = g_enum_register_static ("WnckWindowGravity", values);
200
 
  }
201
 
  return etype;
 
225
  static GType type = 0;
 
226
 
 
227
  if (!type)
 
228
    type = g_enum_register_static ("WnckWindowGravity", _wnck_window_gravity_values);
 
229
 
 
230
  return type;
202
231
}
 
232
 
 
233
static const GEnumValue _wnck_window_move_resize_mask_values[] = {
 
234
  { WNCK_WINDOW_CHANGE_X, "WNCK_WINDOW_CHANGE_X", "x" },
 
235
  { WNCK_WINDOW_CHANGE_Y, "WNCK_WINDOW_CHANGE_Y", "y" },
 
236
  { WNCK_WINDOW_CHANGE_WIDTH, "WNCK_WINDOW_CHANGE_WIDTH", "width" },
 
237
  { WNCK_WINDOW_CHANGE_HEIGHT, "WNCK_WINDOW_CHANGE_HEIGHT", "height" },
 
238
  { 0, NULL, NULL }
 
239
};
 
240
 
203
241
GType
204
242
wnck_window_move_resize_mask_get_type (void)
205
243
{
206
 
  static GType etype = 0;
207
 
  if (etype == 0) {
208
 
    static const GFlagsValue values[] = {
209
 
      { WNCK_WINDOW_CHANGE_X, "WNCK_WINDOW_CHANGE_X", "x" },
210
 
      { WNCK_WINDOW_CHANGE_Y, "WNCK_WINDOW_CHANGE_Y", "y" },
211
 
      { WNCK_WINDOW_CHANGE_WIDTH, "WNCK_WINDOW_CHANGE_WIDTH", "width" },
212
 
      { WNCK_WINDOW_CHANGE_HEIGHT, "WNCK_WINDOW_CHANGE_HEIGHT", "height" },
213
 
      { 0, NULL, NULL }
214
 
    };
215
 
    etype = g_flags_register_static ("WnckWindowMoveResizeMask", values);
216
 
  }
217
 
  return etype;
 
244
  static GType type = 0;
 
245
 
 
246
  if (!type)
 
247
    type = g_enum_register_static ("WnckWindowMoveResizeMask", _wnck_window_move_resize_mask_values);
 
248
 
 
249
  return type;
218
250
}
219
251
 
 
252
 
220
253
/* Generated data ends here */
221
254