| blob | f03604df20bd7f806736f193361c6252e204e3af |
1 /*
2 * This file is part of gtkD.
3 *
4 * gtkD is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published by
6 * the Free Software Foundation; either version 2.1 of the License, or
7 * (at your option) any later version.
8 *
9 * gtkD 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
12 * GNU Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with gtkD; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
19 // generated automatically - do not change
20 // find conversion definition on APILookup.txt
21 // implement new conversion functionalities on the wrap.utils pakage
23 /*
24 * Conversion parameters:
25 * inFile = GtkWidget.html
26 * outPack = gtk
27 * outFile = Widget
28 * strct = GtkWidget
29 * realStrct=
30 * ctorStrct=
31 * clss = Widget
32 * interf =
33 * class Code: Yes
34 * interface Code: No
35 * template for:
36 * extend =
37 * implements:
38 * prefixes:
39 * - gtk_widget_
40 * - gtk_
41 * omit structs:
42 * omit prefixes:
43 * - gtk_widget_ref
44 * omit code:
45 * imports:
46 * - glib.Str
47 * - atk.ObjectAtk
48 * - gdk.Rectangle
49 * - gtk.AccelGroup
50 * - glib.ListG
51 * - gdk.Event
52 * - gdk.Window
53 * - gdk.Colormap
54 * - gdk.Visual
55 * - gtk.Style
56 * - gdk.Bitmap
57 * - gtk.RcStyle
58 * - gdk.Color
59 * - gdk.Pixbuf
60 * - gtk.Adjustment
61 * - gdk.Region
62 * - gobject.Value
63 * - gtk.Settings
64 * - gtk.Clipboard
65 * - gdk.Display
66 * - gdk.Screen
67 * - gtkc.gdk
68 * - gdk.Cursor
69 * - pango.PgLayout
70 * - pango.PgContext
71 * - pango.PgFontDescription
72 * - gdk.Drawable
73 * - gtk.Tooltips
74 * structWrap:
75 * - AtkObject* -> ObjectAtk
76 * - GList* -> ListG
77 * - GValue* -> Value
78 * - GdkBitmap* -> Bitmap
79 * - GdkColor* -> Color
80 * - GdkColormap* -> Colormap
81 * - GdkDisplay* -> Display
82 * - GdkEvent* -> Event
83 * - GdkPixbuf* -> Pixbuf
84 * - GdkRectangle* -> Rectangle
85 * - GdkRegion* -> Region
86 * - GdkScreen* -> Screen
87 * - GdkVisual* -> Visual
88 * - GdkWindow* -> Window
89 * - GtkAccelGroup* -> AccelGroup
90 * - GtkAdjustment* -> Adjustment
91 * - GtkClipboard* -> Clipboard
92 * - GtkRcStyle* -> RcStyle
93 * - GtkSettings* -> Settings
94 * - GtkStyle* -> Style
95 * - PangoContext* -> PgContext
96 * - PangoFontDescription* -> PgFontDescription
97 * - PangoLayout* -> PgLayout
98 * module aliases:
99 * local aliases:
100 */
105 {
107 {
109 }
110 }
149 /**
150 * Description
151 * GtkWidget introduces style
152 * properties - these are basically object properties that are stored
153 * not on the object, but in the style object associated to the widget. Style
154 * properties are set in resource files.
155 * This mechanism is used for configuring such things as the location of the
156 * scrollbar arrows through the theme, giving theme authors more control over the
157 * look of applications without the need to write a theme engine in C.
158 * Use gtk_widget_class_install_style_property() to install style properties for
159 * a widget class, gtk_widget_class_find_style_property() or
160 * gtk_widget_class_list_style_properties() to get information about existing
161 * style properties and gtk_widget_style_get_property(), gtk_widget_style_get() or
162 * gtk_widget_style_get_valist() to obtain the value of a style property.
163 */
166 {
168 /** the main Gtk struct */
173 {
175 }
178 /** the main Gtk struct as a void* */
180 {
182 }
184 /**
185 * Sets our main struct and passes it to the parent class
186 */
188 {
190 {
192 {
195 {
197 }
198 else
199 {
201 }
203 }
204 }
205 else
206 {
208 }
211 }
214 {
218 }
220 {
224 }
226 /**
227 * Gets the drawable for this widget
228 * return:
229 * The drawable for this widget
230 */
232 {
234 // ubyte *p = cast(ubyte*)getStruct();
235 //
236 // for ( int i=0 ; i<120 ; i+=4 )
237 // {
238 // printf("(%d) %X %x %x %x %x\n", i,p,*(p+0), *(p+1), *(p+2), *(p+3));
239 // p+=4;
240 // }
241 //
242 // int* pt =cast(int*)getStruct();
243 //
244 // printf("pt=%X strcut=%X\n", pt, getStruct());
245 // printf("*pt=%X\n", *pt);
246 // pt+=52/4;
247 // printf("pt+52=%X strcut.window=%X\n", pt, getWidgetStruct().window);
248 // printf("*pt+52=%X\n", *pt);
249 //
250 // //return new Drawable(cast(GdkDrawable*)(getWidgetStruct().window));
254 }
255 /**
256 * Gets the Window for this widget
257 * return:
258 * The window for this widget
259 */
261 {
263 // ubyte *p = cast(ubyte*)getStruct();
264 //
265 // for ( int i=0 ; i<120 ; i+=4 )
266 // {
267 // printf("(%d) %X %x %x %x %x\n", i,p,*(p+0), *(p+1), *(p+2), *(p+3));
268 // p+=4;
269 // }
270 //
271 // int* pt =cast(int*)getStruct();
272 //
273 // printf("pt=%X strcut=%X\n", pt, getStruct());
274 // printf("*pt=%X\n", *pt);
275 // pt+=52/4;
276 // printf("pt+52=%X strcut.window=%X\n", pt, getWidgetStruct().window);
277 // printf("*pt+52=%X\n", *pt);
278 //
279 // //return new Drawable(cast(GdkDrawable*)(getWidgetStruct().window));
283 }
284 /**
285 * Sets the cursor.
286 * @param cursor the new cursor
287 * \bug the cursor changes to the parent widget also
288 */
290 {
294 }
296 /**
297 * Resets the cursor.
298 * don't know if this is implemented by GTK+. Seems that it's not
299 * \bug does nothing
300 */
302 {
306 }
310 /**
311 * Modifies the font for this widget.
312 * This just calls modifyFont(new PgFontDescription(PgFontDescription.fromString(family ~ " " ~ size)));
313 */
315 {
319 {
325 )
326 )
327 );
328 }
329 else
330 {
335 )
336 )
337 );
338 }
339 }
342 /**
343 * Sets this widget tooltip
344 * @param tipText the tooltip
345 * @param tipPrivate a private text
346 */
348 {
351 }
355 /**
356 */
358 // imports for the signal processing
364 void addOnAccelClosuresChanged(void delegate(Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
365 {
367 {
374 connectFlags);
376 }
378 }
380 {
384 {
386 }
389 }
392 void addOnButtonPress(gboolean delegate(GdkEventButton*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
393 {
395 {
403 connectFlags);
405 }
407 }
408 extern(C) static void callBackButtonPress(GtkWidget* widgetStruct, GdkEventButton* event, Widget widget)
409 {
413 {
415 }
418 }
421 void addOnButtonRelease(gboolean delegate(GdkEventButton*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
422 {
424 {
432 connectFlags);
434 }
436 }
437 extern(C) static void callBackButtonRelease(GtkWidget* widgetStruct, GdkEventButton* event, Widget widget)
438 {
442 {
444 }
447 }
450 void addOnCanActivateAccel(gboolean delegate(guint, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
451 {
453 {
460 connectFlags);
462 }
464 }
465 extern(C) static void callBackCanActivateAccel(GtkWidget* widgetStruct, guint signalId, Widget widget)
466 {
470 {
472 }
475 }
478 void addOnChildNotify(void delegate(GParamSpec*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
479 {
481 {
488 connectFlags);
490 }
492 }
493 extern(C) static void callBackChildNotify(GtkWidget* widgetStruct, GParamSpec* pspec, Widget widget)
494 {
498 {
500 }
503 }
506 void addOnClient(gboolean delegate(GdkEventClient*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
507 {
509 {
516 connectFlags);
518 }
520 }
521 extern(C) static void callBackClient(GtkWidget* widgetStruct, GdkEventClient* event, Widget widget)
522 {
526 {
528 }
531 }
534 void addOnCompositedChanged(void delegate(Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
535 {
537 {
544 connectFlags);
546 }
548 }
550 {
554 {
556 }
559 }
562 void addOnConfigure(gboolean delegate(GdkEventConfigure*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
563 {
565 {
572 connectFlags);
574 }
576 }
577 extern(C) static void callBackConfigure(GtkWidget* widgetStruct, GdkEventConfigure* event, Widget widget)
578 {
582 {
584 }
587 }
590 void addOnDelete(gboolean delegate(Event, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
591 {
593 {
600 connectFlags);
602 }
604 }
606 {
610 {
612 }
615 }
618 void addOnDestroy(gboolean delegate(Event, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
619 {
621 {
628 connectFlags);
630 }
632 }
634 {
638 {
640 }
643 }
646 void addOnDirectionChanged(void delegate(GtkTextDirection, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
647 {
649 {
656 connectFlags);
658 }
660 }
661 extern(C) static void callBackDirectionChanged(GtkWidget* widgetStruct, GtkTextDirection arg1, Widget widget)
662 {
666 {
668 }
671 }
674 void addOnDragBegin(void delegate(GdkDragContext*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
675 {
677 {
684 connectFlags);
686 }
688 }
689 extern(C) static void callBackDragBegin(GtkWidget* widgetStruct, GdkDragContext* dragContext, Widget widget)
690 {
694 {
696 }
699 }
702 void addOnDragDataDelete(void delegate(GdkDragContext*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
703 {
705 {
712 connectFlags);
714 }
716 }
717 extern(C) static void callBackDragDataDelete(GtkWidget* widgetStruct, GdkDragContext* dragContext, Widget widget)
718 {
722 {
724 }
727 }
729 void delegate(GdkDragContext*, GtkSelectionData*, guint, guint, Widget)[] onDragDataGetListeners;
730 void addOnDragDataGet(void delegate(GdkDragContext*, GtkSelectionData*, guint, guint, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
731 {
733 {
740 connectFlags);
742 }
744 }
745 extern(C) static void callBackDragDataGet(GtkWidget* widgetStruct, GdkDragContext* dragContext, GtkSelectionData* data, guint info, guint time, Widget widget)
746 {
749 foreach ( void delegate(GdkDragContext*, GtkSelectionData*, guint, guint, Widget) dlg ; widget.onDragDataGetListeners )
750 {
752 }
755 }
757 void delegate(GdkDragContext*, gint, gint, GtkSelectionData*, guint, guint, Widget)[] onDragDataReceivedListeners;
758 void addOnDragDataReceived(void delegate(GdkDragContext*, gint, gint, GtkSelectionData*, guint, guint, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
759 {
761 {
768 connectFlags);
770 }
772 }
773 extern(C) static void callBackDragDataReceived(GtkWidget* widgetStruct, GdkDragContext* dragContext, gint x, gint y, GtkSelectionData* data, guint info, guint time, Widget widget)
774 {
777 foreach ( void delegate(GdkDragContext*, gint, gint, GtkSelectionData*, guint, guint, Widget) dlg ; widget.onDragDataReceivedListeners )
778 {
780 }
783 }
786 void addOnDragDrop(gboolean delegate(GdkDragContext*, gint, gint, guint, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
787 {
789 {
796 connectFlags);
798 }
800 }
801 extern(C) static void callBackDragDrop(GtkWidget* widgetStruct, GdkDragContext* dragContext, gint x, gint y, guint time, Widget widget)
802 {
805 foreach ( gboolean delegate(GdkDragContext*, gint, gint, guint, Widget) dlg ; widget.onDragDropListeners )
806 {
808 }
811 }
814 void addOnDragEnd(void delegate(GdkDragContext*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
815 {
817 {
824 connectFlags);
826 }
828 }
829 extern(C) static void callBackDragEnd(GtkWidget* widgetStruct, GdkDragContext* dragContext, Widget widget)
830 {
834 {
836 }
839 }
842 void addOnDragFailed(gboolean delegate(GdkDragContext*, GtkDragResult, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
843 {
845 {
852 connectFlags);
854 }
856 }
857 extern(C) static void callBackDragFailed(GtkWidget* widgetStruct, GdkDragContext* dragContext, GtkDragResult result, Widget widget)
858 {
861 foreach ( gboolean delegate(GdkDragContext*, GtkDragResult, Widget) dlg ; widget.onDragFailedListeners )
862 {
864 }
867 }
870 void addOnDragLeave(void delegate(GdkDragContext*, guint, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
871 {
873 {
880 connectFlags);
882 }
884 }
885 extern(C) static void callBackDragLeave(GtkWidget* widgetStruct, GdkDragContext* dragContext, guint time, Widget widget)
886 {
890 {
892 }
895 }
898 void addOnDragMotion(gboolean delegate(GdkDragContext*, gint, gint, guint, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
899 {
901 {
908 connectFlags);
910 }
912 }
913 extern(C) static void callBackDragMotion(GtkWidget* widgetStruct, GdkDragContext* dragContext, gint x, gint y, guint time, Widget widget)
914 {
917 foreach ( gboolean delegate(GdkDragContext*, gint, gint, guint, Widget) dlg ; widget.onDragMotionListeners )
918 {
920 }
923 }
926 void addOnEnterNotify(gboolean delegate(GdkEventCrossing*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
927 {
929 {
936 connectFlags);
938 }
940 }
941 extern(C) static void callBackEnterNotify(GtkWidget* widgetStruct, GdkEventCrossing* event, Widget widget)
942 {
946 {
948 }
951 }
955 {
957 {
964 connectFlags);
966 }
968 }
970 {
974 {
976 }
979 }
982 void addOnEventAfter(void delegate(Event, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
983 {
985 {
992 connectFlags);
994 }
996 }
997 extern(C) static void callBackEventAfter(GtkWidget* widgetStruct, GdkEvent* event, Widget widget)
998 {
1002 {
1004 }
1007 }
1010 void addOnExpose(gboolean delegate(GdkEventExpose*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1011 {
1013 {
1020 connectFlags);
1022 }
1024 }
1025 extern(C) static void callBackExpose(GtkWidget* widgetStruct, GdkEventExpose* event, Widget widget)
1026 {
1030 {
1032 }
1035 }
1038 void addOnFocus(gboolean delegate(GtkDirectionType, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1039 {
1041 {
1048 connectFlags);
1050 }
1052 }
1053 extern(C) static void callBackFocus(GtkWidget* widgetStruct, GtkDirectionType arg1, Widget widget)
1054 {
1058 {
1060 }
1063 }
1066 void addOnFocusIn(gboolean delegate(GdkEventFocus*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1067 {
1069 {
1076 connectFlags);
1078 }
1080 }
1081 extern(C) static void callBackFocusIn(GtkWidget* widgetStruct, GdkEventFocus* event, Widget widget)
1082 {
1086 {
1088 }
1091 }
1094 void addOnFocusOut(gboolean delegate(GdkEventFocus*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1095 {
1097 {
1104 connectFlags);
1106 }
1108 }
1109 extern(C) static void callBackFocusOut(GtkWidget* widgetStruct, GdkEventFocus* event, Widget widget)
1110 {
1114 {
1116 }
1119 }
1122 void addOnGrabBroken(gboolean delegate(Event, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1123 {
1125 {
1132 connectFlags);
1134 }
1136 }
1137 extern(C) static void callBackGrabBroken(GtkWidget* widgetStruct, GdkEvent* event, Widget widget)
1138 {
1142 {
1144 }
1147 }
1151 {
1153 {
1160 connectFlags);
1162 }
1164 }
1166 {
1170 {
1172 }
1175 }
1178 void addOnGrabNotify(void delegate(gboolean, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1179 {
1181 {
1188 connectFlags);
1190 }
1192 }
1193 extern(C) static void callBackGrabNotify(GtkWidget* widgetStruct, gboolean wasGrabbed, Widget widget)
1194 {
1198 {
1200 }
1203 }
1207 {
1209 {
1216 connectFlags);
1218 }
1220 }
1222 {
1226 {
1228 }
1231 }
1234 void addOnHierarchyChanged(void delegate(GtkWidget*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1235 {
1237 {
1244 connectFlags);
1246 }
1248 }
1249 extern(C) static void callBackHierarchyChanged(GtkWidget* widgetStruct, GtkWidget* widget2, Widget widget)
1250 {
1254 {
1256 }
1259 }
1262 void addOnKeyPress(gboolean delegate(GdkEventKey*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1263 {
1265 {
1272 connectFlags);
1274 }
1276 }
1277 extern(C) static void callBackKeyPress(GtkWidget* widgetStruct, GdkEventKey* event, Widget widget)
1278 {
1282 {
1284 }
1287 }
1290 void addOnKeyRelease(gboolean delegate(GdkEventKey*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1291 {
1293 {
1300 connectFlags);
1302 }
1304 }
1305 extern(C) static void callBackKeyRelease(GtkWidget* widgetStruct, GdkEventKey* event, Widget widget)
1306 {
1310 {
1312 }
1315 }
1318 void addOnKeynavFailed(gboolean delegate(GtkDirectionType, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1319 {
1321 {
1328 connectFlags);
1330 }
1332 }
1333 extern(C) static void callBackKeynavFailed(GtkWidget* widgetStruct, GtkDirectionType direction, Widget widget)
1334 {
1338 {
1340 }
1343 }
1346 void addOnLeaveNotify(gboolean delegate(GdkEventCrossing*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1347 {
1349 {
1356 connectFlags);
1358 }
1360 }
1361 extern(C) static void callBackLeaveNotify(GtkWidget* widgetStruct, GdkEventCrossing* event, Widget widget)
1362 {
1366 {
1368 }
1371 }
1375 {
1377 {
1384 connectFlags);
1386 }
1388 }
1390 {
1394 {
1396 }
1399 }
1402 void addOnMapEvent(gboolean delegate(Event, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1403 {
1405 {
1412 connectFlags);
1414 }
1416 }
1417 extern(C) static void callBackMapEvent(GtkWidget* widgetStruct, GdkEvent* event, Widget widget)
1418 {
1422 {
1424 }
1427 }
1430 void addOnMnemonicActivate(gboolean delegate(gboolean, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1431 {
1433 {
1440 connectFlags);
1442 }
1444 }
1445 extern(C) static void callBackMnemonicActivate(GtkWidget* widgetStruct, gboolean arg1, Widget widget)
1446 {
1450 {
1452 }
1455 }
1458 void addOnMotionNotify(gboolean delegate(GdkEventMotion*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1459 {
1461 {
1469 connectFlags);
1471 }
1473 }
1474 extern(C) static void callBackMotionNotify(GtkWidget* widgetStruct, GdkEventMotion* event, Widget widget)
1475 {
1479 {
1481 }
1484 }
1487 void addOnNoExpose(gboolean delegate(GdkEventNoExpose*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1488 {
1490 {
1497 connectFlags);
1499 }
1501 }
1502 extern(C) static void callBackNoExpose(GtkWidget* widgetStruct, GdkEventNoExpose* event, Widget widget)
1503 {
1507 {
1509 }
1512 }
1515 void addOnParentSet(void delegate(GtkObject*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1516 {
1518 {
1525 connectFlags);
1527 }
1529 }
1530 extern(C) static void callBackParentSet(GtkWidget* widgetStruct, GtkObject* oldParent, Widget widget)
1531 {
1535 {
1537 }
1540 }
1543 void addOnPopupMenu(gboolean delegate(Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1544 {
1546 {
1553 connectFlags);
1555 }
1557 }
1559 {
1563 {
1565 }
1568 }
1571 void addOnPropertyNotify(gboolean delegate(GdkEventProperty*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1572 {
1574 {
1581 connectFlags);
1583 }
1585 }
1586 extern(C) static void callBackPropertyNotify(GtkWidget* widgetStruct, GdkEventProperty* event, Widget widget)
1587 {
1590 foreach ( gboolean delegate(GdkEventProperty*, Widget) dlg ; widget.onPropertyNotifyListeners )
1591 {
1593 }
1596 }
1599 void addOnProximityIn(gboolean delegate(GdkEventProximity*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1600 {
1602 {
1609 connectFlags);
1611 }
1613 }
1614 extern(C) static void callBackProximityIn(GtkWidget* widgetStruct, GdkEventProximity* event, Widget widget)
1615 {
1619 {
1621 }
1624 }
1627 void addOnProximityOut(gboolean delegate(GdkEventProximity*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1628 {
1630 {
1637 connectFlags);
1639 }
1641 }
1642 extern(C) static void callBackProximityOut(GtkWidget* widgetStruct, GdkEventProximity* event, Widget widget)
1643 {
1647 {
1649 }
1652 }
1655 void addOnQueryTooltip(gboolean delegate(gint, gint, gboolean, GtkTooltip*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1656 {
1658 {
1665 connectFlags);
1667 }
1669 }
1670 extern(C) static void callBackQueryTooltip(GtkWidget* widgetStruct, gint x, gint y, gboolean keyboardMode, GtkTooltip* tooltip, Widget widget)
1671 {
1674 foreach ( gboolean delegate(gint, gint, gboolean, GtkTooltip*, Widget) dlg ; widget.onQueryTooltipListeners )
1675 {
1677 }
1680 }
1684 {
1686 {
1693 connectFlags);
1695 }
1697 }
1699 {
1703 {
1705 }
1708 }
1711 void addOnScreenChanged(void delegate(Screen, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1712 {
1714 {
1721 connectFlags);
1723 }
1725 }
1726 extern(C) static void callBackScreenChanged(GtkWidget* widgetStruct, GdkScreen* arg1, Widget widget)
1727 {
1731 {
1733 }
1736 }
1739 void addOnScroll(gboolean delegate(GdkEventScroll*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1740 {
1742 {
1749 connectFlags);
1751 }
1753 }
1754 extern(C) static void callBackScroll(GtkWidget* widgetStruct, GdkEventScroll* event, Widget widget)
1755 {
1759 {
1761 }
1764 }
1767 void addOnSelectionClear(gboolean delegate(GdkEventSelection*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1768 {
1770 {
1777 connectFlags);
1779 }
1781 }
1782 extern(C) static void callBackSelectionClear(GtkWidget* widgetStruct, GdkEventSelection* event, Widget widget)
1783 {
1786 foreach ( gboolean delegate(GdkEventSelection*, Widget) dlg ; widget.onSelectionClearListeners )
1787 {
1789 }
1792 }
1795 void addOnSelectionGet(void delegate(GtkSelectionData*, guint, guint, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1796 {
1798 {
1805 connectFlags);
1807 }
1809 }
1810 extern(C) static void callBackSelectionGet(GtkWidget* widgetStruct, GtkSelectionData* data, guint info, guint time, Widget widget)
1811 {
1814 foreach ( void delegate(GtkSelectionData*, guint, guint, Widget) dlg ; widget.onSelectionGetListeners )
1815 {
1817 }
1820 }
1823 void addOnSelectionNotify(gboolean delegate(GdkEventSelection*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1824 {
1826 {
1833 connectFlags);
1835 }
1837 }
1838 extern(C) static void callBackSelectionNotify(GtkWidget* widgetStruct, GdkEventSelection* event, Widget widget)
1839 {
1842 foreach ( gboolean delegate(GdkEventSelection*, Widget) dlg ; widget.onSelectionNotifyListeners )
1843 {
1845 }
1848 }
1851 void addOnSelectionReceived(void delegate(GtkSelectionData*, guint, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1852 {
1854 {
1861 connectFlags);
1863 }
1865 }
1866 extern(C) static void callBackSelectionReceived(GtkWidget* widgetStruct, GtkSelectionData* data, guint time, Widget widget)
1867 {
1870 foreach ( void delegate(GtkSelectionData*, guint, Widget) dlg ; widget.onSelectionReceivedListeners )
1871 {
1873 }
1876 }
1879 void addOnSelectionRequest(gboolean delegate(GdkEventSelection*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1880 {
1882 {
1889 connectFlags);
1891 }
1893 }
1894 extern(C) static void callBackSelectionRequest(GtkWidget* widgetStruct, GdkEventSelection* event, Widget widget)
1895 {
1898 foreach ( gboolean delegate(GdkEventSelection*, Widget) dlg ; widget.onSelectionRequestListeners )
1899 {
1901 }
1904 }
1908 {
1910 {
1917 connectFlags);
1919 }
1921 }
1923 {
1927 {
1929 }
1932 }
1935 void addOnShowHelp(gboolean delegate(GtkWidgetHelpType, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1936 {
1938 {
1945 connectFlags);
1947 }
1949 }
1950 extern(C) static void callBackShowHelp(GtkWidget* widgetStruct, GtkWidgetHelpType arg1, Widget widget)
1951 {
1955 {
1957 }
1960 }
1963 void addOnSizeAllocate(void delegate(GtkAllocation*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1964 {
1966 {
1973 connectFlags);
1975 }
1977 }
1978 extern(C) static void callBackSizeAllocate(GtkWidget* widgetStruct, GtkAllocation* allocation, Widget widget)
1979 {
1983 {
1985 }
1988 }
1991 void addOnSizeRequest(void delegate(GtkRequisition*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
1992 {
1994 {
2001 connectFlags);
2003 }
2005 }
2006 extern(C) static void callBackSizeRequest(GtkWidget* widgetStruct, GtkRequisition* requisition, Widget widget)
2007 {
2011 {
2013 }
2016 }
2019 void addOnStateChanged(void delegate(GtkStateType, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
2020 {
2022 {
2029 connectFlags);
2031 }
2033 }
2034 extern(C) static void callBackStateChanged(GtkWidget* widgetStruct, GtkStateType state, Widget widget)
2035 {
2039 {
2041 }
2044 }
2049 void addOnStyleSet(void delegate(Style, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
2050 {
2052 {
2059 connectFlags);
2061 }
2063 }
2065 extern(C) static void callBackStyleSet(GtkWidget* widgetStruct, GtkStyle* previousStyle, Widget widget)
2066 {
2070 {
2072 }
2075 }
2079 {
2081 {
2088 connectFlags);
2090 }
2092 }
2094 {
2098 {
2100 }
2103 }
2106 void addOnUnmapEvent(gboolean delegate(Event, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
2107 {
2109 {
2116 connectFlags);
2118 }
2120 }
2121 extern(C) static void callBackUnmapEvent(GtkWidget* widgetStruct, GdkEvent* event, Widget widget)
2122 {
2126 {
2128 }
2131 }
2135 {
2137 {
2144 connectFlags);
2146 }
2148 }
2150 {
2154 {
2156 }
2159 }
2162 void addOnVisibilityNotify(gboolean delegate(GdkEventVisibility*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
2163 {
2165 {
2172 connectFlags);
2174 }
2176 }
2177 extern(C) static void callBackVisibilityNotify(GtkWidget* widgetStruct, GdkEventVisibility* event, Widget widget)
2178 {
2181 foreach ( gboolean delegate(GdkEventVisibility*, Widget) dlg ; widget.onVisibilityNotifyListeners )
2182 {
2184 }
2187 }
2190 void addOnWindowState(gboolean delegate(GdkEventWindowState*, Widget) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
2191 {
2193 {
2200 connectFlags);
2202 }
2204 }
2205 extern(C) static void callBackWindowState(GtkWidget* widgetStruct, GdkEventWindowState* event, Widget widget)
2206 {
2209 foreach ( gboolean delegate(GdkEventWindowState*, Widget) dlg ; widget.onWindowStateListeners )
2210 {
2212 }
2215 }
2253 /**
2254 * This is a convenience function for creating a widget and setting
2255 * its properties in one go. For example you might write:
2256 * gtk_widget_new (GTK_TYPE_LABEL, "label", "Hello World", "xalign",
2257 * 0.0, NULL) to create a left-aligned label. Equivalent to
2258 * g_object_new(), but returns a widget so you don't have to
2259 * cast the object yourself.
2260 * type:
2261 * type ID of the widget to create
2262 * first_property_name:
2263 * name of first property to set
2264 * ...:
2265 * value of first property, followed by more properties, NULL-terminated
2266 * Returns:
2267 * a new GtkWidget of type widget_type
2268 */
2270 {
2271 // GtkWidget* gtk_widget_new (GType type, const gchar *first_property_name, ...);
2273 }
2276 /**
2277 * Inverse of gtk_widget_ref(). Equivalent to g_object_unref().
2278 * widget:
2279 * a GtkWidget
2280 */
2282 {
2283 // void gtk_widget_unref (GtkWidget *widget);
2285 }
2287 /**
2288 * Destroys a widget. Equivalent to gtk_object_destroy(), except that
2289 * you don't have to cast the widget to GtkObject. When a widget is
2290 * destroyed, it will break any references it holds to other objects.
2291 * If the widget is inside a container, the widget will be removed
2292 * from the container. If the widget is a toplevel (derived from
2293 * GtkWindow), it will be removed from the list of toplevels, and the
2294 * reference GTK+ holds to it will be removed. Removing a
2295 * widget from its container or the list of toplevels results in the
2296 * widget being finalized, unless you've added additional references
2297 * to the widget with g_object_ref().
2298 * In most cases, only toplevel widgets (windows) require explicit
2299 * destruction, because when you destroy a toplevel its children will
2300 * be destroyed as well.
2301 * widget:
2302 * a GtkWidget
2303 */
2305 {
2306 // void gtk_widget_destroy (GtkWidget *widget);
2308 }
2310 /**
2311 * This function sets *widget_pointer to NULL if widget_pointer !=
2312 * NULL. It's intended to be used as a callback connected to the
2313 * "destroy" signal of a widget. You connect gtk_widget_destroyed()
2314 * as a signal handler, and pass the address of your widget variable
2315 * as user data. Then when the widget is destroyed, the variable will
2316 * be set to NULL. Useful for example to avoid multiple copies
2317 * of the same dialog.
2318 * widget:
2319 * a GtkWidget
2320 * widget_pointer:
2321 * address of a variable that contains widget
2322 */
2324 {
2325 // void gtk_widget_destroyed (GtkWidget *widget, GtkWidget **widget_pointer);
2327 }
2329 /**
2330 * Warning
2331 * gtk_widget_set is deprecated and should not be used in newly-written code.
2332 * Like g_object_set() - there's no reason to use this instead of
2333 * g_object_set().
2334 * widget:
2335 * a GtkWidget
2336 * first_property_name:
2337 * name of first property to set
2338 * ...:
2339 * value of first property, followed by more properties, NULL-terminated
2340 */
2342 {
2343 // void gtk_widget_set (GtkWidget *widget, const gchar *first_property_name, ...);
2345 }
2347 /**
2348 * This function is only for use in widget implementations.
2349 * Should be called by implementations of the remove method
2350 * on GtkContainer, to dissociate a child from the container.
2351 * widget:
2352 * a GtkWidget
2353 */
2355 {
2356 // void gtk_widget_unparent (GtkWidget *widget);
2358 }
2360 /**
2361 * Flags a widget to be displayed. Any widget that isn't shown will
2362 * not appear on the screen. If you want to show all the widgets in a
2363 * container, it's easier to call gtk_widget_show_all() on the
2364 * container, instead of individually showing the widgets.
2365 * Remember that you have to show the containers containing a widget,
2366 * in addition to the widget itself, before it will appear onscreen.
2367 * When a toplevel container is shown, it is immediately realized and
2368 * mapped; other shown widgets are realized and mapped when their
2369 * toplevel container is realized and mapped.
2370 * widget:
2371 * a GtkWidget
2372 */
2374 {
2375 // void gtk_widget_show (GtkWidget *widget);
2377 }
2379 /**
2380 * Shows a widget. If the widget is an unmapped toplevel widget
2381 * (i.e. a GtkWindow that has not yet been shown), enter the main
2382 * loop and wait for the window to actually be mapped. Be careful;
2383 * because the main loop is running, anything can happen during
2384 * this function.
2385 * widget:
2386 * a GtkWidget
2387 */
2389 {
2390 // void gtk_widget_show_now (GtkWidget *widget);
2392 }
2394 /**
2395 * Reverses the effects of gtk_widget_show(), causing the widget to be
2396 * hidden (invisible to the user).
2397 * widget:
2398 * a GtkWidget
2399 */
2401 {
2402 // void gtk_widget_hide (GtkWidget *widget);
2404 }
2406 /**
2407 * Recursively shows a widget, and any child widgets (if the widget is
2408 * a container).
2409 * widget:
2410 * a GtkWidget
2411 */
2413 {
2414 // void gtk_widget_show_all (GtkWidget *widget);
2416 }
2418 /**
2419 * Recursively hides a widget and any child widgets.
2420 * widget:
2421 * a GtkWidget
2422 */
2424 {
2425 // void gtk_widget_hide_all (GtkWidget *widget);
2427 }
2429 /**
2430 * This function is only for use in widget implementations. Causes
2431 * a widget to be mapped if it isn't already.
2432 * widget:
2433 * a GtkWidget
2434 */
2436 {
2437 // void gtk_widget_map (GtkWidget *widget);
2439 }
2441 /**
2442 * This function is only for use in widget implementations. Causes
2443 * a widget to be unmapped if it's currently mapped.
2444 * widget:
2445 * a GtkWidget
2446 */
2448 {
2449 // void gtk_widget_unmap (GtkWidget *widget);
2451 }
2453 /**
2454 * Creates the GDK (windowing system) resources associated with a
2455 * widget. For example, widget->window will be created when a widget
2456 * is realized. Normally realization happens implicitly; if you show
2457 * a widget and all its parent containers, then the widget will be
2458 * realized and mapped automatically.
2459 * Realizing a widget requires all
2460 * the widget's parent widgets to be realized; calling
2461 * gtk_widget_realize() realizes the widget's parents in addition to
2462 * widget itself. If a widget is not yet inside a toplevel window
2463 * when you realize it, bad things will happen.
2464 * This function is primarily used in widget implementations, and
2465 * isn't very useful otherwise. Many times when you think you might
2466 * need it, a better approach is to connect to a signal that will be
2467 * called after the widget is realized automatically, such as
2468 * "expose_event". Or simply g_signal_connect_after() to the
2469 * "realize" signal.
2470 * widget:
2471 * a GtkWidget
2472 */
2474 {
2475 // void gtk_widget_realize (GtkWidget *widget);
2477 }
2479 /**
2480 * This function is only useful in widget implementations.
2481 * Causes a widget to be unrealized (frees all GDK resources
2482 * associated with the widget, such as widget->window).
2483 * widget:
2484 * a GtkWidget
2485 */
2487 {
2488 // void gtk_widget_unrealize (GtkWidget *widget);
2490 }
2492 /**
2493 * Equivalent to calling gtk_widget_queue_draw_area() for the
2494 * entire area of a widget.
2495 * widget:
2496 * a GtkWidget
2497 */
2499 {
2500 // void gtk_widget_queue_draw (GtkWidget *widget);
2502 }
2504 /**
2505 * This function is only for use in widget implementations.
2506 * Flags a widget to have its size renegotiated; should
2507 * be called when a widget for some reason has a new size request.
2508 * For example, when you change the text in a GtkLabel, GtkLabel
2509 * queues a resize to ensure there's enough space for the new text.
2510 * widget:
2511 * a GtkWidget
2512 */
2514 {
2515 // void gtk_widget_queue_resize (GtkWidget *widget);
2517 }
2519 /**
2520 * This function works like gtk_widget_queue_resize(), except that the
2521 * widget is not invalidated.
2522 * widget:
2523 * a GtkWidget
2524 * Since 2.4
2525 */
2527 {
2528 // void gtk_widget_queue_resize_no_redraw (GtkWidget *widget);
2530 }
2532 /**
2533 * Warning
2534 * gtk_widget_draw is deprecated and should not be used in newly-written code.
2535 * In GTK+ 1.2, this function would immediately render the
2536 * region area of a widget, by invoking the virtual draw method of a
2537 * widget. In GTK+ 2.0, the draw method is gone, and instead
2538 * gtk_widget_draw() simply invalidates the specified region of the
2539 * widget, then updates the invalid region of the widget immediately.
2540 * Usually you don't want to update the region immediately for
2541 * performance reasons, so in general gtk_widget_queue_draw_area() is
2542 * a better choice if you want to draw a region of a widget.
2543 * widget:
2544 * a GtkWidget
2545 * area:
2546 * area to draw
2547 */
2549 {
2550 // void gtk_widget_draw (GtkWidget *widget, GdkRectangle *area);
2552 }
2554 /**
2555 * This function is typically used when implementing a GtkContainer
2556 * subclass. Obtains the preferred size of a widget. The container
2557 * uses this information to arrange its child widgets and decide what
2558 * size allocations to give them with gtk_widget_size_allocate().
2559 * You can also call this function from an application, with some
2560 * caveats. Most notably, getting a size request requires the widget
2561 * to be associated with a screen, because font information may be
2562 * needed. Multihead-aware applications should keep this in mind.
2563 * Also remember that the size request is not necessarily the size
2564 * a widget will actually be allocated.
2565 * See also gtk_widget_get_child_requisition().
2566 * widget:
2567 * a GtkWidget
2568 * requisition:
2569 * a GtkRequisition to be filled in
2570 */
2572 {
2573 // void gtk_widget_size_request (GtkWidget *widget, GtkRequisition *requisition);
2575 }
2577 /**
2578 * This function is only for use in widget implementations. Obtains
2579 * widget->requisition, unless someone has forced a particular
2580 * geometry on the widget (e.g. with gtk_widget_set_usize()), in which
2581 * case it returns that geometry instead of the widget's requisition.
2582 * This function differs from gtk_widget_size_request() in that
2583 * it retrieves the last size request value from widget->requisition,
2584 * while gtk_widget_size_request() actually calls the "size_request" method
2585 * on widget to compute the size request and fill in widget->requisition,
2586 * and only then returns widget->requisition.
2587 * Because this function does not call the "size_request" method, it
2588 * can only be used when you know that widget->requisition is
2589 * up-to-date, that is, gtk_widget_size_request() has been called
2590 * since the last time a resize was queued. In general, only container
2591 * implementations have this information; applications should use
2592 * gtk_widget_size_request().
2593 * widget:
2594 * a GtkWidget
2595 * requisition:
2596 * a GtkRequisition to be filled in
2597 */
2599 {
2600 // void gtk_widget_get_child_requisition (GtkWidget *widget, GtkRequisition *requisition);
2602 }
2604 /**
2605 * This function is only used by GtkContainer subclasses, to assign a size
2606 * and position to their child widgets.
2607 * widget:
2608 * a GtkWidget
2609 * allocation:
2610 * position and size to be allocated to widget
2611 */
2613 {
2614 // void gtk_widget_size_allocate (GtkWidget *widget, GtkAllocation *allocation);
2616 }
2618 /**
2619 * Installs an accelerator for this widget in accel_group that causes
2620 * accel_signal to be emitted if the accelerator is activated.
2621 * The accel_group needs to be added to the widget's toplevel via
2622 * gtk_window_add_accel_group(), and the signal must be of type G_RUN_ACTION.
2623 * Accelerators added through this function are not user changeable during
2624 * runtime. If you want to support accelerators that can be changed by the
2625 * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
2626 * gtk_menu_item_set_accel_path() instead.
2627 * widget:
2628 * widget to install an accelerator on
2629 * accel_signal:
2630 * widget signal to emit on accelerator activation
2631 * accel_group:
2632 * accel group for this widget, added to its toplevel
2633 * accel_key:
2634 * GDK keyval of the accelerator
2635 * accel_mods:
2636 * modifier key combination of the accelerator
2637 * accel_flags:
2638 * flag accelerators, e.g. GTK_ACCEL_VISIBLE
2639 */
2640 public void addAccelerator(char[] accelSignal, AccelGroup accelGroup, uint accelKey, GdkModifierType accelMods, GtkAccelFlags accelFlags)
2641 {
2642 // void gtk_widget_add_accelerator (GtkWidget *widget, const gchar *accel_signal, GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods, GtkAccelFlags accel_flags);
2643 gtk_widget_add_accelerator(gtkWidget, Str.toStringz(accelSignal), (accelGroup is null) ? null : accelGroup.getAccelGroupStruct(), accelKey, accelMods, accelFlags);
2644 }
2646 /**
2647 * Removes an accelerator from widget, previously installed with
2648 * gtk_widget_add_accelerator().
2649 * widget:
2650 * widget to install an accelerator on
2651 * accel_group:
2652 * accel group for this widget
2653 * accel_key:
2654 * GDK keyval of the accelerator
2655 * accel_mods:
2656 * modifier key combination of the accelerator
2657 * Returns:
2658 * whether an accelerator was installed and could be removed
2659 */
2661 {
2662 // gboolean gtk_widget_remove_accelerator (GtkWidget *widget, GtkAccelGroup *accel_group, guint accel_key, GdkModifierType accel_mods);
2663 return gtk_widget_remove_accelerator(gtkWidget, (accelGroup is null) ? null : accelGroup.getAccelGroupStruct(), accelKey, accelMods);
2664 }
2666 /**
2667 * Given an accelerator group, accel_group, and an accelerator path,
2668 * accel_path, sets up an accelerator in accel_group so whenever the
2669 * key binding that is defined for accel_path is pressed, widget
2670 * will be activated. This removes any accelerators (for any
2671 * accelerator group) installed by previous calls to
2672 * gtk_widget_set_accel_path(). Associating accelerators with
2673 * paths allows them to be modified by the user and the modifications
2674 * to be saved for future use. (See gtk_accel_map_save().)
2675 * This function is a low level function that would most likely
2676 * be used by a menu creation system like GtkItemFactory. If you
2677 * use GtkItemFactory, setting up accelerator paths will be done
2678 * automatically.
2679 * Even when you you aren't using GtkItemFactory, if you only want to
2680 * set up accelerators on menu items gtk_menu_item_set_accel_path()
2681 * provides a somewhat more convenient interface.
2682 * widget:
2683 * a GtkWidget
2684 * accel_path:
2685 * path used to look up the accelerator
2686 * accel_group:
2687 * a GtkAccelGroup.
2688 */
2690 {
2691 // void gtk_widget_set_accel_path (GtkWidget *widget, const gchar *accel_path, GtkAccelGroup *accel_group);
2692 gtk_widget_set_accel_path(gtkWidget, Str.toStringz(accelPath), (accelGroup is null) ? null : accelGroup.getAccelGroupStruct());
2693 }
2695 /**
2696 * Lists the closures used by widget for accelerator group connections
2697 * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
2698 * The closures can be used to monitor accelerator changes on widget,
2699 * by connecting to the ::accel_changed signal of the GtkAccelGroup of a
2700 * closure which can be found out with gtk_accel_group_from_accel_closure().
2701 * widget:
2702 * widget to list accelerator closures for
2703 * Returns:
2704 * a newly allocated GList of closures
2705 */
2707 {
2708 // GList* gtk_widget_list_accel_closures (GtkWidget *widget);
2710 }
2712 /**
2713 * Determines whether an accelerator that activates the signal
2714 * identified by signal_id can currently be activated.
2715 * This is done by emitting the GtkWidget::can-activate-accel
2716 * signal on widget; if the signal isn't overridden by a
2717 * handler or in a derived widget, then the default check is
2718 * that the widget must be sensitive, and the widget and all
2719 * its ancestors mapped.
2720 * widget:
2721 * a GtkWidget
2722 * signal_id:
2723 * the ID of a signal installed on widget
2724 * Returns:
2725 * TRUE if the accelerator can be activated.
2726 * Since 2.4
2727 */
2729 {
2730 // gboolean gtk_widget_can_activate_accel (GtkWidget *widget, guint signal_id);
2732 }
2734 /**
2735 * Rarely-used function. This function is used to emit
2736 * the event signals on a widget (those signals should never
2737 * be emitted without using this function to do so).
2738 * If you want to synthesize an event though, don't use this function;
2739 * instead, use gtk_main_do_event() so the event will behave as if
2740 * it were in the event queue. Don't synthesize expose events; instead,
2741 * use gdk_window_invalidate_rect() to invalidate a region of the
2742 * window.
2743 * widget:
2744 * a GtkWidget
2745 * event:
2746 * a GdkEvent
2747 * Returns:
2748 * return from the event signal emission (TRUE if the event was handled)
2749 */
2751 {
2752 // gboolean gtk_widget_event (GtkWidget *widget, GdkEvent *event);
2754 }
2756 /**
2757 * For widgets that can be "activated" (buttons, menu items, etc.)
2758 * this function activates them. Activation is what happens when you
2759 * press Enter on a widget during key navigation. If widget isn't
2760 * activatable, the function returns FALSE.
2761 * widget:
2762 * a GtkWidget that's activatable
2763 * Returns:
2764 * TRUE if the widget was activatable
2765 */
2767 {
2768 // gboolean gtk_widget_activate (GtkWidget *widget);
2770 }
2772 /**
2773 * Moves a widget from one GtkContainer to another, handling reference
2774 * count issues to avoid destroying the widget.
2775 * widget:
2776 * a GtkWidget
2777 * new_parent:
2778 * a GtkContainer to move the widget into
2779 */
2781 {
2782 // void gtk_widget_reparent (GtkWidget *widget, GtkWidget *new_parent);
2784 }
2786 /**
2787 * Computes the intersection of a widget's area and area, storing
2788 * the intersection in intersection, and returns TRUE if there was
2789 * an intersection. intersection may be NULL if you're only
2790 * interested in whether there was an intersection.
2791 * widget:
2792 * a GtkWidget
2793 * area:
2794 * a rectangle
2795 * intersection:
2796 * rectangle to store intersection of widget and area
2797 * Returns:
2798 * TRUE if there was an intersection
2799 */
2801 {
2802 // gboolean gtk_widget_intersect (GtkWidget *widget, GdkRectangle *area, GdkRectangle *intersection);
2803 return gtk_widget_intersect(gtkWidget, (area is null) ? null : area.getRectangleStruct(), (intersection is null) ? null : intersection.getRectangleStruct());
2804 }
2806 /**
2807 * Determines if the widget is the focus widget within its
2808 * toplevel. (This does not mean that the HAS_FOCUS flag is
2809 * necessarily set; HAS_FOCUS will only be set if the
2810 * toplevel widget additionally has the global input focus.)
2811 * widget:
2812 * a GtkWidget
2813 * Returns:
2814 * TRUE if the widget is the focus widget.
2815 */
2817 {
2818 // gboolean gtk_widget_is_focus (GtkWidget *widget);
2820 }
2822 /**
2823 * Causes widget to have the keyboard focus for the GtkWindow it's
2824 * inside. widget must be a focusable widget, such as a GtkEntry;
2825 * something like GtkFrame won't work. (More precisely, it must have the
2826 * GTK_CAN_FOCUS flag set.)
2827 * widget:
2828 * a GtkWidget
2829 */
2831 {
2832 // void gtk_widget_grab_focus (GtkWidget *widget);
2834 }
2836 /**
2837 * Causes widget to become the default widget. widget must have the
2838 * GTK_CAN_DEFAULT flag set; typically you have to set this flag
2839 * yourself by calling GTK_WIDGET_SET_FLAGS (widget,
2840 * GTK_CAN_DEFAULT). The default widget is activated when the user
2841 * presses Enter in a window. Default widgets must be activatable,
2842 * that is, gtk_widget_activate() should affect them.
2843 * widget:
2844 * a GtkWidget
2845 */
2847 {
2848 // void gtk_widget_grab_default (GtkWidget *widget);
2850 }
2852 /**
2853 * Widgets can be named, which allows you to refer to them from a
2854 * gtkrc file. You can apply a style to widgets with a particular name
2855 * in the gtkrc file. See the documentation for gtkrc files (on the
2856 * same page as the docs for GtkRcStyle).
2857 * Note that widget names are separated by periods in paths (see
2858 * gtk_widget_path()), so names with embedded periods may cause confusion.
2859 * widget:
2860 * a GtkWidget
2861 * name:
2862 * name for the widget
2863 */
2865 {
2866 // void gtk_widget_set_name (GtkWidget *widget, const gchar *name);
2868 }
2870 /**
2871 * Retrieves the name of a widget. See gtk_widget_set_name() for the
2872 * significance of widget names.
2873 * widget:
2874 * a GtkWidget
2875 * Returns:
2876 * name of the widget. This string is owned by GTK+ and
2877 * should not be modified or freed
2878 */
2880 {
2881 // const gchar* gtk_widget_get_name (GtkWidget *widget);
2883 }
2885 /**
2886 * This function is for use in widget implementations. Sets the state
2887 * of a widget (insensitive, prelighted, etc.) Usually you should set
2888 * the state using wrapper functions such as gtk_widget_set_sensitive().
2889 * widget:
2890 * a GtkWidget
2891 * state:
2892 * new state for widget
2893 */
2895 {
2896 // void gtk_widget_set_state (GtkWidget *widget, GtkStateType state);
2898 }
2900 /**
2901 * Sets the sensitivity of a widget. A widget is sensitive if the user
2902 * can interact with it. Insensitive widgets are "grayed out" and the
2903 * user can't interact with them. Insensitive widgets are known as
2904 * "inactive", "disabled", or "ghosted" in some other toolkits.
2905 * widget:
2906 * a GtkWidget
2907 * sensitive:
2908 * TRUE to make the widget sensitive
2909 */
2911 {
2912 // void gtk_widget_set_sensitive (GtkWidget *widget, gboolean sensitive);
2914 }
2916 /**
2917 * This function is useful only when implementing subclasses of GtkContainer.
2918 * Sets the container as the parent of widget, and takes care of
2919 * some details such as updating the state and style of the child
2920 * to reflect its new location. The opposite function is
2921 * gtk_widget_unparent().
2922 * widget:
2923 * a GtkWidget
2924 * parent:
2925 * parent container
2926 */
2928 {
2929 // void gtk_widget_set_parent (GtkWidget *widget, GtkWidget *parent);
2931 }
2933 /**
2934 * Sets a non default parent window for widget.
2935 * widget:
2936 * a GtkWidget.
2937 * parent_window:
2938 * the new parent window.
2939 */
2941 {
2942 // void gtk_widget_set_parent_window (GtkWidget *widget, GdkWindow *parent_window);
2943 gtk_widget_set_parent_window(gtkWidget, (parentWindow is null) ? null : parentWindow.getWindowStruct());
2944 }
2946 /**
2947 * Gets widget's parent window.
2948 * widget:
2949 * a GtkWidget.
2950 * Returns:
2951 * the parent window of widget.
2952 */
2954 {
2955 // GdkWindow* gtk_widget_get_parent_window (GtkWidget *widget);
2957 }
2959 /**
2960 * Warning
2961 * gtk_widget_set_uposition is deprecated and should not be used in newly-written code.
2962 * Sets the position of a widget. The funny "u" in the name comes from
2963 * the "user position" hint specified by the X Window System, and
2964 * exists for legacy reasons. This function doesn't work if a widget
2965 * is inside a container; it's only really useful on GtkWindow.
2966 * Don't use this function to center dialogs over the main application
2967 * window; most window managers will do the centering on your behalf
2968 * if you call gtk_window_set_transient_for(), and it's really not
2969 * possible to get the centering to work correctly in all cases from
2970 * application code. But if you insist, use gtk_window_set_position()
2971 * to set GTK_WIN_POS_CENTER_ON_PARENT, don't do the centering
2972 * manually.
2973 * Note that although x and y can be individually unset, the position
2974 * is not honoured unless both x and y are set.
2975 * widget:
2976 * a GtkWidget
2977 * x:
2978 * x position; -1 to unset x; -2 to leave x unchanged
2979 * y:
2980 * y position; -1 to unset y; -2 to leave y unchanged
2981 */
2983 {
2984 // void gtk_widget_set_uposition (GtkWidget *widget, gint x, gint y);
2986 }
2988 /**
2989 * Warning
2990 * gtk_widget_set_usize is deprecated and should not be used in newly-written code.
2991 * Sets the minimum size of a widget; that is, the widget's size
2992 * request will be width by height. You can use this function to
2993 * force a widget to be either larger or smaller than it is. The
2994 * strange "usize" name dates from the early days of GTK+, and derives
2995 * from X Window System terminology. In many cases,
2996 * gtk_window_set_default_size() is a better choice for toplevel
2997 * windows than this function; setting the default size will still
2998 * allow users to shrink the window. Setting the usize will force them
2999 * to leave the window at least as large as the usize. When dealing
3000 * with window sizes, gtk_window_set_geometry_hints() can be a useful
3001 * function as well.
3002 * Note the inherent danger of setting any fixed size - themes,
3003 * translations into other languages, different fonts, and user action
3004 * can all change the appropriate size for a given widget. So, it's
3005 * basically impossible to hardcode a size that will always be
3006 * correct.
3007 * Deprecated: Use gtk_widget_set_size_request() instead.
3008 * widget:
3009 * a GtkWidget
3010 * width:
3011 * minimum width, or -1 to unset
3012 * height:
3013 * minimum height, or -1 to unset
3014 */
3016 {
3017 // void gtk_widget_set_usize (GtkWidget *widget, gint width, gint height);
3019 }
3021 /**
3022 * Sets the event mask (see GdkEventMask) for a widget. The event
3023 * mask determines which events a widget will receive. Keep in mind
3024 * that different widgets have different default event masks, and by
3025 * changing the event mask you may disrupt a widget's functionality,
3026 * so be careful. This function must be called while a widget is
3027 * unrealized. Consider gtk_widget_add_events() for widgets that are
3028 * already realized, or if you want to preserve the existing event
3029 * mask. This function can't be used with GTK_NO_WINDOW widgets;
3030 * to get events on those widgets, place them inside a GtkEventBox
3031 * and receive events on the event box.
3032 * widget:
3033 * a GtkWidget
3034 * events:
3035 * event mask
3036 */
3038 {
3039 // void gtk_widget_set_events (GtkWidget *widget, gint events);
3041 }
3043 /**
3044 * Adds the events in the bitfield events to the event mask for
3045 * widget. See gtk_widget_set_events() for details.
3046 * widget:
3047 * a GtkWidget
3048 * events:
3049 * an event mask, see GdkEventMask
3050 */
3052 {
3053 // void gtk_widget_add_events (GtkWidget *widget, gint events);
3055 }
3057 /**
3058 * Sets the extension events mask to mode. See GdkExtensionMode
3059 * and gdk_input_set_extension_events().
3060 * widget:
3061 * a GtkWidget
3062 * mode:
3063 * bitfield of extension events to receive
3064 */
3066 {
3067 // void gtk_widget_set_extension_events (GtkWidget *widget, GdkExtensionMode mode);
3069 }
3071 /**
3072 * Retrieves the extension events the widget will receive; see
3073 * gdk_input_set_extension_events().
3074 * widget:
3075 * a GtkWidget
3076 * Returns:
3077 * extension events for widget
3078 */
3080 {
3081 // GdkExtensionMode gtk_widget_get_extension_events (GtkWidget *widget);
3083 }
3085 /**
3086 * This function returns the topmost widget in the container hierarchy
3087 * widget is a part of. If widget has no parent widgets, it will be
3088 * returned as the topmost widget. No reference will be added to the
3089 * returned widget; it should not be unreferenced.
3090 * Note the difference in behavior vs. gtk_widget_get_ancestor();
3091 * gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)
3092 * would return
3093 * NULL if widget wasn't inside a toplevel window, and if the
3094 * window was inside a GtkWindow-derived widget which was in turn
3095 * inside the toplevel GtkWindow. While the second case may
3096 * seem unlikely, it actually happens when a GtkPlug is embedded
3097 * inside a GtkSocket within the same application.
3098 * To reliably find the toplevel GtkWindow, use
3099 * gtk_widget_get_toplevel() and check if the TOPLEVEL flags
3100 * is set on the result.
3101 * GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
3102 * if (GTK_WIDGET_TOPLEVEL (toplevel))
3103 * {
3104 * [ Perform action on toplevel. ]
3105 * }
3106 * widget:
3107 * a GtkWidget
3108 * Returns:
3109 * the topmost ancestor of widget, or widget itself if there's no ancestor.
3110 */
3112 {
3113 // GtkWidget* gtk_widget_get_toplevel (GtkWidget *widget);
3115 }
3117 /**
3118 * Gets the first ancestor of widget with type widget_type. For example,
3119 * gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) gets the
3120 * first GtkBox that's
3121 * an ancestor of widget. No reference will be added to the returned widget;
3122 * it should not be unreferenced. See note about checking for a toplevel
3123 * GtkWindow in the docs for gtk_widget_get_toplevel().
3124 * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
3125 * considers widget to be an ancestor of itself.
3126 * widget:
3127 * a GtkWidget
3128 * widget_type:
3129 * ancestor type
3130 * Returns:
3131 * the ancestor widget, or NULL if not found
3132 */
3134 {
3135 // GtkWidget* gtk_widget_get_ancestor (GtkWidget *widget, GType widget_type);
3137 }
3139 /**
3140 * Gets the colormap that will be used to render widget. No reference will
3141 * be added to the returned colormap; it should not be unreferenced.
3142 * widget:
3143 * a GtkWidget
3144 * Returns:
3145 * the colormap used by widget
3146 */
3148 {
3149 // GdkColormap* gtk_widget_get_colormap (GtkWidget *widget);
3151 }
3153 /**
3154 * Sets the colormap for the widget to the given value. Widget must not
3155 * have been previously realized. This probably should only be used
3156 * from an init() function (i.e. from the constructor
3157 * for the widget).
3158 * widget:
3159 * a GtkWidget
3160 * colormap:
3161 * a colormap
3162 */
3164 {
3165 // void gtk_widget_set_colormap (GtkWidget *widget, GdkColormap *colormap);
3167 }
3169 /**
3170 * Gets the visual that will be used to render widget.
3171 * widget:
3172 * a GtkWidget
3173 * Returns:
3174 * the visual for widget
3175 */
3177 {
3178 // GdkVisual* gtk_widget_get_visual (GtkWidget *widget);
3180 }
3182 /**
3183 * Returns the event mask for the widget (a bitfield containing flags
3184 * from the GdkEventMask enumeration). These are the events that the widget
3185 * will receive.
3186 * widget:
3187 * a GtkWidget
3188 * Returns:
3189 * event mask for widget
3190 */
3192 {
3193 // gint gtk_widget_get_events (GtkWidget *widget);
3195 }
3197 /**
3198 * Obtains the location of the mouse pointer in widget coordinates.
3199 * Widget coordinates are a bit odd; for historical reasons, they are
3200 * defined as widget->window coordinates for widgets that are not
3201 * GTK_NO_WINDOW widgets, and are relative to widget->allocation.x,
3202 * widget->allocation.y for widgets that are GTK_NO_WINDOW widgets.
3203 * widget:
3204 * a GtkWidget
3205 * x:
3206 * return location for the X coordinate, or NULL
3207 * y:
3208 * return location for the Y coordinate, or NULL
3209 */
3211 {
3212 // void gtk_widget_get_pointer (GtkWidget *widget, gint *x, gint *y);
3214 }
3216 /**
3217 * Determines whether widget is somewhere inside ancestor, possibly with
3218 * intermediate containers.
3219 * widget:
3220 * a GtkWidget
3221 * ancestor:
3222 * another GtkWidget
3223 * Returns:
3224 * TRUE if ancestor contains widget as a child, grandchild, great grandchild, etc.
3225 */
3227 {
3228 // gboolean gtk_widget_is_ancestor (GtkWidget *widget, GtkWidget *ancestor);
3230 }
3232 /**
3233 * Translate coordinates relative to src_widget's allocation to coordinates
3234 * relative to dest_widget's allocations. In order to perform this
3235 * operation, both widgets must be realized, and must share a common
3236 * toplevel.
3237 * src_widget:
3238 * a GtkWidget
3239 * dest_widget:
3240 * a GtkWidget
3241 * src_x:
3242 * X position relative to src_widget
3243 * src_y:
3244 * Y position relative to src_widget
3245 * dest_x:
3246 * location to store X position relative to dest_widget
3247 * dest_y:
3248 * location to store Y position relative to dest_widget
3249 * Returns:
3250 * FALSE if either widget was not realized, or there
3251 * was no common ancestor. In this case, nothing is stored in
3252 * *dest_x and *dest_y. Otherwise TRUE.
3253 */
3254 public int translateCoordinates(GtkWidget* destWidget, int srcX, int srcY, int* destX, int* destY)
3255 {
3256 // gboolean gtk_widget_translate_coordinates (GtkWidget *src_widget, GtkWidget *dest_widget, gint src_x, gint src_y, gint *dest_x, gint *dest_y);
3258 }
3260 /**
3261 * Utility function; intended to be connected to the "delete_event"
3262 * signal on a GtkWindow. The function calls gtk_widget_hide() on its
3263 * argument, then returns TRUE. If connected to "delete_event", the
3264 * result is that clicking the close button for a window (on the
3265 * window frame, top right corner usually) will hide but not destroy
3266 * the window. By default, GTK+ destroys windows when "delete_event"
3267 * is received.
3268 * widget:
3269 * a GtkWidget
3270 * Returns:
3271 * TRUE
3272 */
3274 {
3275 // gboolean gtk_widget_hide_on_delete (GtkWidget *widget);
3277 }
3279 /**
3280 * Sets the GtkStyle for a widget (widget->style). You probably don't
3281 * want to use this function; it interacts badly with themes, because
3282 * themes work by replacing the GtkStyle. Instead, use
3283 * gtk_widget_modify_style().
3284 * widget:
3285 * a GtkWidget
3286 * style:
3287 * a GtkStyle, or NULL to remove the effect of a previous
3288 * gtk_widget_set_style() and go back to the default style
3289 */
3292 {
3293 // void gtk_widget_set_style (GtkWidget *widget, GtkStyle *style);
3295 }
3298 /**
3299 * Ensures that widget has a style (widget->style). Not a very useful
3300 * function; most of the time, if you want the style, the widget is
3301 * realized, and realized widgets are guaranteed to have a style
3302 * already.
3303 * widget:
3304 * a GtkWidget
3305 */
3307 {
3308 // void gtk_widget_ensure_style (GtkWidget *widget);
3310 }
3312 /**
3313 * Simply an accessor function that returns widget->style.
3314 * widget:
3315 * a GtkWidget
3316 * Returns:
3317 * the widget's GtkStyle
3318 */
3321 {
3322 // GtkStyle* gtk_widget_get_style (GtkWidget *widget);
3324 }
3327 /**
3328 * Reset the styles of widget and all descendents, so when
3329 * they are looked up again, they get the correct values
3330 * for the currently loaded RC file settings.
3331 * This function is not useful for applications.
3332 * widget:
3333 * a GtkWidget.
3334 */
3336 {
3337 // void gtk_widget_reset_rc_styles (GtkWidget *widget);
3339 }
3341 /**
3342 * Pushes cmap onto a global stack of colormaps; the topmost
3343 * colormap on the stack will be used to create all widgets.
3344 * Remove cmap with gtk_widget_pop_colormap(). There's little
3345 * reason to use this function.
3346 * cmap:
3347 * a GdkColormap
3348 */
3350 {
3351 // void gtk_widget_push_colormap (GdkColormap *cmap);
3353 }
3355 /**
3356 * Removes a colormap pushed with gtk_widget_push_colormap().
3357 */
3359 {
3360 // void gtk_widget_pop_colormap (void);
3362 }
3364 /**
3365 * Sets the default colormap to use when creating widgets.
3366 * gtk_widget_push_colormap() is a better function to use if
3367 * you only want to affect a few widgets, rather than all widgets.
3368 * colormap:
3369 * a GdkColormap
3370 */
3372 {
3373 // void gtk_widget_set_default_colormap (GdkColormap *colormap);
3375 }
3377 /**
3378 * Returns the default style used by all widgets initially.
3379 * Returns:
3380 * the default style. This GtkStyle object is owned by GTK+ and
3381 * should not be modified or freed.
3382 */
3385 {
3386 // GtkStyle* gtk_widget_get_default_style (void);
3388 }
3390 /**
3391 * Obtains the default colormap used to create widgets.
3392 * Returns:
3393 * default widget colormap
3394 */
3396 {
3397 // GdkColormap* gtk_widget_get_default_colormap (void);
3399 }
3401 /**
3402 * Obtains the visual of the default colormap. Not really useful;
3403 * used to be useful before gdk_colormap_get_visual() existed.
3404 * Returns:
3405 * visual of the default colormap
3406 */
3408 {
3409 // GdkVisual* gtk_widget_get_default_visual (void);
3411 }
3413 /**
3414 * Sets the reading direction on a particular widget. This direction
3415 * controls the primary direction for widgets containing text,
3416 * and also the direction in which the children of a container are
3417 * packed. The ability to set the direction is present in order
3418 * so that correct localization into languages with right-to-left
3419 * reading directions can be done. Generally, applications will
3420 * let the default reading direction present, except for containers
3421 * where the containers are arranged in an order that is explicitely
3422 * visual rather than logical (such as buttons for text justification).
3423 * If the direction is set to GTK_TEXT_DIR_NONE, then the value
3424 * set by gtk_widget_set_default_direction() will be used.
3425 * widget:
3426 * a GtkWidget
3427 * dir:
3428 * the new direction
3429 */
3431 {
3432 // void gtk_widget_set_direction (GtkWidget *widget, GtkTextDirection dir);
3434 }
3437 /**
3438 * Gets the reading direction for a particular widget. See
3439 * gtk_widget_set_direction().
3440 * widget:
3441 * a GtkWidget
3442 * Returns:
3443 * the reading direction for the widget.
3444 */
3446 {
3447 // GtkTextDirection gtk_widget_get_direction (GtkWidget *widget);
3449 }
3451 /**
3452 * Sets the default reading direction for widgets where the
3453 * direction has not been explicitly set by gtk_widget_set_direction().
3454 * dir:
3455 * the new default direction. This cannot be
3456 * GTK_TEXT_DIR_NONE.
3457 */
3459 {
3460 // void gtk_widget_set_default_direction (GtkTextDirection dir);
3462 }
3464 /**
3465 * Obtains the current default reading direction. See
3466 * gtk_widget_set_default_direction().
3467 * Returns:
3468 * the current default direction.
3469 */
3471 {
3472 // GtkTextDirection gtk_widget_get_default_direction (void);
3474 }
3476 /**
3477 * Sets a shape for this widget's GDK window. This allows for
3478 * transparent windows etc., see gdk_window_shape_combine_mask()
3479 * for more information.
3480 * widget:
3481 * a GtkWidget.
3482 * shape_mask:
3483 * shape to be added, or NULL to remove an existing shape.
3484 * offset_x:
3485 * X position of shape mask with respect to window.
3486 * offset_y:
3487 * Y position of shape mask with respect to window.
3488 */
3490 {
3491 // void gtk_widget_shape_combine_mask (GtkWidget *widget, GdkBitmap *shape_mask, gint offset_x, gint offset_y);
3492 gtk_widget_shape_combine_mask(gtkWidget, (shapeMask is null) ? null : shapeMask.getBitmapStruct(), offsetX, offsetY);
3493 }
3495 /**
3496 * Sets an input shape for this widget's GDK window. This allows for
3497 * windows which react to mouse click in a nonrectangular region, see
3498 * gdk_window_input_shape_combine_mask() for more information.
3499 * widget:
3500 * a GtkWidget.
3501 * shape_mask:
3502 * shape to be added, or NULL to remove an existing shape.
3503 * offset_x:
3504 * X position of shape mask with respect to window.
3505 * offset_y:
3506 * Y position of shape mask with respect to window.
3507 * Since 2.10
3508 */
3510 {
3511 // void gtk_widget_input_shape_combine_mask (GtkWidget *widget, GdkBitmap *shape_mask, gint offset_x, gint offset_y);
3512 gtk_widget_input_shape_combine_mask(gtkWidget, (shapeMask is null) ? null : shapeMask.getBitmapStruct(), offsetX, offsetY);
3513 }
3515 /**
3516 * Obtains the full path to widget. The path is simply the name of a
3517 * widget and all its parents in the container hierarchy, separated by
3518 * periods. The name of a widget comes from
3519 * gtk_widget_get_name(). Paths are used to apply styles to a widget
3520 * in gtkrc configuration files. Widget names are the type of the
3521 * widget by default (e.g. "GtkButton") or can be set to an
3522 * application-specific value with gtk_widget_set_name(). By setting
3523 * the name of a widget, you allow users or theme authors to apply
3524 * styles to that specific widget in their gtkrc
3525 * file. path_reversed_p fills in the path in reverse order,
3526 * i.e. starting with widget's name instead of starting with the name
3527 * of widget's outermost ancestor.
3528 * widget:
3529 * a GtkWidget
3530 * path_length:
3531 * location to store length of the path, or NULL
3532 * path:
3533 * location to store allocated path string, or NULL
3534 * path_reversed:
3535 * location to store allocated reverse path string, or NULL
3536 */
3538 {
3539 // void gtk_widget_path (GtkWidget *widget, guint *path_length, gchar **path, gchar **path_reversed);
3541 }
3543 /**
3544 * Same as gtk_widget_path(), but always uses the name of a widget's type,
3545 * never uses a custom name set with gtk_widget_set_name().
3546 * widget:
3547 * a GtkWidget
3548 * path_length:
3549 * location to store the length of the class path, or NULL
3550 * path:
3551 * location to store the class path as an allocated string, or NULL
3552 * path_reversed:
3553 * location to store the reverse class path as an allocated string, or NULL
3554 */
3556 {
3557 // void gtk_widget_class_path (GtkWidget *widget, guint *path_length, gchar **path, gchar **path_reversed);
3559 }
3561 /**
3562 * Obtains the composite name of a widget.
3563 * widget:
3564 * a GtkWidget.
3565 * Returns:
3566 * the composite name of widget, or NULL if widget is not
3567 * a composite child. The string should not be freed when it is no
3568 * longer needed.
3569 */
3571 {
3572 // gchar* gtk_widget_get_composite_name (GtkWidget *widget);
3574 }
3576 /**
3577 * Modifies style values on the widget. Modifications made using this
3578 * technique take precedence over style values set via an RC file,
3579 * however, they will be overriden if a style is explicitely set on
3580 * the widget using gtk_widget_set_style(). The GtkRcStyle structure
3581 * is designed so each field can either be set or unset, so it is
3582 * possible, using this function, to modify some style values and
3583 * leave the others unchanged.
3584 * Note that modifications made with this function are not cumulative
3585 * with previous calls to gtk_widget_modify_style() or with such
3586 * functions as gtk_widget_modify_fg(). If you wish to retain
3587 * previous values, you must first call gtk_widget_get_modifier_style(),
3588 * make your modifications to the returned style, then call
3589 * gtk_widget_modify_style() with that style. On the other hand,
3590 * if you first call gtk_widget_modify_style(), subsequent calls
3591 * to such functions gtk_widget_modify_fg() will have a cumulative
3592 * effect with the initial modifications.
3593 * widget:
3594 * a GtkWidget
3595 * style:
3596 * the GtkRcStyle holding the style modifications
3597 */
3599 {
3600 // void gtk_widget_modify_style (GtkWidget *widget, GtkRcStyle *style);
3602 }
3604 /**
3605 * Returns the current modifier style for the widget. (As set by
3606 * gtk_widget_modify_style().) If no style has previously set, a new
3607 * GtkRcStyle will be created with all values unset, and set as the
3608 * modifier style for the widget. If you make changes to this rc
3609 * style, you must call gtk_widget_modify_style(), passing in the
3610 * returned rc style, to make sure that your changes take effect.
3611 * Caution: passing the style back to gtk_widget_modify_style() will
3612 * normally end up destroying it, because gtk_widget_modify_style() copies
3613 * the passed-in style and sets the copy as the new modifier style,
3614 * thus dropping any reference to the old modifier style. Add a reference
3615 * to the modifier style if you want to keep it alive.
3616 * widget:
3617 * a GtkWidget
3618 * Returns:
3619 * the modifier style for the widget. This rc style is
3620 * owned by the widget. If you want to keep a pointer to value this
3621 * around, you must add a refcount using g_object_ref().
3622 */
3624 {
3625 // GtkRcStyle* gtk_widget_get_modifier_style (GtkWidget *widget);
3627 }
3629 /**
3630 * Sets the foreground color for a widget in a particular state. All
3631 * other style values are left untouched. See also
3632 * gtk_widget_modify_style().
3633 * widget:
3634 * a GtkWidget.
3635 * state:
3636 * the state for which to set the foreground color.
3637 * color:
3638 * the color to assign (does not need to be allocated),
3639 * or NULL to undo the effect of previous calls to
3640 * of gtk_widget_modify_fg().
3641 */
3643 {
3644 // void gtk_widget_modify_fg (GtkWidget *widget, GtkStateType state, const GdkColor *color);
3646 }
3648 /**
3649 * Sets the background color for a widget in a particular state. All
3650 * other style values are left untouched. See also
3651 * gtk_widget_modify_style().
3652 * Note that "no window" widgets (which have the GTK_NO_WINDOW flag set)
3653 * draw on their parent container's window and thus may not draw any background
3654 * themselves. This is the case for e.g. GtkLabel. To modify the background
3655 * of such widgets, you have to set the background color on their parent; if you want
3656 * to set the background of a rectangular area around a label, try placing the
3657 * label in a GtkEventBox widget and setting the background color on that.
3658 * widget:
3659 * a GtkWidget.
3660 * state:
3661 * the state for which to set the background color.
3662 * color:
3663 * the color to assign (does not need to be allocated),
3664 * or NULL to undo the effect of previous calls to
3665 * of gtk_widget_modify_bg().
3666 */
3668 {
3669 // void gtk_widget_modify_bg (GtkWidget *widget, GtkStateType state, const GdkColor *color);
3671 }
3673 /**
3674 * Sets the text color for a widget in a particular state. All other
3675 * style values are left untouched. The text color is the foreground
3676 * color used along with the base color (see gtk_widget_modify_base())
3677 * for widgets such as GtkEntry and GtkTextView. See also
3678 * gtk_widget_modify_style().
3679 * widget:
3680 * a GtkWidget.
3681 * state:
3682 * the state for which to set the text color.
3683 * color:
3684 * the color to assign (does not need to be allocated),
3685 * or NULL to undo the effect of previous calls to
3686 * of gtk_widget_modify_text().
3687 */
3689 {
3690 // void gtk_widget_modify_text (GtkWidget *widget, GtkStateType state, const GdkColor *color);
3692 }
3694 /**
3695 * Sets the base color for a widget in a particular state.
3696 * All other style values are left untouched. The base color
3697 * is the background color used along with the text color
3698 * (see gtk_widget_modify_text()) for widgets such as GtkEntry
3699 * and GtkTextView. See also gtk_widget_modify_style().
3700 * Note that "no window" widgets (which have the GTK_NO_WINDOW flag set)
3701 * draw on their parent container's window and thus may not draw any background
3702 * themselves. This is the case for e.g. GtkLabel. To modify the background
3703 * of such widgets, you have to set the base color on their parent; if you want
3704 * to set the background of a rectangular area around a label, try placing the
3705 * label in a GtkEventBox widget and setting the base color on that.
3706 * widget:
3707 * a GtkWidget.
3708 * state:
3709 * the state for which to set the base color.
3710 * color:
3711 * the color to assign (does not need to be allocated),
3712 * or NULL to undo the effect of previous calls to
3713 * of gtk_widget_modify_base().
3714 */
3716 {
3717 // void gtk_widget_modify_base (GtkWidget *widget, GtkStateType state, const GdkColor *color);
3719 }
3721 /**
3722 * Sets the font to use for a widget. All other style values are left
3723 * untouched. See also gtk_widget_modify_style().
3724 * widget:
3725 * a GtkWidget
3726 * font_desc:
3727 * the font description to use, or NULL to undo
3728 * the effect of previous calls to gtk_widget_modify_font().
3729 */
3731 {
3732 // void gtk_widget_modify_font (GtkWidget *widget, PangoFontDescription *font_desc);
3733 gtk_widget_modify_font(gtkWidget, (fontDesc is null) ? null : fontDesc.getPgFontDescriptionStruct());
3734 }
3736 /**
3737 * Creates a new PangoContext with the appropriate font map,
3738 * font description, and base direction for drawing text for
3739 * this widget. See also gtk_widget_get_pango_context().
3740 * widget:
3741 * a GtkWidget
3742 * Returns:
3743 * the new PangoContext
3744 */
3746 {
3747 // PangoContext* gtk_widget_create_pango_context (GtkWidget *widget);
3749 }
3751 /**
3752 * Gets a PangoContext with the appropriate font map, font description,
3753 * and base direction for this widget. Unlike the context returned
3754 * by gtk_widget_create_pango_context(), this context is owned by
3755 * the widget (it can be used until the screen for the widget changes
3756 * or the widget is removed from its toplevel), and will be updated to
3757 * match any changes to the widget's attributes.
3758 * If you create and keep a PangoLayout using this context, you must
3759 * deal with changes to the context by calling pango_layout_context_changed()
3760 * on the layout in response to the ::style-set and ::direction-changed signals
3761 * for the widget.
3762 * widget:
3763 * a GtkWidget
3764 * Returns:
3765 * the PangoContext for the widget.
3766 */
3768 {
3769 // PangoContext* gtk_widget_get_pango_context (GtkWidget *widget);
3771 }
3773 /**
3774 * Creates a new PangoLayout with the appropriate font map,
3775 * font description, and base direction for drawing text for
3776 * this widget.
3777 * If you keep a PangoLayout created in this way around, in order to
3778 * notify the layout of changes to the base direction or font of this
3779 * widget, you must call pango_layout_context_changed() in response to
3780 * the ::style-set and ::direction-changed signals for the widget.
3781 * widget:
3782 * a GtkWidget
3783 * text:
3784 * text to set on the layout (can be NULL)
3785 * Returns:
3786 * the new PangoLayout
3787 */
3789 {
3790 // PangoLayout* gtk_widget_create_pango_layout (GtkWidget *widget, const gchar *text);
3792 }
3794 /**
3795 * A convenience function that uses the theme engine and RC file
3796 * settings for widget to look up stock_id and render it to
3797 * a pixbuf. stock_id should be a stock icon ID such as
3798 * GTK_STOCK_OPEN or GTK_STOCK_OK. size should be a size
3799 * such as GTK_ICON_SIZE_MENU. detail should be a string that
3800 * identifies the widget or code doing the rendering, so that
3801 * theme engines can special-case rendering for that widget or code.
3802 * The pixels in the returned GdkPixbuf are shared with the rest of
3803 * the application and should not be modified. The pixbuf should be freed
3804 * after use with g_object_unref().
3805 * widget:
3806 * a GtkWidget
3807 * stock_id:
3808 * a stock ID
3809 * size:
3810 * a stock size. A size of (GtkIconSize)-1 means render at
3811 * the size of the source and don't scale (if there are multiple
3812 * source sizes, GTK+ picks one of the available sizes).
3813 * detail:
3814 * render detail to pass to theme engine
3815 * Returns:
3816 * a new pixbuf, or NULL if the stock ID wasn't known
3817 */
3819 {
3820 // GdkPixbuf* gtk_widget_render_icon (GtkWidget *widget, const gchar *stock_id, GtkIconSize size, const gchar *detail);
3821 return new Pixbuf( gtk_widget_render_icon(gtkWidget, Str.toStringz(stockId), size, Str.toStringz(detail)) );
3822 }
3824 /**
3825 * Cancels the effect of a previous call to gtk_widget_push_composite_child().
3826 */
3828 {
3829 // void gtk_widget_pop_composite_child (void);
3831 }
3833 /**
3834 * Makes all newly-created widgets as composite children until
3835 * the corresponding gtk_widget_pop_composite_child() call.
3836 * A composite child is a child that's an implementation detail of the
3837 * container it's inside and should not be visible to people using the
3838 * container. Composite children aren't treated differently by GTK (but
3839 * see gtk_container_foreach() vs. gtk_container_forall()), but e.g. GUI
3840 * builders might want to treat them in a different way.
3841 * Here is a simple example:
3842 * gtk_widget_push_composite_child ();
3843 * scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
3844 * gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
3845 * gtk_widget_pop_composite_child ();
3846 * gtk_widget_set_parent (scrolled_window->hscrollbar,
3847 * GTK_WIDGET (scrolled_window));
3848 * g_object_ref (scrolled_window->hscrollbar);
3849 */
3851 {
3852 // void gtk_widget_push_composite_child (void);
3854 }
3856 /**
3857 * Warning
3858 * gtk_widget_queue_clear is deprecated and should not be used in newly-written code.
3859 * This function does the same as gtk_widget_queue_draw().
3860 * Deprecated: Use gtk_widget_queue_draw() instead.
3861 * widget:
3862 * a GtkWidget
3863 */
3865 {
3866 // void gtk_widget_queue_clear (GtkWidget *widget);
3868 }
3870 /**
3871 * Warning
3872 * gtk_widget_queue_clear_area is deprecated and should not be used in newly-written code.
3873 * This function is no longer different from
3874 * gtk_widget_queue_draw_area(), though it once was. Now it just calls
3875 * gtk_widget_queue_draw_area(). Originally
3876 * gtk_widget_queue_clear_area() would force a redraw of the
3877 * background for GTK_NO_WINDOW widgets, and
3878 * gtk_widget_queue_draw_area() would not. Now both functions ensure
3879 * the background will be redrawn.
3880 * Deprecated: Use gtk_widget_queue_draw_area() instead.
3881 * widget:
3882 * a GtkWidget
3883 * x:
3884 * x coordinate of upper-left corner of rectangle to redraw
3885 * y:
3886 * y coordinate of upper-left corner of rectangle to redraw
3887 * width:
3888 * width of region to draw
3889 * height:
3890 * height of region to draw
3891 */
3893 {
3894 // void gtk_widget_queue_clear_area (GtkWidget *widget, gint x, gint y, gint width, gint height);
3896 }
3898 /**
3899 * Invalidates the rectangular area of widget defined by x, y,
3900 * width and height by calling gdk_window_invalidate_rect() on the
3901 * widget's window and all its child windows. Once the main loop
3902 * becomes idle (after the current batch of events has been processed,
3903 * roughly), the window will receive expose events for the union of
3904 * all regions that have been invalidated.
3905 * Normally you would only use this function in widget
3906 * implementations. You might also use it, or
3907 * gdk_window_invalidate_rect() directly, to schedule a redraw of a
3908 * GtkDrawingArea or some portion thereof.
3909 * Frequently you can just call gdk_window_invalidate_rect() or
3910 * gdk_window_invalidate_region() instead of this function. Those
3911 * functions will invalidate only a single window, instead of the
3912 * widget and all its children.
3913 * The advantage of adding to the invalidated region compared to
3914 * simply drawing immediately is efficiency; using an invalid region
3915 * ensures that you only have to redraw one time.
3916 * widget:
3917 * a GtkWidget
3918 * x:
3919 * x coordinate of upper-left corner of rectangle to redraw
3920 * y:
3921 * y coordinate of upper-left corner of rectangle to redraw
3922 * width:
3923 * width of region to draw
3924 * height:
3925 * height of region to draw
3926 */
3928 {
3929 // void gtk_widget_queue_draw_area (GtkWidget *widget, gint x, gint y, gint width, gint height);
3931 }
3933 /**
3934 * Recursively resets the shape on this widget and its descendants.
3935 * widget:
3936 * a GtkWidget.
3937 */
3939 {
3940 // void gtk_widget_reset_shapes (GtkWidget *widget);
3942 }
3944 /**
3945 * Sets whether the application intends to draw on the widget in
3946 * an ::expose-event handler.
3947 * This is a hint to the widget and does not affect the behavior of
3948 * the GTK+ core; many widgets ignore this flag entirely. For widgets
3949 * that do pay attention to the flag, such as GtkEventBox and GtkWindow,
3950 * the effect is to suppress default themed drawing of the widget's
3951 * background. (Children of the widget will still be drawn.) The application
3952 * is then entirely responsible for drawing the widget background.
3953 * Note that the background is still drawn when the widget is mapped.
3954 * If this is not suitable (e.g. because you want to make a transparent
3955 * window using an RGBA visual), you can work around this by doing:
3956 * gtk_widget_realize (window);
3957 * gdk_window_set_back_pixmap (window->window, NULL, FALSE);
3958 * gtk_widget_show (window);
3959 * widget:
3960 * a GtkWidget
3961 * app_paintable:
3962 * TRUE if the application will paint on the widget
3963 */
3965 {
3966 // void gtk_widget_set_app_paintable (GtkWidget *widget, gboolean app_paintable);
3968 }
3970 /**
3971 * Widgets are double buffered by default; you can use this function
3972 * to turn off the buffering. "Double buffered" simply means that
3973 * gdk_window_begin_paint_region() and gdk_window_end_paint() are called
3974 * automatically around expose events sent to the
3975 * widget. gdk_window_begin_paint() diverts all drawing to a widget's
3976 * window to an offscreen buffer, and gdk_window_end_paint() draws the
3977 * buffer to the screen. The result is that users see the window
3978 * update in one smooth step, and don't see individual graphics
3979 * primitives being rendered.
3980 * In very simple terms, double buffered widgets don't flicker,
3981 * so you would only use this function to turn off double buffering
3982 * if you had special needs and really knew what you were doing.
3983 * Note: if you turn off double-buffering, you have to handle
3984 * expose events, since even the clearing to the background color or
3985 * pixmap will not happen automatically (as it is done in
3986 * gdk_window_begin_paint()).
3987 * widget:
3988 * a GtkWidget
3989 * double_buffered:
3990 * TRUE to double-buffer a widget
3991 */
3993 {
3994 // void gtk_widget_set_double_buffered (GtkWidget *widget, gboolean double_buffered);
3996 }
3998 /**
3999 * Sets whether the entire widget is queued for drawing when its size
4000 * allocation changes. By default, this setting is TRUE and
4001 * the entire widget is redrawn on every size change. If your widget
4002 * leaves the upper left unchanged when made bigger, turning this
4003 * setting on will improve performance.
4004 * Note that for NO_WINDOW widgets setting this flag to FALSE turns
4005 * off all allocation on resizing: the widget will not even redraw if
4006 * its position changes; this is to allow containers that don't draw
4007 * anything to avoid excess invalidations. If you set this flag on a
4008 * NO_WINDOW widget that does draw on widget->window,
4009 * you are responsible for invalidating both the old and new allocation
4010 * of the widget when the widget is moved and responsible for invalidating
4011 * regions newly when the widget increases size.
4012 * widget:
4013 * a GtkWidget
4014 * redraw_on_allocate:
4015 * if TRUE, the entire widget will be redrawn
4016 * when it is allocated to a new size. Otherwise, only the
4017 * new portion of the widget will be redrawn.
4018 */
4020 {
4021 // void gtk_widget_set_redraw_on_allocate (GtkWidget *widget, gboolean redraw_on_allocate);
4023 }
4025 /**
4026 * Sets a widgets composite name. The widget must be
4027 * a composite child of its parent; see gtk_widget_push_composite_child().
4028 * widget:
4029 * a GtkWidget.
4030 * name:
4031 * the name to set.
4032 */
4034 {
4035 // void gtk_widget_set_composite_name (GtkWidget *widget, const gchar *name);
4037 }
4039 /**
4040 * For widgets that support scrolling, sets the scroll adjustments and
4041 * returns TRUE. For widgets that don't support scrolling, does
4042 * nothing and returns FALSE. Widgets that don't support scrolling
4043 * can be scrolled by placing them in a GtkViewport, which does
4044 * support scrolling.
4045 * widget:
4046 * a GtkWidget
4047 * hadjustment:
4048 * an adjustment for horizontal scrolling, or NULL
4049 * vadjustment:
4050 * an adjustment for vertical scrolling, or NULL
4051 * Returns:
4052 * TRUE if the widget supports scrolling
4053 */
4055 {
4056 // gboolean gtk_widget_set_scroll_adjustments (GtkWidget *widget, GtkAdjustment *hadjustment, GtkAdjustment *vadjustment);
4057 return gtk_widget_set_scroll_adjustments(gtkWidget, (hadjustment is null) ? null : hadjustment.getAdjustmentStruct(), (vadjustment is null) ? null : vadjustment.getAdjustmentStruct());
4058 }
4060 /**
4061 * widget:
4062 * group_cycling:
4063 * Returns:
4064 */
4066 {
4067 // gboolean gtk_widget_mnemonic_activate (GtkWidget *widget, gboolean group_cycling);
4069 }
4071 /**
4072 * Installs a style property on a widget class. The parser for the
4073 * style property is determined by the value type of pspec.
4074 * klass:
4075 * a GtkWidgetClass
4076 * pspec:
4077 * the GParamSpec for the property
4078 */
4080 {
4081 // void gtk_widget_class_install_style_property (GtkWidgetClass *klass, GParamSpec *pspec);
4083 }
4085 /**
4086 * Installs a style property on a widget class.
4087 * klass:
4088 * a GtkWidgetClass
4089 * pspec:
4090 * the GParamSpec for the style property
4091 * parser:
4092 * the parser for the style property
4093 */
4094 public static void classInstallStylePropertyParser(GtkWidgetClass* klass, GParamSpec* pspec, GtkRcPropertyParser parser)
4095 {
4096 // void gtk_widget_class_install_style_property_parser (GtkWidgetClass *klass, GParamSpec *pspec, GtkRcPropertyParser parser);
4098 }
4100 /**
4101 * Finds a style property of a widget class by name.
4102 * klass:
4103 * a GtkWidgetClass
4104 * property_name:
4105 * the name of the style property to find
4106 * Returns:
4107 * the GParamSpec of the style property or NULL if class has no
4108 * style property with that name.
4109 * Since 2.2
4110 */
4112 {
4113 // GParamSpec* gtk_widget_class_find_style_property (GtkWidgetClass *klass, const gchar *property_name);
4115 }
4117 /**
4118 * Returns all style properties of a widget class.
4119 * klass:
4120 * a GtkWidgetClass
4121 * n_properties:
4122 * location to return the number of style properties found
4123 * Returns:
4124 * an newly allocated array of GParamSpec*. The array must be freed with g_free().
4125 * Since 2.2
4126 */
4128 {
4129 // GParamSpec** gtk_widget_class_list_style_properties (GtkWidgetClass *klass, guint *n_properties);
4131 }
4133 /**
4134 * Computes the intersection of a widget's area and region, returning
4135 * the intersection. The result may be empty, use gdk_region_empty() to
4136 * check.
4137 * widget:
4138 * a GtkWidget
4139 * region:
4140 * a GdkRegion, in the same coordinate system as
4141 * widget->allocation. That is, relative to widget->window
4142 * for NO_WINDOW widgets; relative to the parent window
4143 * of widget->window for widgets with their own window.
4144 * Returns:
4145 * A newly allocated region holding the intersection of widget
4146 * and region. The coordinates of the return value are
4147 * relative to widget->window for NO_WINDOW widgets, and
4148 * relative to the parent window of widget->window for
4149 * widgets with their own window.
4150 */
4152 {
4153 // GdkRegion* gtk_widget_region_intersect (GtkWidget *widget, GdkRegion *region);
4154 return new Region( gtk_widget_region_intersect(gtkWidget, (region is null) ? null : region.getRegionStruct()) );
4155 }
4157 /**
4158 * Very rarely-used function. This function is used to emit
4159 * an expose event signals on a widget. This function is not
4160 * normally used directly. The only time it is used is when
4161 * propagating an expose event to a child NO_WINDOW widget, and
4162 * that is normally done using gtk_container_propagate_expose().
4163 * If you want to force an area of a window to be redrawn,
4164 * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
4165 * To cause the redraw to be done immediately, follow that call
4166 * with a call to gdk_window_process_updates().
4167 * widget:
4168 * a GtkWidget
4169 * event:
4170 * a expose GdkEvent
4171 * Returns:
4172 * return from the event signal emission (TRUE if the event was handled)
4173 */
4175 {
4176 // gint gtk_widget_send_expose (GtkWidget *widget, GdkEvent *event);
4178 }
4180 /**
4181 * Gets the values of a multiple style properties of widget.
4182 * widget:
4183 * a GtkWidget
4184 * first_property_name:
4185 * the name of the first property to get
4186 * ...:
4187 * pairs of property names and locations to
4188 * return the property values, starting with the location for
4189 * first_property_name, terminated by NULL.
4190 */
4192 {
4193 // void gtk_widget_style_get (GtkWidget *widget, const gchar *first_property_name, ...);
4195 }
4197 /**
4198 * Gets the value of a style property of widget.
4199 * widget:
4200 * a GtkWidget
4201 * property_name:
4202 * the name of a style property
4203 * value:
4204 * location to return the property value
4205 */
4207 {
4208 // void gtk_widget_style_get_property (GtkWidget *widget, const gchar *property_name, GValue *value);
4209 gtk_widget_style_get_property(gtkWidget, Str.toStringz(propertyName), (value is null) ? null : value.getValueStruct());
4210 }
4212 /**
4213 * Non-vararg variant of gtk_widget_style_get(). Used primarily by language
4214 * bindings.
4215 * widget:
4216 * a GtkWidget
4217 * first_property_name:
4218 * the name of the first property to get
4219 * var_args:
4220 * a va_list of pairs of property names and
4221 * locations to return the property values, starting with the location
4222 * for first_property_name.
4223 */
4225 {
4226 // void gtk_widget_style_get_valist (GtkWidget *widget, const gchar *first_property_name, va_list var_args);
4228 }
4230 /**
4231 * Returns the accessible object that describes the widget to an
4232 * assistive technology.
4233 * If no accessibility library is loaded (i.e. no ATK implementation library is
4234 * loaded via GTK_MODULES or via another application library,
4235 * such as libgnome), then this AtkObject instance may be a no-op. Likewise,
4236 * if no class-specific AtkObject implementation is available for the widget
4237 * instance in question, it will inherit an AtkObject implementation from the
4238 * first ancestor class for which such an implementation is defined.
4239 * The documentation of the ATK
4240 * library contains more information about accessible objects and their uses.
4241 * widget:
4242 * a GtkWidget
4243 * Returns:
4244 * the AtkObject associated with widget
4245 */
4247 {
4248 // AtkObject* gtk_widget_get_accessible (GtkWidget *widget);
4250 }
4252 /**
4253 * This function is used by custom widget implementations; if you're
4254 * writing an app, you'd use gtk_widget_grab_focus() to move the focus
4255 * to a particular widget, and gtk_container_set_focus_chain() to
4256 * change the focus tab order. So you may want to investigate those
4257 * functions instead.
4258 * gtk_widget_child_focus() is called by containers as the user moves
4259 * around the window using keyboard shortcuts. direction indicates
4260 * what kind of motion is taking place (up, down, left, right, tab
4261 * forward, tab backward). gtk_widget_child_focus() invokes the
4262 * "focus" signal on GtkWidget; widgets override the default handler
4263 * for this signal in order to implement appropriate focus behavior.
4264 * The "focus" default handler for a widget should return TRUE if
4265 * moving in direction left the focus on a focusable location inside
4266 * that widget, and FALSE if moving in direction moved the focus
4267 * outside the widget. If returning TRUE, widgets normally
4268 * call gtk_widget_grab_focus() to place the focus accordingly;
4269 * if returning FALSE, they don't modify the current focus location.
4270 * This function replaces gtk_container_focus() from GTK+ 1.2. It was
4271 * necessary to check that the child was visible, sensitive, and
4272 * focusable before calling
4273 * gtk_container_focus(). gtk_widget_child_focus() returns FALSE if
4274 * the widget is not currently in a focusable state, so there's no
4275 * need for those checks.
4276 * widget:
4277 * a GtkWidget
4278 * direction:
4279 * direction of focus movement
4280 * Returns:
4281 * TRUE if focus ended up inside widget
4282 */
4284 {
4285 // gboolean gtk_widget_child_focus (GtkWidget *widget, GtkDirectionType direction);
4287 }
4289 /**
4290 * Emits a "child-notify" signal for the
4291 * child property child_property
4292 * on widget.
4293 * This is the analogue of g_object_notify() for child properties.
4294 * widget:
4295 * a GtkWidget
4296 * child_property:
4297 * the name of a child property installed on the
4298 * class of widget's parent.
4299 */
4301 {
4302 // void gtk_widget_child_notify (GtkWidget *widget, const gchar *child_property);
4304 }
4306 /**
4307 * Stops emission of "child-notify" signals on widget. The signals are
4308 * queued until gtk_widget_thaw_child_notify() is called on widget.
4309 * This is the analogue of g_object_freeze_notify() for child properties.
4310 * widget:
4311 * a GtkWidget
4312 */
4314 {
4315 // void gtk_widget_freeze_child_notify (GtkWidget *widget);
4317 }
4319 /**
4320 * Gets the value set with gtk_widget_set_child_visible().
4321 * If you feel a need to use this function, your code probably
4322 * needs reorganization.
4323 * This function is only useful for container implementations and
4324 * never should be called by an application.
4325 * widget:
4326 * a GtkWidget
4327 * Returns:
4328 * TRUE if the widget is mapped with the parent.
4329 */
4331 {
4332 // gboolean gtk_widget_get_child_visible (GtkWidget *widget);
4334 }
4336 /**
4337 * Returns the parent container of widget.
4338 * widget:
4339 * a GtkWidget
4340 * Returns:
4341 * the parent container of widget, or NULL
4342 */
4344 {
4345 // GtkWidget* gtk_widget_get_parent (GtkWidget *widget);
4347 }
4349 /**
4350 * Gets the settings object holding the settings (global property
4351 * settings, RC file information, etc) used for this widget.
4352 * Note that this function can only be called when the GtkWidget
4353 * is attached to a toplevel, since the settings object is specific
4354 * to a particular GdkScreen.
4355 * widget:
4356 * a GtkWidget
4357 * Returns:
4358 * the relevant GtkSettings object
4359 */
4361 {
4362 // GtkSettings* gtk_widget_get_settings (GtkWidget *widget);
4364 }
4366 /**
4367 * Returns the clipboard object for the given selection to
4368 * be used with widget. widget must have a GdkDisplay
4369 * associated with it, so must be attached to a toplevel
4370 * window.
4371 * widget:
4372 * a GtkWidget
4373 * selection:
4374 * a GdkAtom which identifies the clipboard
4375 * to use. GDK_SELECTION_CLIPBOARD gives the
4376 * default clipboard. Another common value
4377 * is GDK_SELECTION_PRIMARY, which gives
4378 * the primary X selection.
4379 * Returns:
4380 * the appropriate clipboard object. If no
4381 * clipboard already exists, a new one will
4382 * be created. Once a clipboard object has
4383 * been created, it is persistent for all time.
4384 * Since 2.2
4385 */
4387 {
4388 // GtkClipboard* gtk_widget_get_clipboard (GtkWidget *widget, GdkAtom selection);
4390 }
4392 /**
4393 * Get the GdkDisplay for the toplevel window associated with
4394 * this widget. This function can only be called after the widget
4395 * has been added to a widget hierarchy with a GtkWindow at the top.
4396 * In general, you should only create display specific
4397 * resources when a widget has been realized, and you should
4398 * free those resources when the widget is unrealized.
4399 * widget:
4400 * a GtkWidget
4401 * Returns:
4402 * the GdkDisplay for the toplevel for this widget.
4403 * Since 2.2
4404 */
4406 {
4407 // GdkDisplay* gtk_widget_get_display (GtkWidget *widget);
4409 }
4411 /**
4412 * Get the root window where this widget is located. This function can
4413 * only be called after the widget has been added to a widget
4414 * heirarchy with GtkWindow at the top.
4415 * The root window is useful for such purposes as creating a popup
4416 * GdkWindow associated with the window. In general, you should only
4417 * create display specific resources when a widget has been realized,
4418 * and you should free those resources when the widget is unrealized.
4419 * widget:
4420 * a GtkWidget
4421 * Returns:
4422 * the GdkWindow root window for the toplevel for this widget.
4423 * Since 2.2
4424 */
4426 {
4427 // GdkWindow* gtk_widget_get_root_window (GtkWidget *widget);
4429 }
4431 /**
4432 * Get the GdkScreen from the toplevel window associated with
4433 * this widget. This function can only be called after the widget
4434 * has been added to a widget hierarchy with a GtkWindow
4435 * at the top.
4436 * In general, you should only create screen specific
4437 * resources when a widget has been realized, and you should
4438 * free those resources when the widget is unrealized.
4439 * widget:
4440 * a GtkWidget
4441 * Returns:
4442 * the GdkScreen for the toplevel for this widget.
4443 * Since 2.2
4444 */
4446 {
4447 // GdkScreen* gtk_widget_get_screen (GtkWidget *widget);
4449 }
4451 /**
4452 * Checks whether there is a GdkScreen is associated with
4453 * this widget. All toplevel widgets have an associated
4454 * screen, and all widgets added into a heirarchy with a toplevel
4455 * window at the top.
4456 * widget:
4457 * a GtkWidget
4458 * Returns:
4459 * TRUE if there is a GdkScreen associcated
4460 * with the widget.
4461 * Since 2.2
4462 */
4464 {
4465 // gboolean gtk_widget_has_screen (GtkWidget *widget);
4467 }
4469 /**
4470 * Gets the size request that was explicitly set for the widget using
4471 * gtk_widget_set_size_request(). A value of -1 stored in width or
4472 * height indicates that that dimension has not been set explicitly
4473 * and the natural requisition of the widget will be used intead. See
4474 * gtk_widget_set_size_request(). To get the size a widget will
4475 * actually use, call gtk_widget_size_request() instead of
4476 * this function.
4477 * widget:
4478 * a GtkWidget
4479 * width:
4480 * return location for width, or NULL
4481 * height:
4482 * return location for height, or NULL
4483 */
4485 {
4486 // void gtk_widget_get_size_request (GtkWidget *widget, gint *width, gint *height);
4488 }
4492 /**
4493 * Sets whether widget should be mapped along with its when its parent
4494 * is mapped and widget has been shown with gtk_widget_show().
4495 * The child visibility can be set for widget before it is added to
4496 * a container with gtk_widget_set_parent(), to avoid mapping
4497 * children unnecessary before immediately unmapping them. However
4498 * it will be reset to its default state of TRUE when the widget
4499 * is removed from a container.
4500 * Note that changing the child visibility of a widget does not
4501 * queue a resize on the widget. Most of the time, the size of
4502 * a widget is computed from all visible children, whether or
4503 * not they are mapped. If this is not the case, the container
4504 * can queue a resize itself.
4505 * This function is only useful for container implementations and
4506 * never should be called by an application.
4507 * widget:
4508 * a GtkWidget
4509 * is_visible:
4510 * if TRUE, widget should be mapped along with its parent.
4511 */
4513 {
4514 // void gtk_widget_set_child_visible (GtkWidget *widget, gboolean is_visible);
4516 }
4519 /**
4520 * Sets the minimum size of a widget; that is, the widget's size
4521 * request will be width by height. You can use this function to
4522 * force a widget to be either larger or smaller than it normally
4523 * would be.
4524 * In most cases, gtk_window_set_default_size() is a better choice for
4525 * toplevel windows than this function; setting the default size will
4526 * still allow users to shrink the window. Setting the size request
4527 * will force them to leave the window at least as large as the size
4528 * request. When dealing with window sizes,
4529 * gtk_window_set_geometry_hints() can be a useful function as well.
4530 * Note the inherent danger of setting any fixed size - themes,
4531 * translations into other languages, different fonts, and user action
4532 * can all change the appropriate size for a given widget. So, it's
4533 * basically impossible to hardcode a size that will always be
4534 * correct.
4535 * The size request of a widget is the smallest size a widget can
4536 * accept while still functioning well and drawing itself correctly.
4537 * However in some strange cases a widget may be allocated less than
4538 * its requested size, and in many cases a widget may be allocated more
4539 * space than it requested.
4540 * If the size request in a given direction is -1 (unset), then
4541 * the "natural" size request of the widget will be used instead.
4542 * Widgets can't actually be allocated a size less than 1 by 1, but
4543 * you can pass 0,0 to this function to mean "as small as possible."
4544 * widget:
4545 * a GtkWidget
4546 * width:
4547 * width widget should request, or -1 to unset
4548 * height:
4549 * height widget should request, or -1 to unset
4550 */
4552 {
4553 // void gtk_widget_set_size_request (GtkWidget *widget, gint width, gint height);
4555 }
4558 /**
4559 * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
4560 * This causes all queued "child-notify" signals on widget to be emitted.
4561 * widget:
4562 * a GtkWidget
4563 */
4565 {
4566 // void gtk_widget_thaw_child_notify (GtkWidget *widget);
4568 }
4570 /**
4571 * Sets the "no_show_all" property, which determines whether calls to
4572 * gtk_widget_show_all() and gtk_widget_hide_all() will affect this widget.
4573 * This is mostly for use in constructing widget hierarchies with externally
4574 * controlled visibility, see GtkUIManager.
4575 * widget:
4576 * a GtkWidget
4577 * no_show_all:
4578 * the new value for the "no_show_all" property
4579 * Since 2.4
4580 */
4582 {
4583 // void gtk_widget_set_no_show_all (GtkWidget *widget, gboolean no_show_all);
4585 }
4587 /**
4588 * Returns the current value of the "no_show_all" property, which determines
4589 * whether calls to gtk_widget_show_all() and gtk_widget_hide_all()
4590 * will affect this widget.
4591 * widget:
4592 * a GtkWidget
4593 * Returns:
4594 * the current value of the "no_show_all" property.
4595 * Since 2.4
4596 */
4598 {
4599 // gboolean gtk_widget_get_no_show_all (GtkWidget *widget);
4601 }
4603 /**
4604 * Returns a newly allocated list of the widgets, normally labels, for
4605 * which this widget is a the target of a mnemonic (see for example,
4606 * gtk_label_set_mnemonic_widget()).
4607 * The widgets in the list are not individually referenced. If you
4608 * want to iterate through the list and perform actions involving
4609 * callbacks that might destroy the widgets, you
4610 * must call g_list_foreach (result,
4611 * (GFunc)g_object_ref, NULL) first, and then unref all the
4612 * widgets afterwards.
4613 * widget:
4614 * a GtkWidget
4615 * Returns:
4616 * the list of mnemonic labels; free this list
4617 * with g_list_free() when you are done with it.
4618 * Since 2.4
4619 */
4621 {
4622 // GList* gtk_widget_list_mnemonic_labels (GtkWidget *widget);
4624 }
4626 /**
4627 * Adds a widget to the list of mnemonic labels for
4628 * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
4629 * list of mnemonic labels for the widget is cleared when the
4630 * widget is destroyed, so the caller must make sure to update
4631 * its internal state at this point as well, by using a connection
4632 * to the ::destroy signal or a weak notifier.
4633 * widget:
4634 * a GtkWidget
4635 * label:
4636 * a GtkWidget that acts as a mnemonic label for widget.
4637 * Since 2.4
4638 */
4640 {
4641 // void gtk_widget_add_mnemonic_label (GtkWidget *widget, GtkWidget *label);
4643 }
4645 /**
4646 * Removes a widget from the list of mnemonic labels for
4647 * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
4648 * must have previously been added to the list with
4649 * gtk_widget_add_mnemonic_label().
4650 * widget:
4651 * a GtkWidget
4652 * label:
4653 * a GtkWidget that was previously set as a mnemnic label for
4654 * widget with gtk_widget_add_mnemonic_label().
4655 * Since 2.4
4656 */
4658 {
4659 // void gtk_widget_remove_mnemonic_label (GtkWidget *widget, GtkWidget *label);
4661 }
4663 /**
4664 * Returns the GtkAction that widget is a proxy for.
4665 * See also gtk_action_get_proxies().
4666 * widget:
4667 * a GtkWidget
4668 * Returns:
4669 * the action that a widget is a proxy for, or
4670 * NULL, if it is not attached to an action.
4671 * Since 2.10
4672 */
4674 {
4675 // GtkAction* gtk_widget_get_action (GtkWidget *widget);
4677 }
4679 /**
4680 * Whether widget can rely on having its alpha channel
4681 * drawn correctly. On X11 this function returns whether a
4682 * compositing manager is running for widget's screen
4683 * widget:
4684 * a GtkWidget
4685 * Returns:
4686 * TRUE if the widget can rely on its alpha
4687 * channel being drawn correctly.
4688 * Since 2.10
4689 */
4691 {
4692 // gboolean gtk_widget_is_composited (GtkWidget *widget);
4694 }
4696 /**
4697 * Notifies the user about an input-related error on this widget. If
4698 * the gtk-error-bell settings property is TRUE, it calls
4699 * gdk_window_beep(), otherwise it does nothing.
4700 * Note that the effect of gdk_window_beep() can be configured in many
4701 * ways, depending on the windowing backend and the desktop environment
4702 * or window manager that is used.
4703 * widget:
4704 * a GtkWidget
4705 * Since 2.12
4706 */
4708 {
4709 // void gtk_widget_error_bell (GtkWidget *widget);
4711 }
4713 /**
4714 * This function should be called whenever keyboard navigation within
4715 * a single widget hits a boundary. The function emits the
4716 * "keynav-changed" signal on the widget and its return value should
4717 * be interpreted in a way similar to the return value of
4718 * gtk_widget_child_focus():
4719 * When TRUE is returned, stay in the widget, the failed keyboard
4720 * navigation is Ok and/or there is nowhere we can/should move the
4721 * focus to.
4722 * When FALSE is returned, the caller should continue with keyboard
4723 * navigation outside the widget, e.g. by calling
4724 * gtk_widget_child_focus() on the widget's toplevel.
4725 * The default implementation for the "keynav-failed" signal is to
4726 * return TRUE for GTK_DIR_TAB_FORWARD and
4727 * GTK_DIR_TAB_BACKWARD. For the other values of GtkDirectionType,
4728 * it looks at the "gtk-keynav-cursor-only" settings property and
4729 * returns FALSE if the setting is TRUE. This way the entire GUI
4730 * becomes cursor-navigatable on input devices such as mobile phones
4731 * which only have cursor keys but no tab key.
4732 * Whenever the default implementation returns TRUE, it also calls
4733 * gtk_widget_error_bell() to notify the user of the failed keyboard
4734 * navigation.
4735 * A use case for providing an own implementation of keynav-failed (by
4736 * either connecting to it or by overriding it) would be a row of
4737 * GtkEntry widgets where the user should be able to navigate the
4738 * entire row with the cursor keys, as e.g. known from GUIs that
4739 * require entering license keys.
4740 * widget:
4741 * a GtkWidget
4742 * direction:
4743 * direction of focus movement
4744 * Returns:
4745 * TRUE if stopping keyboard navigation is fine, FALSE
4746 * if the emitting widget should try to handle the keyboard
4747 * navigation attempt in its parent container(s).
4748 * Since 2.12
4749 */
4751 {
4752 // gboolean gtk_widget_keynav_failed (GtkWidget *widget, GtkDirectionType direction);
4754 }
4756 /**
4757 * Copies a GtkRequisition.
4758 * requisition:
4759 * a GtkRequisition.
4760 * Returns:
4761 * a copy of requisition.
4762 */
4764 {
4765 // GtkRequisition* gtk_requisition_copy (const GtkRequisition *requisition);
4767 }
4769 /**
4770 * Frees a GtkRequisition.
4771 * requisition:
4772 * a GtkRequisition.
4773 * Property Details
4774 * The "app-paintable" property
4775 * "app-paintable" gboolean : Read / Write
4776 * Whether the application will paint directly on the widget.
4777 * Default value: FALSE
4778 */
4780 {
4781 // void gtk_requisition_free (GtkRequisition *requisition);
4783 }
4882 }