X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fmatita%2Fmatita.ml;h=a422ece1655ba7321d9ce31d1cb5fb68aaf74d0a;hb=6915a58db8db95966b9519d1d984d895e7b5fe39;hp=5056a88a26521750b551c6f9f366d075d8b97a6d;hpb=c5d4ad1c98c1434b95a8a9b1c8697dd36cf39623;p=helm.git diff --git a/helm/matita/matita.ml b/helm/matita/matita.ml index 5056a88a2..a422ece16 100644 --- a/helm/matita/matita.ml +++ b/helm/matita/matita.ml @@ -1,4 +1,4 @@ -(* Copyright (C) 2004, HELM Team. +(* Copyright (C) 2004-2005, HELM Team. * * This file is part of HELM, an Hypertextual, Electronic * Library of Mathematics, developed at the Computer Science @@ -23,132 +23,160 @@ * http://helm.cs.unibo.it/ *) -exception Not_implemented of string -let not_implemented feature = raise (Not_implemented feature) +open Printf - (** exceptions whose content should be presented to the user *) -exception Failure of string -let error s = raise (Failure s) +open MatitaGtkMisc +open MatitaTypes +open MatitaMisc -let _ = Helm_registry.load_from "matita.conf.xml" -let _ = GMain.Main.init () -let gui = new MatitaGui.gui (Helm_registry.get "matita.glade_file") +(** {2 Initialization} *) -let interactive_user_uri_choice - ~(selection_mode:[`MULTIPLE|`SINGLE]) ?(nonvars_button=false) ~title ~msg - uris -= - let only_constant_choices = - lazy - (List.filter - (fun uri -> not (String.sub uri (String.length uri - 4) 4 = ".var")) - uris) - in - if (selection_mode <> `SINGLE) && - (Helm_registry.get_bool "matita.auto_disambiguation") - then - Lazy.force only_constant_choices - else begin - let win = gui#uriChoice in - let choices = ref [] in - let chosen = ref false in - let use_only_constants = ref false in - win#uriChoiceDialog#set_title title; - win#uriChoiceLabel#set_text msg; - gui#uriChoices#list_store#clear (); - List.iter gui#uriChoices#easy_append uris; - win#uriChoiceConstantsButton#misc#set_sensitive nonvars_button; - let bye = ref (fun () -> ()) in - let id1 = - win#uriChoiceConstantsButton#connect#clicked (fun _ -> - use_only_constants := true; - !bye ()) - in - let id2 = - win#uriChoiceAutoButton#connect#clicked (fun _ -> - use_only_constants := true ; - Helm_registry.set_bool "matita.auto_disambiguation" true; - !bye ()) - in - let id3 = - win#uriChoiceSelectedButton#connect#clicked (fun _ -> - choices := gui#uriChoices#easy_selection (); - !bye ()) - in - bye := (fun () -> - win#uriChoiceDialog#misc#hide (); - win#uriChoiceConstantsButton#misc#disconnect id1; - win#uriChoiceAutoButton#misc#disconnect id2; - win#uriChoiceSelectedButton#misc#disconnect id3; - prerr_endline "quit"; - GMain.Main.quit ()); - win#uriChoiceDialog#show (); - GtkThread.main (); - if !use_only_constants then - Lazy.force only_constant_choices - else - match !choices with - | [] -> error "No choice" - | choices -> choices - end +let _ = + Helm_registry.load_from "matita.conf.xml"; (* read conf *) + Http_getter.init (); + MetadataTypes.ownerize_tables (Helm_registry.get "matita.owner"); + MatitaDb.clean_owner_environment (); + MatitaDb.create_owner_environment (); + GtkMain.Rc.add_default_file BuildTimeConf.gtkrc; (* loads gtk rc files *) + ignore (GMain.Main.init ()); -(* -module DisambiguateCallbacks = - struct - let interactive_user_uri_choice = - assert false (* TODO *) -(* interactive_user_uri_choice *) - let interactive_interpretation_choice choices = - assert false (* TODO *) - let input_or_locate_uri ~title = - assert false (* TODO *) - end -*) + (* environment trust *) + CicEnvironment.set_trust + (let trust = Helm_registry.get_bool "matita.environment_trust" in + fun _ -> trust) -let debugDialog () = - let dialog = - new MatitaGeneratedGui.debug - ~file:(Helm_registry.get "matita.glade_file") () - in - let retval = ref None in - let return v = - retval := Some v; - dialog#debug#destroy (); - GMain.Main.quit () - in - ignore (dialog#debug#event#connect#delete (fun _ -> true)); - ignore (dialog#okbutton2#connect#clicked (fun _ -> return 1)); - ignore (dialog#cancelbutton2#connect#clicked (fun _ -> return 2)); - dialog#debug#show (); - GtkThread.main (); - (match !retval with None -> assert false | Some v -> v) +(** {2 GUI callbacks} *) + +let gui = MatitaGui.instance () let _ = - gui#main#debugMenuItem2#connect#activate (fun _ -> - prerr_endline (string_of_int (debugDialog ()))) + ignore (gui#main#newCicBrowserMenuItem#connect#activate (fun _ -> + ignore (MatitaMathView.cicBrowser ()))); + (* disambiguator callback *) + MatitaDisambiguator.set_choose_uris_callback + (MatitaGui.interactive_uri_choice ()); + MatitaDisambiguator.set_choose_interp_callback + (MatitaGui.interactive_interp_choice ()) + +let script = + MatitaScript.script + ~buffer:gui#main#scriptTextView#buffer + ~init:(Lazy.force MatitaEngine.initial_status) + ~mathviewer:(MatitaMathView.mathViewer ()) + ~urichooser:(fun uris -> + try + MatitaGui.interactive_uri_choice ~selection_mode:`SINGLE + ~title:"Matita: URI chooser" + ~msg:"Select the URI" ~hide_uri_entry:true + ~hide_try:true ~ok_label:"_Apply" + ~copy_cb:(fun s -> gui#main#scriptTextView#buffer#insert ("\n"^s^"\n")) + () ~id:"boh?" uris + with MatitaTypes.Cancel -> []) + () - (** quit program, possibly asking for confirmation *) -let quit () = GMain.Main.quit () -let _ = gui#setQuitCallback quit + (* math viewers *) let _ = - gui#main#debugMenuItem0#connect#activate (fun _ -> - let uris = - interactive_user_uri_choice - ~selection_mode:`MULTIPLE - ~nonvars_button:false - ~title:"titolo" - ~msg:"messaggio" - ["cic:/uno.con"; "cic:/due.var"; "cic:/tre.con"; "cic:/quattro.con"; - "cic:/cinque.var"] - in - List.iter prerr_endline uris; print_newline ()) + let sequent_viewer = MatitaMathView.sequentViewer_instance () in + let sequents_viewer = MatitaMathView.sequentsViewer_instance () in + sequent_viewer#set_href_callback + (Some (fun uri -> (MatitaMathView.cicBrowser ())#load (`Uri uri))); + let browser_observer _ = MatitaMathView.refresh_all_browsers () in + let sequents_observer status = + sequents_viewer#reset; + match status.proof_status with + | Incomplete_proof ((proof, goal) as status) -> + sequents_viewer#load_sequents status; + sequents_viewer#goto_sequent goal + | Proof proof -> + prerr_endline "sequents_viewer#load_logo_with_qed (no proof)"; () + | No_proof -> + prerr_endline "sequents_viewer#load_logo (no proof)"; () + | Intermediate _ -> + assert false (* only the engine may be in this state *) + in + script#addObserver sequents_observer; + script#addObserver browser_observer + + (** *) let _ = - gui#main#debugMenuItem1#connect#activate (fun _ -> - Helm_registry.set_bool "matita.auto_disambiguation" - (not (Helm_registry.get_bool "matita.auto_disambiguation"))) + if BuildTimeConf.debug then begin + gui#main#debugMenu#misc#show (); + let addDebugItem ~label callback = + let item = + GMenu.menu_item ~packing:gui#main#debugMenu_menu#append ~label () + in + ignore (item#connect#activate callback) + in + addDebugItem "dump environment to \"env.dump\"" (fun _ -> + let oc = open_out "env.dump" in + CicEnvironment.dump_to_channel oc; + close_out oc); + addDebugItem "load environment from \"env.dump\"" (fun _ -> + let ic = open_in "env.dump" in + CicEnvironment.restore_from_channel ic; + close_in ic); + addDebugItem "dump universes" (fun _ -> + List.iter (fun (u,_,g) -> + prerr_endline (UriManager.string_of_uri u); + CicUniv.print_ugraph g) (CicEnvironment.list_obj ()) + ); + addDebugItem "print selected terms" (fun () -> + let i = ref 0 in + List.iter + (fun t -> + incr i; + MatitaLog.debug (sprintf "%d: %s" !i (CicPp.ppterm t))) + (MatitaMathView.sequentViewer_instance ())#get_selected_terms); + addDebugItem "dump getter settings" (fun _ -> + prerr_endline (Http_getter_env.env_to_string ())); + addDebugItem "getter: update" + (fun _ -> + ignore (Thread.create (fun () -> + MatitaLog.message "Rebuilding getter maps in background ..."; + Http_getter.update (); + MatitaLog.message "Getter maps successfully rebuilt.") ())); + addDebugItem "getter: getalluris" (fun _ -> + List.iter prerr_endline (Http_getter.getalluris ())); + addDebugItem "dump script status" script#dump; + addDebugItem "dump metasenv" + (fun _ -> + if script#onGoingProof () then + MatitaLog.debug (CicMetaSubst.ppmetasenv script#proofMetasenv [])); + addDebugItem "rotate light bulbs" + (fun _ -> + let nb = gui#main#hintNotebook in + nb#goto_page ((nb#current_page + 1) mod 3)); + (* + addDebugItem "print (on stdout) \"statement\" grammar entry" + (fun _ -> + Grammar.print_entry Format.std_formatter + (Grammar.Entry.obj CicTextualParser2.statement); + Format.pp_print_flush Format.std_formatter ());*) + end + + (** *) let _ = -(* gui#uriChoices#easy_append "pippo"; *) -(* gui#uriChoices#list_store#clear (); *) - GtkThread.main () + at_exit + (fun () -> + Http_getter_logger.log "Sync map tree to disk..."; + Http_getter.sync_dump_file (); + print_endline "\nThanks for using Matita!\n"); + Sys.catch_break true; + (try + gui#loadScript Sys.argv.(1); + with Invalid_argument _ -> ()); + if Filename.basename Sys.argv.(0) = "cicbrowser" then begin (* cicbrowser *) + Helm_registry.set "matita.mode" "cicbrowser"; + let browser = MatitaMathView.cicBrowser () in + try + browser#load (`Uri Sys.argv.(1)) + with Invalid_argument _ -> () + end else begin (* matita *) + Helm_registry.set "matita.mode" "matita"; + gui#main#mainWin#show (); + end; + try + GtkThread.main () + with Sys.Break -> ()