Mercurial > projects > dwt-linux

comparison dwt/internal/gtk/c/gtktypes.d @ 15:758bbbe4b86a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Fixup gtk bindings; OS.d updates
author John Reimer<terminal.node@gmail.com>
date Sun, 06 Jan 2008 13:35:33 -0800
parents 5f725d09c076
children 09f5459a5014
comparison
equal deleted inserted replaced
11:5f725d09c076 15:758bbbe4b86a
31 /****************************************************************************** 31 /******************************************************************************
32 32
33 ******************************************************************************/ 33 ******************************************************************************/
34 34
35 alias void GtkAccelGroupEntry; 35 alias void GtkAccelGroupEntry;
36 alias void GtkContainerClass; 36
37 // GtkContainerClass Needed by dwt macros - JJR
38 struct GtkContainerClass
39 {
40 GtkWidgetClass parent_class;
41
42 void (*add) (GtkContainer *container,
43 GtkWidget *widget);
44 void (*remove) (GtkContainer *container,
45 GtkWidget *widget);
46 void (*check_resize) (GtkContainer *container);
47 void (*forall) (GtkContainer *container,
48 gboolean include_internals,
49 GtkCallback callback,
50 gpointer callback_data);
51 void (*set_focus_child) (GtkContainer *container,
52 GtkWidget *widget);
53 GType (*child_type) (GtkContainer *container);
54 gchar* (*composite_name) (GtkContainer *container,
55 GtkWidget *child);
56 void (*set_child_property) (GtkContainer *container,
57 GtkWidget *child,
58 guint property_id,
59 GValue *value,
60 GParamSpec *pspec);
61 void (*get_child_property) (GtkContainer *container,
62 GtkWidget *child,
63 guint property_id,
64 GValue *value,
65 GParamSpec *pspec);
66
67 /* Padding for future expansion */
68 void (*_gtk_reserved1) ();
69 void (*_gtk_reserved2) ();
70 void (*_gtk_reserved3) ();
71 void (*_gtk_reserved4) ();
72 }
37 73
38 //alias GTokenType.G_TOKEN_LAST G_TOKEN_LAST;"; 74 //alias GTokenType.G_TOKEN_LAST G_TOKEN_LAST;";
39 //alias GtkSignalRunType.G_SIGNAL_RUN_FIRST G_SIGNAL_RUN_FIRST; 75 //alias GtkSignalRunType.G_SIGNAL_RUN_FIRST G_SIGNAL_RUN_FIRST;
40 //alias GtkSignalRunType.G_SIGNAL_RUN_LAST G_SIGNAL_RUN_LAST; 76 //alias GtkSignalRunType.G_SIGNAL_RUN_LAST G_SIGNAL_RUN_LAST;
41 //alias GtkSignalRunType.G_SIGNAL_NO_RECURSE G_SIGNAL_NO_RECURSE; 77 //alias GtkSignalRunType.G_SIGNAL_NO_RECURSE G_SIGNAL_NO_RECURSE;
2458 /** 2494 /**
2459 * Main Gtk struct. 2495 * Main Gtk struct.
2460 * The GtkAccelLabel struct contains private data only, and 2496 * The GtkAccelLabel struct contains private data only, and
2461 * should be accessed using the functions below. 2497 * should be accessed using the functions below.
2462 */ 2498 */
2463 public struct GtkAccelLabel{} 2499 public struct GtkAccelLabel
2500 {
2501 GtkLabel label;
2502
2503 guint gtk_reserved;
2504 guint accel_padding;
2505 GtkWidget *accel_widget;
2506 GClosure *accel_closure;
2507 GtkAccelGroup *accel_group;
2508 gchar *accel_string;
2509 guint16 accel_string_width;
2510 }
2464 2511
2465 2512
2466 /** 2513 /**
2467 * Main Gtk struct. 2514 * Main Gtk struct.
2468 * This struct contain private data only and should be accessed by the functions 2515 * This struct contain private data only and should be accessed by the functions
2552 2599
2553 /** 2600 /**
2554 * Main Gtk struct. 2601 * Main Gtk struct.
2555 * The GtkEntry struct contains only private data. 2602 * The GtkEntry struct contains only private data.
2556 */ 2603 */
2557 public struct GtkEntry{} 2604 public struct GtkEntry
2605 {
2606 GtkWidget widget;
2607
2608 gchar *text;
2609 guint flags;
2610
2611 // guint editable : 1;
2612 // guint visible : 1;
2613 // guint overwrite_mode : 1;
2614 // guint in_drag : 1; /* Dragging within the selection */
2615
2616 guint16 text_length; /* length in use, in chars */
2617 guint16 text_max_length;
2618
2619 /*< private >*/
2620 GdkWindow *text_area;
2621 GtkIMContext *im_context;
2622 GtkWidget *popup_menu;
2623
2624 gint current_pos;
2625 gint selection_bound;
2626
2627 PangoLayout *cached_layout;
2628
2629 guint flags2;
2630 // guint cache_includes_preedit : 1;
2631 // guint need_im_reset : 1;
2632 // guint has_frame : 1;
2633 // guint activates_default : 1;
2634 // guint cursor_visible : 1;
2635 // guint in_click : 1; /* Flag so we don't select all when clicking in entry to focus in */
2636 // guint is_cell_renderer : 1;
2637 // guint editing_canceled : 1; /* Only used by GtkCellRendererText */
2638 // guint mouse_cursor_obscured : 1;
2639 // guint select_words : 1;
2640 // guint select_lines : 1;
2641 // guint resolved_dir : 4; /* PangoDirection */
2642 // guint truncate_multiline : 1;
2643
2644 guint button;
2645 guint blink_timeout;
2646 guint recompute_idle;
2647 gint scroll_offset;
2648 gint ascent; /* font ascent, in pango units */
2649 gint descent; /* font descent, in pango units */
2650
2651 guint16 text_size; /* allocated size, in bytes */
2652 guint16 n_bytes; /* length in use, in bytes */
2653
2654 guint16 preedit_length; /* length of preedit string, in bytes */
2655 guint16 preedit_cursor; /* offset of cursor within preedit string, in chars */
2656
2657 gint dnd_position; /* In chars, -1 == no DND cursor */
2658
2659 gint drag_start_x;
2660 gint drag_start_y;
2661
2662 gunichar invisible_char;
2663
2664 gint width_chars;
2665 }
2558 2666
2559 2667
2560 /** 2668 /**
2561 * Main Gtk struct. 2669 * Main Gtk struct.
2562 * The GtkEntryCompletion struct contains only private data. 2670 * The GtkEntryCompletion struct contains only private data.
2752 2860
2753 2861
2754 /** 2862 /**
2755 * Main Gtk struct. 2863 * Main Gtk struct.
2756 */ 2864 */
2757 public struct GtkTextView{} 2865 public struct GtkTextView
2866 {
2867 GtkContainer parent_instance;
2868
2869 // GtkTextLayout *layout;
2870 void *layout;
2871 GtkTextBuffer *buffer;
2872
2873 guint selection_drag_handler;
2874 guint scroll_timeout;
2875
2876 /* Default style settings */
2877 gint pixels_above_lines;
2878 gint pixels_below_lines;
2879 gint pixels_inside_wrap;
2880 GtkWrapMode wrap_mode;
2881 GtkJustification justify;
2882 gint left_margin;
2883 gint right_margin;
2884 gint indent;
2885 PangoTabArray *tabs;
2886 guint flags;
2887 // guint editable : 1;
2888 // guint overwrite_mode : 1;
2889 // guint cursor_visible : 1;
2890
2891 /* if we have reset the IM since the last character entered */
2892 // guint need_im_reset : 1;
2893 // guint accepts_tab : 1;
2894 // guint width_changed : 1;
2895
2896 /* debug flag - means that we've validated onscreen since the
2897 * last "invalidate" signal from the layout
2898 */
2899 // guint onscreen_validated : 1;
2900 // guint mouse_cursor_obscured : 1;
2901
2902 // changed next five declarations to void* from GtkTextWindow*
2903 void *text_window;
2904 void *left_window;
2905 void *right_window;
2906 void *top_window;
2907 void *bottom_window;
2908
2909 GtkAdjustment *hadjustment;
2910 GtkAdjustment *vadjustment;
2911
2912 gint xoffset; /* Offsets between widget coordinates and buffer coordinates */
2913 gint yoffset;
2914 gint width; /* Width and height of the buffer */
2915 gint height;
2916
2917 /* The virtual cursor position is normally the same as the
2918 * actual (strong) cursor position, except in two circumstances:
2919 *
2920 * a) When the cursor is moved vertically with the keyboard
2921 * b) When the text view is scrolled with the keyboard
2922 *
2923 * In case a), virtual_cursor_x is preserved, but not virtual_cursor_y
2924 * In case b), both virtual_cursor_x and virtual_cursor_y are preserved.
2925 */
2926 gint virtual_cursor_x; /* -1 means use actual cursor position */
2927 gint virtual_cursor_y; /* -1 means use actual cursor position */
2928
2929 GtkTextMark *first_para_mark; /* Mark at the beginning of the first onscreen paragraph */
2930 gint first_para_pixels; /* Offset of top of screen in the first onscreen paragraph */
2931
2932 GtkTextMark *dnd_mark;
2933 guint blink_timeout;
2934
2935 guint first_validate_idle; /* Idle to revalidate onscreen portion, runs before resize */
2936 guint incremental_validate_idle; /* Idle to revalidate offscreen portions, runs after redraw */
2937
2938 GtkIMContext *im_context;
2939 GtkWidget *popup_menu;
2940
2941 gint drag_start_x;
2942 gint drag_start_y;
2943
2944 GSList *children;
2945 // changed next to void* from GtkTextPendingScroll* - JJR
2946 void *pending_scroll;
2947
2948 gint pending_place_cursor_button;
2949 }
2950
2758 2951
2759 2952
2760 /** 2953 /**
2761 * A GtkTextChildAnchor is a spot in the buffer 2954 * A GtkTextChildAnchor is a spot in the buffer
2762 * where child widgets can be "anchored" (inserted inline, as if they were 2955 * where child widgets can be "anchored" (inserted inline, as if they were
3895 /** 4088 /**
3896 * Main Gtk struct. 4089 * Main Gtk struct.
3897 * There are no public fields in the GtkScrolledWindow struct; it should 4090 * There are no public fields in the GtkScrolledWindow struct; it should
3898 * only be accessed using the functions below. 4091 * only be accessed using the functions below.
3899 */ 4092 */
3900 public struct GtkScrolledWindow{} 4093 public struct GtkScrolledWindow
3901 // GtkWidget *hscrollbar; 4094 {
3902 // GtkScrolledWindow.html 4095 GtkBin container;
3903 // GtkWidget *vscrollbar; 4096
3904 // GtkScrolledWindow.html 4097 /*< public >*/
3905 4098 GtkWidget *hscrollbar;
4099 GtkWidget *vscrollbar;
4100
4101 /*< private >*/
4102 guint flags;
4103 // guint hscrollbar_policy : 2;
4104 // guint vscrollbar_policy : 2;
4105 // guint hscrollbar_visible : 1;
4106 // guint vscrollbar_visible : 1;
4107 // guint window_placement : 2;
4108 // guint focus_out : 1;
4109
4110 guint16 shadow_type;
4111 }
4112
4113
4114 public struct GtkBinClass
4115 {
4116 GtkContainerClass parent_class;
4117 }
4118
4119 // GtkScrolledWindowClass is accessed by dwt macros :p - JJR
4120
4121 public struct GtkScrolledWindowClass
4122 {
4123 GtkBinClass parent_class;
4124
4125 gint scrollbar_spacing;
4126
4127 /* Action signals for keybindings. Do not connect to these signals
4128 */
4129
4130 /* Unfortunately, GtkScrollType is deficient in that there is
4131 * no horizontal/vertical variants for GTK_SCROLL_START/END,
4132 * so we have to add an additional boolean flag.
4133 */
4134 gboolean (*scroll_child) (GtkScrolledWindow *scrolled_window,
4135 GtkScrollType scroll,
4136 gboolean horizontal);
4137
4138 void (* move_focus_out) (GtkScrolledWindow *scrolled_window,
4139 GtkDirectionType direction);
4140
4141 /* Padding for future expansion */
4142 void (*_gtk_reserved1) ();
4143 void (*_gtk_reserved2) ();
4144 void (*_gtk_reserved3) ();
4145 void (*_gtk_reserved4) ();
4146 }
3906 4147
3907 /** 4148 /**
3908 * Main Gtk struct. 4149 * Main Gtk struct.
3909 */ 4150 */
3910 public struct GtkPrintOperation{} 4151 public struct GtkPrintOperation{}
4164 4405
4165 4406
4166 /** 4407 /**
4167 * Main Gtk struct. 4408 * Main Gtk struct.
4168 */ 4409 */
4169 public struct GtkContainer{} 4410 public struct GtkContainer
4411 {
4412 GtkWidget widget;
4413
4414 GtkWidget *focus_child;
4415
4416 guint flags;
4417 // guint border_width : 16;
4418
4419 /*< private >*/
4420 // guint need_resize : 1;
4421 // guint resize_mode : 2;
4422 // guint reallocate_redraws : 1;
4423 // guint has_focus_chain : 1;
4424 }
4170 4425
4171 4426
4172 /** 4427 /**
4173 * Main Gtk struct. 4428 * Main Gtk struct.
4174 * The GtkItem struct contains private data only, and 4429 * The GtkItem struct contains private data only, and
4209 4464
4210 /** 4465 /**
4211 * Main Gtk struct. 4466 * Main Gtk struct.
4212 * The object itself. You should never use these members directly - 4467 * The object itself. You should never use these members directly -
4213 */ 4468 */
4214 public struct GtkObject{} 4469
4470 public struct GtkObject
4471 {
4472 GInitiallyUnowned parent_instance;
4473
4474 /* 32 bits of flags. GtkObject only uses 4 of these bits and
4475 * GtkWidget uses the rest. This is done because structs are
4476 * aligned on 4 or 8 byte boundaries. If a new bitfield were
4477 * used in GtkWidget much space would be wasted.
4478 */
4479 guint32 flags;
4480 }
4215 4481
4216 4482
4217 /** 4483 /**
4218 * Main Gtk struct. 4484 * Main Gtk struct.
4219 */ 4485 */
4260 /** 4526 /**
4261 * Main Gtk struct. 4527 * Main Gtk struct.
4262 * GtkStyle*style; 4528 * GtkStyle*style;
4263 * The style for the widget. The style contains the colors the widget should be 4529 * The style for the widget. The style contains the colors the widget should be
4264 */ 4530 */
4265 public struct GtkWidget{} 4531 public struct GtkWidget
4532 {
4533 GtkObject object;
4534 guint16 private_flags;
4535 guint8 state;
4536 guint8 saved_state;
4537 gchar* name;
4538
4539 /*< public >*/
4540
4541 /* The style for the widget. The style contains the
4542 * colors the widget should be drawn in for each state
4543 * along with graphics contexts used to draw with and
4544 * the font to use for text.
4545 */
4546 GtkStyle *style;
4547
4548 /* The widget's desired size.
4549 */
4550 GtkRequisition requisition;
4551
4552 /* The widget's allocated size.
4553 */
4554 GtkAllocation allocation;
4555
4556 /* The widget's window or its parent window if it does
4557 * not have a window. (Which will be indicated by the
4558 * GTK_NO_WINDOW flag being set).
4559 */
4560 GdkWindow *window;
4561
4562 /* The widget's parent.
4563 */
4564 GtkWidget *parent;
4565 }
4266 // /+* The style for the widget. The style contains the 4566 // /+* The style for the widget. The style contains the
4267 // GtkWidget.html 4567 // GtkWidget.html
4268 // * colors the widget should be drawn inn for each state 4568 // * colors the widget should be drawn inn for each state
4269 // GtkWidget.html 4569 // GtkWidget.html
4270 // * along with graphics contexts used to draw with and 4570 // * along with graphics contexts used to draw with and
4314 * This signal is emitted when a widget of this class is added 4614 * This signal is emitted when a widget of this class is added
4315 * to a scrolling aware parent, gtk_widget_set_scroll_adjustments() 4615 * to a scrolling aware parent, gtk_widget_set_scroll_adjustments()
4316 * handles the emission. 4616 * handles the emission.
4317 * Implementation of this signal is optional. 4617 * Implementation of this signal is optional.
4318 */ 4618 */
4319 public struct GtkWidgetClass{} 4619 struct GtkObjectClass
4320 // /+* The object class structure needs to be the first 4620 {
4321 // GtkWidget.html 4621 GInitiallyUnownedClass parent_class;
4322 // * element inn the widget class structure inn order for 4622
4323 // GtkWidget.html 4623 /* Non overridable class methods to set and get per class arguments */
4324 // * the class mechanism to work correctly. This allows a 4624 void (*set_arg) (GtkObject *object,
4325 // GtkWidget.html 4625 GtkArg *arg,
4326 // * GtkWidgetClass pointer to be cast to a GtkObjectClass 4626 guint arg_id);
4327 // GtkWidget.html 4627 void (*get_arg) (GtkObject *object,
4328 // * pointer. 4628 GtkArg *arg,
4329 // GtkWidget.html 4629 guint arg_id);
4330 // +/ 4630
4331 // GtkWidget.html 4631 /* Default signal handler for the ::destroy signal, which is
4332 // GtkObjectClass parentClass; 4632 * invoked to request that references to the widget be dropped.
4333 // GtkWidget.html 4633 * If an object class overrides destroy() in order to perform class
4334 // uint activateSignal; 4634 * specific destruction then it must still invoke its superclass'
4335 // GtkWidget.html 4635 * implementation of the method after it is finished with its
4336 // uint setScrollAdjustmentsSignal; 4636 * own cleanup. (See gtk_widget_real_destroy() for an example of
4337 // GtkWidget.html 4637 * how to do this).
4338 4638 */
4639 void (*destroy) (GtkObject *object);
4640 }
4641
4642 struct GtkWidgetClass
4643 {
4644 /* The object class structure needs to be the first
4645 * element in the widget class structure in order for
4646 * the class mechanism to work correctly. This allows a
4647 * GtkWidgetClass pointer to be cast to a GtkObjectClass
4648 * pointer.
4649 */
4650 GtkObjectClass parent_class;
4651
4652 /*< public >*/
4653
4654 guint activate_signal;
4655
4656 guint set_scroll_adjustments_signal;
4657
4658 /*< private >*/
4659
4660 /* seldomly overidden */
4661 void (*dispatch_child_properties_changed) (GtkWidget *widget,
4662 guint n_pspecs,
4663 GParamSpec **pspecs);
4664
4665 /* basics */
4666 void (* show) (GtkWidget *widget);
4667 void (* show_all) (GtkWidget *widget);
4668 void (* hide) (GtkWidget *widget);
4669 void (* hide_all) (GtkWidget *widget);
4670 void (* map) (GtkWidget *widget);
4671 void (* unmap) (GtkWidget *widget);
4672 void (* realize) (GtkWidget *widget);
4673 void (* unrealize) (GtkWidget *widget);
4674 void (* size_request) (GtkWidget *widget,
4675 GtkRequisition *requisition);
4676 void (* size_allocate) (GtkWidget *widget,
4677 GtkAllocation *allocation);
4678 void (* state_changed) (GtkWidget *widget,
4679 GtkStateType previous_state);
4680 void (* parent_set) (GtkWidget *widget,
4681 GtkWidget *previous_parent);
4682 void (* hierarchy_changed) (GtkWidget *widget,
4683 GtkWidget *previous_toplevel);
4684 void (* style_set) (GtkWidget *widget,
4685 GtkStyle *previous_style);
4686 void (* direction_changed) (GtkWidget *widget,
4687 GtkTextDirection previous_direction);
4688 void (* grab_notify) (GtkWidget *widget,
4689 gboolean was_grabbed);
4690 void (* child_notify) (GtkWidget *widget,
4691 GParamSpec *pspec);
4692
4693 /* Mnemonics */
4694 gboolean (* mnemonic_activate) (GtkWidget *widget,
4695 gboolean group_cycling);
4696
4697 /* explicit focus */
4698 void (* grab_focus) (GtkWidget *widget);
4699 gboolean (* focus) (GtkWidget *widget,
4700 GtkDirectionType direction);
4701
4702 /* events */
4703 gboolean (* event) (GtkWidget *widget,
4704 GdkEvent *event);
4705 gboolean (* button_press_event) (GtkWidget *widget,
4706 GdkEventButton *event);
4707 gboolean (* button_release_event) (GtkWidget *widget,
4708 GdkEventButton *event);
4709 gboolean (* scroll_event) (GtkWidget *widget,
4710 GdkEventScroll *event);
4711 gboolean (* motion_notify_event) (GtkWidget *widget,
4712 GdkEventMotion *event);
4713 gboolean (* delete_event) (GtkWidget *widget,
4714 GdkEventAny *event);
4715 gboolean (* destroy_event) (GtkWidget *widget,
4716 GdkEventAny *event);
4717 gboolean (* expose_event) (GtkWidget *widget,
4718 GdkEventExpose *event);
4719 gboolean (* key_press_event) (GtkWidget *widget,
4720 GdkEventKey *event);
4721 gboolean (* key_release_event) (GtkWidget *widget,
4722 GdkEventKey *event);
4723 gboolean (* enter_notify_event) (GtkWidget *widget,
4724 GdkEventCrossing *event);
4725 gboolean (* leave_notify_event) (GtkWidget *widget,
4726 GdkEventCrossing *event);
4727 gboolean (* configure_event) (GtkWidget *widget,
4728 GdkEventConfigure *event);
4729 gboolean (* focus_in_event) (GtkWidget *widget,
4730 GdkEventFocus *event);
4731 gboolean (* focus_out_event) (GtkWidget *widget,
4732 GdkEventFocus *event);
4733 gboolean (* map_event) (GtkWidget *widget,
4734 GdkEventAny *event);
4735 gboolean (* unmap_event) (GtkWidget *widget,
4736 GdkEventAny *event);
4737 gboolean (* property_notify_event) (GtkWidget *widget,
4738 GdkEventProperty *event);
4739 gboolean (* selection_clear_event) (GtkWidget *widget,
4740 GdkEventSelection *event);
4741 gboolean (* selection_request_event) (GtkWidget *widget,
4742 GdkEventSelection *event);
4743 gboolean (* selection_notify_event) (GtkWidget *widget,
4744 GdkEventSelection *event);
4745 gboolean (* proximity_in_event) (GtkWidget *widget,
4746 GdkEventProximity *event);
4747 gboolean (* proximity_out_event) (GtkWidget *widget,
4748 GdkEventProximity *event);
4749 gboolean (* visibility_notify_event) (GtkWidget *widget,
4750 GdkEventVisibility *event);
4751 gboolean (* client_event) (GtkWidget *widget,
4752 GdkEventClient *event);
4753 gboolean (* no_expose_event) (GtkWidget *widget,
4754 GdkEventAny *event);
4755 gboolean (* window_state_event) (GtkWidget *widget,
4756 GdkEventWindowState *event);
4757
4758 /* selection */
4759 void (* selection_get) (GtkWidget *widget,
4760 GtkSelectionData *selection_data,
4761 guint info,
4762 guint time_);
4763 void (* selection_received) (GtkWidget *widget,
4764 GtkSelectionData *selection_data,
4765 guint time_);
4766
4767 /* Source side drag signals */
4768 void (* drag_begin) (GtkWidget *widget,
4769 GdkDragContext *context);
4770 void (* drag_end) (GtkWidget *widget,
4771 GdkDragContext *context);
4772 void (* drag_data_get) (GtkWidget *widget,
4773 GdkDragContext *context,
4774 GtkSelectionData *selection_data,
4775 guint info,
4776 guint time_);
4777 void (* drag_data_delete) (GtkWidget *widget,
4778 GdkDragContext *context);
4779
4780 /* Target side drag signals */
4781 void (* drag_leave) (GtkWidget *widget,
4782 GdkDragContext *context,
4783 guint time_);
4784 gboolean (* drag_motion) (GtkWidget *widget,
4785 GdkDragContext *context,
4786 gint x,
4787 gint y,
4788 guint time_);
4789 gboolean (* drag_drop) (GtkWidget *widget,
4790 GdkDragContext *context,
4791 gint x,
4792 gint y,
4793 guint time_);
4794 void (* drag_data_received) (GtkWidget *widget,
4795 GdkDragContext *context,
4796 gint x,
4797 gint y,
4798 GtkSelectionData *selection_data,
4799 guint info,
4800 guint time_);
4801
4802 /* Signals used only for keybindings */
4803 gboolean (* popup_menu) (GtkWidget *widget);
4804
4805 /* If a widget has multiple tooltips/whatsthis, it should show the
4806 * one for the current focus location, or if that doesn't make
4807 * sense, should cycle through them showing each tip alongside
4808 * whatever piece of the widget it applies to.
4809 */
4810 gboolean (* show_help) (GtkWidget *widget,
4811 GtkWidgetHelpType help_type);
4812
4813 /* accessibility support
4814 */
4815 AtkObject* (*get_accessible) (GtkWidget *widget);
4816
4817 void (*screen_changed) (GtkWidget *widget,
4818 GdkScreen *previous_screen);
4819 gboolean (*can_activate_accel) (GtkWidget *widget,
4820 guint signal_id);
4821
4822 /* Sent when a grab is broken. */
4823 gboolean (*grab_broken_event) (GtkWidget *widget,
4824 GdkEventGrabBroken *event);
4825
4826 void (* composited_changed) (GtkWidget *widget);
4827
4828 gboolean (* query_tooltip) (GtkWidget *widget,
4829 gint x,
4830 gint y,
4831 gboolean keyboard_tooltip,
4832 GtkTooltip *tooltip);
4833
4834 /* Padding for future expansion */
4835 void (*_gtk_reserved5) ();
4836 void (*_gtk_reserved6) ();
4837 void (*_gtk_reserved7) ();
4838 }
4339 4839
4340 /** 4840 /**
4341 * A GtkRequisition represents the desired size of a widget. See 4841 * A GtkRequisition represents the desired size of a widget. See
4342 * the section called Size Requisition for more information. 4842 * the section called Size Requisition for more information.
4343 * gintwidth; 4843 * gintwidth;
4884 * Main Gtk struct. 5384 * Main Gtk struct.
4885 * Warning 5385 * Warning
4886 * GtkTooltips is deprecated and should not be used in newly-written code. 5386 * GtkTooltips is deprecated and should not be used in newly-written code.
4887 * Holds information about a group of tooltips. Fields should be changed using the functions provided, rather than directly accessing the struct's members. 5387 * Holds information about a group of tooltips. Fields should be changed using the functions provided, rather than directly accessing the struct's members.
4888 */ 5388 */
4889 public struct GtkTooltips{} 5389 public struct GtkTooltips
5390 {
5391 GtkObject parent_instance;
5392
5393 /*< private >*/
5394 GtkWidget *tip_window;
5395 GtkWidget *tip_label;
5396 GtkTooltipsData *active_tips_data;
5397 GList *tips_data_list; /* unused */
5398
5399 guint flags1;
5400 guint flags2;
5401
5402 // guint delay : 30;
5403 // guint enabled : 1;
5404 // guint have_grab : 1;
5405 // guint use_sticky_delay : 1;
5406 // gint timer_tag;
5407 GTimeVal last_popdown;
5408 }
4890 5409
4891 5410
4892 /** 5411 /**
4893 * Warning 5412 * Warning
4894 * GtkTooltipsData has been deprecated since version 2.12 and should not be used in newly-written code. 5413 * GtkTooltipsData has been deprecated since version 2.12 and should not be used in newly-written code.