From: Stefano Zacchiroli Date: Fri, 20 Feb 2004 18:03:21 +0000 (+0000) Subject: first check in of mathita gui X-Git-Tag: v0_0_4~123 X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=commitdiff_plain;h=012882cec674d741f69fce307a6822a584fd6a45;p=helm.git first check in of mathita gui --- diff --git a/helm/mathita/.cvsignore b/helm/mathita/.cvsignore new file mode 100644 index 000000000..bba30b067 --- /dev/null +++ b/helm/mathita/.cvsignore @@ -0,0 +1,4 @@ +mathita +*.cm[aiox] +*.cmxa +*.[ao] diff --git a/helm/mathita/.depend b/helm/mathita/.depend new file mode 100644 index 000000000..d55a5e488 --- /dev/null +++ b/helm/mathita/.depend @@ -0,0 +1,4 @@ +mathitaGui.cmo: mathitaGui.cmi +mathitaGui.cmx: mathitaGui.cmi +mathita.cmo: mathitaGui.cmi +mathita.cmx: mathitaGui.cmx diff --git a/helm/mathita/Makefile b/helm/mathita/Makefile new file mode 100644 index 000000000..02b52eab3 --- /dev/null +++ b/helm/mathita/Makefile @@ -0,0 +1,41 @@ + +OCAMLFIND = ocamlfind +REQUIRES = lablgtk2.glade +OCAML_FLAGS = -package "$(REQUIRES)" -pp camlp4o +OCAML_THREADS_FLAGS = -thread +OCAML_DEBUG_FLAGS = +OCAMLC = $(OCAMLFIND) ocamlc $(OCAML_FLAGS) $(OCAML_THREADS_FLAGS) $(OCAML_DEBUG_FLAGS) +OCAMLOPT = $(OCAMLFIND) opt $(OCAML_FLAGS) $(OCAML_THREADS_FLAGS) $(OCAML_DEBUG_FLAGS) +OCAMLDEP = $(OCAMLFIND) ocamldep $(OCAML_FLAGS) +LABLGLADECC = lablgladecc2 +CMOS = \ + mathitaGui.cmo + +all: mathita + +mathita: $(CMOS) mathita.ml + $(OCAMLC) -linkpkg -o $@ $^ + +mathitaGui.ml mathitaGui.mli: mathita.glade + $(LABLGLADECC) $< > $@ + $(OCAMLC) -i mathitaGui.ml > mathitaGui.mli + +%.cmi: %.mli + $(OCAMLC) -c $< +%.cmo %.cmi: %.ml + $(OCAMLC) -c $< +%.cmx: %.ml + $(OCAMLOPT) -c $< +%.ml %.mli: %.mly + $(OCAMLYACC) $< + +clean: + rm -rf *.cm[aoix] *.cmxa *.[ao] mathita +distclean: clean + rm -f mathitaGui.ml + +depend: mathitaGui.ml + $(OCAMLDEP) *.ml *.mli > .depend + +include .depend + diff --git a/helm/mathita/mathita.glade b/helm/mathita/mathita.glade new file mode 100644 index 000000000..a1150cfbc --- /dev/null +++ b/helm/mathita/mathita.glade @@ -0,0 +1,467 @@ + + + + + + + True + Mathita + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + 800 + 600 + True + False + + + + True + False + 0 + + + + True + + + + True + _File + True + + + + + + + True + Exit + True + + + + + + + + + + + True + _Edit + True + + + + + + True + _View + True + + + + + + + True + Show Button Bar + True + True + + + + + + True + Show Proof Window + True + False + + + + + + + + + + + True + _Help + True + + + + + + + True + About... + True + + + + + + + + + 0 + False + False + + + + + + True + True + 450 + + + + True + GTK_POLICY_ALWAYS + GTK_POLICY_ALWAYS + GTK_SHADOW_NONE + GTK_CORNER_TOP_LEFT + + + + + + + True + False + + + + + + True + GTK_POLICY_NEVER + GTK_POLICY_ALWAYS + GTK_SHADOW_IN + GTK_CORNER_TOP_LEFT + + + + True + True + False + GTK_JUSTIFY_LEFT + GTK_WRAP_WORD + True + 0 + 0 + 0 + 0 + 0 + 0 + + + + + + True + True + + + + + 0 + True + True + + + + + + True + True + + + 0 + False + False + + + + + + + + Mathita: current proof + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + 700 + 525 + True + False + + + + True + + + + True + GTK_POLICY_ALWAYS + GTK_POLICY_ALWAYS + GTK_SHADOW_NONE + GTK_CORNER_TOP_LEFT + + + + True + GTK_SHADOW_IN + + + + + + + + + + + + + + 10 + Select File + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + True + False + True + + + + True + True + True + GTK_RELIEF_NORMAL + + + + + + True + True + True + GTK_RELIEF_NORMAL + + + + + + 130 + 450 + True + ToolBar + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + False + False + + + + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_DEFAULT_STYLE + 0 + + + + 120 + True + True + True + button1 + True + GTK_RELIEF_NORMAL + + + + + + True + True + True + button2 + True + GTK_RELIEF_NORMAL + + + + + + True + True + True + button3 + True + GTK_RELIEF_NORMAL + + + + + + True + True + True + button4 + True + GTK_RELIEF_NORMAL + + + + + 0 + False + True + + + + + + True + + + 5 + False + True + + + + + + + + + + + + + + DUMMY + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + False + False + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + True + True + gtk-cancel + True + GTK_RELIEF_NORMAL + -6 + + + + + + True + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + -5 + + + + + 0 + False + True + GTK_PACK_END + + + + + + + + + + + + Mathita: about + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + True + False + False + True + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + True + True + gtk-ok + True + GTK_RELIEF_NORMAL + -5 + + + + + 0 + False + True + GTK_PACK_END + + + + + + + + + + + diff --git a/helm/mathita/mathita.gladep b/helm/mathita/mathita.gladep new file mode 100644 index 000000000..996d23c10 --- /dev/null +++ b/helm/mathita/mathita.gladep @@ -0,0 +1,8 @@ + + + + + Mathita + mathita + FALSE + diff --git a/helm/mathita/mathita.ml b/helm/mathita/mathita.ml new file mode 100644 index 000000000..0d3b622ff --- /dev/null +++ b/helm/mathita/mathita.ml @@ -0,0 +1,86 @@ +(* Copyright (C) 2004, HELM Team. + * + * This file is part of HELM, an Hypertextual, Electronic + * Library of Mathematics, developed at the Computer Science + * Department, University of Bologna, Italy. + * + * HELM is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * HELM 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with HELM; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA. + * + * For details, see the HELM World-Wide-Web page, + * http://helm.cs.unibo.it/ + *) + + (** quit program, possibly asking for confirmation *) +let quit () = + GMain.Main.quit () + + (** given a window and a check menu item it links the two so that the former + * is only hidden on delete and the latter toggle show/hide of the former *) +let toggle_visibility (win: GWindow.window) (check: GMenu.check_menu_item) = + ignore (check#connect#toggled (fun _ -> + if check#active then win#show () else win#misc#hide ())); + ignore (win#event#connect#delete (fun _ -> + win#misc#hide (); + check#set_active false; + true)) + +let toggle_win ?check win () = + if win#is_active then win#misc#hide () else win#show (); + match check with + | None -> () + | Some check -> check#set_active (not check#active) + +let add_key_bindings bindings (evbox: GBin.event_box) = + List.iter + (fun (key, callback) -> + ignore (evbox#event#connect#key_press (function + | key' when GdkEvent.Key.keyval key' = key -> + callback (); + false + | _ -> false))) + bindings + +class gui file = + object (self) + val about = new MathitaGui.aboutWin ~file () + val dialog = new MathitaGui.genericDialog ~file () + val filesel = new MathitaGui.fileSelectionWin ~file () + val main = new MathitaGui.mainWin ~file () + val proof = new MathitaGui.proofWin ~file () + val toolbar = new MathitaGui.toolBarWin ~file () + initializer + let c w = (w :> unit>) in + List.iter (fun w -> w#check_widgets ()) + [ c about; c dialog; c filesel; c main; c proof; c toolbar ]; + ignore (main#toplevel#connect#destroy quit); + ignore (main#exitMenuItem#connect#activate quit); + toggle_visibility toolbar#toolBarWin main#showToolBarMenuItem; + toggle_visibility proof#proofWin main#showProofMenuItem; + let key_bindings = [ + GdkKeysyms._F3, toggle_win ~check:main#showProofMenuItem proof#proofWin; + GdkKeysyms._q, quit; + ] in + add_key_bindings key_bindings toolbar#toolBarEventBox; + add_key_bindings key_bindings proof#proofWinEventBox; + () + end + +let _ = + let glade_file = "mathita.glade" in + let _ = GMain.Main.init () in + let gui = new gui glade_file in + GtkThread.main () + diff --git a/helm/mathita/mathitaGui.ml b/helm/mathita/mathitaGui.ml new file mode 100644 index 000000000..b11877a11 --- /dev/null +++ b/helm/mathita/mathitaGui.ml @@ -0,0 +1,260 @@ +(* Automatically generated from mathita.glade by lablgladecc *) + +class mainWin ?(file="mathita.glade") ?domain ?autoconnect(*=true*) () = + let xmldata = Glade.create ~file ~root:"MainWin" ?domain () in + object (self) + inherit Glade.xml ?autoconnect xmldata + val toplevel = + new GWindow.window (GtkWindow.Window.cast + (Glade.get_widget_msg ~name:"MainWin" ~info:"GtkWindow" xmldata)) + method toplevel = toplevel + val mainWin = + new GWindow.window (GtkWindow.Window.cast + (Glade.get_widget_msg ~name:"MainWin" ~info:"GtkWindow" xmldata)) + method mainWin = mainWin + val mainWinShape = + new GPack.box (GtkPack.Box.cast + (Glade.get_widget_msg ~name:"MainWinShape" ~info:"GtkVBox" xmldata)) + method mainWinShape = mainWinShape + val mainMenuBar = + new GMenu.menu_shell (GtkMenu.MenuBar.cast + (Glade.get_widget_msg ~name:"MainMenuBar" ~info:"GtkMenuBar" xmldata)) + method mainMenuBar = mainMenuBar + val fileMenu = + new GMenu.menu_item (GtkMenu.MenuItem.cast + (Glade.get_widget_msg ~name:"fileMenu" ~info:"GtkMenuItem" xmldata)) + method fileMenu = fileMenu + val fileMenu_menu = + new GMenu.menu (GtkMenu.Menu.cast + (Glade.get_widget_msg ~name:"fileMenu_menu" ~info:"GtkMenu" xmldata)) + method fileMenu_menu = fileMenu_menu + val exitMenuItem = + new GMenu.menu_item (GtkMenu.MenuItem.cast + (Glade.get_widget_msg ~name:"ExitMenuItem" ~info:"GtkMenuItem" xmldata)) + method exitMenuItem = exitMenuItem + val editMenu = + new GMenu.menu_item (GtkMenu.MenuItem.cast + (Glade.get_widget_msg ~name:"EditMenu" ~info:"GtkMenuItem" xmldata)) + method editMenu = editMenu + val viewMenu = + new GMenu.menu_item (GtkMenu.MenuItem.cast + (Glade.get_widget_msg ~name:"ViewMenu" ~info:"GtkMenuItem" xmldata)) + method viewMenu = viewMenu + val viewMenu_menu = + new GMenu.menu (GtkMenu.Menu.cast + (Glade.get_widget_msg ~name:"ViewMenu_menu" ~info:"GtkMenu" xmldata)) + method viewMenu_menu = viewMenu_menu + val showToolBarMenuItem = + new GMenu.check_menu_item (GtkMenu.CheckMenuItem.cast + (Glade.get_widget_msg ~name:"ShowToolBarMenuItem" ~info:"GtkCheckMenuItem" xmldata)) + method showToolBarMenuItem = showToolBarMenuItem + val showProofMenuItem = + new GMenu.check_menu_item (GtkMenu.CheckMenuItem.cast + (Glade.get_widget_msg ~name:"ShowProofMenuItem" ~info:"GtkCheckMenuItem" xmldata)) + method showProofMenuItem = showProofMenuItem + val helpMenu = + new GMenu.menu_item (GtkMenu.MenuItem.cast + (Glade.get_widget_msg ~name:"HelpMenu" ~info:"GtkMenuItem" xmldata)) + method helpMenu = helpMenu + val helpMenu_menu = + new GMenu.menu (GtkMenu.Menu.cast + (Glade.get_widget_msg ~name:"HelpMenu_menu" ~info:"GtkMenu" xmldata)) + method helpMenu_menu = helpMenu_menu + val aboutMenuItem = + new GMenu.menu_item (GtkMenu.MenuItem.cast + (Glade.get_widget_msg ~name:"AboutMenuItem" ~info:"GtkMenuItem" xmldata)) + method aboutMenuItem = aboutMenuItem + val mainVPanes = + new GPack.paned (GtkPack.Paned.cast + (Glade.get_widget_msg ~name:"MainVPanes" ~info:"GtkVPaned" xmldata)) + method mainVPanes = mainVPanes + val proofStatus = + new GBin.scrolled_window (GtkBin.ScrolledWindow.cast + (Glade.get_widget_msg ~name:"ProofStatus" ~info:"GtkScrolledWindow" xmldata)) + method proofStatus = proofStatus + val scrolledUserInput = + new GBin.scrolled_window (GtkBin.ScrolledWindow.cast + (Glade.get_widget_msg ~name:"ScrolledUserInput" ~info:"GtkScrolledWindow" xmldata)) + method scrolledUserInput = scrolledUserInput + val userInput = + new GText.view (GtkText.View.cast + (Glade.get_widget_msg ~name:"UserInput" ~info:"GtkTextView" xmldata)) + method userInput = userInput + val mainStatusBar = + new GMisc.statusbar (GtkMisc.Statusbar.cast + (Glade.get_widget_msg ~name:"MainStatusBar" ~info:"GtkStatusbar" xmldata)) + method mainStatusBar = mainStatusBar + method reparent parent = + mainWinShape#misc#reparent parent; + toplevel#destroy () + method check_widgets () = () + end +class proofWin ?(file="mathita.glade") ?domain ?autoconnect(*=true*) () = + let xmldata = Glade.create ~file ~root:"ProofWin" ?domain () in + object (self) + inherit Glade.xml ?autoconnect xmldata + val toplevel = + new GWindow.window (GtkWindow.Window.cast + (Glade.get_widget_msg ~name:"ProofWin" ~info:"GtkWindow" xmldata)) + method toplevel = toplevel + val proofWin = + new GWindow.window (GtkWindow.Window.cast + (Glade.get_widget_msg ~name:"ProofWin" ~info:"GtkWindow" xmldata)) + method proofWin = proofWin + val proofWinEventBox = + new GBin.event_box (GtkBin.EventBox.cast + (Glade.get_widget_msg ~name:"ProofWinEventBox" ~info:"GtkEventBox" xmldata)) + method proofWinEventBox = proofWinEventBox + val scrolledProof = + new GBin.scrolled_window (GtkBin.ScrolledWindow.cast + (Glade.get_widget_msg ~name:"ScrolledProof" ~info:"GtkScrolledWindow" xmldata)) + method scrolledProof = scrolledProof + val viewport1 = + new GBin.viewport (GtkBin.Viewport.cast + (Glade.get_widget_msg ~name:"viewport1" ~info:"GtkViewport" xmldata)) + method viewport1 = viewport1 + method reparent parent = + proofWinEventBox#misc#reparent parent; + toplevel#destroy () + method check_widgets () = () + end +class fileSelectionWin ?(file="mathita.glade") ?domain ?autoconnect(*=true*) () = + let xmldata = Glade.create ~file ~root:"FileSelectionWin" ?domain () in + object (self) + inherit Glade.xml ?autoconnect xmldata + val toplevel = + new GWindow.file_selection (GtkWindow.FileSelection.cast + (Glade.get_widget_msg ~name:"FileSelectionWin" ~info:"GtkFileSelection" xmldata)) + method toplevel = toplevel + val fileSelectionWin = + new GWindow.file_selection (GtkWindow.FileSelection.cast + (Glade.get_widget_msg ~name:"FileSelectionWin" ~info:"GtkFileSelection" xmldata)) + method fileSelectionWin = fileSelectionWin + val cancel_button1 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"cancel_button1" ~info:"GtkButton" xmldata)) + method cancel_button1 = cancel_button1 + val ok_button1 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"ok_button1" ~info:"GtkButton" xmldata)) + method ok_button1 = ok_button1 + method check_widgets () = () + end +class toolBarWin ?(file="mathita.glade") ?domain ?autoconnect(*=true*) () = + let xmldata = Glade.create ~file ~root:"ToolBarWin" ?domain () in + object (self) + inherit Glade.xml ?autoconnect xmldata + val toplevel = + new GWindow.window (GtkWindow.Window.cast + (Glade.get_widget_msg ~name:"ToolBarWin" ~info:"GtkWindow" xmldata)) + method toplevel = toplevel + val toolBarWin = + new GWindow.window (GtkWindow.Window.cast + (Glade.get_widget_msg ~name:"ToolBarWin" ~info:"GtkWindow" xmldata)) + method toolBarWin = toolBarWin + val toolBarEventBox = + new GBin.event_box (GtkBin.EventBox.cast + (Glade.get_widget_msg ~name:"ToolBarEventBox" ~info:"GtkEventBox" xmldata)) + method toolBarEventBox = toolBarEventBox + val vbox1 = + new GPack.box (GtkPack.Box.cast + (Glade.get_widget_msg ~name:"vbox1" ~info:"GtkVBox" xmldata)) + method vbox1 = vbox1 + val button1 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"button1" ~info:"GtkButton" xmldata)) + method button1 = button1 + val button2 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"button2" ~info:"GtkButton" xmldata)) + method button2 = button2 + val button3 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"button3" ~info:"GtkButton" xmldata)) + method button3 = button3 + val button4 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"button4" ~info:"GtkButton" xmldata)) + method button4 = button4 + method reparent parent = + toolBarEventBox#misc#reparent parent; + toplevel#destroy () + method check_widgets () = () + end +class genericDialog ?(file="mathita.glade") ?domain ?autoconnect(*=true*) () = + let xmldata = Glade.create ~file ~root:"GenericDialog" ?domain () in + object (self) + inherit Glade.xml ?autoconnect xmldata + val toplevel : [`NONE | `DELETE_EVENT | `ID of int] GWindow.dialog = + new GWindow.dialog (GtkWindow.Dialog.cast + (Glade.get_widget_msg ~name:"GenericDialog" ~info:"GtkDialog" xmldata)) + method toplevel = toplevel + val genericDialog : [`NONE | `DELETE_EVENT | `ID of int] GWindow.dialog = + new GWindow.dialog (GtkWindow.Dialog.cast + (Glade.get_widget_msg ~name:"GenericDialog" ~info:"GtkDialog" xmldata)) + method genericDialog = genericDialog + val dialog_vbox1 = + new GPack.box (GtkPack.Box.cast + (Glade.get_widget_msg ~name:"dialog-vbox1" ~info:"GtkVBox" xmldata)) + method dialog_vbox1 = dialog_vbox1 + val cancelbutton1 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"cancelbutton1" ~info:"GtkButton" xmldata)) + method cancelbutton1 = cancelbutton1 + val okbutton1 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"okbutton1" ~info:"GtkButton" xmldata)) + method okbutton1 = okbutton1 + method reparent parent = + dialog_vbox1#misc#reparent parent; + toplevel#destroy () + method check_widgets () = () + end +class aboutWin ?(file="mathita.glade") ?domain ?autoconnect(*=true*) () = + let xmldata = Glade.create ~file ~root:"AboutWin" ?domain () in + object (self) + inherit Glade.xml ?autoconnect xmldata + val toplevel : [`NONE | `DELETE_EVENT | `ID of int] GWindow.dialog = + new GWindow.dialog (GtkWindow.Dialog.cast + (Glade.get_widget_msg ~name:"AboutWin" ~info:"GtkDialog" xmldata)) + method toplevel = toplevel + val aboutWin : [`NONE | `DELETE_EVENT | `ID of int] GWindow.dialog = + new GWindow.dialog (GtkWindow.Dialog.cast + (Glade.get_widget_msg ~name:"AboutWin" ~info:"GtkDialog" xmldata)) + method aboutWin = aboutWin + val dialog_vbox2 = + new GPack.box (GtkPack.Box.cast + (Glade.get_widget_msg ~name:"dialog-vbox2" ~info:"GtkVBox" xmldata)) + method dialog_vbox2 = dialog_vbox2 + val okbutton2 = + new GButton.button (GtkButton.Button.cast + (Glade.get_widget_msg ~name:"okbutton2" ~info:"GtkButton" xmldata)) + method okbutton2 = okbutton2 + method reparent parent = + dialog_vbox2#misc#reparent parent; + toplevel#destroy () + method check_widgets () = () + end + +let check_all ?(show=false) () = + ignore (GMain.Main.init ()); + let aboutWin = new aboutWin () in + if show then aboutWin#toplevel#show (); + aboutWin#check_widgets (); + let genericDialog = new genericDialog () in + if show then genericDialog#toplevel#show (); + genericDialog#check_widgets (); + let toolBarWin = new toolBarWin () in + if show then toolBarWin#toplevel#show (); + toolBarWin#check_widgets (); + let fileSelectionWin = new fileSelectionWin () in + if show then fileSelectionWin#toplevel#show (); + fileSelectionWin#check_widgets (); + let proofWin = new proofWin () in + if show then proofWin#toplevel#show (); + proofWin#check_widgets (); + let mainWin = new mainWin () in + if show then mainWin#toplevel#show (); + mainWin#check_widgets (); + if show then GMain.Main.main () +;; diff --git a/helm/mathita/mathitaGui.mli b/helm/mathita/mathitaGui.mli new file mode 100644 index 000000000..2f8416c3b --- /dev/null +++ b/helm/mathita/mathitaGui.mli @@ -0,0 +1,165 @@ +class mainWin : + ?file:string -> + ?domain:string -> + ?autoconnect:bool -> + unit -> + object + val aboutMenuItem : GMenu.menu_item + val editMenu : GMenu.menu_item + val exitMenuItem : GMenu.menu_item + val fileMenu : GMenu.menu_item + val fileMenu_menu : GMenu.menu + val helpMenu : GMenu.menu_item + val helpMenu_menu : GMenu.menu + val mainMenuBar : GMenu.menu_shell + val mainStatusBar : GMisc.statusbar + val mainVPanes : GPack.paned + val mainWin : GWindow.window + val mainWinShape : GPack.box + val proofStatus : GBin.scrolled_window + val scrolledUserInput : GBin.scrolled_window + val showProofMenuItem : GMenu.check_menu_item + val showToolBarMenuItem : GMenu.check_menu_item + val toplevel : GWindow.window + val userInput : GText.view + val viewMenu : GMenu.menu_item + val viewMenu_menu : GMenu.menu + val xml : Glade.glade_xml Gtk.obj + method aboutMenuItem : GMenu.menu_item + method bind : name:string -> callback:(unit -> unit) -> unit + method check_widgets : unit -> unit + method editMenu : GMenu.menu_item + method exitMenuItem : GMenu.menu_item + method fileMenu : GMenu.menu_item + method fileMenu_menu : GMenu.menu + method helpMenu : GMenu.menu_item + method helpMenu_menu : GMenu.menu + method mainMenuBar : GMenu.menu_shell + method mainStatusBar : GMisc.statusbar + method mainVPanes : GPack.paned + method mainWin : GWindow.window + method mainWinShape : GPack.box + method proofStatus : GBin.scrolled_window + method reparent : GObj.widget -> unit + method scrolledUserInput : GBin.scrolled_window + method showProofMenuItem : GMenu.check_menu_item + method showToolBarMenuItem : GMenu.check_menu_item + method toplevel : GWindow.window + method userInput : GText.view + method viewMenu : GMenu.menu_item + method viewMenu_menu : GMenu.menu + method xml : Glade.glade_xml Gtk.obj + end +class proofWin : + ?file:string -> + ?domain:string -> + ?autoconnect:bool -> + unit -> + object + val proofWin : GWindow.window + val proofWinEventBox : GBin.event_box + val scrolledProof : GBin.scrolled_window + val toplevel : GWindow.window + val viewport1 : GBin.viewport + val xml : Glade.glade_xml Gtk.obj + method bind : name:string -> callback:(unit -> unit) -> unit + method check_widgets : unit -> unit + method proofWin : GWindow.window + method proofWinEventBox : GBin.event_box + method reparent : GObj.widget -> unit + method scrolledProof : GBin.scrolled_window + method toplevel : GWindow.window + method viewport1 : GBin.viewport + method xml : Glade.glade_xml Gtk.obj + end +class fileSelectionWin : + ?file:string -> + ?domain:string -> + ?autoconnect:bool -> + unit -> + object + val cancel_button1 : GButton.button + val fileSelectionWin : GWindow.file_selection + val ok_button1 : GButton.button + val toplevel : GWindow.file_selection + val xml : Glade.glade_xml Gtk.obj + method bind : name:string -> callback:(unit -> unit) -> unit + method cancel_button1 : GButton.button + method check_widgets : unit -> unit + method fileSelectionWin : GWindow.file_selection + method ok_button1 : GButton.button + method toplevel : GWindow.file_selection + method xml : Glade.glade_xml Gtk.obj + end +class toolBarWin : + ?file:string -> + ?domain:string -> + ?autoconnect:bool -> + unit -> + object + val button1 : GButton.button + val button2 : GButton.button + val button3 : GButton.button + val button4 : GButton.button + val toolBarEventBox : GBin.event_box + val toolBarWin : GWindow.window + val toplevel : GWindow.window + val vbox1 : GPack.box + val xml : Glade.glade_xml Gtk.obj + method bind : name:string -> callback:(unit -> unit) -> unit + method button1 : GButton.button + method button2 : GButton.button + method button3 : GButton.button + method button4 : GButton.button + method check_widgets : unit -> unit + method reparent : GObj.widget -> unit + method toolBarEventBox : GBin.event_box + method toolBarWin : GWindow.window + method toplevel : GWindow.window + method vbox1 : GPack.box + method xml : Glade.glade_xml Gtk.obj + end +class genericDialog : + ?file:string -> + ?domain:string -> + ?autoconnect:bool -> + unit -> + object + val cancelbutton1 : GButton.button + val dialog_vbox1 : GPack.box + val genericDialog : [ `DELETE_EVENT | `ID of int | `NONE ] GWindow.dialog + val okbutton1 : GButton.button + val toplevel : [ `DELETE_EVENT | `ID of int | `NONE ] GWindow.dialog + val xml : Glade.glade_xml Gtk.obj + method bind : name:string -> callback:(unit -> unit) -> unit + method cancelbutton1 : GButton.button + method check_widgets : unit -> unit + method dialog_vbox1 : GPack.box + method genericDialog : + [ `DELETE_EVENT | `ID of int | `NONE ] GWindow.dialog + method okbutton1 : GButton.button + method reparent : GObj.widget -> unit + method toplevel : [ `DELETE_EVENT | `ID of int | `NONE ] GWindow.dialog + method xml : Glade.glade_xml Gtk.obj + end +class aboutWin : + ?file:string -> + ?domain:string -> + ?autoconnect:bool -> + unit -> + object + val aboutWin : [ `DELETE_EVENT | `ID of int | `NONE ] GWindow.dialog + val dialog_vbox2 : GPack.box + val okbutton2 : GButton.button + val toplevel : [ `DELETE_EVENT | `ID of int | `NONE ] GWindow.dialog + val xml : Glade.glade_xml Gtk.obj + method aboutWin : [ `DELETE_EVENT | `ID of int | `NONE ] GWindow.dialog + method bind : name:string -> callback:(unit -> unit) -> unit + method check_widgets : unit -> unit + method dialog_vbox2 : GPack.box + method okbutton2 : GButton.button + method reparent : GObj.widget -> unit + method toplevel : [ `DELETE_EVENT | `ID of int | `NONE ] GWindow.dialog + method xml : Glade.glade_xml Gtk.obj + end +val check_all : ?show:bool -> unit -> unit