class type cicBrowser =
object
- method loadUri: string -> unit
- method loadTerm: term_source -> unit
+ method load: MatitaTypes.mathViewer_entry -> unit
+ method loadList: string list -> MatitaTypes.mathViewer_entry-> unit
+ method loadInput: string -> unit
end
-class cicBrowser_impl ~(history:string MatitaMisc.history) () =
+class cicBrowser_impl ~(history:MatitaTypes.mathViewer_entry MatitaMisc.history)
+ ()
+=
let term_RE = Pcre.regexp "^term:(.*)" in
let trailing_slash_RE = Pcre.regexp "/$" in
let gui = MatitaGui.instance () in
inherit scriptAccessor
initializer
+ win#browserForwardButton#misc#set_sensitive false;
+ win#browserBackButton#misc#set_sensitive false;
ignore (win#browserUri#connect#activate (handle_error' (fun () ->
- self#_loadUri win#browserUri#text)));
+ self#loadInput win#browserUri#text)));
ignore (win#browserHomeButton#connect#clicked (handle_error' (fun () ->
- self#_loadUri current_proof_uri)));
+ self#_load (`About `Current_proof))));
ignore (win#browserRefreshButton#connect#clicked
(handle_error' self#refresh));
ignore (win#browserBackButton#connect#clicked (handle_error' self#back));
then
GMain.quit ();
false));
+ ignore(win#whelpResultTreeview#connect#row_activated
+ ~callback:(fun _ _ ->
+ let old = win#browserUri#text in
+ self#loadInput (old ^ self#_getWhelpResultTreeviewSelection ())));
mathView#set_href_callback (Some (fun uri ->
- handle_error (fun () -> self#_loadUri uri)));
- self#_loadUri ~add_to_history:false blank_uri;
- toplevel#show ();
+ handle_error (fun () -> self#_load (`Uri uri))));
+ self#_load (`About `Blank);
+ toplevel#show ()
- val mutable current_uri = ""
+ val mutable current_entry = `About `Blank
val mutable current_infos = None
val mutable current_mathml = None
+ val model = new MatitaGtkMisc.stringListModel win#whelpResultTreeview
+
+ method private _getWhelpResultTreeviewSelection () =
+ match model#easy_selection () with
+ | [u] -> u
+ | _ -> assert false
+
+ (** history RATIONALE
+ *
+ * all operations about history are done using _historyFoo
+ *
+ * only toplevel function like load loadList loadInput can call
+ * _historyAdd
+ *)
+
+ method private _historyAdd item =
+ history#add item;
+ win#browserBackButton#misc#set_sensitive true;
+ win#browserForwardButton#misc#set_sensitive false
+
+ method private _historyPrev () =
+ let item = history#previous in
+ if history#is_begin then win#browserBackButton#misc#set_sensitive false;
+ win#browserForwardButton#misc#set_sensitive true;
+ item
+
+ method private _historyNext () =
+ let item = history#next in
+ if history#is_end then win#browserForwardButton#misc#set_sensitive false;
+ win#browserBackButton#misc#set_sensitive true;
+ item
+
+ (** notebook RATIONALE
+ *
+ * Use only these functions to switch between the tabs
+ *)
+ method private _showList = win#mathOrListNotebook#goto_page 1
+ method private _showMath = win#mathOrListNotebook#goto_page 0
+
+
+
method private back () =
try
- self#_loadUri ~add_to_history:false history#previous
+ self#_load (self#_historyPrev ())
with MatitaMisc.History_failure -> ()
method private forward () =
try
- self#_loadUri ~add_to_history:false history#next
+ self#_load (self#_historyNext ())
with MatitaMisc.History_failure -> ()
(* loads a uri which can be a cic uri or an about:* uri
* @param uri string *)
- method private _loadUri ?(add_to_history = true) uri =
+ method private _load entry =
try
- if current_uri <> uri || uri = current_proof_uri then begin
- (match uri with
- | uri when uri = blank_uri -> self#blank ()
- | uri when uri = current_proof_uri -> self#home ()
- | uri when Pcre.pmatch ~rex:term_RE uri ->
- self#loadTerm (`String (Pcre.extract ~rex:term_RE uri).(1))
- | uri when Pcre.pmatch ~rex:trailing_slash_RE uri -> self#loadDir uri
- | _ -> self#loadUriManagerUri (UriManager.uri_of_string uri));
- self#setUri uri;
- if add_to_history then history#add uri
- end
+ if entry <> current_entry || entry = `About `Current_proof then begin
+ (match entry with
+ | `About `Current_proof -> self#home ()
+ | `About `Blank -> self#blank ()
+ | `About `Us -> () (* TODO implement easter egg here :-] *)
+ | `Check term -> self#_loadCheck term
+ | `Cic (term, metasenv) -> self#_loadTermCic term metasenv
+ | `Dir dir -> self#_loadDir dir
+ | `Uri uri -> self#_loadUriManagerUri (UriManager.uri_of_string uri)
+ | `Whelp (query, results) -> self#loadList results entry);
+ self#setEntry entry
+ end
with
- | UriManager.IllFormedUri _ -> fail (sprintf "invalid uri: %s" uri)
- | CicEnvironment.Object_not_found _ ->
- fail (sprintf "object not found: %s" uri)
+ | UriManager.IllFormedUri uri -> fail (sprintf "invalid uri: %s" uri)
+ | CicEnvironment.Object_not_found uri ->
+ fail (sprintf "object not found: %s" (UriManager.string_of_uri uri))
| Browser_failure msg -> fail msg
- method loadUri uri =
- handle_error (fun () -> self#_loadUri ~add_to_history:true uri)
method private blank () =
- mathView#load_root (MatitaMisc.empty_mathml ())#get_documentElement
+ mathView#load_root (MatitaMisc.empty_mathml ())#get_documentElement;
+ self#_showMath
+
+ method private _loadCheck term =
+ failwith "not implemented _loadCheck";
+ self#_showMath
method private home () =
+ self#_showMath;
match self#script#status.proof_status with
| Proof (uri, metasenv, bo, ty) ->
let name = UriManager.name_of_uri (MatitaMisc.unopt uri) in
let obj = Cic.CurrentProof (name, metasenv, bo, ty, [], []) in
- self#loadObj obj
+ self#_loadObj obj
| Incomplete_proof ((uri, metasenv, bo, ty), _) ->
let name = UriManager.name_of_uri (MatitaMisc.unopt uri) in
let obj = Cic.CurrentProof (name, metasenv, bo, ty, [], []) in
- self#loadObj obj
+ self#_loadObj obj
| _ -> self#blank ()
(** loads a cic uri from the environment
* @param uri UriManager.uri *)
- method private loadUriManagerUri uri =
+ method private _loadUriManagerUri uri =
let uri = UriManager.strip_xpointer uri in
let (obj, _) = CicEnvironment.get_obj CicUniv.empty_ugraph uri in
- self#loadObj obj
-
- method private loadDir dir =
- let mathml = MatitaMisc.empty_boxml () in
+ self#_loadObj obj
+
+ method private _loadDir dir =
let content = Http_getter.ls dir in
- let root = mathml#get_documentElement in
- let new_box_elt name =
- mathml#createElementNS ~namespaceURI:(Some Misc.boxml_ns)
- ~qualifiedName:(Gdome.domString ("b:" ^ name))
+ let l = List.map (function
+ | Http_getter_types.Ls_section sec -> sec
+ | Http_getter_types.Ls_object obj -> obj.Http_getter_types.uri
+ ) content
in
- let new_text content = mathml#createTextNode (Gdome.domString content) in
- let b_v = new_box_elt "v" in
- List.iter
- (fun item ->
- let b_text = new_box_elt "text" in
- let uri, elt =
- match item with
- | Http_getter_types.Ls_section subdir ->
- (dir ^ subdir ^ "/"), (new_text (subdir ^ "/"))
- | Http_getter_types.Ls_object obj ->
- (dir ^ obj.Http_getter_types.uri),
- (new_text obj.Http_getter_types.uri)
- in
- b_text#setAttributeNS ~namespaceURI:(Some Misc.xlink_ns)
- ~qualifiedName:(Gdome.domString "xlink:href")
- ~value:(Gdome.domString uri);
- ignore (b_v#appendChild ~newChild:(b_text :> Gdome.node));
- ignore (b_text#appendChild ~newChild:(elt :> Gdome.node)))
- content;
- ignore (root#appendChild ~newChild:(b_v :> Gdome.node));
-(* Misc.domImpl#saveDocumentToFile ~doc:mathml ~name:"pippo" (); *)
- mathView#load_root ~root:root
-
- method private setUri uri =
- win#browserUri#set_text uri;
- current_uri <- uri
-
- method private loadObj obj =
+ self#_loadList l
+
+ method private setEntry entry =
+ win#browserUri#set_text (string_of_entry entry);
+ current_entry <- entry
+
+ method private _loadObj obj =
+ self#_showMath;
+ (* this must be _before_ loading the document, since
+ * if the widget is not mapped (hidden by the notebook)
+ * the document is not rendered *)
let use_diff = false in (* ZACK TODO use XmlDiff when re-rendering? *)
let (mathml, (_,(ids_to_terms, ids_to_father_ids, ids_to_conjectures,
ids_to_hypotheses,_,_))) =
in
current_infos <- Some (ids_to_terms, ids_to_father_ids,
ids_to_conjectures, ids_to_hypotheses);
- match current_mathml with
+ (match current_mathml with
| Some current_mathml when use_diff ->
mathView#freeze;
XmlDiff.update_dom ~from:current_mathml mathml;
mathView#thaw
| _ ->
mathView#load_root ~root:mathml#get_documentElement;
- current_mathml <- Some mathml
-
- method private _loadTerm s = failwith "not implemented _loadTerm"
-(* TODO self#_loadTermAst (disambiguator#parserr#parseTerm (Stream.of_string s)) *)
-
- method private _loadTermAst ast = failwith "not implemented _loadTermAst"
-(* TODO
- let (_, metasenv, term, _) =
- MatitaCicMisc.disambiguate ~disambiguator ~currentProof ast
- in
- self#_loadTermCic term metasenv
-*)
+ current_mathml <- Some mathml);
method private _loadTermCic term metasenv =
let context = self#script#proofContext in
let dummyno = CicMkImplicit.new_meta metasenv [] in
let sequent = (dummyno, context, term) in
- mathView#load_sequent (sequent :: metasenv) dummyno
-
- method loadTerm (src:term_source) =
- handle_error (fun () ->
- (match src with
- | `Ast ast -> self#_loadTermAst ast
- | `Cic (cic, metasenv) -> self#_loadTermCic cic metasenv
- | `String s -> self#_loadTerm s);
- self#setUri "check")
-
+ mathView#load_sequent (sequent :: metasenv) dummyno;
+ self#_showMath
+
+ method private _loadList l =
+ model#list_store#clear ();
+ List.iter model#easy_append l;
+ self#_showList
+
+ (** { public methods } *)
+
+ method load uri =
+ handle_error (fun () -> self#_load uri);
+ self#_historyAdd uri
+
+ method loadList l entry =
+ self#_loadList l;
+ self#_historyAdd entry
+
+ method loadInput txt =
+ let add_terminating_slash s =
+ if s.[String.length s - 1] <> '/' then s^"/" else s
+ in
+ let is_uri =
+ try
+ ignore(Http_getter.resolve txt); true
+ with
+ | Http_getter_types.Key_not_found _
+ | Http_getter_types.Unresolvable_URI _ -> false
+ in
+ let entry =
+ if is_uri then
+ (`Uri txt)
+ else
+ (`Dir (add_terminating_slash txt))
+ in
+ self#_load entry;
+ self#_historyAdd entry
+
+
(** {2 methods used by constructor only} *)
method win = win
method history = history
- method currentUri = current_uri
+ method currentEntry = current_entry
method refresh () =
- if current_uri = current_proof_uri then
- self#_loadUri ~add_to_history:false current_proof_uri
-
+ if current_entry = `About `Current_proof then
+ self#_load (`About `Current_proof)
end
+
let sequentsViewer ~(notebook:GPack.notebook)
~(sequentViewer:sequentViewer) ()
=
let win = browser#win in
ignore (win#browserNewButton#connect#clicked (fun () ->
let history =
- new MatitaMisc.browser_history ~memento:history#save size ""
+ new MatitaMisc.browser_history ~memento:history#save size
+ (`About `Blank)
in
let newBrowser = aux history in
- newBrowser#loadUri browser#currentUri));
+ newBrowser#load browser#currentEntry));
(*
(* attempt (failed) to close windows on CTRL-W ... *)
MatitaGtkMisc.connect_key win#browserWinEventBox#event ~modifiers:[`CONTROL]
cicBrowsers := browser :: !cicBrowsers;
(browser :> cicBrowser)
in
- let history = new MatitaMisc.browser_history size blank_uri in
+ let history = new MatitaMisc.browser_history size (`About `Blank) in
aux history
let refresh_all_browsers () = List.iter (fun b -> b#refresh ()) !cicBrowsers
sequentsViewer ~notebook:gui#main#sequentsNotebook ~sequentViewer ()
let sequentsViewer_instance = MatitaMisc.singleton default_sequentsViewer
-
let mathViewer () =
- object
- method show_term t = (cicBrowser ()) # loadTerm t
+ object(self)
+ method private get_browser reuse =
+ if reuse then
+ (match !cicBrowsers with
+ | [] -> cicBrowser ()
+ | b :: _ -> (b :> cicBrowser))
+ else
+ (cicBrowser ())
+
+ method show_entry ?(reuse=false) t = (self#get_browser reuse)#load t
+
+ method show_uri_list ?(reuse=false) ~entry l =
+ (self#get_browser reuse)#loadList l entry
end
projects / helm.git / blobdiff