CoreGTK 3.10.0 CoreGTK is an Objective-C language binding for the GTK+ widget toolkit

- Main Page
- Classes
- Files

- File List

All Classes Functions Variables
CGTKWindow.m
1 /*
2 * CGTKWindow.m
3 * This file is part of CoreGTK
4 *
5 * Copyright (C) 2015 - Tyler Burton
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /*
23 * Modified by the CoreGTK Team, 2015. See the AUTHORS file for a
24 * list of people on the CoreGTK Team.
25 * See the ChangeLog files for a list of changes.
26 *
27 */
28
29 /*
30 * Objective-C imports
31 */
32 #import "CoreGTK/CGTKWindow.h"
33
34 @implementation CGTKWindow
35
36 +(GList*)getDefaultIconList
37 {
38 return gtk_window_get_default_icon_list();
39 }
40
41 +(NSString*)getDefaultIconName
42 {
43 return [NSString stringWithUTF8String:gtk_window_get_default_icon_name()];
44 }
45
46 +(GList*)listToplevels
47 {
48 return gtk_window_list_toplevels();
49 }
50
51 +(void)setAutoStartupNotification:(BOOL) setting
52 {
53 gtk_window_set_auto_startup_notification((setting ? TRUE : FALSE));
54 }
55
56 +(void)setDefaultIcon:(GdkPixbuf*) icon
57 {
58 gtk_window_set_default_icon(icon);
59 }
60
61 +(BOOL)setDefaultIconFromFileWithFilename:(NSString*) filename andErr:(GError**) err
62 {
63 return (gtk_window_set_default_icon_from_file([filename UTF8String], err) ? YES : NO);
64 }
65
66 +(void)setDefaultIconList:(GList*) list
67 {
68 gtk_window_set_default_icon_list(list);
69 }
70
71 +(void)setDefaultIconName:(NSString*) name
72 {
73 gtk_window_set_default_icon_name([name UTF8String]);
74 }
75
76 -(id)init:(GtkWindowType) type
77 {
78 self = [super initWithGObject:(GObject *)gtk_window_new(type)];
79
80 if(self)
81 {
82 //Do nothing
83 }
84
85 return self;
86 }
87
88 -(GtkWindow*)WINDOW
89 {
90 return GTK_WINDOW([self GOBJECT]);
91 }
92
93 -(BOOL)activateDefault
94 {
95 return (gtk_window_activate_default(GTK_WINDOW([self GOBJECT])) ? YES : NO);
96 }
97
98 -(BOOL)activateFocus
99 {
100 return (gtk_window_activate_focus(GTK_WINDOW([self GOBJECT])) ? YES : NO);
101 }
102
103 -(BOOL)activateKey:(GdkEventKey*) event
104 {
105 return (gtk_window_activate_key(GTK_WINDOW([self GOBJECT]), event) ? YES : NO);
106 }
107
108 -(void)addAccelGroup:(GtkAccelGroup*) accelGroup
109 {
110 gtk_window_add_accel_group(GTK_WINDOW([self GOBJECT]), accelGroup);
111 }
112
113 -(void)addMnemonicWithKeyval:(guint) keyval andTarget:(CGTKWidget*) target
114 {
115 gtk_window_add_mnemonic(GTK_WINDOW([self GOBJECT]), keyval, [target WIDGET]);
116 }
117
118 -(void)beginMoveDragWithButton:(gint) button andRootX:(gint) rootX andRootY:(gint) rootY andTimestamp:(guint32) timestamp
119 {
120 gtk_window_begin_move_drag(GTK_WINDOW([self GOBJECT]), button, rootX, rootY, timestamp);
121 }
122
123 -(void)beginResizeDragWithEdge:(GdkWindowEdge) edge andButton:(gint) button andRootX:(gint) rootX andRootY:(gint) rootY andTimestamp:(guint32) timestamp
124 {
125 gtk_window_begin_resize_drag(GTK_WINDOW([self GOBJECT]), edge, button, rootX, rootY, timestamp);
126 }
127
128 -(void)close
129 {
130 gtk_window_close(GTK_WINDOW([self GOBJECT]));
131 }
132
133 -(void)deiconify
134 {
135 gtk_window_deiconify(GTK_WINDOW([self GOBJECT]));
136 }
137
138 -(void)fullscreen
139 {
140 gtk_window_fullscreen(GTK_WINDOW([self GOBJECT]));
141 }
142
143 -(BOOL)getAcceptFocus
144 {
145 return (gtk_window_get_accept_focus(GTK_WINDOW([self GOBJECT])) ? YES : NO);
146 }
147
148 -(GtkApplication*)getApplication
149 {
150 return gtk_window_get_application(GTK_WINDOW([self GOBJECT]));
151 }
152
153 -(CGTKWidget*)getAttachedTo
154 {
155 return [[CGTKWidget alloc] initWithGObject:(GObject *)gtk_window_get_attached_to(GTK_WINDOW([self GOBJECT]))];
156 }
157
158 -(BOOL)getDecorated
159 {
160 return (gtk_window_get_decorated(GTK_WINDOW([self GOBJECT])) ? YES : NO);
161 }
162
163 -(void)getDefaultSizeWithWidth:(gint*) width andHeight:(gint*) height
164 {
165 gtk_window_get_default_size(GTK_WINDOW([self GOBJECT]), width, height);
166 }
167
168 -(CGTKWidget*)getDefaultWidget
169 {
170 return [[CGTKWidget alloc] initWithGObject:(GObject *)gtk_window_get_default_widget(GTK_WINDOW([self GOBJECT]))];
171 }
172
173 -(BOOL)getDeletable
174 {
175 return (gtk_window_get_deletable(GTK_WINDOW([self GOBJECT])) ? YES : NO);
176 }
177
178 -(BOOL)getDestroyWithParent
179 {
180 return (gtk_window_get_destroy_with_parent(GTK_WINDOW([self GOBJECT])) ? YES : NO);
181 }
182
183 -(CGTKWidget*)getFocus
184 {
185 return [[CGTKWidget alloc] initWithGObject:(GObject *)gtk_window_get_focus(GTK_WINDOW([self GOBJECT]))];
186 }
187
188 -(BOOL)getFocusOnMap
189 {
190 return (gtk_window_get_focus_on_map(GTK_WINDOW([self GOBJECT])) ? YES : NO);
191 }
192
193 -(BOOL)getFocusVisible
194 {
195 return (gtk_window_get_focus_visible(GTK_WINDOW([self GOBJECT])) ? YES : NO);
196 }
197
198 -(GdkGravity)getGravity
199 {
200 return gtk_window_get_gravity(GTK_WINDOW([self GOBJECT]));
201 }
202
203 -(GtkWindowGroup*)getGroup
204 {
205 return gtk_window_get_group(GTK_WINDOW([self GOBJECT]));
206 }
207
208 -(BOOL)getHasResizeGrip
209 {
210 return (gtk_window_get_has_resize_grip(GTK_WINDOW([self GOBJECT])) ? YES : NO);
211 }
212
213 -(BOOL)getHideTitlebarWhenMaximized
214 {
215 return (gtk_window_get_hide_titlebar_when_maximized(GTK_WINDOW([self GOBJECT])) ? YES : NO);
216 }
217
218 -(GdkPixbuf*)getIcon
219 {
220 return gtk_window_get_icon(GTK_WINDOW([self GOBJECT]));
221 }
222
223 -(GList*)getIconList
224 {
225 return gtk_window_get_icon_list(GTK_WINDOW([self GOBJECT]));
226 }
227
228 -(NSString*)getIconName
229 {
230 return [NSString stringWithUTF8String:gtk_window_get_icon_name(GTK_WINDOW([self GOBJECT]))];
231 }
232
233 -(GdkModifierType)getMnemonicModifier
234 {
235 return gtk_window_get_mnemonic_modifier(GTK_WINDOW([self GOBJECT]));
236 }
237
238 -(BOOL)getMnemonicsVisible
239 {
240 return (gtk_window_get_mnemonics_visible(GTK_WINDOW([self GOBJECT])) ? YES : NO);
241 }
242
243 -(BOOL)getModal
244 {
245 return (gtk_window_get_modal(GTK_WINDOW([self GOBJECT])) ? YES : NO);
246 }
247
248 -(gdouble)getOpacity
249 {
250 return gtk_window_get_opacity(GTK_WINDOW([self GOBJECT]));
251 }
252
253 -(void)getPositionWithRootX:(gint*) rootX andRootY:(gint*) rootY
254 {
255 gtk_window_get_position(GTK_WINDOW([self GOBJECT]), rootX, rootY);
256 }
257
258 -(BOOL)getResizable
259 {
260 return (gtk_window_get_resizable(GTK_WINDOW([self GOBJECT])) ? YES : NO);
261 }
262
263 -(BOOL)getResizeGripArea:(GdkRectangle*) rect
264 {
265 return (gtk_window_get_resize_grip_area(GTK_WINDOW([self GOBJECT]), rect) ? YES : NO);
266 }
267
268 -(NSString*)getRole
269 {
270 return [NSString stringWithUTF8String:gtk_window_get_role(GTK_WINDOW([self GOBJECT]))];
271 }
272
273 -(GdkScreen*)getScreen
274 {
275 return gtk_window_get_screen(GTK_WINDOW([self GOBJECT]));
276 }
277
278 -(void)getSizeWithWidth:(gint*) width andHeight:(gint*) height
279 {
280 gtk_window_get_size(GTK_WINDOW([self GOBJECT]), width, height);
281 }
282
283 -(BOOL)getSkipPagerHint
284 {
285 return (gtk_window_get_skip_pager_hint(GTK_WINDOW([self GOBJECT])) ? YES : NO);
286 }
287
288 -(BOOL)getSkipTaskbarHint
289 {
290 return (gtk_window_get_skip_taskbar_hint(GTK_WINDOW([self GOBJECT])) ? YES : NO);
291 }
292
293 -(NSString*)getTitle
294 {
295 return [NSString stringWithUTF8String:gtk_window_get_title(GTK_WINDOW([self GOBJECT]))];
296 }
297
298 -(GtkWindow*)getTransientFor
299 {
300 return gtk_window_get_transient_for(GTK_WINDOW([self GOBJECT]));
301 }
302
303 -(GdkWindowTypeHint)getTypeHint
304 {
305 return gtk_window_get_type_hint(GTK_WINDOW([self GOBJECT]));
306 }
307
308 -(BOOL)getUrgencyHint
309 {
310 return (gtk_window_get_urgency_hint(GTK_WINDOW([self GOBJECT])) ? YES : NO);
311 }
312
313 -(GtkWindowType)getWindowType
314 {
315 return gtk_window_get_window_type(GTK_WINDOW([self GOBJECT]));
316 }
317
318 -(BOOL)hasGroup
319 {
320 return (gtk_window_has_group(GTK_WINDOW([self GOBJECT])) ? YES : NO);
321 }
322
323 -(BOOL)hasToplevelFocus
324 {
325 return (gtk_window_has_toplevel_focus(GTK_WINDOW([self GOBJECT])) ? YES : NO);
326 }
327
328 -(void)iconify
329 {
330 gtk_window_iconify(GTK_WINDOW([self GOBJECT]));
331 }
332
333 -(BOOL)isActive
334 {
335 return (gtk_window_is_active(GTK_WINDOW([self GOBJECT])) ? YES : NO);
336 }
337
338 -(void)maximize
339 {
340 gtk_window_maximize(GTK_WINDOW([self GOBJECT]));
341 }
342
343 -(BOOL)mnemonicActivateWithKeyval:(guint) keyval andModifier:(GdkModifierType) modifier
344 {
345 return (gtk_window_mnemonic_activate(GTK_WINDOW([self GOBJECT]), keyval, modifier) ? YES : NO);
346 }
347
348 -(void)moveWithX:(gint) x andY:(gint) y
349 {
350 gtk_window_move(GTK_WINDOW([self GOBJECT]), x, y);
351 }
352
353 -(BOOL)parseGeometry:(NSString*) geometry
354 {
355 return (gtk_window_parse_geometry(GTK_WINDOW([self GOBJECT]), [geometry UTF8String]) ? YES : NO);
356 }
357
358 -(void)present
359 {
360 gtk_window_present(GTK_WINDOW([self GOBJECT]));
361 }
362
363 -(void)presentWithTime:(guint32) timestamp
364 {
365 gtk_window_present_with_time(GTK_WINDOW([self GOBJECT]), timestamp);
366 }
367
368 -(BOOL)propagateKeyEvent:(GdkEventKey*) event
369 {
370 return (gtk_window_propagate_key_event(GTK_WINDOW([self GOBJECT]), event) ? YES : NO);
371 }
372
373 -(void)removeAccelGroup:(GtkAccelGroup*) accelGroup
374 {
375 gtk_window_remove_accel_group(GTK_WINDOW([self GOBJECT]), accelGroup);
376 }
377
378 -(void)removeMnemonicWithKeyval:(guint) keyval andTarget:(CGTKWidget*) target
379 {
380 gtk_window_remove_mnemonic(GTK_WINDOW([self GOBJECT]), keyval, [target WIDGET]);
381 }
382
383 -(void)reshowWithInitialSize
384 {
385 gtk_window_reshow_with_initial_size(GTK_WINDOW([self GOBJECT]));
386 }
387
388 -(void)resizeWithWidth:(gint) width andHeight:(gint) height
389 {
390 gtk_window_resize(GTK_WINDOW([self GOBJECT]), width, height);
391 }
392
393 -(BOOL)resizeGripIsVisible
394 {
395 return (gtk_window_resize_grip_is_visible(GTK_WINDOW([self GOBJECT])) ? YES : NO);
396 }
397
398 -(void)resizeToGeometryWithWidth:(gint) width andHeight:(gint) height
399 {
400 gtk_window_resize_to_geometry(GTK_WINDOW([self GOBJECT]), width, height);
401 }
402
403 -(void)setAcceptFocus:(BOOL) setting
404 {
405 gtk_window_set_accept_focus(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
406 }
407
408 -(void)setApplication:(GtkApplication*) application
409 {
410 gtk_window_set_application(GTK_WINDOW([self GOBJECT]), application);
411 }
412
413 -(void)setAttachedTo:(CGTKWidget*) attachWidget
414 {
415 gtk_window_set_attached_to(GTK_WINDOW([self GOBJECT]), [attachWidget WIDGET]);
416 }
417
418 -(void)setDecorated:(BOOL) setting
419 {
420 gtk_window_set_decorated(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
421 }
422
423 -(void)setDefault:(CGTKWidget*) defaultWidget
424 {
425 gtk_window_set_default(GTK_WINDOW([self GOBJECT]), [defaultWidget WIDGET]);
426 }
427
428 -(void)setDefaultGeometryWithWidth:(gint) width andHeight:(gint) height
429 {
430 gtk_window_set_default_geometry(GTK_WINDOW([self GOBJECT]), width, height);
431 }
432
433 -(void)setDefaultSizeWithWidth:(gint) width andHeight:(gint) height
434 {
435 gtk_window_set_default_size(GTK_WINDOW([self GOBJECT]), width, height);
436 }
437
438 -(void)setDeletable:(BOOL) setting
439 {
440 gtk_window_set_deletable(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
441 }
442
443 -(void)setDestroyWithParent:(BOOL) setting
444 {
445 gtk_window_set_destroy_with_parent(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
446 }
447
448 -(void)setFocus:(CGTKWidget*) focus
449 {
450 gtk_window_set_focus(GTK_WINDOW([self GOBJECT]), [focus WIDGET]);
451 }
452
453 -(void)setFocusOnMap:(BOOL) setting
454 {
455 gtk_window_set_focus_on_map(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
456 }
457
458 -(void)setFocusVisible:(BOOL) setting
459 {
460 gtk_window_set_focus_visible(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
461 }
462
463 -(void)setGeometryHintsWithGeometryWidget:(CGTKWidget*) geometryWidget andGeometry:(GdkGeometry*) geometry andGeomMask:(GdkWindowHints) geomMask
464 {
465 gtk_window_set_geometry_hints(GTK_WINDOW([self GOBJECT]), [geometryWidget WIDGET], geometry, geomMask);
466 }
467
468 -(void)setGravity:(GdkGravity) gravity
469 {
470 gtk_window_set_gravity(GTK_WINDOW([self GOBJECT]), gravity);
471 }
472
473 -(void)setHasResizeGrip:(BOOL) value
474 {
475 gtk_window_set_has_resize_grip(GTK_WINDOW([self GOBJECT]), (value ? TRUE : FALSE));
476 }
477
478 -(void)setHasUserRefCount:(BOOL) setting
479 {
480 gtk_window_set_has_user_ref_count(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
481 }
482
483 -(void)setHideTitlebarWhenMaximized:(BOOL) setting
484 {
485 gtk_window_set_hide_titlebar_when_maximized(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
486 }
487
488 -(void)setIcon:(GdkPixbuf*) icon
489 {
490 gtk_window_set_icon(GTK_WINDOW([self GOBJECT]), icon);
491 }
492
493 -(BOOL)setIconFromFileWithFilename:(NSString*) filename andErr:(GError**) err
494 {
495 return (gtk_window_set_icon_from_file(GTK_WINDOW([self GOBJECT]), [filename UTF8String], err) ? YES : NO);
496 }
497
498 -(void)setIconList:(GList*) list
499 {
500 gtk_window_set_icon_list(GTK_WINDOW([self GOBJECT]), list);
501 }
502
503 -(void)setIconName:(NSString*) name
504 {
505 gtk_window_set_icon_name(GTK_WINDOW([self GOBJECT]), [name UTF8String]);
506 }
507
508 -(void)setKeepAbove:(BOOL) setting
509 {
510 gtk_window_set_keep_above(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
511 }
512
513 -(void)setKeepBelow:(BOOL) setting
514 {
515 gtk_window_set_keep_below(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
516 }
517
518 -(void)setMnemonicModifier:(GdkModifierType) modifier
519 {
520 gtk_window_set_mnemonic_modifier(GTK_WINDOW([self GOBJECT]), modifier);
521 }
522
523 -(void)setMnemonicsVisible:(BOOL) setting
524 {
525 gtk_window_set_mnemonics_visible(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
526 }
527
528 -(void)setModal:(BOOL) modal
529 {
530 gtk_window_set_modal(GTK_WINDOW([self GOBJECT]), (modal ? TRUE : FALSE));
531 }
532
533 -(void)setOpacity:(gdouble) opacity
534 {
535 gtk_window_set_opacity(GTK_WINDOW([self GOBJECT]), opacity);
536 }
537
538 -(void)setPosition:(GtkWindowPosition) position
539 {
540 gtk_window_set_position(GTK_WINDOW([self GOBJECT]), position);
541 }
542
543 -(void)setResizable:(BOOL) resizable
544 {
545 gtk_window_set_resizable(GTK_WINDOW([self GOBJECT]), (resizable ? TRUE : FALSE));
546 }
547
548 -(void)setRole:(NSString*) role
549 {
550 gtk_window_set_role(GTK_WINDOW([self GOBJECT]), [role UTF8String]);
551 }
552
553 -(void)setScreen:(GdkScreen*) screen
554 {
555 gtk_window_set_screen(GTK_WINDOW([self GOBJECT]), screen);
556 }
557
558 -(void)setSkipPagerHint:(BOOL) setting
559 {
560 gtk_window_set_skip_pager_hint(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
561 }
562
563 -(void)setSkipTaskbarHint:(BOOL) setting
564 {
565 gtk_window_set_skip_taskbar_hint(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
566 }
567
568 -(void)setStartupId:(NSString*) startupId
569 {
570 gtk_window_set_startup_id(GTK_WINDOW([self GOBJECT]), [startupId UTF8String]);
571 }
572
573 -(void)setTitle:(NSString*) title
574 {
575 gtk_window_set_title(GTK_WINDOW([self GOBJECT]), [title UTF8String]);
576 }
577
578 -(void)setTitlebar:(CGTKWidget*) titlebar
579 {
580 gtk_window_set_titlebar(GTK_WINDOW([self GOBJECT]), [titlebar WIDGET]);
581 }
582
583 -(void)setTransientFor:(GtkWindow*) parent
584 {
585 gtk_window_set_transient_for(GTK_WINDOW([self GOBJECT]), parent);
586 }
587
588 -(void)setTypeHint:(GdkWindowTypeHint) hint
589 {
590 gtk_window_set_type_hint(GTK_WINDOW([self GOBJECT]), hint);
591 }
592
593 -(void)setUrgencyHint:(BOOL) setting
594 {
595 gtk_window_set_urgency_hint(GTK_WINDOW([self GOBJECT]), (setting ? TRUE : FALSE));
596 }
597
598 -(void)setWmclassWithWmclassName:(NSString*) wmclassName andWmclassClass:(NSString*) wmclassClass
599 {
600 gtk_window_set_wmclass(GTK_WINDOW([self GOBJECT]), [wmclassName UTF8String], [wmclassClass UTF8String]);
601 }
602
603 -(void)stick
604 {
605 gtk_window_stick(GTK_WINDOW([self GOBJECT]));
606 }
607
608 -(void)unfullscreen
609 {
610 gtk_window_unfullscreen(GTK_WINDOW([self GOBJECT]));
611 }
612
613 -(void)unmaximize
614 {
615 gtk_window_unmaximize(GTK_WINDOW([self GOBJECT]));
616 }
617
618 -(void)unstick
619 {
620 gtk_window_unstick(GTK_WINDOW([self GOBJECT]));
621 }
622
623
624 @end
-[CGTKWindow getTypeHint]
GdkWindowTypeHint getTypeHint()
Definition: CGTKWindow.m:303
-[CGTKWindow unfullscreen]
void unfullscreen()
Definition: CGTKWindow.m:608
-[CGTKWindow getFocusVisible]
BOOL getFocusVisible()
Definition: CGTKWindow.m:193
-[CGTKWindow getGroup]
GtkWindowGroup * getGroup()
Definition: CGTKWindow.m:203
-[CGTKWindow getDestroyWithParent]
BOOL getDestroyWithParent()
Definition: CGTKWindow.m:178
-[CGTKBase GOBJECT]
GObject * GOBJECT()
Definition: CGTKBase.m:82
-[CGTKWindow fullscreen]
void fullscreen()
Definition: CGTKWindow.m:138
-[CGTKWindow getRole]
NSString * getRole()
Definition: CGTKWindow.m:268
-[CGTKWindow isActive]
BOOL isActive()
Definition: CGTKWindow.m:333
-[CGTKWindow getIconList]
GList * getIconList()
Definition: CGTKWindow.m:223
-[CGTKWindow close]
void close()
Definition: CGTKWindow.m:128
-[CGTKWindow iconify]
void iconify()
Definition: CGTKWindow.m:328
-[CGTKBase initWithGObject:]
id initWithGObject:(GObject *obj)
Definition: CGTKBase.m:48
-[CGTKWindow getDeletable]
BOOL getDeletable()
Definition: CGTKWindow.m:173
-[CGTKWindow getModal]
BOOL getModal()
Definition: CGTKWindow.m:243
CGTKWindow
Definition: CGTKWindow.h:34
-[CGTKWindow getTransientFor]
GtkWindow * getTransientFor()
Definition: CGTKWindow.m:298
-[CGTKWindow WINDOW]
GtkWindow * WINDOW()
Definition: CGTKWindow.m:88
+[CGTKWindow getDefaultIconList]
GList * getDefaultIconList()
Definition: CGTKWindow.m:36
-[CGTKWindow stick]
void stick()
Definition: CGTKWindow.m:603
-[CGTKWindow deiconify]
void deiconify()
Definition: CGTKWindow.m:133
-[CGTKWindow getIconName]
NSString * getIconName()
Definition: CGTKWindow.m:228
-[CGTKWindow getGravity]
GdkGravity getGravity()
Definition: CGTKWindow.m:198
-[CGTKWindow getFocusOnMap]
BOOL getFocusOnMap()
Definition: CGTKWindow.m:188
-[CGTKWindow getHideTitlebarWhenMaximized]
BOOL getHideTitlebarWhenMaximized()
Definition: CGTKWindow.m:213
-[CGTKWindow getResizable]
BOOL getResizable()
Definition: CGTKWindow.m:258
-[CGTKWindow getUrgencyHint]
BOOL getUrgencyHint()
Definition: CGTKWindow.m:308
-[CGTKWidget WIDGET]
GtkWidget * WIDGET()
Definition: CGTKWidget.m:61
-[CGTKWindow getApplication]
GtkApplication * getApplication()
Definition: CGTKWindow.m:148
-[CGTKWindow getSkipTaskbarHint]
BOOL getSkipTaskbarHint()
Definition: CGTKWindow.m:288
-[CGTKWindow getFocus]
CGTKWidget * getFocus()
Definition: CGTKWindow.m:183
-[CGTKWindow hasGroup]
BOOL hasGroup()
Definition: CGTKWindow.m:318
-[CGTKWindow getIcon]
GdkPixbuf * getIcon()
Definition: CGTKWindow.m:218
-[CGTKWindow getAttachedTo]
CGTKWidget * getAttachedTo()
Definition: CGTKWindow.m:153
-[CGTKWindow getTitle]
NSString * getTitle()
Definition: CGTKWindow.m:293
-[CGTKWindow getScreen]
GdkScreen * getScreen()
Definition: CGTKWindow.m:273
-[CGTKWindow getMnemonicModifier]
GdkModifierType getMnemonicModifier()
Definition: CGTKWindow.m:233
-[CGTKWindow unstick]
void unstick()
Definition: CGTKWindow.m:618
-[CGTKWindow resizeGripIsVisible]
BOOL resizeGripIsVisible()
Definition: CGTKWindow.m:393
-[CGTKWindow getSkipPagerHint]
BOOL getSkipPagerHint()
Definition: CGTKWindow.m:283
-[CGTKWindow reshowWithInitialSize]
void reshowWithInitialSize()
Definition: CGTKWindow.m:383
-[CGTKWindow maximize]
void maximize()
Definition: CGTKWindow.m:338
-[CGTKWindow hasToplevelFocus]
BOOL hasToplevelFocus()
Definition: CGTKWindow.m:323
CGTKWidget
Definition: CGTKWidget.h:34
-[CGTKWindow getOpacity]
gdouble getOpacity()
Definition: CGTKWindow.m:248
-[CGTKWindow getHasResizeGrip]
BOOL getHasResizeGrip()
Definition: CGTKWindow.m:208
-[CGTKWindow getDecorated]
BOOL getDecorated()
Definition: CGTKWindow.m:158
-[CGTKWindow present]
void present()
Definition: CGTKWindow.m:358
-[CGTKWindow getMnemonicsVisible]
BOOL getMnemonicsVisible()
Definition: CGTKWindow.m:238
-[CGTKWindow getAcceptFocus]
BOOL getAcceptFocus()
Definition: CGTKWindow.m:143
-[CGTKWindow getDefaultWidget]
CGTKWidget * getDefaultWidget()
Definition: CGTKWindow.m:168
-[CGTKWindow unmaximize]
void unmaximize()
Definition: CGTKWindow.m:613
-[CGTKWindow activateDefault]
BOOL activateDefault()
Definition: CGTKWindow.m:93
-[CGTKWindow activateFocus]
BOOL activateFocus()
Definition: CGTKWindow.m:98
-[CGTKWindow getWindowType]
GtkWindowType getWindowType()
Definition: CGTKWindow.m:313