open MatitaTypes
open MatitaGtkMisc
+module Stack = Continuationals.Stack
+
(** inherit from this class if you want to access current script *)
class scriptAccessor =
object (self)
- method private script = MatitaScript.instance ()
+ method private script = MatitaScript.current ()
end
let cicBrowsers = ref []
let distance = sqrt (((x2 -. x1) ** 2.) +. ((y2 -. y1) ** 2.)) in
(distance < 4.)
+let xlink_ns = Gdome.domString "http://www.w3.org/1999/xlink"
+let helm_ns = Gdome.domString "http://www.cs.unibo.it/helm"
let href_ds = Gdome.domString "href"
let xref_ds = Gdome.domString "xref"
+let domImpl = Gdome.domImplementation ()
+
+ (** Gdome.element of a MathML document whose rendering should be blank. Used
+ * by cicBrowser to render "about:blank" document *)
+let empty_mathml = lazy (
+ domImpl#createDocument ~namespaceURI:(Some DomMisc.mathml_ns)
+ ~qualifiedName:(Gdome.domString "math") ~doctype:None)
+
+let empty_boxml = lazy (
+ domImpl#createDocument ~namespaceURI:(Some DomMisc.boxml_ns)
+ ~qualifiedName:(Gdome.domString "box") ~doctype:None)
+
+ (** shown for goals closed by side effects *)
+let closed_goal_mathml = lazy (
+ domImpl#createDocumentFromURI ~uri:BuildTimeConf.closed_xml ())
+
(* ids_to_terms should not be passed here, is just for debugging *)
let find_root_id annobj id ids_to_father_ids ids_to_terms ids_to_inner_types =
let find_parent id ids =
(match self#get_element_at x y with
| None -> ()
| Some elt ->
- let namespaceURI = DomMisc.xlink_ns in
let localName = href_ds in
- if elt#hasAttributeNS ~namespaceURI ~localName then
+ if elt#hasAttributeNS ~namespaceURI:xlink_ns ~localName then
self#invoke_href_callback
- (elt#getAttributeNS ~namespaceURI ~localName)#to_string
+ (elt#getAttributeNS ~namespaceURI:xlink_ns
+ ~localName)#to_string
gdk_button
else
ignore (self#action_toggle elt));
match href_callback with
| None -> ()
| Some f ->
- (match MatitaMisc.split href_value with
+ (match HExtlib.split href_value with
| [ uri ] -> f uri
| uris ->
let menu = GMenu.menu () in
ignore (self#coerce#misc#grab_selection Gdk.Atom.primary)
in
let rec aux elt =
- if (elt#getAttributeNS ~namespaceURI:DomMisc.helm_ns
+ if (elt#getAttributeNS ~namespaceURI:helm_ns
~localName:xref_ds)#to_string <> ""
then
set_selection elt
with GdomeInit.DOMCastException _ -> ()
in
(match gdome_elt with
- | Some elt when (elt#getAttributeNS ~namespaceURI:DomMisc.xlink_ns
+ | Some elt when (elt#getAttributeNS ~namespaceURI:xlink_ns
~localName:href_ds)#to_string <> "" ->
set_selection elt
| Some elt -> aux elt
(try Hashtbl.find ids_to_terms id with Not_found -> assert false)
method private string_of_node node =
- if node#hasAttributeNS ~namespaceURI:DomMisc.xlink_ns ~localName:href_ds
- then string_of_dom_node node
- else self#string_of_id_node node
+ if node#hasAttributeNS ~namespaceURI:helm_ns ~localName:xref_ds
+ then self#string_of_id_node node
+ else string_of_dom_node node
method private string_of_id_node node =
let get_id (node: Gdome.element) =
let xref_attr =
- node#getAttributeNS ~namespaceURI:DomMisc.helm_ns ~localName:xref_ds
+ node#getAttributeNS ~namespaceURI:helm_ns ~localName:xref_ds
in
- xref_attr#to_string
+ List.hd (HExtlib.split ~sep:' ' xref_attr#to_string)
in
let id = get_id node in
- let script = MatitaScript.instance () in
+ let script = MatitaScript.current () in
let metasenv = script#proofMetasenv in
let context = script#proofContext in
let metasenv, context, conclusion =
ApplyTransformation.mml_of_cic_sequent metasenv sequent
in
self#set_cic_info
- (Some (ids_to_terms, ids_to_hypotheses, ids_to_father_ids, Hashtbl.create 1, None));
+ (Some (ids_to_terms, ids_to_hypotheses, ids_to_father_ids,
+ Hashtbl.create 1, None));
let name = "sequent_viewer.xml" in
MatitaLog.debug ("load_sequent: dumping MathML to ./" ^ name);
- ignore (DomMisc.domImpl#saveDocumentToFile ~name ~doc:mathml ());
+ ignore (domImpl#saveDocumentToFile ~name ~doc:mathml ());
self#load_root ~root:mathml#get_documentElement
method load_object obj =
| _ ->
let name = "cic_browser.xml" in
MatitaLog.debug ("cic_browser: dumping MathML to ./" ^ name);
- ignore (DomMisc.domImpl#saveDocumentToFile ~name ~doc:mathml ());
+ ignore (domImpl#saveDocumentToFile ~name ~doc:mathml ());
self#load_root ~root:mathml#get_documentElement;
current_mathml <- Some mathml);
end
+let tab_label meta_markup =
+ let rec aux =
+ function
+ | `Current m -> sprintf "<b>%s</b>" (aux m)
+ | `Closed m -> sprintf "<s>%s</s>" (aux m)
+ | `Shift (pos, m) -> sprintf "|<sub>%d</sub>: %s" pos (aux m)
+ | `Meta n -> sprintf "?%d" n
+ in
+ let markup = aux meta_markup in
+ (GMisc.label ~markup ~show:true ())#coerce
+
+let goal_of_switch = function Stack.Open g | Stack.Closed g -> g
+
class sequentsViewer ~(notebook:GPack.notebook) ~(cicMathView:cicMathView) () =
object (self)
inherit scriptAccessor
notebook#set_show_tabs false;
notebook#append_page logo_with_qed
- method private tab_label metano =
- (GMisc.label ~text:(sprintf "?%d" metano) ~show:true ())#coerce
-
method reset =
(match scrolledWin with
| Some w ->
_metasenv <- [];
self#script#setGoal ~-1;
- method load_sequents (status: ProofEngineTypes.status) =
- let ((_, metasenv, _, _), goal) = status in
+ method load_sequents { proof = (_,metasenv,_,_) as proof; stack = stack } =
let sequents_no = List.length metasenv in
_metasenv <- metasenv;
- pages <- sequents_no;
- self#script#setGoal goal;
- let win metano =
+ pages <- 0;
+ let win goal_switch =
let w =
GBin.scrolled_window ~hpolicy:`AUTOMATIC ~vpolicy:`ALWAYS
~shadow_type:`IN ~show:true ()
parent#remove cicMathView#coerce;
w#add cicMathView#coerce
in
- goal2win <- (metano, reparent) :: goal2win;
+ goal2win <- (goal_switch, reparent) :: goal2win;
w#coerce
in
+ assert (
+ let stack_goals = Stack.open_goals stack in
+ let proof_goals = ProofEngineTypes.goals_of_proof proof in
+ if
+ HExtlib.list_uniq (List.sort Pervasives.compare stack_goals)
+ <> List.sort Pervasives.compare proof_goals
+ then begin
+ prerr_endline ("STACK GOALS = " ^ String.concat " " (List.map string_of_int stack_goals));
+ prerr_endline ("PROOF GOALS = " ^ String.concat " " (List.map string_of_int proof_goals));
+ false
+ end
+ else true
+ );
+ let render_switch =
+ function Stack.Open i ->`Meta i | Stack.Closed i ->`Closed (`Meta i)
+ in
let page = ref 0 in
- List.iter
- (fun (metano, _, _) ->
- page2goal <- (!page, metano) :: page2goal;
- goal2page <- (metano, !page) :: goal2page;
+ let added_goals = ref [] in
+ (* goals can be duplicated on the tack due to focus, but we should avoid
+ * multiple labels in the user interface *)
+ let add_tab markup goal_switch =
+ let goal = Stack.goal_of_switch goal_switch in
+ if not (List.mem goal !added_goals) then begin
+ notebook#append_page ~tab_label:(tab_label markup) (win goal_switch);
+ page2goal <- (!page, goal_switch) :: page2goal;
+ goal2page <- (goal_switch, !page) :: goal2page;
incr page;
- notebook#append_page ~tab_label:(self#tab_label metano) (win metano))
- metasenv;
+ pages <- pages + 1;
+ added_goals := goal :: !added_goals
+ end
+ in
+ let add_switch _ _ (_, sw) = add_tab (render_switch sw) sw in
+ Stack.iter (** populate notebook with tabs *)
+ ~env:(fun depth tag (pos, sw) ->
+ let markup =
+ match depth, pos with
+ | 0, _ -> `Current (render_switch sw)
+ | 1, pos when Stack.head_tag stack = `BranchTag ->
+ `Shift (pos, render_switch sw)
+ | _ -> render_switch sw
+ in
+ add_tab markup sw)
+ ~cont:add_switch ~todo:add_switch
+ stack;
switch_page_callback <-
Some (notebook#connect#switch_page ~callback:(fun page ->
- let goal =
- try
- List.assoc page page2goal
- with Not_found -> assert false
+ let goal_switch =
+ try List.assoc page page2goal with Not_found -> assert false
in
- self#script#setGoal goal;
- self#render_page ~page ~goal))
-
- method private render_page ~page ~goal =
- cicMathView#load_sequent _metasenv goal;
- try
- List.assoc goal goal2win ();
- cicMathView#set_selection None
- with Not_found -> assert false
+ self#script#setGoal (goal_of_switch goal_switch);
+ self#render_page ~page ~goal_switch))
+
+ method private render_page ~page ~goal_switch =
+ (match goal_switch with
+ | Stack.Open goal -> cicMathView#load_sequent _metasenv goal
+ | Stack.Closed goal ->
+ let doc = Lazy.force closed_goal_mathml in
+ cicMathView#load_root ~root:doc#get_documentElement);
+ (try
+ cicMathView#set_selection None;
+ List.assoc goal_switch goal2win ()
+ with Not_found -> assert false)
method goto_sequent goal =
- let page =
+ let goal_switch, page =
try
- List.assoc goal goal2page
+ List.find
+ (function Stack.Open g, _ | Stack.Closed g, _ -> g = goal)
+ goal2page
with Not_found -> assert false
in
notebook#goto_page page;
- self#render_page page goal
+ self#render_page page goal_switch
end
let handle_error f =
try
f ()
- with exn -> fail (MatitaExcPp.to_string exn)
+ with exn ->
+ if not (Helm_registry.get_bool "matita.debug") then
+ fail (MatitaExcPp.to_string exn)
+ else raise exn
in
let handle_error' f = (fun () -> handle_error (fun () -> f ())) in
let load_easter_egg = lazy (
let query = String.lowercase (List.nth queries combo#active) in
let input = win#queryInputText#text in
let statement = "whelp " ^ query ^ " " ^ input ^ "." in
- (MatitaScript.instance ())#advance ~statement ()
+ (MatitaScript.current ())#advance ~statement ()
in
ignore(win#queryInputText#connect#activate ~callback:start_query);
ignore(combo#connect#changed ~callback:start_query);
(* loads a uri which can be a cic uri or an about:* uri
* @param uri string *)
method private _load ?(force=false) entry =
- try
+ handle_error (fun () ->
if entry <> current_entry || entry = `About `Current_proof || force then
begin
(match entry with
self#_loadList (List.map (fun r -> "obj",
UriManager.string_of_uri r) results));
self#setEntry entry
- end
- with exn -> fail (MatitaExcPp.to_string exn)
+ end)
method private blank () =
self#_showMath;
- mathView#load_root (MatitaMisc.empty_mathml ())#get_documentElement
+ mathView#load_root (Lazy.force empty_mathml)#get_documentElement
method private _loadCheck term =
failwith "not implemented _loadCheck";
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 name = UriManager.name_of_uri (HExtlib.unopt uri) in
let obj = Cic.CurrentProof (name, metasenv, bo, ty, [], []) in
self#_loadObj obj
- | Incomplete_proof ((uri, metasenv, bo, ty), _) ->
- let name = UriManager.name_of_uri (MatitaMisc.unopt uri) in
+ | Incomplete_proof { proof = (uri, metasenv, bo, ty) } ->
+ let name = UriManager.name_of_uri (HExtlib.unopt uri) in
let obj = Cic.CurrentProof (name, metasenv, bo, ty, [], []) in
self#_loadObj obj
| _ -> self#blank ()
(** this is what the browser does when you enter a string an hit enter *)
method loadInput txt =
- let txt = MatitaMisc.trim_blanks txt in
+ let txt = HExtlib.trim_blanks txt in
let fix_uri txt =
UriManager.string_of_uri
(UriManager.strip_xpointer (UriManager.uri_of_string txt))
in
if is_whelp txt then begin
set_whelp_query txt;
- (MatitaScript.instance ())#advance ~statement:(txt ^ ".") ()
+ (MatitaScript.current ())#advance ~statement:(txt ^ ".") ()
end else begin
let entry =
match txt with
end
-let sequentsViewer ~(notebook:GPack.notebook) ~(cicMathView:cicMathView) () =
+let sequentsViewer ~(notebook:GPack.notebook) ~(cicMathView:cicMathView) ():
+ MatitaGuiTypes.sequentsViewer
+=
new sequentsViewer ~notebook ~cicMathView ()
let cicBrowser () =
:: (List.map (fun b -> b#mathView) !cicBrowsers)
let get_selections () =
- if (MatitaScript.instance ())#onGoingProof () then
+ if (MatitaScript.current ())#onGoingProof () then
let rec aux =
function
| [] -> None