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

- Main Page
- Classes
- Files

- File List

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