File: gMenu.mli

package info (click to toggle)
lablgtk2 2.18.11-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye
  • size: 5,916 kB
  • sloc: ml: 41,447; ansic: 23,090; makefile: 684; sh: 75
file content (283 lines) | stat: -rw-r--r-- 9,069 bytes parent folder | download | duplicates (5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
(**************************************************************************)
(*                Lablgtk                                                 *)
(*                                                                        *)
(*    This program is free software; you can redistribute it              *)
(*    and/or modify it under the terms of the GNU Library General         *)
(*    Public License as published by the Free Software Foundation         *)
(*    version 2, with the exception described in file COPYING which       *)
(*    comes with the library.                                             *)
(*                                                                        *)
(*    This program is distributed in the hope that it will be useful,     *)
(*    but WITHOUT ANY WARRANTY; without even the implied warranty of      *)
(*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the       *)
(*    GNU Library General Public License for more details.                *)
(*                                                                        *)
(*    You should have received a copy of the GNU Library General          *)
(*    Public License along with this program; if not, write to the        *)
(*    Free Software Foundation, Inc., 59 Temple Place, Suite 330,         *)
(*    Boston, MA 02111-1307  USA                                          *)
(*                                                                        *)
(*                                                                        *)
(**************************************************************************)

(* $Id$ *)

open Gtk
open GObj
open GContainer

(** Menus *)

(** @gtkdoc gtk GtkMenuShell *)
class menu_shell_signals : [> menu_shell] obj ->
  object
    inherit GContainer.container_signals
    method deactivate : callback:(unit -> unit) -> GtkSignal.id
  end

(** @gtkdoc gtk GtkMenuItem *)
class menu_item_signals : [> menu_item] obj ->
  object
    inherit GContainer.item_signals
    method activate : callback:(unit -> unit) -> GtkSignal.id
  end

(** @gtkdoc gtk GtkMenuItem *)
class menu_item_skel :
  'a obj ->
  object
    inherit GContainer.container
    constraint 'a = [> Gtk.menu_item]
    val obj : 'a obj
    method activate : unit -> unit
    method add_accelerator :
      group:accel_group ->
      ?modi:Gdk.Tags.modifier list ->
      ?flags:Tags.accel_flag list -> Gdk.keysym -> unit
    method as_item : Gtk.menu_item obj
    method remove_submenu : unit -> unit
    method set_right_justified : bool -> unit
    method select : unit -> unit
    method deselect : unit -> unit
    method right_justified : bool
    method set_submenu : menu -> unit
    method get_submenu : GObj.widget option

  end

(** The widget used for item in menus
   @gtkdoc gtk GtkMenuItem *)
and menu_item : 'a obj ->
  object
    inherit menu_item_skel
    constraint 'a = [> Gtk.menu_item]
    val obj : 'a obj
    method event : event_ops
    method connect : menu_item_signals
  end

(** A drop down menu widget
   @gtkdoc gtk GtkMenu *)
and menu : Gtk.menu obj ->
  object
    inherit [menu_item] GContainer.item_container
    val obj : Gtk.menu obj
    method add : menu_item -> unit
    method event : event_ops
    method append : menu_item -> unit
    method as_menu : Gtk.menu obj
    method children : menu_item list
    method connect : menu_shell_signals
    method deactivate : unit -> unit
    method insert : menu_item -> pos:int -> unit
    method popdown : unit -> unit
    method popup : button:int -> time:int32 -> unit
    method prepend : menu_item -> unit
    method remove : menu_item -> unit
    method set_accel_group : accel_group -> unit
    method set_accel_path : string -> unit
    method set_border_width : int -> unit
    method private wrap : Gtk.widget obj -> menu_item
  end

(** @gtkdoc gtk GtkMenu *)
val menu :
  ?accel_path:string ->
  ?border_width:int -> ?packing:(menu -> unit) -> ?show:bool -> unit -> menu

(** @gtkdoc gtk GtkMenuItem *)
val menu_item :
  ?use_mnemonic:bool ->
  ?label:string ->
  ?right_justified:bool ->
  ?packing:(menu_item -> unit) -> ?show:bool -> unit -> menu_item

(** @gtkdoc gtk GtkTearoffMenuItem *)
val tearoff_item :
  ?packing:(menu_item -> unit) -> ?show:bool -> unit -> menu_item

(** @gtkdoc gtk GtkSeparatorMenuItem *)
val separator_item :
  ?packing:(menu_item -> unit) -> ?show:bool -> unit -> menu_item

(** A menu item with an icon
   @gtkdoc gtk GtkImageMenuItem *)
class image_menu_item : 'a obj ->
object
  inherit menu_item_skel
  constraint 'a =  Gtk.image_menu_item
  val obj : 'a obj
  method event : event_ops
  method connect : menu_item_signals
  method image : widget
  method set_image : widget -> unit
end

(** @gtkdoc gtk GtkImageMenuItem *)
val image_menu_item :
  ?image:#widget ->
  ?label:string ->
  ?use_mnemonic:bool ->
  ?stock:GtkStock.id ->
  ?right_justified:bool ->
  ?packing:(menu_item -> unit) -> ?show:bool -> unit -> image_menu_item

(** @gtkdoc gtk GtkCheckMenuItem *)
class check_menu_item_signals : [> check_menu_item] obj ->
  object
    inherit menu_item_signals
    method toggled : callback:(unit -> unit) -> GtkSignal.id
  end

(** A menu item with a check box
   @gtkdoc gtk GtkCheckMenuItem *)
class check_menu_item : 'a obj ->
  object
    inherit menu_item_skel
    constraint 'a = [> Gtk.check_menu_item]
    val obj : 'a obj
    method active : bool
    method event : event_ops
    method connect : check_menu_item_signals
    method set_active : bool -> unit
    method set_inconsistent : bool -> unit
    method inconsistent : bool
    method set_show_toggle : bool -> unit
    method toggled : unit -> unit
  end

(** @gtkdoc gtk GtkCheckMenuItem *)
val check_menu_item :
  ?label:string ->
  ?use_mnemonic:bool ->
  ?active:bool ->
  ?show_toggle:bool ->
  ?right_justified:bool ->
  ?packing:(menu_item -> unit) -> ?show:bool -> unit -> check_menu_item

(** A choice from multiple check menu items
   @gtkdoc gtk GtkRadioMenuItem *)
class radio_menu_item : Gtk.radio_menu_item obj ->
  object
    inherit check_menu_item
    val obj : Gtk.radio_menu_item obj
    method group : Gtk.radio_menu_item group
    method set_group : Gtk.radio_menu_item group -> unit
  end

(** @gtkdoc gtk GtkRadioMenuItem *)
val radio_menu_item :
  ?group:Gtk.radio_menu_item group ->
  ?label:string ->
  ?use_mnemonic:bool ->
  ?active:bool ->
  ?show_toggle:bool ->
  ?right_justified:bool ->
  ?packing:(menu_item -> unit) -> ?show:bool -> unit -> radio_menu_item

(** @gtkdoc gtk GtkMenuShell *)
class menu_shell : 'a obj ->
  object
    inherit [menu_item] GContainer.item_container
    constraint 'a = [> Gtk.menu_shell]
    val obj : 'a obj
    method event : event_ops
    method deactivate : unit -> unit
    method connect : menu_shell_signals
    method insert : menu_item -> pos:int -> unit
    method private wrap : Gtk.widget obj -> menu_item
  end

(** @gtkdoc gtk GtkMenuBar *)
val menu_bar :
  ?border_width:int ->
  ?width:int ->
  ?height:int ->
  ?packing:(GObj.widget -> unit) -> ?show:bool -> unit -> menu_shell

(** A widget used to choose from a list of valid choices
   @gtkdoc gtk GtkOptionMenu *)
class option_menu : 'a obj ->
  object
    inherit GButton.button_skel
    constraint 'a = [> Gtk.option_menu]
    val obj : 'a obj
    method event : event_ops
    method connect : GButton.button_signals
    method get_menu : menu
    method remove_menu : unit -> unit
    method set_history : int -> unit
    method set_menu : menu -> unit
  end

(** @gtkdoc gtk GtkOptionMenu *)
val option_menu :
  ?menu:#menu ->
  ?border_width:int ->
  ?width:int ->
  ?height:int ->
  ?packing:(GObj.widget -> unit) -> ?show:bool -> unit -> option_menu


(** A factory for menus
   @gtkdoc gtk GtkItemFactory *)
class ['a] factory :
  ?accel_group:accel_group ->
  ?accel_path:string -> 
  ?accel_modi:Gdk.Tags.modifier list ->
  ?accel_flags:Tags.accel_flag list ->
  'a ->
  object
    constraint 'a = #menu_shell
    val flags : Tags.accel_flag list
    val group : accel_group
    val m : Gdk.Tags.modifier list
    val menu_shell : 'a
    method accel_group : accel_group
    method add_check_item :
      ?active:bool ->
      ?key:Gdk.keysym ->
      ?callback:(bool -> unit) -> string -> check_menu_item
    method add_item :
      ?key:Gdk.keysym ->
      ?callback:(unit -> unit) ->
      ?submenu:menu -> string -> menu_item
    method add_image_item :
      ?image:widget ->
      ?key:Gdk.keysym ->
      ?callback:(unit -> unit) ->
      ?stock:GtkStock.id -> ?label:string -> unit -> image_menu_item
    method add_radio_item :
      ?group:Gtk.radio_menu_item group ->
      ?active:bool ->
      ?key:Gdk.keysym ->
      ?callback:(bool -> unit) -> string -> radio_menu_item
    method add_separator : unit -> menu_item
    method add_submenu : ?key:Gdk.keysym -> string -> menu
    method add_tearoff : unit -> menu_item
    method private bind :
      ?modi:Gdk.Tags.modifier list -> 
      ?key:Gdk.keysym -> 
      ?callback:(unit -> unit) -> menu_item -> string -> unit
    method menu : 'a
  end