open MatitaTypes
open MatitaGtkMisc
-let add_trailing_slash =
- let rex = Pcre.regexp "/$" in
- fun s ->
- if Pcre.pmatch ~rex s then s
- else s ^ "/"
-
-let strip_blanks =
- let rex = Pcre.regexp "^\\s*([^\\s]*)\\s*$" in
- fun s ->
- (Pcre.extract ~rex s).(1)
-
(** inherit from this class if you want to access current script *)
class scriptAccessor =
object (self)
let href_ds = Gdome.domString "href"
let xref_ds = Gdome.domString "xref"
+(* 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 =
+ let rec aux id =
+(* (prerr_endline (sprintf "id %s = %s" id
+ (try
+ CicPp.ppterm (Hashtbl.find ids_to_terms id)
+ with Not_found -> "NONE"))); *)
+ if List.mem id ids then Some id
+ else
+ (match
+ (try Hashtbl.find ids_to_father_ids id with Not_found -> None)
+ with
+ | None -> None
+ | Some id' -> aux id')
+ in
+ aux id
+ in
+ let return_father id ids =
+ match find_parent id ids with
+ | None -> assert false
+ | Some parent_id -> parent_id
+ in
+ let mk_ids terms = List.map CicUtil.id_of_annterm terms in
+ let inner_types =
+ Hashtbl.fold
+ (fun _ types acc ->
+ match types.Cic2acic.annexpected with
+ None -> types.Cic2acic.annsynthesized :: acc
+ | Some ty -> ty :: types.Cic2acic.annsynthesized :: acc
+ ) ids_to_inner_types [] in
+ match annobj with
+ | Cic.AConstant (_, _, _, Some bo, ty, _, _)
+ | Cic.AVariable (_, _, Some bo, ty, _, _)
+ | Cic.ACurrentProof (_, _, _, _, bo, ty, _, _) ->
+ return_father id (mk_ids (ty :: bo :: inner_types))
+ | Cic.AConstant (_, _, _, None, ty, _, _)
+ | Cic.AVariable (_, _, None, ty, _, _) ->
+ return_father id (mk_ids (ty::inner_types))
+ | Cic.AInductiveDefinition _ ->
+ assert false (* TODO *)
+
+ (** @return string content of a dom node having a single text child node, e.g.
+ * <m:mi xlink:href="...">bool</m:mi> *)
+let string_of_dom_node node =
+ match node#get_firstChild with
+ | None -> ""
+ | Some node ->
+ (try
+ let text = new Gdome.text_of_node node in
+ text#get_data#to_string
+ with GdomeInit.DOMCastException _ -> "")
+
class clickableMathView obj =
let text_width = 80 in
object (self)
val mutable _cic_info = None
method private set_cic_info info = _cic_info <- info
- method private cic_info =
- match _cic_info with
- | Some info -> info
- | None -> assert false
+ method private cic_info = _cic_info
initializer
self#set_font_size !current_font_size;
ignore (self#event#connect#button_press self#button_press_cb);
ignore (self#event#connect#button_release self#button_release_cb);
ignore (self#event#connect#selection_clear self#selection_clear_cb);
- ignore (self#coerce#misc#connect#selection_get self#selection_get_cb);
- self#coerce#misc#add_selection_target
- ~target:(Gdk.Atom.name Gdk.Atom.string) Gdk.Atom.primary
+ ignore (self#coerce#misc#connect#selection_get self#selection_get_cb)
val mutable button_press_x = -1.
val mutable button_press_y = -1.
val mutable selection_changed = false
-(* val mutable ignore_next_selection_clear = false *)
method private selection_get_cb ctxt ~info ~time =
(match self#get_selections with
method private choose_selection_cb gdome_elt =
let (gui: MatitaGuiTypes.gui) = get_gui () in
let clipboard = GData.clipboard Gdk.Atom.primary in
+ let set_selection elt =
+ self#set_selection (Some elt);
+ self#coerce#misc#add_selection_target
+ ~target:(Gdk.Atom.name Gdk.Atom.string) Gdk.Atom.primary;
+ ignore (self#coerce#misc#grab_selection Gdk.Atom.primary)
+ in
let rec aux elt =
if (elt#getAttributeNS ~namespaceURI:DomMisc.helm_ns
~localName:xref_ds)#to_string <> ""
-(* if elt#hasAttributeNS ~namespaceURI:DomMisc.helm_ns ~localName:xref_ds
- && (elt#getAttributeNS ~namespaceURI:DomMisc.helm_ns
- ~localName:xref_ds)#to_string <> "" *)
- then begin
- self#set_selection (Some elt);
- ignore (self#coerce#misc#grab_selection Gdk.Atom.primary)
- end else
+ then
+ set_selection elt
+ else
try
(match elt#get_parentNode with
| None -> assert false
with GdomeInit.DOMCastException _ -> ()
in
(match gdome_elt with
+ | Some elt when (elt#getAttributeNS ~namespaceURI:DomMisc.xlink_ns
+ ~localName:href_ds)#to_string <> "" ->
+ set_selection elt
| Some elt -> aux elt
| None -> self#set_selection None);
selection_changed <- true
method update_font_size = self#set_font_size !current_font_size
- method private get_term_by_id context id =
- let ids_to_terms, ids_to_hypotheses = self#cic_info in
+ method private get_term_by_id context cic_info id =
+ let ids_to_terms, ids_to_hypotheses, _, _, _ = cic_info in
try
`Term (Hashtbl.find ids_to_terms id)
with Not_found ->
`Hyp context'
with Not_found -> assert false
+ method private find_obj_conclusion id =
+ match self#cic_info with
+ | None
+ | Some (_, _, _, _, None) -> assert false
+ | Some (ids_to_terms, _, ids_to_father_ids, ids_to_inner_types, Some annobj) ->
+ let id =
+ find_root_id annobj id ids_to_father_ids ids_to_terms ids_to_inner_types
+ in
+ (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
+
+ 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
in
xref_attr#to_string
in
+ let id = get_id node in
let script = MatitaScript.instance () in
let metasenv = script#proofMetasenv in
let context = script#proofContext in
- let conclusion = script#proofConclusion in
+ let metasenv, context, conclusion =
+ if script#onGoingProof () then
+ script#proofMetasenv, script#proofContext, script#proofConclusion
+ else
+ [], [],
+ let t = self#find_obj_conclusion id in
+ MatitaLog.debug (CicPp.ppterm t);
+ t
+ in
(* TODO: code for patterns
let conclusion = (MatitaScript.instance ())#proofConclusion in
let conclusion_pattern =
ProofEngineHelpers.pattern_of ~term:conclusion cic_terms
in
*)
- let dummy_goal = ~-1 in
let string_of_cic_sequent cic_sequent =
let acic_sequent, _, _, ids_to_inner_sorts, _ =
Cic2acic.asequent_of_sequent metasenv cic_sequent
let markup = CicNotationPres.render ids_to_uris pped_ast in
BoxPp.render_to_string text_width markup
in
- let term = self#get_term_by_id context (get_id node) in
+ let cic_info =
+ match self#cic_info with Some info -> info | None -> assert false
+ in
let cic_sequent =
- match term with
+ match self#get_term_by_id context cic_info id with
| `Term t ->
let context' =
- ProofEngineHelpers.locate_in_conjecture t
- (dummy_goal, context, conclusion)
+ match
+ ProofEngineHelpers.locate_in_conjecture t
+ (~-1, context, conclusion)
+ with
+ [context,_] -> context
+ | _ -> assert false (* since it uses physical equality *)
in
- dummy_goal, context', t
- | `Hyp context -> dummy_goal, context, Cic.Rel 1
+ ~-1, context', t
+ | `Hyp context -> ~-1, context, Cic.Rel 1
in
string_of_cic_sequent cic_sequent
~font_size:None ~log_verbosity:None))
[]
-class sequentViewer obj =
+class cicMathView obj =
object (self)
inherit clickableMathView obj
+ val mutable current_mathml = None
+
method load_sequent metasenv metano =
let sequent = CicUtil.lookup_meta metano metasenv in
- let (mathml, (_, (ids_to_terms, _, ids_to_hypotheses,_ ))) =
+ let (mathml, (_, (ids_to_terms, ids_to_father_ids, ids_to_hypotheses,_ ))) =
ApplyTransformation.mml_of_cic_sequent metasenv sequent
in
- self#set_cic_info (Some (ids_to_terms, ids_to_hypotheses));
+ self#set_cic_info
+ (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 ());
self#load_root ~root:mathml#get_documentElement
- end
-class sequentsViewer ~(notebook:GPack.notebook)
- ~(sequentViewer:sequentViewer) ()
-=
+ method load_object obj =
+ let use_diff = false in (* ZACK TODO use XmlDiff when re-rendering? *)
+ let (mathml,
+ (annobj, (ids_to_terms, ids_to_father_ids, _, ids_to_hypotheses, _, ids_to_inner_types)))
+ =
+ ApplyTransformation.mml_of_cic_object obj
+ in
+ self#set_cic_info
+ (Some (ids_to_terms, ids_to_hypotheses, ids_to_father_ids, ids_to_inner_types, Some annobj));
+ (match current_mathml with
+ | Some current_mathml when use_diff ->
+ self#freeze;
+ XmlDiff.update_dom ~from:current_mathml mathml;
+ self#thaw
+ | _ ->
+ let name = "cic_browser.xml" in
+ MatitaLog.debug ("cic_browser: dumping MathML to ./" ^ name);
+ ignore (DomMisc.domImpl#saveDocumentToFile ~name ~doc:mathml ());
+ self#load_root ~root:mathml#get_documentElement;
+ current_mathml <- Some mathml);
+end
+
+class sequentsViewer ~(notebook:GPack.notebook) ~(cicMathView:cicMathView) () =
object (self)
inherit scriptAccessor
val mutable _metasenv = []
val mutable scrolledWin: GBin.scrolled_window option = None
(* scrolled window to which the sequentViewer is currently attached *)
+ val logo = (GMisc.image
+ ~file:(BuildTimeConf.runtime_base_dir ^ "/logo/matita_medium.png") ()
+ :> GObj.widget)
+
+ val logo_with_qed = (GMisc.image
+ ~file:(BuildTimeConf.runtime_base_dir ^ "/logo/matita_small.png") ()
+ :> GObj.widget)
+
+ method load_logo =
+ notebook#set_show_tabs false;
+ notebook#append_page logo
+
+ method load_logo_with_qed =
+ 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
(match scrolledWin with
| Some w ->
(* removing page from the notebook will destroy all contained widget,
- * we do not want the sequentViewer to be destroyed as well *)
- w#remove sequentViewer#coerce;
+ * we do not want the cicMathView to be destroyed as well *)
+ w#remove cicMathView#coerce;
scrolledWin <- None
| None -> ());
- for i = 1 to pages do notebook#remove_page 0 done;
+ (match switch_page_callback with
+ | Some id ->
+ GtkSignal.disconnect notebook#as_widget id;
+ switch_page_callback <- None
+ | None -> ());
+ for i = 0 to pages do notebook#remove_page 0 done;
+ notebook#set_show_tabs true;
pages <- 0;
page2goal <- [];
goal2page <- [];
goal2win <- [];
- _metasenv <- [];
+ _metasenv <- [];
self#script#setGoal ~-1;
- (match switch_page_callback with
- | Some id ->
- GtkSignal.disconnect notebook#as_widget id;
- switch_page_callback <- None
- | None -> ())
method load_sequents (status: ProofEngineTypes.status) =
let ((_, metasenv, _, _), goal) = status in
self#script#setGoal goal;
let win metano =
let w =
- GBin.scrolled_window ~hpolicy:`AUTOMATIC ~vpolicy:`AUTOMATIC
+ GBin.scrolled_window ~hpolicy:`AUTOMATIC ~vpolicy:`ALWAYS
~shadow_type:`IN ~show:true ()
in
let reparent () =
scrolledWin <- Some w;
- match sequentViewer#misc#parent with
- | None -> w#add sequentViewer#coerce
+ match cicMathView#misc#parent with
+ | None -> w#add cicMathView#coerce
| Some parent ->
let parent =
- match sequentViewer#misc#parent with
+ match cicMathView#misc#parent with
None -> assert false
| Some p -> GContainer.cast_container p
in
- parent#remove sequentViewer#coerce;
- w#add sequentViewer#coerce
+ parent#remove cicMathView#coerce;
+ w#add cicMathView#coerce
in
goal2win <- (metano, reparent) :: goal2win;
w#coerce
self#render_page ~page ~goal))
method private render_page ~page ~goal =
- sequentViewer#load_sequent _metasenv goal;
+ cicMathView#load_sequent _metasenv goal;
try
List.assoc goal goal2win ();
- sequentViewer#set_selection None
+ cicMathView#set_selection None
with Not_found -> assert false
method goto_sequent goal =
unit ->
'widget
-let sequentViewer ?hadjustment ?vadjustment ?font_size ?log_verbosity =
+let cicMathView ?hadjustment ?vadjustment ?font_size ?log_verbosity =
GtkBase.Widget.size_params
~cont:(OgtkMathViewProps.pack_return (fun p ->
OgtkMathViewProps.set_params
- (new sequentViewer (GtkMathViewProps.MathView_GMetaDOM.create p))
+ (new cicMathView (GtkMathViewProps.MathView_GMetaDOM.create p))
~font_size ~log_verbosity))
[]
| `String of string
]
-let reloadable = function
- | `About `Current_proof
- | `Dir _ ->
- true
- | _ -> false
-
class cicBrowser_impl ~(history:MatitaTypes.mathViewer_entry MatitaMisc.history)
()
=
activate_combo_query arg query
in
let toplevel = win#toplevel in
- let mathView = sequentViewer ~packing:win#scrolledBrowser#add () in
+ let mathView = cicMathView ~packing:win#scrolledBrowser#add () in
let fail message =
MatitaGtkMisc.report_error ~title:"Cic browser" ~message
~parent:toplevel ()
ignore(combo#connect#changed ~callback:start_query);
win#whelpBarImage#set_file (MatitaMisc.image_path "whelp.png");
win#mathOrListNotebook#set_show_tabs false;
-
win#browserForwardButton#misc#set_sensitive false;
win#browserBackButton#misc#set_sensitive false;
ignore (win#browserUri#entry#connect#activate (handle_error' (fun () ->
ignore (win#browserHomeButton#connect#clicked (handle_error' (fun () ->
self#load (`About `Current_proof))));
ignore (win#browserRefreshButton#connect#clicked
- (handle_error' self#refresh));
+ (handle_error' (self#refresh ~force:true)));
ignore (win#browserBackButton#connect#clicked (handle_error' self#back));
ignore (win#browserForwardButton#connect#clicked
(handle_error' self#forward));
toplevel#show ()
val mutable current_entry = `About `Blank
- val mutable current_infos = None
- val mutable current_mathml = None
val model =
new MatitaGtkMisc.taggedStringListModel tags win#whelpResultTreeview
(* loads a uri which can be a cic uri or an about:* uri
* @param uri string *)
- method private _load entry =
+ method private _load ?(force=false) entry =
try
- if entry <> current_entry || reloadable entry then begin
+ if entry <> current_entry || entry = `About `Current_proof || force then
+ begin
(match entry with
| `About `Current_proof -> self#home ()
| `About `Blank -> self#blank ()
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, ids_to_inner_sorts, ids_to_inner_types) as info)))
- =
- ApplyTransformation.mml_of_cic_object obj
- in
- current_infos <- Some info;
- (match current_mathml with
- | Some current_mathml when use_diff ->
- mathView#freeze;
- XmlDiff.update_dom ~from:current_mathml mathml;
- mathView#thaw
- | _ ->
- let name = "cic_browser.xml" in
- MatitaLog.debug ("cic_browser: dumping MathML to ./" ^ name);
- ignore (DomMisc.domImpl#saveDocumentToFile ~name ~doc:mathml ());
- mathView#load_root ~root:mathml#get_documentElement;
- current_mathml <- Some mathml);
+ (* showMath must be done _before_ loading the document, since if the
+ * widget is not mapped (hidden by the notebook) the document is not
+ * rendered *)
+ self#_showMath;
+ mathView#load_object obj
method private _loadTermCic term metasenv =
let context = self#script#proofContext in
(** this is what the browser does when you enter a string an hit enter *)
method loadInput txt =
- let txt = strip_blanks txt in
+ let txt = MatitaMisc.trim_blanks txt in
let fix_uri txt =
UriManager.string_of_uri
(UriManager.strip_xpointer (UriManager.uri_of_string txt))
let entry =
match txt with
| txt when is_uri txt -> `Uri (UriManager.uri_of_string (fix_uri txt))
- | txt when is_dir txt -> `Dir (add_trailing_slash txt)
+ | txt when is_dir txt -> `Dir (MatitaMisc.normalize_dir txt)
| txt ->
(try
entry_of_string txt
method win = win
method history = history
method currentEntry = current_entry
- method refresh () =
- if reloadable current_entry then self#_load current_entry
+ method refresh ~force () = self#_load ~force current_entry
end
-let sequentsViewer ~(notebook:GPack.notebook)
- ~(sequentViewer:sequentViewer) ()
-=
- new sequentsViewer ~notebook ~sequentViewer ()
+let sequentsViewer ~(notebook:GPack.notebook) ~(cicMathView:cicMathView) () =
+ new sequentsViewer ~notebook ~cicMathView ()
let cicBrowser () =
let size = BuildTimeConf.browser_history_size in
let history = new MatitaMisc.browser_history size (`About `Blank) in
aux history
-let default_sequentViewer () = sequentViewer ~show:true ()
-let sequentViewer_instance = MatitaMisc.singleton default_sequentViewer
+let default_cicMathView () = cicMathView ~show:true ()
+let cicMathView_instance = MatitaMisc.singleton default_cicMathView
let default_sequentsViewer () =
let gui = get_gui () in
- let sequentViewer = sequentViewer_instance () in
- sequentsViewer ~notebook:gui#main#sequentsNotebook ~sequentViewer ()
+ let cicMathView = cicMathView_instance () in
+ sequentsViewer ~notebook:gui#main#sequentsNotebook ~cicMathView ()
let sequentsViewer_instance = MatitaMisc.singleton default_sequentsViewer
let mathViewer () =
(self#get_browser reuse)#load entry
end
-let refresh_all_browsers () = List.iter (fun b -> b#refresh ()) !cicBrowsers
+let refresh_all_browsers () =
+ List.iter (fun b -> b#refresh ~force:false ()) !cicBrowsers
let update_font_sizes () =
List.iter (fun b -> b#updateFontSize) !cicBrowsers;
- (sequentViewer_instance ())#update_font_size
+ (cicMathView_instance ())#update_font_size
let get_math_views () =
- ((sequentViewer_instance ()) :> MatitaGuiTypes.clickableMathView)
+ ((cicMathView_instance ()) :> MatitaGuiTypes.clickableMathView)
:: (List.map (fun b -> b#mathView) !cicBrowsers)
let get_selections () =
projects / helm.git / blobdiff