1 % Heinrich Heine Universitaet Duesseldorf
2 % (c) 2021-2025 Lehrstuhl fuer Softwaretechnik und Programmiersprachen,
3 % This software is licenced under EPL 1.0 (http://www.eclipse.org/org/documents/epl-v10.html)
4
5 :- module(visb_visualiser,[load_visb_file/1,
6 load_visb_definitions_from_list_of_facts/2,
7 load_visb_definitions_from_term/2,
8 load_visb_file_if_necessary/1,
9 visb_file_is_loaded/1, visb_file_is_loaded/3,
10 visb_current_state_can_be_visualised/0,
11 get_default_visb_file/2, extended_static_check_default_visb_file/0,
12 load_default_visb_file_if_necessary/0,
13 generate_visb_html_for_history/1, generate_visb_html_for_history/2,
14 generate_visb_html_for_history_with_vars/1,
15 generate_visb_html_for_history_with_source/1,
16 generate_visb_html_for_current_state/1, generate_visb_html_for_current_state/2,
17 generate_visb_html_codes_for_states/3,
18 generate_visb_html/3,
19 tcltk_get_visb_items/1, tcltk_get_visb_events/1,
20 tcltk_get_visb_objects/1, tcltk_get_visb_hovers/1,
21 get_visb_items/1, get_visb_attributes_for_state/2,
22 get_visb_click_events/1, get_visb_hovers/1,
23 perform_visb_click_event/4,
24 tcltk_perform_visb_click_event/1,
25 get_visb_default_svg_file_contents/1,
26 get_visb_svg_objects/1]).
27
28 :- use_module(probsrc(module_information),[module_info/2]).
29 :- module_info(group,visualization).
30 :- module_info(description,'This module provides VisB visualisation functionality.').
31
32 % special SVG object attributes treated by VisB
33 % title (creates hover tooltip; currently only works with objects created by VisB itself)
34 % id
35 % svg_class
36 % text
37 % hovers
38 % event, events
39 % predicate
40
41 :- meta_predicate process_repeat(-,-,-,2).
42
43 :- use_module(extrasrc(json_parser),[json_parse_file/3]).
44 :- use_module(library(lists)).
45
46 :- use_module(probsrc(error_manager)).
47 :- use_module(probsrc(preferences),[get_preference/2]).
48 :- use_module(probsrc(debug)).
49 :- use_module(probsrc(state_space), [visited_expression/2, visited_state_corresponds_to_initialised_b_machine/1,
50 get_constants_id_for_state_id/2, get_constants_state_id_for_id/2,
51 set_context_state/2, clear_context_state/0,
52 transition/3, transition/4, invariant_violated/1, invariant_not_yet_checked/1,
53 multiple_concrete_constants_exist/0, is_concrete_constants_state_id/1]).
54 :- use_module(probsrc(translate), [translate_bvalue_to_codes/2, translate_bvalue_to_codes_with_limit/3,
55 translate_bvalue_with_limit/3]).
56 :- use_module(probsrc(specfile),[eventb_mode/0, xtl_mode/0,
57 state_corresponds_to_initialised_b_machine/2,
58 state_corresponds_to_fully_setup_b_machine/2,
59 state_corresponds_to_set_up_constants_only/2,
60 expand_to_constants_and_variables/3,
61 extract_variables_from_state/2]).
62
63 :- use_module(probsrc(tools),[start_ms_timer/1,stop_ms_walltimer_with_msg/2, ajoin_with_sep/3]).
64 :- use_module(probsrc(tools_io),[safe_open_file/4, with_open_stream_to_codes/4]).
65 :- use_module(probsrc(bmachine), [b_machine_name/1, b_get_definition_name_with_pos/4, bmachine_is_precompiled/0,
66 pre_expand_typing_scope/2, determine_type_of_formula/2, determine_type_of_formula/3]).
67 :- use_module(probsrc(bsyntaxtree), [get_texpr_ids/2]).
68 :- use_module(probsrc(tools_lists),[include_maplist/3]).
69 :- use_module(probsrc(tools),[split_list/4, html_escape_codes/2]).
70 :- use_module(probsrc(tools_matching),[get_all_svg_attributes/1, is_svg_attribute/1, is_virtual_svg_attribute/1,
71 is_svg_number_attribute/2, is_svg_color_attribute/1]).
72
73 % --------------------------
74
75 % facts storing loaded JSON VisB file:
76 :- dynamic visb_file_loaded/3, visb_svg_file/5, visb_empty_svg_box_height_width/3,
77 visb_definition/6, visb_special_definition/6,
78 visb_item/7,
79 visb_event/6, visb_hover/6, visb_has_hovers/1, visb_has_visibility_hover/1,
80 visb_event_enable_list/5,
81 visb_svg_object/5, visb_svg_object_debug_info/2,
82 visb_svg_child/2, visb_svg_parent/2.
83 :- dynamic auxiliary_visb_event/5.
84 % visb_svg_file(SVGFile, AbsolutePathSVGFile, JSONFileFromWhichWeImportSVG,PosTerm,ModLocTime)
85 % visb_item(SVGID,Attribute,TypedExpression,UsedIds,Description/Comment,StartPos,OtherMetaInfos)
86 % visb_event(SVGID,Event,PredicateList,TypedPredicate,File,Pos)
87 % visb_svg_object(SVGID,SVG_Class,AttrList,Description/Comment,Pos) ; AttrList contains svg_attribute(Attr,Val)
88
89 reset_visb :- debug_println(9,resetting_visb),
90 retractall(visb_file_loaded(_,_,_)),
91 retractall(visb_empty_svg_box_height_width(_,_,_)),
92 retractall(visb_svg_file(_,_,_,_,_)),
93 retractall(visb_definition(_,_,_,_,_,_)),
94 retractall(visb_special_definition(_,_,_,_,_,_)),
95 retractall(visb_item(_,_,_,_,_,_,_)),
96 retractall(visb_event(_,_,_,_,_,_)),
97 retractall(visb_hover(_,_,_,_,_,_)),
98 retractall(visb_has_hovers(_)),
99 retractall(visb_has_visibility_hover(_)),
100 retractall(visb_event_enable_list(_,_,_,_,_)),
101 retractall(auxiliary_visb_event(_,_,_,_,_)),
102 retractall(visb_svg_object(_,_,_,_,_)),
103 retractall(visb_svg_object_debug_info(_,_)),
104 retractall(visb_svg_child(_,_)),
105 retractall(visb_svg_parent(_,_)),
106 reset_auto_attrs.
107
108 visb_file_is_loaded(JSONFile) :-
109 visb_file_is_loaded(JSONFile,_,true).
110 visb_file_is_loaded(JSONFile,SVGFile,AllowEmpty) :-
111 visb_file_loaded(JSONFile,_,_),
112 (visb_svg_file(_,SVGFile,_,_,_) -> true
113 ; visb_empty_svg_box_height_width(_,_,_) -> SVGFile = ''
114 ; user_has_defined_visb_objects -> SVGFile = ''
115 ; JSONFile='' ->
116 AllowEmpty=true,
117 add_warning(visb_visualiser,'No VISB_SVG_FILE or VISB_SVG_OBJECTS specified in DEFINITIONS',''),
118 % Note: warning also generated below No VisB JSON file is specified and no VISB_SVG_OBJECTS were created
119 SVGFile = ''
120 ; add_warning(visb_visualiser,'No SVG file or objects specified for VisB file:',JSONFile),
121 AllowEmpty=true,
122 SVGFile = ''
123 ).
124
125 no_svg_available :-
126 \+ user_has_defined_visb_objects,
127 no_svg_file_available,
128 \+ visb_empty_svg_box_height_width(_,_,_). % no SVG box provided
129
130 no_svg_file_available :- (visb_svg_file(_,SVGFile,_,_,_) -> SVGFile='' ; true).
131
132 :- use_module(probsrc(state_space),[current_state_id/1,
133 current_state_corresponds_to_setup_constants_b_machine/0]).
134 visb_current_state_can_be_visualised :-
135 %visb_file_is_loaded(_), % no longer checked; Tcl/Tk will automatically load VisB file if required
136 (b_or_z_mode -> current_state_corresponds_to_setup_constants_b_machine
137 ; \+ current_state_id(root)
138 ).
139
140 :- use_module(probsrc(eventhandling),[register_event_listener/3]).
141 :- register_event_listener(reset_specification,reset_visb,'Reset VisB information').
142 :- register_event_listener(reset_prob,reset_visb,'Reset VisB information').
143
144 %static_check_visb :- % now done when adding items and not storing multiple items
145 % visb_item(ID,Attr,F1,_,_,Pos1), visb_item(ID,Attr,F2,_,Pos2), F1 @< F2,
146 % add_warning(visb_visualiser,'Multiple formulas for SVG identifier and attribute:',ID/Attr,Pos1),
147 % add_message(visb_visualiser,'Location of second formula for:',ID/Attr,Pos2),
148 % fail.
149 % TO DO: some sanity checks on attributes and values
150 static_check_visb :-
151 no_svg_file_available,
152 ? visb_hover(SVGID,_ID,Attr,_Enter,_Exit,Pos),
153 \+ svg_id_exists(SVGID),
154 ajoin(['Hover for attribute ',Attr,' has unknown trigger-id (can lead to blank visualisation): '],Msg),
155 add_warning(visb_visualiser,Msg,SVGID,Pos),
156 fail.
157 static_check_visb :-
158 no_svg_file_available,
159 ? visb_hover(SVGID,ID,Attr,_Enter,_Exit,Pos), ID \= SVGID,
160 \+ svg_id_exists(ID),
161 ajoin(['Hover for attribute ',Attr,' has unknown id (can lead to blank visualisation): '],Msg),
162 add_warning(visb_visualiser,Msg,ID,Pos),
163 fail.
164 static_check_visb :-
165 visb_svg_file(SvgFile,_,_,Pos,_),
166 SvgFile \= '',
167 visb_empty_svg_box_height_width(H,W,ViewBox),
168 ajoin(['VISB_SVG_BOX (width=', W, ', height=', H, ', viewBox=', ViewBox,
169 ') cannot be applied to an existing SVG file (use VISB_SVG_CONTENTS for file or put info into SVG file): '],Msg),
170 add_warning(visb_visualiser,Msg,SvgFile,Pos),
171 fail.
172 static_check_visb.
173
174 svg_id_exists(SVGID) :- visb_svg_object(SVGID,_,_StaticAttrList,_,_ExitPos).
175 % --------------------------
176
177 :- use_module(probsrc(tools),[read_string_from_file/2]).
178
179 % store templates as facts, so that compiled version of probcli does not need to find files
180 :- dynamic visb_template_file_codes/2.
181
182 assert_from_template(Filename) :- %formatsilent('Loading ~w~n',[Filename]),
183 absolute_file_name(visbsrc(Filename), Absolute, []),
184 read_string_from_file(Absolute,String),
185 assertz(visb_template_file_codes(Filename,String)).
186
187 :- assert_from_template('visb_template_header.html').
188 :- assert_from_template('visb_template_svg_downloads.html').
189 :- assert_from_template('visb_template_replayTrace.html').
190 :- assert_from_template('visb_template_middle.html').
191 :- assert_from_template('visb_template_footer.html').
192
193 write_visb_template(HtmlFile,Stream) :-
194 visb_template_file_codes(HtmlFile,Codes),
195 format(Stream,'~s~n',[Codes]).
196
197
198 % --------------------------
199
200 :- use_module(probsrc(pref_definitions),[b_get_definition_string_from_spec/3]).
201 get_default_visb_file(Path, Pos) :- get_default_visb_file(Path, _, Pos).
202 get_default_visb_file(Path, Kind, Pos) :- bmachine_is_precompiled,
203 (b_get_definition_string_from_spec('VISB_JSON_FILE', Pos, Path)
204 -> Kind=json % user provided explicit path to VISB JSON file
205 ; b_get_definition_string_from_spec('VISB_DEFINITIONS_FILE', Pos, Path)
206 -> Kind=def % user provided explicit path to VISB DEFINITIONS file
207 % TODO: in future check that file extension is compatible
208 % advantage of VISB_DEFINITIONS_FILE == "File" over "File"
209 % 1) visualisation can be re-loaded without re-loading machine
210 % 2) can be used in TLA+ or similar
211 % 3) avoid clash if definitions file itself defines empty VISB_JSON_FILE
212 % 4) avoid problems with Atelier-B or other tools
213 ; get_default_visb_svg_file(_,Pos)
214 -> Kind=empty, Path='' % user provided SVG file path
215 ; user_has_defined_visb_objects_in_defs
216 -> Kind=empty, Path='' % user provided SVG object definitions
217 ).
218
219 user_has_defined_visb_objects :-
220 ? (visb_svg_object(_,_,_,_,_) -> true % created in JSON file
221 ; user_has_defined_visb_objects_in_defs).
222
223 user_has_defined_visb_objects_in_defs :-
224 b_sorted_b_definition_prefixed(expression,'VISB_SVG_OBJECTS',_,_).
225
226 % you should do b_absolute_file_name_relative_to_main_machine
227 get_default_visb_svg_file(Path, Pos) :-
228 b_get_definition_string_from_spec('VISB_SVG_FILE', Pos, Path).
229
230
231 % load default VISB_JSON_FILE if it is specified and not already loaded
232 load_default_visb_file_if_necessary :-
233 get_default_visb_file(File, Pos),!,
234 (load_visb_file_if_necessary(File) -> true
235 ; add_error(visb_visualiser,'Could not load VISB_JSON_FILE:',File,Pos)).
236 load_default_visb_file_if_necessary :-
237 (eventb_mode -> true ; add_message(visb_visualiser,'No VISB_JSON_FILE DEFINITION provided')).
238
239 % --------------------------
240 % Loading a JSON VisB file:
241
242
243 :- use_module(probsrc(tools), [get_filename_extension/2]).
244 :- use_module(probsrc(bmachine), [
245 b_load_additional_definitions_file/1,
246 b_load_additional_definitions_from_list_of_facts/1,
247 b_load_additional_definitions_from_term/1
248 ]).
249 load_visb_file(File) :-
250 temporary_set_preference(allow_arith_operators_on_reals,true,Old),
251 call_cleanup((load_visb_file1(File)),
252 reset_temporary_preference(allow_arith_operators_on_reals,Old)).
253 load_visb_file1(File) :-
254 get_filename_extension(File,def), % a .def B definition file
255 !,
256 add_message(visb_visualiser,'Loading VisB DEFINITIONS from B file: ',File),
257 b_load_additional_definitions_file(File),
258 load_visb_file2('',File).
259 load_visb_file1(File) :- load_visb_file2(File,File).
260
261 load_visb_definitions_from_list_of_facts(DefFilePath, ListOfFacts) :-
262 temporary_set_preference(allow_arith_operators_on_reals,true,Old),
263 call_cleanup(
264 (b_load_additional_definitions_from_list_of_facts(ListOfFacts),
265 load_visb_file2('', DefFilePath)),
266 reset_temporary_preference(allow_arith_operators_on_reals,Old)).
267
268 load_visb_definitions_from_term(DefFilePath, Machine) :-
269 temporary_set_preference(allow_arith_operators_on_reals,true,Old),
270 call_cleanup(
271 (b_load_additional_definitions_from_term(Machine),
272 load_visb_file2('', DefFilePath)),
273 reset_temporary_preference(allow_arith_operators_on_reals,Old)).
274
275 load_visb_file2(File,OrigFileName) :-
276 reset_visb,
277 load_visb_from_definitions(no_inlining), % TODO: pass InlineObjects?
278 start_ms_timer(T),
279 (File='' % No JSON file
280 -> (get_default_visb_svg_file(SvgFile,DefaultSVGPos)
281 -> (SvgFile='' -> AbsFile=SvgFile % just dummy empty string provided by user
282 ; b_absolute_file_name_relative_to_main_machine(SvgFile,AbsFile)
283 ),
284 add_visb_svg_file(SvgFile,AbsFile,'',DefaultSVGPos)
285 ; check_objects_created(File) % no JSON and SVG file; check we have created objects
286 )
287 ; add_visb_file(File,[]),
288 stop_ms_walltimer_with_msg(T,'loading VisB file: ')
289 ),
290 static_check_visb,
291 (OrigFileName = ''
292 -> ModTime=0, ModLocTime=0 % We could get modification time of files with VISB_SVG_OBJECTS, ... DEFINITIONS
293 ; file_property(OrigFileName, modify_timestamp, ModTime),
294 file_property(OrigFileName, modify_localtime, ModLocTime)
295 ),
296 assertz(visb_file_loaded(OrigFileName,ModTime,ModLocTime)).
297
298 check_objects_created(File) :-
299 (visb_svg_object(_,_,_,_,_) -> true
300 ; add_warning(visb_visualiser,'No VisB JSON file is specified and no VISB_SVG_OBJECTS were created:',File)
301 ).
302
303 load_visb_from_definitions(InlineObjects) :-
304 start_ms_timer(T),
305 pre_expand_typing_scope([variables_and_additional_defs],ExpandedScope), % do this only once for all defs
306 get_svg_objects_from_definitions(InlineObjects,ExpandedScope),
307 (get_SVG_BOX_definition(InlineObjects) -> true ; true), % TODO: also pass scope
308 stop_ms_walltimer_with_msg(T,'extracting VisB infos from DEFINITIONS: ').
309
310 :- use_module(library(file_systems),[file_exists/1, file_property/3]).
311 %:- use_module(library(system),[now/1, datime/2]).
312 load_visb_file_if_necessary(File) :-
313 visb_file_loaded(File,ModTime1,_), % this file is already loaded
314 (File = '' -> true
315 ; file_exists(File),
316 file_property(File, modify_timestamp, ModTime2), % check if it has the same time stamp
317 debug_println(19,visb_json_already_loaded(File,ModTime1,ModTime2)),
318 ModTime1=ModTime2
319 ),
320 !.
321 load_visb_file_if_necessary(File) :- load_visb_file(File).
322
323
324 :- use_module(probsrc(bmachine),[set_additional_filename_as_parsing_default/3, reset_filename_parsing_default/2]).
325
326 add_visb_file(File,LoadedFiles) :- member(File,LoadedFiles),!,
327 add_error(visb_visualiser,'Circular inclusion of JSON files:',[File|LoadedFiles]).
328 add_visb_file(File,_) :- \+ file_exists(File),!,
329 add_error(visb_visualiser,'JSON file does not exist:',File), fail.
330 add_visb_file(File,LoadedFiles) :-
331 debug_format(19,'Loading JSON File: ~w~n',[File]),
332 set_additional_filename_as_parsing_default(File,NewNr,OldNr),
333 call_cleanup(add_visb_file2(File,LoadedFiles), reset_filename_parsing_default(NewNr,OldNr)).
334
335 add_visb_file2(File,LoadedFiles) :-
336 json_parse_file(File,json(List2),[position_infos(true),multiline_strings(true)]),
337 % tools_printing:trace_print(List2),nl,nl,
338 process_json(List2,File),
339 !,
340 (get_attr_with_pos(include,List2,JsonFileTerm,File,Pos)
341 -> check_json_string(JsonFileTerm,include,Pos,JsonFile),
342 absolute_file_name(JsonFile,AF,[relative_to(File)]),
343 formatsilent('Including JSON file: ~w~n',[JsonFile]),
344 add_visb_file(AF,[File|LoadedFiles])
345 ; true
346 ),
347 (LoadedFiles=[], % only check for main included file
348 ? get_attr_with_pos('model-name',List2,string(ModelName),File,MPos),
349 b_machine_name(Main), Main \= ModelName
350 -> ajoin(['VisB JSON file expects model-name ',ModelName,' instead of: '],MMsg),
351 add_warning(visb_visualiser,MMsg,Main,MPos)
352 ; true
353 ).
354 add_visb_file2(File,_) :-
355 add_error(visb_visualiser,'Unable to process JSON file:',File),
356 fail.
357
358 % process json content of a VisB file:
359 process_json(List,JSONFile) :- visb_svg_file(_,_,_,_,_),!, % we have already determined the SVG file
360 process_json2(List,JSONFile).
361 process_json(List,JSONFile) :-
362 ? get_attr_with_pos(svg_box,List,json(BoxList),JSONFile,Pos),
363 % json([=(width,400,3-3),=(height,400,3-3)])
364 ? (get_attr(svg,List,string(SvgFile)) -> SvgFile='' ; true), % check if svg attr empty or non-existant
365 force_get_attr_nr(height,BoxList,H,JSONFile),
366 force_get_attr_nr(width,BoxList,W,JSONFile),!,
367 (get_attr(viewBox,BoxList,string(VB)) -> ViewBox=VB ; ViewBox=''),
368 add_message(visb_visualiser,'Will create empty SVG image with specified dimensions: ',H:W,Pos),
369 assert_visb_empty_svg_box_height_width(H,W,ViewBox,Pos),
370 process_json2(List,JSONFile).
371 process_json(List,JSONFile) :-
372 ? get_attr_with_pos(svg,List,FileTerm,JSONFile,Pos),
373 check_json_string(FileTerm,svg,Pos,File),
374 (File = '' -> get_default_visb_svg_file(SvgFile, _)
375 ; get_default_visb_svg_file(SvgFile, DPos)
376 -> add_message(visb_visualiser,'Overriding svg file specified in JSON file: ',File,DPos)
377 ; SvgFile=File),
378 !,
379 absolute_file_name(SvgFile,AbsFile,[relative_to(JSONFile)]),
380 add_visb_svg_file(SvgFile,AbsFile,JSONFile,Pos),
381 process_json2(List,JSONFile).
382 process_json(List,JSONFile) :-
383 get_default_visb_svg_file(SvgFile, Pos), SvgFile \= '',
384 !,
385 absolute_file_name(SvgFile,AbsFile,[]), % relative to B machine??
386 add_visb_svg_file(SvgFile,AbsFile,JSONFile,Pos),
387 process_json2(List,JSONFile).
388 process_json(List,JSONFile) :-
389 process_json2(List,JSONFile),
390 (get_SVG_BOX_definition(no_inlining) -> true % TODO: pass (InlineObjects)
391 ; get_attr_with_pos(svg,List,_,JSONFile,Pos) -> % File is empty
392 add_message(visb_visualiser,'Creating empty SVG image. You can add a declaration like "svg_box": {"width":W,"height":H} to specify dimensions in: ',JSONFile,Pos)
393 ; add_warning(visb_visualiser,'Creating empty SVG image. The JSON file contains no svg attribute (pointing to the SVG file): ',JSONFile)
394 ).
395
396 add_visb_svg_file(SvgFile,AbsFile,JSONFile,Pos) :-
397 (SvgFile='' -> add_message(visb_visualiser,'Empty VisB SVG file:',SvgFile,Pos)
398 ; file_exists(AbsFile)
399 -> debug_format(19,'SVG file = ~w (~w)~n',[SvgFile, AbsFile]),
400 file_property(AbsFile, modify_localtime, ModLocTime)
401 ; add_error(visb_visualiser,'The specified VisB SVG file does not exist:',SvgFile,Pos),
402 ModLocTime=unknown
403 ),
404 assertz(visb_svg_file(SvgFile,AbsFile,JSONFile,Pos,ModLocTime)).
405
406 process_json2(List,JSONFile) :-
407 process_json_definitions(List,JSONFile),
408 process_json_items(List,JSONFile),
409 process_json_events(List,JSONFile),
410 process_json_new_svg_objects(List,JSONFile).
411
412 :- use_module(probsrc(tools_strings),[ajoin/2]).
413 check_json_string(Term,_,_,Atom) :- Term = string(Atom), atom(Atom), !.
414 check_json_string(Term,Attr,Pos,_) :- !,
415 ajoin(['Illegal JSON attribute ',Attr,', expected a JSON string:'],Msg),
416 add_error(visb_visualiser,Msg,Term,Pos),fail.
417 % ----------------
418
419 % B definitions that can help write items, events more compactly
420 process_json_definitions(List,File) :-
421 ? get_attr(definitions,List,array(Defs)),!,
422 length(Defs,Len),
423 formatsilent('VisB Definitions: ~w~n',[Len]),
424 maplist(process_json_definition(File),Defs).
425 process_json_definitions(_,_File).
426
427 % VisB items which modify attributes of SVG objects
428 process_json_items(List,File) :-
429 ? get_attr(items,List,array(Items)),!,
430 length(Items,Len),
431 formatsilent('VisB Item declarations: ~w~n',[Len]),
432 maplist(process_visb_json_item(File),Items).
433 process_json_items(_,File) :- \+ visb_special_definition(visb_updates,_,_,_,_,_),!,
434 add_message(visb_visualiser,'The JSON file contains no items: ',File).
435 process_json_items(_,_).
436
437 % VisB events which react to clicks on SVG objects and display hovers
438 process_json_events(List,File) :-
439 get_attr(events,List,array(Items)),!,
440 length(Items,Len),
441 formatsilent('VisB Event declarations: ~w~n',[Len]),
442 maplist(process_json_event(File),Items).
443 process_json_events(_,_).
444
445 % VisB additional SVG objects added to SVG file
446 process_json_new_svg_objects(List,File) :-
447 ? get_attr(svg_objects,List,array(Items)),!,
448 length(Items,Len),
449 formatsilent('VisB additional svg_objects declarations: ~w~n',[Len]),
450 maplist(process_json_svg_object(File),Items).
451 process_json_new_svg_objects(List,File) :-
452 get_attr_with_pos(objects,List,array(Items),File,Pos),!,
453 add_warning(visb_visualiser,'Use "svg_objects" attribute instead of "objects" in: ',File,Pos),
454 maplist(process_json_svg_object(File),Items).
455 process_json_new_svg_objects(_,_).
456
457 :- use_module(probsrc(custom_explicit_sets),[try_expand_custom_set_with_catch/3,
458 is_custom_explicit_set/1, is_set_value/2]).
459 % evaluate all VISB_SVG_OBJECTS... DEFINITIONS and try and extract SVG objects
460 % this must be a set of records with at least id and svg_class field
461 get_svg_objects_from_definitions(InlineObjects,ExpandedScope) :-
462 ? find_and_eval_visb_DEFINITION('VISB_SVG_OBJECTS', visb_objects, SVG_ID, AttrList, Desc, DefName,
463 _DefPos, EvalPos, InlineObjects, allow_separation, ExpandedScope),
464 %formatsilent('Generating new SVG object ~w with attrs ~w~n',[SVG_ID,AttrList]),
465 add_visb_object_from_definition(visb_objects, SVG_ID, AttrList, Desc, DefName, EvalPos),
466 fail.
467 get_svg_objects_from_definitions(InlineObjects,ExpandedScope) :-
468 find_and_eval_visb_DEFINITION('VISB_SVG_EVENTS', visb_events, SVG_ID, AttrList, Desc, DefName,
469 _DefPos, EvalPos, InlineObjects, no_separation, ExpandedScope),
470 add_visb_object_from_definition(visb_events, SVG_ID, AttrList, Desc, DefName, EvalPos),
471 fail.
472 get_svg_objects_from_definitions(InlineObjects,ExpandedScope) :-
473 ? find_and_eval_visb_DEFINITION('VISB_SVG_HOVERS', visb_hovers, SVG_ID, AttrList, Desc, DefName,
474 _DefPos, EvalPos, InlineObjects, no_separation, ExpandedScope),
475 add_visb_hovers_from_definition(SVG_ID, AttrList, Desc, DefName, EvalPos),
476 fail.
477 get_svg_objects_from_definitions(_InlineObjects,ExpandedScope) :- precompile_svg_object_updates(ExpandedScope).
478
479 % a hovers field can be something like:
480 % rec(.... hovers: (rec(class:"train-hover"),rec(trigger_id:"track_polyline",class:"train-hover")), ...)
481 % also used, e.g., as attribute in VISB_SVG_OBJECTS
482 add_visb_hovers_from_definition(SVG_ID,AttrList, Desc, DefName, DefPos) :-
483 select(svg_attribute(hovers,Hovers),AttrList,AttrList2),
484 !,
485 (AttrList2=[] -> true ; add_warning(visb_visualiser,'Unknown extra hover attributes:',AttrList2,DefPos)),
486 flex_member(Record,Hovers,DefName,DefPos),
487 (get_VISB_record_fields(Record,Fields) -> true
488 ; add_warning(visb_visualiser,'VisB hovers field value is not a record of SVG attributes: ',Record,DefPos),fail),
489 include_maplist(extract_attribute_from_record(DefPos),Fields,HoverAttrList),
490 add_visb_object_from_definition(visb_hovers, SVG_ID, HoverAttrList, Desc, DefName, DefPos).
491 add_visb_hovers_from_definition(SVG_ID,AttrList, Desc, DefName, DefPos) :-
492 add_visb_object_from_definition(visb_hovers, SVG_ID, AttrList, Desc, DefName, DefPos).
493
494
495 % add a VisB record object from a HOVER or OBJECT definition:
496 add_visb_object_from_definition(visb_objects,SVG_ID, AttrList, Desc, DefName, DefPos) :- !,
497 ? (select(svg_attribute(svg_class,SVG_Class),AttrList,AttrList2)
498 -> true % maybe we should call svg_class svg_shape and
499 % allow html_tag for children of foreignObject
500 ; add_warning(visb_visualiser,'SVG objects have no svg_class field: ',DefName,DefPos),
501 fail
502 ),
503 assert_visb_svg_object(SVG_ID,SVG_Class,AttrList2,Desc,DefName,DefPos).
504 add_visb_object_from_definition(visb_hovers,SVG_ID, AttrList, _Desc, _DefName, DefPos) :- !,
505 (select(svg_attribute(trigger_id,TriggerID),AttrList,AttrList2) -> true
506 ; select(svg_attribute('trigger-id',TriggerID),AttrList,AttrList2) -> true
507 ; TriggerID = SVG_ID, AttrList2=AttrList),
508 member(svg_attribute(Attr,EnterVal),AttrList2), % will backtrack for every SVG attribute
509 (visb_svg_object(SVG_ID,_,StaticAttrList,_,ExitPos)
510 -> (member(svg_attribute(Attr,ExitVal),StaticAttrList) -> true
511 ; default_attribute_value(Attr,ExitVal)
512 -> add_message(visb_visualiser,'Assuming default hover exit value for attribute: ',Attr,DefPos)
513 ; Attr = 'svg_class'
514 -> add_warning(visb_visualiser,
515 'svg_class cannot be set in hover for: ',SVG_ID,ExitPos),
516 ExitVal=EnterVal
517 ; (Attr = hover ; Attr = hovers) ->
518 add_error(visb_visualiser,
519 'Only provide SVG attributes here; no need to wrap them in this attribute:',Attr,DefPos),fail
520 ; add_warning(visb_visualiser,
521 'No static (exit) value can be retrieved for hover for attribute (be sure to define a static value for this attribute in a VISB_SVG_OBJECT definition): ',Attr,ExitPos),
522 ExitVal=EnterVal
523 )
524 ; ajoin(['No VISB_SVG_OBJECT for id ',SVG_ID,', cannot retrieve hover exit value for attribute: '],Msg),
525 add_warning(visb_visualiser,Msg,Attr,DefPos),
526 fail %ExitVal=EnterVal
527 ),
528 assert_visb_hover(TriggerID,SVG_ID,Attr,EnterVal,ExitVal,DefPos).
529 add_visb_object_from_definition(visb_events,SVG_ID, AttrList, _Desc, DefName, DefPos) :- !,
530 ( select(svg_attribute(event,Event),AttrList,AttrList1) -> true
531 ; select(svg_attribute(events,Events),AttrList,AttrList1) -> % we have events attributes with multiple events
532 flex_member(EvVal,Events,DefName,DefPos),
533 extract_attr_value(event,EvVal,Event,DefPos)
534 ; AttrList = [_|_], % at least one other attribute than id; otherwise it may stem from separating VISB_SVG_OBJECTS
535 add_warning(visb_visualiser,'Missing event attribute in VisB definition: ',DefName,DefPos),
536 fail
537 ),
538 (select(svg_attribute(predicate,Pred),AttrList1,AttrList2) -> Preds=[Pred]
539 ; member(P,[preds,predicates]),
540 select(svg_attribute(P,Pred),AttrList1,AttrList2)
541 -> Preds=[Pred], add_warning(visb_visualiser,'Use predicate as attribute for VisB events instead of: ',P,DefPos)
542 ; Preds=[], AttrList2=AttrList1
543 ),
544 EnableItems=[],
545 maplist(process_remaining_attributes(DefName,DefPos),AttrList2),
546 % TODO extract from AttrList2: visb_enable_item(SvgID,Attr,EnabledValExpr,DisabledValExpr,PosAttr)
547 (error_manager:extract_file_number_and_name(DefPos,_,File) -> true ; File='?'),
548 PredPos = DefPos, %TODO: improve
549 add_visb_event(SVG_ID,Event,Preds,[],EnableItems,File,DefPos,PredPos,[]).
550 add_visb_object_from_definition(SpecialClass,_, _, _, _DefName, DefPos) :-
551 add_warning(visb_visualiser,'Unknown special class, cannot add VisB objects for definition: ',SpecialClass,DefPos).
552
553 process_remaining_attributes(DefName,DefPos,svg_attribute(hover,_)) :- !,
554 add_warning(visb_visualiser,'Attribute hover not supported here (use separate VISB_SVG_HOVERS definition): ',DefName,DefPos).
555 process_remaining_attributes(DefName,DefPos,svg_attribute(hovers,_)) :- !,
556 add_warning(visb_visualiser,'Attribute hovers not supported here (use separate VISB_SVG_HOVERS definition): ',DefName,DefPos).
557 process_remaining_attributes(_,DefPos,Attr) :-
558 add_warning(visb_visualiser,'Unrecognised attribute in VISB_SVG_EVENTS definition: ',Attr,DefPos).
559
560
561 default_attribute_value(fill,black). % is remove for animate, ...
562 default_attribute_value(opacity,1).
563 default_attribute_value('stop-dasharray',none).
564 default_attribute_value('stop-opacity',1).
565 default_attribute_value('stroke-opacity',1).
566 default_attribute_value('stroke-width','1px').
567 default_attribute_value(stroke,none).
568 default_attribute_value(transform,none).
569 default_attribute_value(visibility,visible).
570
571 % is called in process_json when no SVG file specified
572 % VISB_SVG_BOX == rec(width:1000,height:1000,viewBox:"minx miny w h"),
573 get_SVG_BOX_definition(InlineObjects) :-
574 ? get_and_eval_special_definition('VISB_SVG_BOX','VISB_SVG_BOX',visb_box,DefPos,ResValue,InlineObjects),
575 (ResValue=(BH,BW) -> ViewBox=''
576 ; get_VISB_record_fields(ResValue,Fields),
577 ? select(field(height,BH),Fields,F1),
578 ? select(field(width,BW),F1,F2)
579 -> (select(field(viewBox,VBVal),F2,F3)
580 -> (VBVal=string(VB) -> ViewBox=VB
581 % Viewbox is "mx my w h" string, ie: minimum_x, minimum_y, width and height
582 ; VBVal = rec(VBFields)
583 -> (get_view_box_rec(VBFields,DefPos,ViewBox) -> true
584 ; ViewBox='',
585 add_warning(visb_visualiser,'VISB_SVG_BOX viewBox record has illegal fields (expected minx miny width height):',VBVal,DefPos))
586 ; add_warning(visb_visualiser,'VISB_SVG_BOX viewBox is not a string ("minx miny width height") or record:',VBVal,DefPos),
587 ViewBox=''
588 )
589 ; ViewBox='', F3=F2
590 ),
591 (F3=[] -> true
592 ; add_warning(visb_visualiser,'VISB_SVG_BOX unknown attributes (not height, width, viewBox): ',F2,DefPos))
593 ; add_error(visb_visualiser,'Ignoring VISB_SVG_BOX, must be record or pair of integers (height,width):',ResValue,DefPos)),
594 (get_number_from_bvalue(BH,H) -> true
595 ; add_error(visb_visualiser,'VISB_SVG_BOX Height is not a number:',ResValue,DefPos)),
596 (get_number_from_bvalue(BW,W) -> true
597 ; add_error(visb_visualiser,'VISB_SVG_BOX Width is not a number:',ResValue,DefPos)),
598 !,
599 assert_visb_empty_svg_box_height_width(H,W,ViewBox,DefPos).
600
601 get_view_box_rec([field(height,VH),field(minx,MXH),field(miny,MYH),field(width,VW)],DefPos,ViewBoxString) :-
602 (get_number_from_bvalue(VH,Height) -> true
603 ; add_error('VISB_SVG_BOX viewBox\'height is not a number:',VH,DefPos),fail),
604 (get_number_from_bvalue(VW,Width) -> true
605 ; add_error('VISB_SVG_BOX viewBox\'width is not a number:',VH,DefPos),fail),
606 (get_number_from_bvalue(MXH,MinX) -> true
607 ; add_error('VISB_SVG_BOX viewBox\'minx is not a number:',VH,DefPos),fail),
608 (get_number_from_bvalue(MYH,MinY) -> true
609 ; add_error('VISB_SVG_BOX viewBox\'miny is not a number:',VH,DefPos),fail),
610 ajoin([MinX,' ',MinY,' ', Width,' ',Height],ViewBoxString).
611
612
613 assert_visb_empty_svg_box_height_width(H,W,_ViewBox,Pos) :-
614 retract(visb_empty_svg_box_height_width(OldH,OldW,_)),
615 (OldH,OldW) \= (H,W),
616 add_message(visb_visualiser,'Overriding VisB SVG_BOX default dimensions: ',(OldH,OldW),Pos),
617 fail.
618 assert_visb_empty_svg_box_height_width(H,W,ViewBox,_Pos) :-
619 %add_message(visb_visualiser,'Setting VisB SVG_BOX default dimensions: ',(H,W,ViewBox),Pos),
620 assert(visb_empty_svg_box_height_width(H,W,ViewBox)).
621
622 :- use_module(probsrc(bsyntaxtree), [get_texpr_pos/2]).
623 :- use_module(probsrc(bmachine),[b_sorted_b_definition_prefixed/4, b_get_typed_definition/3]).
624 % find DEFINITION with given prefix in name, evaluate it and return SVG_ID and attribute list:
625 % AllowSep = allow_seperation means that the record fields can be separated into static objects and dynamic updates
626 % and only static ones will be retained (dynamic ones dealt with later)
627 find_and_eval_visb_DEFINITION(DEFPREFIX, Kind, SVG_ID, AttrList,Desc, DefName, DefPos,EvalPos,
628 InlineObjects,AllowSep,ExpandedScope) :-
629 ( b_sorted_b_definition_prefixed(expression,DEFPREFIX,DefName,DefPos),
630 ? if(b_get_typed_definition(DefName,ExpandedScope,Body),true,
631 (add_message(visb_visualiser,'Ignoring VisB DEFINITION due to errors: ',DefName),fail))
632 ; special_backup(DEFPREFIX,Kind),
633 % also look at stored definitions (e.g., from static/dynamic separation of VISB_SVG_OBJECTS)
634 visb_special_definition(Kind,DefName,_Type,Body,_Class,DefPos)
635 ),
636 set_error_context(visb_error_context(definition,DefName,'all_attributes',DefPos)),
637 ? call_cleanup((get_typed_static_definition_with_constants_state(DefName,Body,
638 ResBody,DefPos,ConstState,InlineObjects,AllowSep),
639 (get_texpr_pos(ResBody,Pos0) -> true ; Pos0=DefPos), % this could be a part of the full definition body
640 get_visb_DEFINITION_svg_object(Kind,DefName,ResBody,Pos0,ConstState,SVG_ID,AttrList,Desc,EvalPos)),
641 clear_error_context).
642
643 special_backup('VISB_SVG_HOVERS',visb_hovers).
644
645 % evaluate a typed body expressions evaluating to a record or set of records
646 % and translate into SVG attribute lists:
647 get_visb_static_svg_object_for_typed_expr(Kind,DefName,Body,DefPos,SVG_ID,AttrList,Desc,InnerPos) :-
648 AllowSep=no_separation,
649 Inline=no_inlining,
650 get_typed_static_definition_with_constants_state(DefName,Body,ResBody,DefPos,ConstState,Inline,AllowSep),
651 get_visb_DEFINITION_svg_object(Kind,DefName,ResBody,DefPos,ConstState,SVG_ID,AttrList,Desc,InnerPos).
652
653
654 flatten_couple(b(couple(A,B),_,_)) --> !,flatten_couple(A),flatten_couple(B).
655 % we could also flatten union(A,B), but at the risk of duplicate warnings when the same element occurs in A and B
656 flatten_couple(A) --> [A].
657
658 get_typed_static_definition_with_constants_state(DefName,Body,ResBody,DefPos,ConstantsState,InlineObjects,AllowSep) :-
659 flatten_couple(Body,TupleList,[]),
660 % the VISB_SVG_OBJECT definition may consist of a tuple (Obj1,Obj2,...) to allow grouping
661 (TupleList = [_,_|_]
662 -> add_debug_message(visb_visualiser,'Decomposed VisB definition body tuple:',DefName,DefPos)
663 ; true),
664 ? nth1(DefNr,TupleList,TupleBody),
665 (get_texpr_pos(TupleBody,TuplePos) -> true ; TuplePos=DefPos),
666 get_typed_static_definition_with_constants_state3(DefName,DefNr,TupleBody,ResBody,TuplePos,
667 ConstantsState,InlineObjects,AllowSep).
668 get_typed_static_definition_with_constants_state3(DefName,DefNr,Body,ResBody,DefPos,ConstantsState,InlineObjects,AllowSep) :-
669 determine_type_of_visb_formula(Body,TIds,Class),
670 debug_format(19,'Detected VisB DEFINITION ~w (~w)~n',[DefName,Class]),
671 (%Class=requires_variables, % now also useful if event field present
672 AllowSep=allow_separation, % allowed for VISB_SVG_OBJECTS
673 ? if(separate_into_static_and_dynamic_part(DefName,DefNr,Body,StaticBody,DynamicBody,EventBody,HoverBody),
674 true,
675 (get_texpr_type(Body,Type),
676 (contains_events_or_hovers_field(Type)
677 -> add_warning(visb_visualiser,'Static/Dynamic separation failed for (required for events or hovers): ',DefName,DefPos)
678 % VISB_SVG_OBJECT definition contains events/hovers and as such requires separation; which failed here
679 ; add_debug_message(visb_visualiser,'Static/Dynamic separation failed or not useful for: ',DefName,DefPos)
680 ),
681 fail)),
682 determine_type_of_visb_formula(StaticBody,SIds,SClass),
683 get_unique_initial_state_for_visb(SClass,DefName,DefPos,SIds,ConstantsState)
684 -> Separated=true, ResBody=StaticBody,
685 add_debug_message(visb_visualiser,'Automatically separated fields into static and dynamic: ',DefName,DefPos),
686 %write('STATIC: '),translate:print_bexpr(StaticBody),nl, write('DYNAMIC: '),translate:print_bexpr(DynamicBody),nl,
687 assert_visb_udpate_def_body(visb_updates,DefName,DynamicBody,DefPos),
688 add_visb_events_from_def_body(visb_events,DefName,EventBody,DefPos),
689 assert_visb_udpate_def_body(visb_hovers,DefName,HoverBody,DefPos) % needs to be asserted so that it can be evaluated after svg objects have been created to extract exit value
690 ; get_unique_initial_state_for_visb(Class,DefName,DefPos,TIds,ConstantsState)
691 -> ResBody=Body
692 ; ResBody=Body,
693 (Class=requires_constants ->
694 get_texpr_ids(TIds,Ids),
695 % we could check if values of Ids are identical in all constants solutions
696 (is_concrete_constants_state_id(_)
697 -> BMsg='multiple solutions for used constants exist: '
698 ; BMsg='but no constants were found or setup yet: '
699 ),
700 ajoin(['DEFINITION ',DefName, ' requires constants but ',BMsg],Msg),
701 (get_a_constants_state(ConstantsState,StateID,InlineObjects)
702 -> (member(CstID,Ids),
703 other_constant_value_exists_for(CstID,ConstantsState,StateID)
704 -> add_warning(visb_visualiser,Msg,CstID,DefPos)
705 ; ajoin(['DEFINITION ',DefName,
706 ' requires constants and all SETUP_CONSTANTS solutions have same value thus far: '],Msg2),
707 % constraint-based checks or execute by predicate could later create others !
708 add_message(visb_visualiser,Msg2,Ids,DefPos)
709 )
710 ; add_error(visb_visualiser,Msg,Ids,DefPos), ConstantsState=[]
711 )
712 ; ConstantsState=[]
713 )
714 ),
715 (Class=requires_variables, Separated=false
716 -> get_texpr_ids(TIds,AIds),
717 include(b_is_variable,AIds,VIds),
718 ajoin_with_sep(VIds,',',SVids),
719 (get_preference(visb_allow_variables_for_objects,false)
720 -> ajoin(['Ignoring DEFINITION which requires variables ',SVids,': '],WMsg),
721 add_warning(visb_visualiser,WMsg,DefName,DefPos),fail
722 ; ConstantsState=[]
723 -> add_warning(visb_visualiser,'Ignoring DEFINITION which requires variables, could not find unique initial state: ',DefName,DefPos),fail
724 ; ajoin(['DEFINITION requires variables ',SVids,
725 '; exporting history to HTML may not work correctly: '],WMsg),
726 add_message(visb_visualiser,WMsg,DefName,DefPos)
727 )
728 ; true).
729
730
731 :- use_module(probsrc(bsyntaxtree), [create_couple/2, create_couple/3]).
732 % separate/split/filter VISB_SVG_OBJECTS definitions into a static part and a dynamic part depending on variables
733 % (aka updates/items)
734 separate_into_static_and_dynamic_part(DefName,DefNr,Body,StaticBody,DynamicBody,EventBody,HoverBody) :-
735 ? separate_static_dyn_aux(DefName,DefNr,[],[],Body,StaticBody,DynamicBody,EventBody,HoverBody).
736
737
738 :- use_module(probsrc(bsyntaxtree),[replace_ids_by_exprs/4]).
739 rewrite_expression(let_expression(Ids,Exprs,Body),NewBody) :-
740 % currently we cannot process LET's here, expand them
741 replace_ids_by_exprs(Body,Ids,Exprs,NewBody). % see also expand_all_lets/2
742
743 separate_static_dyn_aux(DefName,DefNr,OuterQuantifiedIds,Path,b(Expr,_Type,_Info), Static,Dynamic,Event,Hover) :-
744 rewrite_expression(Expr,NewExpr),!,
745 separate_static_dyn_aux(DefName,DefNr,OuterQuantifiedIds,Path,NewExpr, Static,Dynamic,Event,Hover).
746 separate_static_dyn_aux(DefName,DefNr,OuterQuantifiedIds,Path,b(couple(A,B),_,_Info),
747 StaticCouple,DynamicCouple,EventCouple,HoverCouple) :- !,
748 separate_static_dyn_aux(DefName,DefNr,OuterQuantifiedIds,[0|Path],A,SA,DA,EA,HA),
749 separate_static_dyn_aux(DefName,DefNr,OuterQuantifiedIds,[1|Path],B,SB,DB,EB,HB),
750 create_couple(SA,SB,StaticCouple),
751 create_couple(DA,DB,DynamicCouple),
752 create_couple(EA,EB,EventCouple),
753 create_couple(HA,HB,HoverCouple).
754 separate_static_dyn_aux(DefName,DefNr,OuterQuantifiedIds,Path,TExpr,
755 b(StaticSetComp,set(ST),I),
756 b(DynamicSetComp,set(DT),I),
757 b(EventsSetComp,set(ET),I),
758 b(HoversSetComp,set(HT),I)) :-
759 ? bsyntaxtree:is_eventb_comprehension_set(TExpr,Ids,Pred,Expr),
760 (OuterQuantifiedIds = []
761 -> add_debug_message(visb_visualiser,'Top-level set comprehensions for VISB: ',Ids,TExpr)
762 ; add_message(visb_visualiser,'Nested set comprehensions for VISB: ',OuterQuantifiedIds,TExpr)
763 ),
764 !,
765 determine_type_of_visb_formula(b(exists(Ids,Pred),pred,[]),SIds,Class),
766 (get_unique_initial_state_for_visb(Class,DefName,Pred,SIds,_)
767 -> true % The predicate must be statically executable
768 ; add_message(visb_visualiser,'Cannot statically evaluate comprehension set domain: ',Pred,Pred),
769 % at the moment we require the domain to be computable statically for both static/dynamic attributes
770 fail
771 ),
772 append(OuterQuantifiedIds,Ids,NewOuterQuantifiedIds),
773 ? separate_static_dyn_aux(DefName,DefNr,NewOuterQuantifiedIds,Path,Expr,
774 StaticRec,DynamicRec,EventRec,HoverRec),
775 get_texpr_type(StaticRec,ST),
776 get_texpr_type(DynamicRec,DT),
777 get_texpr_type(EventRec,ET),
778 get_texpr_type(HoverRec,HT),
779 bsyntaxtree:get_texpr_info(TExpr,I),
780 b_ast_cleanup:rewrite_event_b_comprehension_set(Ids,StaticRec,Pred, set(ST), StaticSetComp),
781 b_ast_cleanup:rewrite_event_b_comprehension_set(Ids,DynamicRec,Pred,set(DT), DynamicSetComp),
782 b_ast_cleanup:rewrite_event_b_comprehension_set(Ids,EventRec,Pred,set(ET), EventsSetComp),
783 b_ast_cleanup:rewrite_event_b_comprehension_set(Ids,HoverRec,Pred,set(HT), HoversSetComp).
784 separate_static_dyn_aux(DefName,DefNr,OuterQuantifiedIds,Path,b(rec(Fields),_,Info),
785 b(rec(StaticFields),record(SFT),Info), % VISB_OBJECTS (static)
786 b(UpdateRecWithDynamicFields,record(DFT),Info), % VISB_UPDATES (dynamic)
787 b(rec(AllEventFields),record(EFT),Info), % VISB_EVENTS
788 b(rec(AllHoverFields),record(HFT),Info) % VISB_HOVERS
789 ) :- !,
790 split_list(is_visb_event_field,Fields,EventFields,ObjectAndHoverFields),
791 (select(field(hovers,HoverRec),ObjectAndHoverFields,ObjectFields)
792 -> HoverFields = [field(hovers,HoverRec)] % record deconstructed in add_visb_hovers_from_definition
793 ; ObjectFields=ObjectAndHoverFields, HoverFields = []),
794 % maplist(check_field_is_supported(Info),ObjectFields), % will lead to duplicate warning messages, check_visb_update_type e.g., will be called for dynamic updates
795 separate_fields(ObjectFields,StaticFields0,DynamicFields,DefName),
796 ? (member(field(svg_class,_SVG_Class),StaticFields0) -> true
797 ; member(field(svg_class,SVG_Class),DynamicFields)
798 -> add_warning(visb_visualiser,'SVG svg_class field is not static in: ',DefName,SVG_Class),
799 fail
800 ; add_warning(visb_visualiser,'No svg_class field in: ',DefName,Info),
801 fail
802 ),
803 ? (member(field(id,SVGID),StaticFields0)
804 -> (DynamicFields \= [] ; EventFields \= [] ; HoverFields \= [] % separation is useful for this record
805 ; Path \= [] % we are part of a couple; maybe other records have a dynamic,event or hover part; so proceed
806 ),
807 StaticFields = StaticFields0,
808 TStatic_SVGID = SVGID
809 ; member(field(id,SVGID),DynamicFields)
810 -> add_warning(visb_visualiser,'SVG id field is not static in: ',DefName,SVGID),
811 fail
812 ; OuterQuantifiedIds = []
813 -> gensym(svg_id,GenID),
814 ajoin(['Generated id ',GenID, ' for SVG object without id field in: '],Msg),
815 add_debug_message(visb_visualiser,Msg,DefName,Info),
816 SVGID = b(string(GenID),string,[]),
817 sort([field(id,SVGID) | StaticFields0],StaticFields)
818 ; % the record is quantified within a set comprehension; we need to compute the ID from OuterQuantifiedIds
819 % it has to be identical for VISB_SVG_OBJECTS and VISB_SVG_UPDATES
820 SVGID = b(ExtFunCall,string,[]),
821 convert_path_to_int(Path,IntPath),
822 PathExpr = b(integer(IntPath),integer,[]),
823 create_couple([b(string(DefName),string,[]),b(integer(DefNr),integer,[]),PathExpr|OuterQuantifiedIds],Tuple),
824 % add DefName and DefNr to avoid clash if other Definition has same quantified ids
825 ExtFunCall = external_function_call('SHA_HASH_HEX',[Tuple]),
826 add_debug_message(visb_visualiser,'Generated SHA_HASH_HEX call for id of SVG objects without id field in: ',DefName,Info),
827 sort([field(id,SVGID) | StaticFields0],StaticFields)
828 ),
829 maplist(get_field_type,StaticFields,SFT),
830 ( (select(field(visibility,VisibExpr),DynamicFields,RestDynamicFields)
831 ; member(field(visibility,VisibExpr),StaticFields0), % the visibility expression is static
832 RestDynamicFields = DynamicFields
833 ),
834 RestDynamicFields = [_|_],
835 \+ hovers_can_set_visibility(HoverFields),
836 (nonvar(TStatic_SVGID), TStatic_SVGID = b(string(Static_SVGID),_,_) % TODO: evaluate properly
837 -> \+ visb_has_visibility_hover(Static_SVGID) % TODO: check no other hover definition added later
838 ; true) % the ID is generated and cannot be accessed by other hovers which could make object visible
839 -> % create IF-THEN-ELSE to avoid evaluating fields when object not visible; also fixes WD issues
840 TRUE = b(boolean_true,boolean,[]),
841 sort([field(id,SVGID),field(visibility,TRUE)|RestDynamicFields],AllDynamicFields),
842 maplist(construct_dummy_value,RestDynamicFields,RestDummyFields),
843 sort([field(id,SVGID),field(visibility,b(boolean_false,boolean,[]))|RestDummyFields],AllDummyFields),
844 create_visibility_check(VisibExpr,VisibilityCond),
845 UpdateRecWithDynamicFields = if_then_else(VisibilityCond,
846 b(rec(AllDynamicFields),record(DFT),Info),
847 b(rec(AllDummyFields),record(DFT),Info)),
848 add_debug_message(visb_visualiser,'Refactoring VisB Record with visibility attribute: ',VisibilityCond)
849 % ,translate:print_bexpr(b(UpdateRecWithDynamicFields,any,[])),nl
850 ; sort([field(id,SVGID)|DynamicFields],AllDynamicFields), % TODO: use kernel_records
851 UpdateRecWithDynamicFields = rec(AllDynamicFields)
852 ),
853 maplist(get_field_type,AllDynamicFields,DFT),
854 sort([field(id,SVGID)|EventFields],AllEventFields), % ditto
855 maplist(get_field_type,AllEventFields,EFT),
856 sort([field(id,SVGID)|HoverFields],AllHoverFields), % ditto
857 maplist(get_field_type,AllHoverFields,HFT).
858 separate_static_dyn_aux(DefName,DefNr,OuterQuantifiedIds,_Path,TEXPR, _, _, _,_) :-
859 ajoin(['Uncovered expression for ',DefName,'-',DefNr,' ',OuterQuantifiedIds],Msg),
860 add_debug_message(visb_visualiser,Msg,TEXPR,TEXPR),fail.
861
862 hovers_can_set_visibility(HoverFields) :- member(field(hovers,Expr),HoverFields),
863 hover_expr_can_set_visibility(Expr).
864
865 hover_expr_can_set_visibility(b(E,_,_)) :- hovers_can_set_visib_aux(E).
866 hovers_can_set_visib_aux(couple(A,B)) :- !, (hover_expr_can_set_visibility(A) ; hover_expr_can_set_visibility(B)).
867 hovers_can_set_visib_aux(rec(Fields)) :- !, member(field(visibility,_),Fields).
868 hovers_can_set_visib_aux(set_extension(L)) :- !, member(E,L), hover_expr_can_set_visibility(E).
869 hovers_can_set_visib_aux(E) :- write(assume_hover_can_set_visibility(E)),nl.
870 % TODO: synchronise with flex_expand and check we cover all relevant cases like partial functions
871
872 :- use_module(probsrc(bsyntaxtree), [create_equality/3]).
873 create_visibility_check(VisibExpr,VisibilityCond) :- get_texpr_type(VisibExpr,string),!,
874 VISIBLE = b(string('visible'),string,[]),
875 create_equality(VisibExpr,VISIBLE,VisibilityCond).
876 create_visibility_check(VisibExpr,VisibilityCond) :-
877 TRUE = b(boolean_true,boolean,[]),
878 create_equality(VisibExpr,TRUE,VisibilityCond).
879
880 :- use_module(probsrc(typing_tools),[any_value_for_type/2]).
881 construct_dummy_value(field(Name,TExpr),field(Name,b(value(DummyValue),Type,[]))) :-
882 get_texpr_type(TExpr,Type),
883 any_value_for_type(Type,DummyValue). % object not visible: do not evaluate expression; just produce dummy value
884
885 % treat path of 0,1 as binary number, but add 1 at end to distinguish [0,0] and [0] or [1,0] and [1,0,0]
886 convert_path_to_int([],1).
887 convert_path_to_int([H|T],Res) :- convert_path_to_int(T,IT),
888 Res is IT*2+H.
889
890 % is the name of a field for events inside a VISB_SVG_OBJECT record
891 is_visb_event_field(field(Name,_)) :- is_visb_event_field_name(Name).
892 is_visb_event_field_name(event).
893 is_visb_event_field_name(events). % tuple or set of events inside VISB_SVG_OBJECTS
894 is_visb_event_field_name(predicate).
895 % is the name of a field for hovers inside a VISB_SVG_OBJECT record
896 %is_visb_hover_field_name(hovers).
897 %is_visb_hover_field_name(items). % enable items
898 %is_visb_hover_field_name(optional). % not needed ?
899 %is_visb_hover_field_name(override). % not needed ?
900
901 % check if the type of a VISB_SVG_OBJECTS expression requires separation for hovers/events
902 contains_events_or_hovers_field(set(X)) :- contains_events_or_hovers_field(X).
903 contains_events_or_hovers_field(couple(A,B)) :-
904 (contains_events_or_hovers_field(A) -> true ; contains_events_or_hovers_field(B)).
905 contains_events_or_hovers_field(record(F)) :- member(field(Name,_),F),
906 (is_visb_event_field_name(Name) -> true ; is_visb_event_field_name(Name)).
907
908 get_field_type(field(Name,Expr),field(Name,T)) :- get_texpr_type(Expr,T).
909
910 % separate fields from a SVG/VISB_SVG_OBJECT record into static part and dynamic update expressions
911 separate_fields([],[],[],_).
912 separate_fields([field(Field,Expr)|T],[field(Field,Expr)|TS],TD,DefName) :-
913 is_static_expr(Expr,Field,DefName),!,
914 separate_fields(T,TS,TD,DefName).
915 separate_fields([field(Field,Expr)|T],[field(Field,Default)|TS],[field(Field,Expr)|TD],DefName) :-
916 requires_static_default_value(Field,Default), !,
917 separate_fields(T,TS,TD,DefName).
918 separate_fields([H|T],TS,[H|TD],DefName) :-
919 separate_fields(T,TS,TD,DefName).
920
921 % fields which require a static default value; here to set up child SVG objects of title
922 % static default values could also be useful for hovers in general?
923 requires_static_default_value(title,b(string('-title-not-set-'),string,[])).
924
925 % virtual SVG attributes which are translated to children tags/objects
926 attribute_automatically_creates_children(title).
927
928 is_static_expr(Expr,Field,DefName) :-
929 determine_type_of_visb_formula(Expr,_TIds,Class), % TODO pass local variables from exists above
930 (Class=requires_nothing -> true
931 ; Class=requires_constants,
932 \+ multiple_concrete_constants_exist, % TODO: check if _TIds have multiple solutions
933 is_concrete_constants_state_id(_) -> true
934 ; ajoin(['Detected dynamic expression for field ',Field,' in ',DefName,': '],Msg),
935 add_debug_message(visb_visualiser,Msg,Expr,Expr),fail
936 ).
937
938 % --------
939
940
941 extract_attribute_from_record(DefPos,field(OrigName,Value),svg_attribute(Name,SVal)) :-
942 opt_rewrite_field_name(OrigName,Name),
943 extract_attribute_value(DefPos,Name,Value,SVal).
944 extract_attribute_from_record(DefPos,F,_) :-
945 add_error(bvisualiser,'Extract SVG attribute failed: ',F,DefPos),fail.
946
947 % extract a value for a particular field Name
948 extract_attribute_value(DefPos,Name,Value,SVal) :-
949 (deconstruct_singleton_set(Name,Value,Element)
950 -> Element \= '$optional_field_absent',
951 extract_attr_value(Name,Element,SVal,DefPos)
952 ; extract_attr_value(Name,Value,SVal,DefPos)
953 ).
954
955 :- use_module(probsrc(specfile), [classical_b_mode/0]).
956
957 % in TLA+ mode optional record fields have {TRUE|->VALUE} rather than VALUE
958 % this can also be useful in B to allow mixing different SVG records in a set
959 % for Alloy mode we may want to also support singleton sets as scalars
960 deconstruct_singleton_set(Name,Set,Res) :-
961 singleton_set(Set,El),
962 detect_partial_records_for_field(Name),
963 (El=(pred_true,El2)
964 -> Val=El2 % TLA2B encoding for optional fields that are present
965 ; Val=El), % Alloy
966 !,
967 Res = Val.
968 deconstruct_singleton_set(Name,[],Res) :-
969 detect_partial_records_for_field(Name),
970 Res = '$optional_field_absent'.
971
972 detect_partial_records_for_field(children) :- !, fail. % children field for groups is a set of ids
973 detect_partial_records_for_field(Name) :-
974 is_svg_number_attribute(Name),!. % sets never sensible as a numerical value
975 detect_partial_records_for_field(Name) :- is_id_or_text_attribute(Name),!. % ditto for ids
976 detect_partial_records_for_field(Name) :- is_svg_color_attribute(Name),!. % ditto for colors
977 detect_partial_records_for_field(_) :-
978 \+ classical_b_mode. % TODO: check that we are in TLA or Alloy mode?
979 % TODO: ensure ProB2 sets animation minor mode for TLA
980
981 :- use_module(probsrc(tools),[split_chars/3, safe_number_codes/2,safe_atom_codes/2]).
982 :- use_module(extrasrc(external_functions_svg),[svg_points/4]).
983 extract_attr_value(Name,Value,SVal,DefPos) :-
984 is_svg_number_attribute(Name),!, % we could try and extract svg_class from attribute list above
985 (get_number_from_bvalue(Value,NrVal)
986 -> SVal=NrVal % convert to atom?
987 ; b_value_to_string(Value,SVal),
988 (is_special_svg_number_form(SVal) -> true
989 ; atom_codes(SVal,CC),
990 safe_number_codes(_NrVal,CC) -> true
991 ; ajoin(['The value of the SVG attribute "',Name,
992 '" is not a number: '],Msg),
993 add_warning(visb_visualiser,Msg,SVal,DefPos)
994 )
995 ).
996 extract_attr_value(children,Value,SVal,DefPos) :- !,
997 (is_set_value(Value,extract_attr_value)
998 -> (try_expand_custom_set_with_catch(Value,ExpandedSet,extract_attr_value),
999 maplist(b_value_to_id_string,ExpandedSet,SVal) -> true
1000 ; add_warning(visb_visualiser,'The children attribute should be a finite set of identifiers: ',Value,DefPos),
1001 SVal=[]
1002 )
1003 ; add_warning(visb_visualiser,'The children attribute should be a set of identifiers: ',Value,DefPos),
1004 SVal=[]).
1005 extract_attr_value(points,Value,SVal,DefPos) :- % Class should be polygon or polyline
1006 % automatically translate sequences of pairs of numbers to SVG string format
1007 (Value = [(int(_),_)|_] ; Value = avl_set(node((int(_),_),_,_,_,_))), % TODO: check typing
1008 svg_points(Value,Str,DefPos,no_wf_available),!,
1009 string(SVal)=Str.
1010 extract_attr_value(points,Value,SVal,_DefPos) :- Value = [],!, SVal = ''.
1011 extract_attr_value(visibility,Value,SVal,DefPos) :- !,
1012 % convert TRUE -> visible, FALSE -> hidden
1013 ( Value=pred_true -> TxtVal='visible'
1014 ; Value=pred_false -> TxtVal='hidden'
1015 ; b_value_to_text_string(Value,TxtVal),
1016 ? (member(TxtVal,[collapse,hidden,visible]) -> true
1017 ; add_warning(visb_visualiser,'Value of SVG attribute "visibility" must be collapse,hidden or visible and not: ',TxtVal,DefPos))
1018 ),
1019 SVal=TxtVal.
1020 extract_attr_value(Name,Value,_,DefPos) :-
1021 is_svg_color_attribute(Name),
1022 illegal_color(Value),
1023 ajoin(['Value of SVG attribute "',Name,
1024 '" is not a colour: ' ],Msg),
1025 add_warning(visb_visualiser,Msg,Value,DefPos),fail.
1026 extract_attr_value(Name,Value,SVal,_) :-
1027 ? is_id_or_text_attribute(Name),!,
1028 (is_text_attribute(Name)
1029 -> b_value_to_text_string(Value,SVal)
1030 ; b_value_to_id_string(Value,SVal)).
1031 extract_attr_value(Attr,RawValue,ResValue,_DefPos) :- raw_value_attribute(Attr),!, % keep value intact
1032 ResValue = RawValue.
1033 extract_attr_value(_Name,Value,SVal,_) :-
1034 b_value_to_string(Value,SVal).
1035
1036 % do not convert to string; these are treated separately
1037 raw_value_attribute(hovers).
1038 raw_value_attribute(events).
1039
1040 % now checked by check_attribute_type for updates, we could later check strings, currentcolor is allowed
1041 illegal_color(pred_false).
1042 illegal_color(pred_true).
1043 illegal_color([]).
1044 illegal_color(avl_set(_)).
1045 illegal_color([_|_]).
1046 illegal_color(closure(_,_,_)).
1047 illegal_color(term(floating(_))).
1048
1049 % evaluate a DEFINITION to a set of B records representing SVG objects
1050 % returns a possibly refined sub-position corresponding to generated SVG objects as last argument
1051 get_visb_DEFINITION_svg_object(SpecialClass,DefName,Body,_DefPos,ExpandedState,SVG_ID,AttrList,Desc,InnerPos) :-
1052 get_preference(visb_show_debug_infos,true),
1053 bsyntaxtree:is_eventb_comprehension_set(Body,Ids,Pred,Expr),
1054 % try and separate couple in Expr so that we have better position info for source of VISB_SVG_OBJECTS
1055 Body = b(_,Type,II),
1056 Expr = b(couple(_,_),_,_),
1057 !,
1058 couple_member(NewExpr,Expr), % evaluate each part of the couple in isolation, with better position info
1059 get_texpr_pos(NewExpr,InnerPos),
1060 b_ast_cleanup:rewrite_event_b_comprehension_set(Ids,NewExpr,Pred, Type, NewBody),
1061 get_visb_DEF_svg_object_aux(SpecialClass,DefName,b(NewBody,Type,II),InnerPos,ExpandedState,SVG_ID,AttrList,Desc).
1062 get_visb_DEFINITION_svg_object(SpecialClass,DefName,Body,DefPos,ExpandedState,SVG_ID,AttrList,Desc,DefPos) :-
1063 ? get_visb_DEF_svg_object_aux(SpecialClass,DefName,Body,DefPos,ExpandedState,SVG_ID,AttrList,Desc).
1064
1065 couple_member(TExpr,b(couple(A,B),_,_)) :- !, (couple_member(TExpr,A) ; couple_member(TExpr,B)).
1066 couple_member(TExpr,TExpr).
1067
1068 get_visb_DEF_svg_object_aux(SpecialClass,DefName,Body,DefPos,ExpandedState,SVG_ID,AttrList,Desc) :-
1069 evaluate_visb_formula(Body,DefName,'',ExpandedState,ResValue,DefPos),
1070 flex_expand(ResValue,DefName,DefPos,Expanded,[]),
1071 (Expanded = [] -> add_message(visb_visualiser,'Empty set of SVG object records: ',DefName,DefPos)
1072 ; Expanded =[Record|_] ->
1073 (get_VISB_record_fields(Record,Fs)
1074 % TODO: as we now can have different type of records, check in flex_expand below
1075 ? -> (member(field(id,_),Fs)
1076 -> true
1077 ; add_message(visb_visualiser,'DEFINITION needs an `id` field if you want to use updates: ',DefName,DefPos)
1078 )
1079 ; ajoin(['DEFINITION ', DefName,' should evaluate to a set of records or tuples of records: '],Msg),
1080 add_warning(visb_visualiser,Msg,Record,DefPos)
1081 )
1082 ),
1083 ? member(Records,Expanded),
1084 get_VISB_record_fields(Records,Fields),
1085 ? (select(field(id,VID),Fields,F1)
1086 -> extract_attribute_value(DefPos,id,VID,SVG_ID)
1087 ; gensym(svg_id,SVG_ID), F1=Fields),
1088 (select(field(comment,CC),F1,F2), b_value_to_string(CC,Desc) -> true
1089 ; Desc = '', F2=F1),
1090 (SpecialClass=visb_updates, member(field(visibility,VV),F2),
1091 is_invisible(VV),
1092 \+ visb_has_visibility_hover(SVG_ID) % check for hover which may make object visible
1093 -> AttrList=[svg_attribute(visibility,'hidden')] % do not transmit updates
1094 ? ; include_maplist(extract_attribute_from_record(DefPos),F2,AttrList0),
1095 exclude(check_unsupported_special_visb_attribute(SpecialClass,DefPos),AttrList0,AttrList),
1096 ? (select(svg_attribute(svg_class,SVG_Class),AttrList,A2)
1097 -> maplist(check_attribute_is_supported(SVG_Class,DefPos),A2)
1098 ; true)
1099 ).
1100
1101 is_invisible(string(hidden)). % also treat collapse ?
1102 is_invisible(pred_false).
1103
1104 % expand nested tuples/sets to a single list of SVG records (possibly of different types)
1105 flex_expand(Value,DefName,Pos) --> {is_custom_explicit_set(Value)},!,
1106 {try_expand_custom_set_with_catch(Value,ExpandedSet,flex_expand),
1107 (is_custom_explicit_set(ExpandedSet)
1108 -> ajoin(['Could not expand set of SVG object records or tuples thereof for ',DefName,': '],Msg),
1109 add_warning(visb_visualiser,Msg,Value,Pos),
1110 fail
1111 ; true)},
1112 flex_expand(ExpandedSet,DefName,Pos).
1113 flex_expand([],_,_) --> !, [].
1114 flex_expand(L,_DefName,_Pos) --> {L =[(string(_),string(_))|_]}, !,
1115 [L]. % is probably a partial function {"id" |-> ,...}
1116 flex_expand([H|T],DefName,Pos) --> !, flex_expand(H,DefName,Pos), l_flex_expand(T,DefName,Pos).
1117 flex_expand((A,B),DefName,Pos) --> !, flex_expand(A,DefName,Pos), flex_expand(B,DefName,Pos).
1118 flex_expand(T,_,_) --> [T].
1119
1120 l_flex_expand([],_,_) --> !, [].
1121 l_flex_expand([H|T],DefName,Pos) --> !, flex_expand(H,DefName,Pos), l_flex_expand(T,DefName,Pos).
1122 l_flex_expand(T,_,_) --> [T].
1123
1124 flex_member(X,SetPairVal,DefName,Pos) :- flex_expand(SetPairVal,DefName,Pos,List,[]), member(X,List).
1125
1126
1127 % get the fields of a B value record
1128 % also transparently handles alternative representations, like a function from STRING to STRING
1129 get_VISB_record_fields(rec(Fields),Res) :- !, Res=Fields.
1130 get_VISB_record_fields(StringFunction,Fields) :-
1131 is_set_value(StringFunction,get_VISB_record_fields),
1132 try_expand_custom_set_with_catch(StringFunction,Expanded,get_VISB_record_fields),
1133 % TODO: check we have no duplicates
1134 maplist(convert_to_field,Expanded,Fields).
1135 % TODO: support records as generated by READ_XML:
1136 % rec(attributes:{("fill"|->"#90ee90"),("height"|->"360px"),("id"|->"background_rect"),("width"|->"600px"),("x"|->"1px"),("y"|->"2px")},element:"rect",meta:{("xmlLineNumber"|->"3")},pId:5,recId:6)
1137 % for <rect height="360px" x="1px" y="2px" id="background_rect" width="600px" fill="#90ee90"></rect>
1138
1139 convert_to_field((string(FieldName),Value),field(FieldName,Value)).
1140 % TODO: maybe handle enumerated set values as field names
1141
1142
1143 % already extract and type-check VISB_SVG_UPDATES definitions
1144 precompile_svg_object_updates(ExpandedScope) :-
1145 b_sorted_b_definition_prefixed(expression,'VISB_SVG_UPDATES',DefName,DefPos),
1146 b_get_typed_definition(DefName,ExpandedScope,TypedExpr),
1147 assert_visb_udpate_def_body(visb_updates,DefName,TypedExpr,DefPos),
1148 fail.
1149 precompile_svg_object_updates(_).
1150
1151 % assert VisB updates or hovers from B DEFINITION,
1152 % either from VISB_SVG_UPDATES or hovers or dynamic parts of VISB_SVG_OBJECTS:
1153 assert_visb_udpate_def_body(_Kind,DefName,TypedExpr,_DefPos) :-
1154 TypedExpr=b(rec([field(id,_)]),_,Info),!, % can happen when all fields are static
1155 add_debug_message(visb_visualiser,'Useless update/hover (just id field): ',DefName,Info).
1156 assert_visb_udpate_def_body(Kind,DefName,TypedExpr,DefPos) :-
1157 get_texpr_type(TypedExpr,Type),
1158 determine_type_of_visb_formula(TypedExpr,_,FormulaClass),
1159 debug_format(19,'Detected ~w: ~w (~w)~n',[Kind,DefName,FormulaClass]),
1160 assertz(visb_special_definition(Kind,DefName,Type,TypedExpr,FormulaClass,DefPos)),
1161 check_visb_update_type(Kind,Type,DefName,unknown_svg_class,DefPos).
1162
1163 % assert VisB events or hovers from B DEFINITION, from part of VISB_SVG_OBJECTS:
1164 % supporting event attribute and optional predicate attribute
1165 % Kind = visb_events or visb_hovers
1166 add_visb_events_from_def_body(Kind,DefName,Body,DefPos) :-
1167 get_texpr_type(Body,Type),
1168 \+ empty_update_or_hover_type(Type), % at least one more field than just id field
1169 get_visb_static_svg_object_for_typed_expr(Kind,DefName,Body,DefPos,SVG_ID,AttrList,Desc,InnerPos),
1170 add_visb_object_from_definition(Kind, SVG_ID, AttrList, Desc, DefName, InnerPos),
1171 fail.
1172 add_visb_events_from_def_body(_,_,_,_).
1173
1174 empty_update_or_hover_type(record(Fields)) :- !, Fields \= [_,_|_]. % at least one more field than just id field
1175 empty_update_or_hover_type(set(X)) :- !, empty_update_or_hover_type(X).
1176 empty_update_or_hover_type(couple(A,B)) :- !, empty_update_or_hover_type(A), empty_update_or_hover_type(B).
1177
1178 get_svg_object_updates_from_definitions(ExpandedBState,SVG_ID,SvgAttribute,Value,Pos) :-
1179 ? visb_special_definition(visb_updates,DefName,_Type,BodyTypedExpr,_Class,DefPos),
1180 ? get_visb_DEFINITION_svg_object(visb_updates,DefName,BodyTypedExpr,DefPos,ExpandedBState,SVG_ID,AttrList,_Desc,Pos),
1181 ? member(svg_attribute(SvgAttribute,Value),AttrList).
1182
1183 check_visb_update_type(Kind,Type,DefName,Class,DefPos) :-
1184 get_update_record_fields_type(Type,Fields),
1185 % other types are STRING +-> STRING, ...; this will be checked in get_visb_DEFINITION_svg_object
1186 (memberchk(field('svg_class',_),Fields)
1187 -> add_warning(visb_visualiser,'VisB updates should not set svg_class:',DefName,DefPos)
1188 ; true),
1189 ? member(field(Name,FieldType),Fields),
1190 (Name = trigger_id ->
1191 (Kind=visb_hovers -> true ;
1192 add_warning(visb_visualiser,'Attribute trigger_id can only be used for hovers:',DefName,DefPos)
1193 )
1194 ; check_attribute_type(FieldType,Name,DefName,Class,DefPos)
1195 ),
1196 fail.
1197 check_visb_update_type(_,_,_,_,_).
1198
1199 % get a fields type list from a type
1200 get_update_record_fields_type(set(X),Fields) :- !,
1201 get_update_record_fields_type(X,Fields).
1202 get_update_record_fields_type(record(Fields),R) :- !, R=Fields.
1203 get_update_record_fields_type(couple(A,B),Fields) :-
1204 (get_update_record_fields_type(A,Fields)
1205 ; get_update_record_fields_type(B,Fields)).
1206
1207 :- use_module(probsrc(translate), [pretty_type/2]).
1208 % check B type of a field for an SVG update or object
1209 check_attribute_type(Type,Name,DefName,Class,DefPos) :- alternative_spelling(Name,AName),!,
1210 check_attribute_type(Type,AName,DefName,Class,DefPos).
1211 check_attribute_type(Type,Name,DefName,Class,DefPos) :- Class \= unknown_svg_class,
1212 check_is_number_attribute(Name,Class,DefPos),!,
1213 illegal_number_type(Type),
1214 ajoin(['Type of field ',Name,' of ', DefName, ' is not a number: '],Msg),
1215 pretty_type(Type,TS),
1216 add_warning(visb_visualiser,Msg,TS,DefPos).
1217 check_attribute_type(Type,Name,DefName,_,DefPos) :-
1218 is_svg_color_attribute(Name),!,
1219 illegal_col_type(Type),
1220 ajoin(['Type of field ',Name,' of ', DefName, ' is not a color: '],Msg),
1221 pretty_type(Type,TS),
1222 add_warning(visb_visualiser,Msg,TS,DefPos).
1223 check_attribute_type(_Type,Name,_DefName,Class,DefPos) :-
1224 check_attribute_name_is_supported(Class,Name,DefPos).
1225
1226 illegal_nr_or_col_type(boolean).
1227 illegal_nr_or_col_type(set(_)).
1228 illegal_nr_or_col_type(seq(_)).
1229 illegal_nr_or_col_type(record(_)).
1230 illegal_nr_or_col_type(couple(A,B)) :- (illegal_nr_or_col_type(A) -> true ; illegal_nr_or_col_type(B)).
1231 % check if couple types can work by concatenating string representations
1232
1233 illegal_col_type(X) :- illegal_nr_or_col_type(X),!.
1234 illegal_col_type(real).
1235 % integer ? or can we map integers to colours using a color scheme like in DOT?
1236
1237 illegal_number_type(X) :- illegal_nr_or_col_type(X),!.
1238 %illegal_number_type(global(_)). % what if we use a global set with weird constants using back-quotes ?
1239
1240 % ----------------
1241
1242 % parse and load an individual JSON VisB item, e.g, :
1243 % { "name":"xscale",
1244 % "value" : "(100.0 / real(TrackElementNumber))"
1245 % }
1246
1247 process_json_definition(File,json(List)) :-
1248 (get_attr_true(ignore,List,File) -> true % ignore this definition
1249 ; process_json_def_lst(File,List)).
1250
1251 :- use_module(probsrc(bsyntaxtree), [get_texpr_type/2]).
1252 process_json_def_lst(File,List) :-
1253 force_del_attr_with_pos(name,List,string(ID),L1,File,NamePos),
1254 force_del_attr_with_pos(value,L1,string(Formula),L2,File,VPos),
1255 debug_format(19,' Processing definition for ~w with value-formula (lines ~w):~w~n',[ID,VPos,Formula]),
1256 !,
1257 set_gen_parse_errors(L2,VPos,GenParseErrors), % treat optional attribute
1258 process_json_definition(ID,NamePos,Formula,VPos,GenParseErrors).
1259 process_json_def_lst(File,List) :- get_pos_from_list(List,File,Pos),
1260 add_error(visb_visualiser,'Illegal VisB Definition:',List,Pos).
1261
1262 % we could also load a classical B Definition file and process its definitions like this:
1263 process_json_definition(ID,NamePos,Formula,VPos,GenParseErrors) :-
1264 atom_codes(Formula,FCodes),
1265 set_error_context(visb_error_context(definition,ID,'value',VPos)),
1266 (b_get_definition_name_with_pos(ID,_Arity,_DefType,_DPos)
1267 -> add_warning(visb_visualiser,'Ignoring VisB definition, DEFINITION of the same name already exists:',ID,NamePos)
1268 ; parse_expr(FCodes,TypedExpr,GenParseErrors)
1269 -> add_visb_json_definition(ID,TypedExpr,VPos)
1270 ; GenParseErrors=false -> formatsilent('Ignoring optional VisB definition for ~w due to error in B formula~n',[ID])
1271 ; add_error(visb_visualiser,'Cannot parse or typecheck VisB formula for definition',ID,VPos)
1272 ),
1273 clear_error_context.
1274
1275 add_visb_json_definition(ID,TypedExpr,VPos) :-
1276 get_texpr_type(TypedExpr,Type),
1277 determine_type_of_visb_formula(TypedExpr,TIds,Class), %write(type(ID,Class,TIds)),nl,
1278 (try_eval_static_def(Class,'static definition', ID,TypedExpr,TIds,StaticValue,VPos)
1279 -> get_texpr_type(TypedExpr,Type),StaticValueExpr = b(value(StaticValue),Type,[]),
1280 assert_visb_json_definition(ID,Type,StaticValueExpr,TIds,Class,VPos)
1281 ; assert_visb_json_definition(ID,Type,TypedExpr,TIds,Class,VPos)
1282 ).
1283
1284 % assert a VisB definition stemming from the JSON definitions section:
1285 assert_visb_json_definition(DefName,Type,TypedExpr,UsedTIds,Class,DefPos) :-
1286 ? (is_special_visb_def_name(DefName,SpecialClass) -> true ; SpecialClass = regular_def),
1287 assertz(visb_definition(DefName,Type,TypedExpr,Class,DefPos,SpecialClass)),
1288 (SpecialClass \= regular_def
1289 -> formatsilent('Detected special ~w definition ~w (~w)~n',[SpecialClass,DefName,Class]),
1290 add_special_json_definition(SpecialClass,DefName,Type,TypedExpr,UsedTIds,Class,DefPos)
1291 ; true
1292 ).
1293
1294 % register some special definitions, in which a set of objects/hovers/updates can be specified
1295 % by a single definition returning a set of records
1296 add_special_json_definition(visb_updates,DefName,Type,TypedExpr,_,Class,DefPos) :- !,
1297 check_visb_update_type(visb_updates,Type,DefName,Class,DefPos),
1298 assertz(visb_special_definition(visb_updates,DefName,Type,TypedExpr,Class,DefPos)). % will be evaluated later
1299 add_special_json_definition(visb_contents,DefName,Type,TypedExpr,_,Class,DefPos) :- !,
1300 assertz(visb_special_definition(visb_contents,DefName,Type,TypedExpr,Class,DefPos)).
1301 add_special_json_definition(visb_box,DefName,Type,TypedExpr,_,Class,DefPos) :- !,
1302 assertz(visb_special_definition(visb_box,DefName,Type,TypedExpr,Class,DefPos)).
1303 add_special_json_definition(visb_objects,DefName,_Type,TypedExpr,_UsedTIds,_Class,DefPos) :- !,
1304 AllowSep=allow_separation, % TODO: we re-determine the class and used ids below:
1305 get_typed_static_definition_with_constants_state(DefName,TypedExpr,ResBody,DefPos,CS,no_inlining,AllowSep),
1306 (get_visb_DEFINITION_svg_object(visb_objects,DefName,ResBody,DefPos,CS,SVG_ID,AttrList,Desc,InnerPos),
1307 %formatsilent('Adding ~w : ~w (from ~w)~n',[visb_objects,SVG_ID,DefName]),
1308 add_visb_object_from_definition(visb_objects, SVG_ID, AttrList, Desc, DefName, InnerPos),
1309 fail ; true).
1310 add_special_json_definition(SpecialClass,DefName,_Type,TypedExpr,UsedTIds,Class,DefPos) :-
1311 (get_unique_initial_state_for_visb(Class,DefName,DefPos,UsedTIds,ConstantsState) -> true
1312 ; ConstantsState=[]),
1313 get_static_visb_state(ConstantsState,FullState), % add static VisB Defs
1314 (Class=requires_variables,
1315 (get_preference(visb_allow_variables_for_objects,false) ; ConstantsState=[])
1316 -> add_warning(visb_visualiser,'Ignoring VisB definition which requires variables:',DefName,DefPos)
1317 ; get_visb_DEFINITION_svg_object(SpecialClass,DefName,TypedExpr,DefPos,FullState,SVG_ID,AttrList,Desc,InnerPos),
1318 %formatsilent('Adding ~w : ~w (from ~w)~n',[SpecialClass,SVG_ID,DefName]),
1319 add_visb_object_from_definition(SpecialClass, SVG_ID, AttrList, Desc, DefName, InnerPos)
1320 ; true).
1321
1322 is_special_visb_def_name(DefName,visb_updates) :- atom_concat('VISB_SVG_UPDATES',_,DefName).
1323 is_special_visb_def_name(DefName,visb_hovers) :- atom_concat('VISB_SVG_HOVERS',_,DefName).
1324 is_special_visb_def_name(DefName,visb_objects) :- atom_concat('VISB_SVG_OBJECTS',_,DefName).
1325 is_special_visb_def_name(DefName,visb_contents) :- atom_concat('VISB_SVG_CONTENTS',_,DefName).
1326 is_special_visb_def_name(DefName,visb_events) :- atom_concat('VISB_SVG_EVENTS',_,DefName).
1327 is_special_visb_def_name('VISB_SVG_BOX',visb_box).
1328 % TODO: maybe provide VISB_HTML_CONTENTS which appear after the SVG
1329
1330 % evaluate static VisB defs only once or evaluate expressions in svg_objects and loop bounds
1331 eval_static_def(Class,VisBKind,ID,TypedExpr,UsedTIds,StaticValue,VPos) :-
1332 get_unique_initial_state_for_visb(Class,ID,VPos,UsedTIds,ConstantsState),
1333 evaluate_static_visb_formula(TypedExpr,VisBKind,ID,ConstantsState,StaticValue,VPos).
1334
1335 % only evaluate statically if possible; no warnings/messages if not possible (just fail)
1336 try_eval_static_def(requires_variables,_VisBKind,_ID,_TypedExpr,_UsedTIds,_StaticValue,_VPos) :- !,
1337 fail. % do not try to evaluate statically; events will change the variable values anyway
1338 try_eval_static_def(Class,VisBKind,ID,TypedExpr,UsedTIds,StaticValue,VPos) :-
1339 % TODO: disable messages for multiple constants values; just fail
1340 eval_static_def(Class,VisBKind,ID,TypedExpr,UsedTIds,StaticValue,VPos).
1341
1342 % check if a unique constant value exists for a model
1343 get_unique_initial_state_for_visb(requires_nothing,_,_,_,State) :- !, State=[].
1344 get_unique_initial_state_for_visb(Class,DefName,DefPos,_,State) :-
1345 \+ multiple_concrete_constants_exist,
1346 is_concrete_constants_state_id(StateID),!,
1347 (Class=requires_variables
1348 -> get_preference(visb_allow_variables_for_objects,true),
1349 unique_initialisation_id_exists_from(StateID,DefName,DefPos,State)
1350 % Note: variable can still be modified by other events later, e.g., in ProB2-UI
1351 ; visited_expression(StateID,StateTerm),
1352 state_corresponds_to_set_up_constants_only(StateTerm,State)).
1353 get_unique_initial_state_for_visb(requires_constants,DefName,DefPos,Ids,State) :- Ids \= all,
1354 % try and see if all values for Ids are the same; TODO: also support requires_variables
1355 is_concrete_constants_state_id(StateID),!,
1356 visited_expression(StateID,StateTerm),
1357 state_corresponds_to_set_up_constants_only(StateTerm,State),
1358 (member(C,Ids), get_texpr_id(C,CstID),
1359 other_constant_value_exists_for(CstID,State,StateID)
1360 -> ajoin(['Multiple values for constant ',CstID, ' in context of: '],Msg),
1361 add_message(visb_visualiser,Msg,DefName,DefPos),fail
1362 ; true).
1363
1364 get_a_constants_state(State,StateID,inline_objects(SingleStateId)) :-
1365 get_constants_state_id_for_id(SingleStateId,StateID),!,
1366 visited_expression(StateID,StateTerm),
1367 state_corresponds_to_set_up_constants_only(StateTerm,State).
1368 get_a_constants_state(State,StateID,InlineObjects) :-
1369 check_inlining(InlineObjects),
1370 is_concrete_constants_state_id(StateID),!,
1371 visited_expression(StateID,StateTerm),
1372 state_corresponds_to_set_up_constants_only(StateTerm,State).
1373
1374 check_inlining(no_inlining) :- !.
1375 check_inlining(inline_objects(_SingleStateId)) :- !.
1376 check_inlining(X) :- add_internal_error('Invalid inlining value:',check_inlining(X)).
1377
1378 :- use_module(probsrc(store), [lookup_value_for_existing_id/3]).
1379 other_constant_value_exists_for(CstID,State,StateId) :-
1380 lookup_value_for_existing_id(CstID,State,Val1),
1381 is_concrete_constants_state_id(StateId2), StateId2 \= StateId,
1382 visited_expression(StateId2,StateTerm2),
1383 state_corresponds_to_set_up_constants_only(StateTerm2,State2),
1384 lookup_value_for_existing_id(CstID,State2,Val2),
1385 Val2 \= Val1.
1386
1387
1388 unique_initialisation_id_exists_from(FromStateId,DefName,DefPos,State) :-
1389 transition(FromStateId,_,StateID),!,
1390 (transition(FromStateId,_,StateID2),
1391 StateID2 \= StateID
1392 -> ajoin(['Multiple initialisations exists (state ids ',StateID,',',StateID2,') for: '],Msg),
1393 add_message(visb_visualiser,Msg,DefName,DefPos),fail
1394 ; true),
1395 visited_expression(StateID,StateTerm),
1396 state_corresponds_to_initialised_b_machine(StateTerm,State).
1397
1398 parse_expr_for_visb(Formula,JsonList,Pos,TypedExpr) :-
1399 set_gen_parse_errors(JsonList,Pos,GenParseErrors),
1400 parse_expr(Formula,TypedExpr,GenParseErrors).
1401
1402 set_gen_parse_errors(JSonList,Pos,GenParseErrors) :-
1403 (get_attr(optional,JSonList,_)
1404 -> GenParseErrors=false
1405 ; %get_pos_from_list(JSonList,File,Position),
1406 GenParseErrors=gen_parse_errors_for(Pos)).
1407
1408 % ----------------
1409
1410 % parse and load an individual JSON SVG object listed under svg_objects, e.g, :
1411 % {
1412 % "svg_class":"rect",
1413 % "id":"train_rect",
1414 % "x":"0",
1415 % "y":"0",
1416 % "comment":"..."
1417 % },
1418 process_json_svg_object(File,Json) :-
1419 process_repeat(0,Json,File,add_visb_json_svg_object).
1420
1421 add_visb_json_svg_object(File,json(List)) :- get_attr_true(ignore,List,File), !. % ignore this item
1422 add_visb_json_svg_object(File,json(List)) :-
1423 (force_del_attr_with_pos(svg_class,List,string(SVG_Class),L1,File,Pos1) -> true % shape: line, rect, ...
1424 ; infer_svg_class(List,SVG_Class,File,Pos1)
1425 -> add_message(visb_visualiser,'Inferred svg_class: ',SVG_Class,Pos1),L1=List),
1426 force_del_attr(id,L1,string(ID),L2,File),
1427 (del_attr(comment,L2,string(Desc),JsonList3) -> true ; Desc = '', JsonList3=L2),
1428 debug_format(19,' Creating new SVG object ~w with id:~w~n',[SVG_Class,ID]),
1429 add_debug_message(visb_visualiser,'New object: ',ID,Pos1),
1430 % TODO: we could pre-process all attributes not depending on %0, %1, ...
1431 maplist(get_svg_attr(SVG_Class,File),JsonList3,AttrList),
1432 %formatsilent('Adding SVG Object ~w with ID ~w (~w): ~w~n',[SVG_Class,ID,Desc,AttrList]),
1433 assert_visb_svg_object(ID,SVG_Class,AttrList,Desc,'JSON',Pos1),
1434 !.
1435 add_visb_json_svg_object(File,Json) :-
1436 !,
1437 get_pos_from_list(Json,File,Pos),
1438 add_error(visb_visualiser,'Illegal VisB additional SVG object:',Json,Pos).
1439
1440 infer_svg_class(List,line,File,Pos) :- get_attr_with_pos(x1,List,_,File,Pos),!.
1441 infer_svg_class(List,circle,File,Pos) :- get_attr_with_pos(r,List,_,File,Pos),!.
1442 infer_svg_class(List,rect,File,Pos) :- get_attr_with_pos(height,List,_,File,Pos),!.
1443 infer_svg_class(List,rect,File,Pos) :- get_attr_with_pos(width,List,_,File,Pos),!.
1444 infer_svg_class(List,ellipse,File,Pos) :- get_attr_with_pos(rx,List,_,File,Pos),!. % could also be rect
1445 infer_svg_class(List,text,File,Pos) :- get_attr_with_pos(text,List,_,File,Pos),!.
1446 infer_svg_class(List,g,File,Pos) :- get_attr_with_pos(children,List,_,File,Pos),!. % group + foreignObject have children
1447 infer_svg_class(List,use,File,Pos) :- get_attr_with_pos(href,List,_,File,Pos),!. % href can also be used with image, pattern, ...
1448
1449 % assert a new SVG object to be created upon SETUP_CONSTANTS/INITIALISATION:
1450 assert_visb_svg_object(ID,SVG_Class,_AttrList,_Desc,DefName,Pos1) :-
1451 visb_svg_object(ID,_,_,_,_Pos0),!,
1452 ajoin(['SVG object (from ',DefName,', svg_class=',SVG_Class,') with same id already created: '],Msg),
1453 add_warning(visb_visualiser,Msg,ID,Pos1).
1454 assert_visb_svg_object(_ID,_SVG_Class,AttrList,_Desc,_DefName,Pos1) :-
1455 \+ (AttrList=[] ; AttrList=[_|_]),!,
1456 add_error(visb_visualiser,'SVG objects attributes are not a list:',AttrList,Pos1).
1457 assert_visb_svg_object(ID,SVG_Class,AttrList,Desc,DefName,Pos1) :-
1458 check_svg_shape_class(ID,SVG_Class,Pos1),
1459 add_visb_debug_infos(ID,SVG_Class,AttrList,AttrList2,DefName,Pos1),
1460 sort(AttrList2,SAttrList),
1461 get_all_children(SAttrList,Children,RestAttrs,DefName,Pos1),
1462 (Children = [] -> true
1463 ? ; svg_shape_can_have_children(SVG_Class) -> true % g, foreignObject, HTML tags
1464 ; Children = [C1_ID|_], visb_svg_object(C1_ID,CAttr,_,_,_),
1465 attribute_automatically_creates_children(CAttr) % e.g., title object created for title attribute of ID
1466 -> true
1467 ; add_message(visb_visualiser,'Children attribute only useful for certain SVG classes such as groups (g) or foreignObject or when adding title objects (as tooltips): ',Children,Pos1)
1468 ),
1469 ? (select(svg_attribute(group_id,ParentGroupId),RestAttrs,RestAttrs2)
1470 -> assert_visb_svg_child(ParentGroupId,Pos1,ID) % register parent group id
1471 ; RestAttrs2=RestAttrs),
1472 compute_auto_attributes(RestAttrs,RestAttrs2,SVG_Class,NewRestAttrs),
1473 assertz(visb_svg_object(ID,SVG_Class,NewRestAttrs,Desc,Pos1)),
1474 maplist(assert_visb_svg_child(ID,Pos1),Children).
1475
1476 % adapt visb_svg_object to provide developer debug infos, e.g., in title hover messages
1477 add_visb_debug_infos(ID,SVG_Class,AttrList,NewAttrList,DefName,Pos) :- SVG_Class \= title,
1478 get_preference(visb_show_debug_infos,true),
1479 (select(svg_attribute(title,Title),AttrList,RestAttrs) -> true
1480 ; Title='', RestAttrs=AttrList),
1481 !,
1482 extract_span_description_with_opts(Pos,PosStr,
1483 [relative_file_name,compact_pos_info,
1484 inner_context_separator('\n in ','\n at ')]),
1485 %extract_definition_call_stack_desc(Pos,CS), already displayed in inner context
1486 ajoin(['-- VISB_DEBUG_INFO --\nid=',ID, '\nsvg_class=',SVG_Class, '\nsrc=',DefName,'\n', PosStr],DebugInfo),
1487 (Title='' -> NewTitle=DebugInfo ; ajoin([Title,'\n',DebugInfo],NewTitle)),
1488 %format('~nDEBUG::~n~w~n~w~n---~n',[ID,DebugInfo]),
1489 assert(visb_svg_object_debug_info(ID,DebugInfo)),
1490 NewAttrList = [svg_attribute(title,NewTitle)|RestAttrs].
1491 add_visb_debug_infos(_,_,AttrList,AttrList,_,_).
1492
1493 % compute the value of VisB auto attributes, e.g., automatically
1494 % doing a layout of objects in a grid
1495 % TODO: SVG/special_svg_number already supports auto but not for x,y coordinates?
1496 % TODO: try and determine width of object automatically; keep track of auto objects max height per row
1497 % TODO: support cx,cy
1498 compute_auto_attributes([],_,_,[]).
1499 compute_auto_attributes([svg_attribute(Attr,Val)|T],AllAttrs,SVG_Class,
1500 [svg_attribute(Attr,NewVal)|NT]) :-
1501 (Val=auto, compute_auto_attribute(Attr,AllAttrs,SVG_Class,NewVal)
1502 -> true
1503 ; NewVal=Val),
1504 compute_auto_attributes(T,AllAttrs,SVG_Class,NT).
1505
1506 :- dynamic next_auto_x/1, next_auto_y/2.
1507 next_auto_x(0).
1508 next_auto_y(0,10).
1509 reset_auto_attrs :- retractall(next_auto_x(_)),
1510 retractall(next_auto_y(_,_)),
1511 assertz(next_auto_x(0)),
1512 assertz(next_auto_y(0,10)).
1513
1514 get_x_auto_limit(Limit) :- visb_empty_svg_box_height_width(_H,W,_ViewBox),!,
1515 Limit = W. %TODO: inspect viewBox
1516 get_x_auto_limit(400).
1517
1518 compute_auto_attribute(id,_,_,GenID) :- !, gensym(svg_id,GenID).
1519 compute_auto_attribute(Attr,AllAttrs,SVG_Class,Val) :-
1520 auto_compute_x_coordinate(Attr,Kind),!,
1521 retract(next_auto_x(XV)),
1522 (get_width(SVG_Class,AllAttrs,Offset) -> true ; Offset=10),
1523 Padding = 2, % TODO: make customisable
1524 NewXV is XV+Offset+Padding,
1525 get_x_auto_limit(Lim),
1526 (NewXV > Lim
1527 -> NewVal=0, retract(next_auto_y(OldY,YOffset)),
1528 (get_height(SVG_Class,AllAttrs,Offset) -> true ; Offset = 10),
1529 NewY is OldY+YOffset,
1530 assert(next_auto_y(NewY,YOffset))
1531 ; NewVal=NewXV),
1532 assertz(next_auto_x(NewVal)),
1533 (Kind=left -> Val=XV ; Val is XV + Offset/2).
1534 compute_auto_attribute(Attr,AllAttrs,SVG_Class,Val) :- auto_compute_y_coordinate(Attr,Kind),
1535 next_auto_y(YV,_),
1536 (Kind = top -> Val = YV
1537 ; get_height(SVG_Class,AllAttrs,Height) -> Val is YV + Height/2
1538 ; Val is YV+5).
1539
1540 auto_compute_x_coordinate(x,left). % rect, ..
1541 auto_compute_x_coordinate(cx,center). % circle, ellipse
1542 auto_compute_y_coordinate(y,top). % rect, ..
1543 auto_compute_y_coordinate(cy,center). % circle, ellipse
1544
1545 get_width(rect,Attrs,Wid) :- member(svg_attribute(width,Wid),Attrs).
1546 get_width(circle,Attrs,Wid) :- member(svg_attribute(r,Radius),Attrs), Wid is 2*Radius.
1547 get_width(ellipse,Attrs,Wid) :- member(svg_attribute(rx,Radius),Attrs), Wid is 2*Radius.
1548 get_width(line,Attrs,Wid) :- member(svg_attribute(x1,X1),Attrs),
1549 member(svg_attribute(x2,X2),Attrs), Wid is abs(X2-X1).
1550
1551 get_height(rect,Attrs,Wid) :- member(svg_attribute(height,Wid),Attrs).
1552 get_height(circle,Attrs,Wid) :- member(svg_attribute(r,Radius),Attrs), Wid is 2*Radius.
1553 get_height(ellipse,Attrs,Wid) :- member(svg_attribute(ry,Radius),Attrs), Wid is 2*Radius.
1554 get_height(line,Attrs,Wid) :- member(svg_attribute(y1,X1),Attrs),
1555 member(svg_attribute(y2,X2),Attrs), Wid is abs(X2-X1).
1556
1557
1558 % register an SVG ID as child of a group
1559 assert_visb_svg_child(_ParentId,Pos,ChildID) :- visb_svg_child(ChildID,OldParent),!,
1560 ajoin(['SVG object already child of group ',OldParent,': '],Msg),
1561 add_warning(visb_visualiser,Msg,ChildID,Pos).
1562 assert_visb_svg_child(ParentId,Pos,ChildID) :- visb_svg_child(ParentId,ChildID),!, % TODO: full cycle detection
1563 ajoin(['SVG object already parent of group ',ParentId,' (cycle): '],Msg),
1564 add_warning(visb_visualiser,Msg,ChildID,Pos).
1565 assert_visb_svg_child(ParentId,_Pos,ChildID) :-
1566 assertz(visb_svg_child(ChildID,ParentId)),
1567 assertz(visb_svg_parent(ParentId,ChildID)).
1568
1569
1570
1571
1572 :- use_module(probsrc(gensym),[gensym/2]).
1573 % we need to translate a title attribute to a separate title object and add it as a child
1574 % see also post_process_visb_item which dispatches title updates to the child object
1575 get_all_children(SAttrList,Children,Rest,DefName,Pos) :-
1576 ? select(svg_attribute(title,Title),SAttrList,SList2),!,
1577 gensym(visb_title,TitleID),
1578 assert_visb_svg_object(TitleID,'title',[svg_attribute(text,Title)],'',DefName,Pos),
1579 add_debug_message(visb_visualiser,'Adding virtual title child object: ',TitleID,Pos),
1580 Children=[TitleID|TChilds],
1581 get_children_attribute(SList2,TChilds,Rest,Pos).
1582 get_all_children(SAttrList,Children,Rest,_,Pos) :-
1583 % get the children explicitly defined by the user:
1584 get_children_attribute(SAttrList,Children,Rest,Pos).
1585
1586 get_children_attribute(SAttrList,Children,Rest,Pos) :-
1587 ? select(svg_attribute(children,C),SAttrList,R),!,
1588 (is_list(C) -> Children=C
1589 ; add_warning(visb_visualiser,'Children attribute should be a list (of SVG ids): ',C,Pos),
1590 Children=[]),
1591 Rest=R.
1592 get_children_attribute(SAttrList,[],SAttrList,_).
1593
1594
1595
1596 :- use_module(probsrc(tools_matching), [get_possible_fuzzy_matches_and_completions_msg/3,
1597 get_all_svg_classes/1, is_svg_shape_class/1,
1598 is_html_tag/1, is_html_attribute/1]).
1599
1600
1601 svg_shape_can_have_children(defs).
1602 svg_shape_can_have_children(foreignObject).
1603 svg_shape_can_have_children(g).
1604 svg_shape_can_have_children(pattern).
1605 svg_shape_can_have_children(X) :- is_html_tag(X).
1606
1607
1608 :- use_module(probsrc(tools_matching), [dotshape2svg_class/2]).
1609 % check whether svg_class value seems valid
1610 check_svg_shape_class(ID,Shape,Pos) :-
1611 (is_svg_shape_class(Shape) -> true
1612 ; is_html_tag(Shape) ->
1613 (visb_svg_child(ID,ParentId),
1614 visb_svg_object(ParentId,ParClass,_,_,_),
1615 (is_html_tag(ParClass) -> true ; ParClass=foreignObject)
1616 -> add_debug_message(visb_visualiser,'HTML tag used as svg_class in foreignObject child: ',Shape,Pos)
1617 ; ajoin(['SVG object ', ID, ' has HTML tag as svg_class (and should probably be a child of a foreignObject): '],Msg),
1618 add_message(visb_visualiser,Msg,Shape,Pos) % probably should be child of foreignObject
1619 )
1620 ; dotshape2svg_class(Shape,Class)
1621 -> ajoin(['SVG object ', ID, ' has unknown svg_class (did you mean ',Class,' ?): '],Msg),
1622 add_warning(visb_visualiser,Msg,Shape,Pos)
1623 ; get_all_svg_classes(Classes),
1624 get_possible_fuzzy_matches_and_completions_msg(Shape,Classes,FMsg)
1625 -> ajoin(['SVG object ', ID, ' has unknown svg_class (did you mean ',FMsg,' ?): '],Msg),
1626 add_warning(visb_visualiser,Msg,Shape,Pos)
1627 ; ajoin(['SVG object ', ID, ' has unknown svg_class: '],Msg),
1628 add_message(visb_visualiser,Msg,Shape,Pos)
1629 ).
1630
1631 % get SVG attribute for an svg_object:
1632 get_svg_attr(SVG_Class,File,'='(Attr,AttrVal,Pos),svg_attribute(Attr,Val)) :- !,
1633 construct_prob_pos_term(Pos,File,PosTerm),
1634 get_svg_static_attribute_value(Attr,SVG_Class,PosTerm,AttrVal,Val).
1635 get_svg_attr(_,File,Json,_) :-
1636 get_pos_from_list([Json],File,Position),
1637 add_error(visb_visualiser,'Illegal SVG object attribute',Json,Position),fail.
1638
1639 get_svg_static_attribute_value(Attr,SVG_Class,Pos,AttrVal,Nr) :-
1640 check_is_number_attribute(Attr,SVG_Class,Pos),
1641 \+ is_special_svg_number_form(AttrVal),
1642 !,
1643 (get_number_value(AttrVal,Nr,Attr,Pos) -> true
1644 ; add_error(visb_visualiser,'Illegal number value:',AttrVal,Pos), Nr=0).
1645 get_svg_static_attribute_value(_,_,_,string(Val),Res) :- !, Res=Val.
1646 % for children we get something like array([string(button1_1),string(button1_2)])
1647 get_svg_static_attribute_value(Attr,SVG_Class,Pos,array(List),ResList) :- !,
1648 maplist(get_svg_static_attribute_value(Attr,SVG_Class,Pos),List,ResList).
1649 get_svg_static_attribute_value(_Attr,_,Pos,Val,Val) :-
1650 add_warning(visb_visualiser,'Illegal SVG object attribute value: ',Val,Pos).
1651
1652
1653 % detect special SVG number forms, like 50%
1654 is_special_svg_number_form(string(Atom)) :-
1655 atom_codes(Atom,Codes),
1656 special_svg_number(Codes,[]).
1657
1658 :- use_module(probsrc(self_check)).
1659 :- assert_must_succeed(visb_visualiser:special_svg_number("10%",[])).
1660 :- assert_must_succeed(visb_visualiser:special_svg_number("10 %",[])).
1661 :- assert_must_succeed(visb_visualiser:special_svg_number(" 99em ",[])).
1662 :- assert_must_succeed(visb_visualiser:special_svg_number("1.0em",[])).
1663 :- assert_must_fail(visb_visualiser:special_svg_number("10",[])).
1664 :- assert_must_fail(visb_visualiser:special_svg_number("10+nrcols+%0",[])).
1665 special_svg_number --> " ",!, special_svg_number.
1666 special_svg_number --> [X], {digit(X)},!, special_svg_number2.
1667 special_svg_number --> "auto".
1668 special_svg_number2 --> [X], {digit(X)},!, special_svg_number2.
1669 special_svg_number2 --> ".",!, special_svg_number2. % TODO: only allow one dot; + accept e notation?
1670 special_svg_number2 --> optws,!, svg_unit,!, optws.
1671
1672 % using info from https://oreillymedia.github.io/Using_SVG/guide/units.html
1673 svg_unit --> "%".
1674 svg_unit --> "ch".
1675 svg_unit --> "cm".
1676 svg_unit --> "em".
1677 svg_unit --> "ex".
1678 svg_unit --> "in".
1679 svg_unit --> "mm".
1680 svg_unit --> "pc".
1681 svg_unit --> "pt".
1682 svg_unit --> "px".
1683 svg_unit --> "deg". % angle units
1684 svg_unit --> "grad".
1685 svg_unit --> "rad".
1686 svg_unit --> "turn".
1687 svg_unit --> "rem". % root em
1688 svg_unit --> "vh". % viewport height unit (1%)
1689 svg_unit --> "vw". % viewport width unit (1%)
1690 svg_unit --> "vmin". % min ov vh, vw
1691 svg_unit --> "vmax". % max ov vh, vw
1692
1693
1694 optws --> " ",!,optws.
1695 optws --> [].
1696
1697 digit(X) :- X >= 48, X =< 57.
1698
1699 is_svg_number_attribute(Attr) :- is_svg_number_attribute(Attr,_).
1700
1701
1702 :- use_module(probsrc(tools_matching), [dot2svg_attribute/2, is_dot_attribute/1]).
1703 % some checks to see whether the attribute is supported by the given SVG class
1704
1705 check_attribute_is_supported(SVG_Class,DefPos,svg_attribute(Name,_V)) :- !,
1706 (nonvar(SVG_Class), check_is_number_attribute(Name,SVG_Class,DefPos) -> true
1707 % TODO: check color and other attributes, see also check_attribute_type
1708 ; check_attribute_name_is_supported(SVG_Class,Name,DefPos)).
1709 check_attribute_is_supported(S,DefPos,F) :-
1710 add_internal_error('Illegal call:',check_attribute_is_supported(S,DefPos,F)).
1711
1712 % if these special attributes occur here, something went wrong, e.g.,
1713 % when separating static/dynamic parts
1714 check_unsupported_special_visb_attribute(visb_objects,_,_) :- !,fail. % here we can process everything
1715 check_unsupported_special_visb_attribute(SpecialClass,DefPos,svg_attribute(Name,_)) :-
1716 special_visb_attribute_not_allowed_in_dynamic_objects(Name,SpecialClass,Kind),
1717 ajoin(['The VisB special attribute ',Name,' cannot be used here (',SpecialClass,' use separate ',Kind,' definition): '],Msg),
1718 add_warning(visb_visualiser,Msg,Name,DefPos).
1719
1720 special_visb_attribute_not_allowed_in_dynamic_objects(hover,SC,'VISB_SVG_HOVERS') :- SC \= visb_hovers.
1721 special_visb_attribute_not_allowed_in_dynamic_objects(hovers,SC,'VISB_SVG_HOVERS') :- SC \= visb_hovers.
1722 special_visb_attribute_not_allowed_in_dynamic_objects(event,SC,'VISB_SVG_EVENTS') :- SC \= visb_events.
1723 special_visb_attribute_not_allowed_in_dynamic_objects(events,SC,'VISB_SVG_EVENTS') :- SC \= visb_events.
1724 special_visb_attribute_not_allowed_in_dynamic_objects(predicate,SC,'VISB_SVG_EVENTS') :- SC \= visb_events.
1725 special_visb_attribute_not_allowed_in_dynamic_objects(predicates,SC,'VISB_SVG_EVENTS') :- SC \= visb_events.
1726 special_visb_attribute_not_allowed_in_dynamic_objects(preds,SC,'VISB_SVG_EVENTS') :- SC \= visb_events.
1727
1728
1729 check_attribute_name_is_supported(SVG_Class,Name,DefPos) :-
1730 nonvar(SVG_Class),
1731 is_html_tag(SVG_Class),
1732 \+ is_svg_shape_class(SVG_Class), % script and title can be both SVG and HTML
1733 !,
1734 (is_html_attribute(Name)
1735 -> true % TODO: we could check whether attribute appropriate for Tag
1736 ; is_virtual_svg_attribute(Name) -> true % Virtual VisB attribute like children, text, ...
1737 ; ajoin(['Unknown HTML attribute used inside HTML tag ',SVG_Class,': '],Msg),
1738 add_message(visb_visualiser,Msg,Name,DefPos)
1739 ).
1740 check_attribute_name_is_supported(_SVG_Class,Name,DefPos) :-
1741 ? \+ is_svg_attribute(Name),
1742 !,
1743 (dot2svg_attribute(Name,GraphVizTranslName)
1744 -> ajoin(['Unknown SVG attribute (maybe you want to use ',GraphVizTranslName,' ?): '],Msg),
1745 add_warning(visb_visualiser,Msg,Name,DefPos)
1746 ; get_all_svg_attributes(Attrs),
1747 (get_possible_fuzzy_matches_and_completions_msg(Name,Attrs,FMsg)
1748 -> ajoin(['Unknown SVG attribute (did you mean ',FMsg,' ?): '],Msg),
1749 add_warning(visb_visualiser,Msg,Name,DefPos) % create warning, as it is likely we have made an error
1750 ; is_dot_attribute(Name)
1751 -> add_warning(visb_visualiser,'This Dot/Graphviz attribute is not a valid SVG attribute: ',Name,DefPos)
1752 ; add_message(visb_visualiser,'Unknown SVG attribute: ',Name,DefPos)
1753 )
1754 ).
1755 check_attribute_name_is_supported(_,_,_).
1756
1757 % succeed if attribute is a number attribute and perform a check the attribute is supported by the class
1758 check_is_number_attribute(Attr,Class,Pos) :-
1759 is_svg_number_attribute(Attr,ClassList),
1760 (nonvar(Class), nonmember(Class,ClassList)
1761 -> (equivalent_attribute(Attr,List2,NewAttr), member(Class,List2)
1762 -> ajoin(['The number attribute ',Attr,' is not supported for SVG class ',Class,', use: '],Msg),
1763 add_warning(visb_visualiser,Msg,NewAttr,Pos)
1764 ; ajoin(['The number attribute ',Attr,' is not supported for this SVG class: '],Msg),
1765 add_warning(visb_visualiser,Msg,Class,Pos)
1766 )
1767 ; true
1768 ).
1769
1770 % optionally rewrite record field to alternative spelling
1771 opt_rewrite_field_name(Name,Res) :-
1772 (alternative_spelling(Name,Alt) -> Res=Alt ; Res=Name).
1773
1774 % these alternatives are useful e.g. in TLA+ without backquote:
1775 alternative_spelling(colour,'color').
1776 alternative_spelling(fill_opacity,'fill-opacity').
1777 alternative_spelling(fill_rule,'fill-rule').
1778 alternative_spelling(font_family,'font-family').
1779 alternative_spelling(font_size,'font-size').
1780 alternative_spelling(font_style,'font-style').
1781 alternative_spelling(font_variant,'font-variant').
1782 alternative_spelling(font_weight,'font-weight').
1783 alternative_spelling(marker_end,'marker-end').
1784 alternative_spelling(marker_start,'marker-start').
1785 alternative_spelling(stroke_opacity,'stroke-opacity').
1786 alternative_spelling(stroke_dasharray,'stroke-dasharray').
1787 %alternative_spelling('stroke-dash-array','stroke-dasharray').
1788 alternative_spelling(stroke_linecap,'stroke-linecap').
1789 alternative_spelling(stroke_linejoin,'stroke-linejoin').
1790 alternative_spelling(stroke_width,'stroke-width').
1791
1792
1793
1794 % used to suggest fixing unsupported attributes in SVG objects:
1795 equivalent_attribute(cx,[rect],x).
1796 equivalent_attribute(cy,[rect],y).
1797 equivalent_attribute(x,[circle,ellipse],cx).
1798 equivalent_attribute(x,[line],x1).
1799 equivalent_attribute(y,[circle,ellipse],cy).
1800 equivalent_attribute(y,[line],y1).
1801 equivalent_attribute(r,[rect],rx). % ry also exists
1802 equivalent_attribute(rx,[circle],r).
1803 equivalent_attribute(width,[circle],r).
1804 equivalent_attribute(width,[ellipse],rx).
1805 equivalent_attribute(height,[ellipse],ry).
1806
1807
1808
1809
1810 % ----------------
1811
1812 % parse and load an individual JSON VisB item, e.g, :
1813 % {
1814 % "id":"train_info_text",
1815 % "attr":"x",
1816 % "value":"real(train_rear_end)*100.0/real(TrackElementNumber+1)",
1817 % "comment":"move info field above train"
1818 % },
1819 process_visb_json_item(File,Json) :-
1820 process_repeat(0,Json,File,add_visb_json_item).
1821
1822 add_visb_json_item(File,json(List)) :-
1823 get_attr_true(ignore,List,File), % ignore this item
1824 !.
1825 add_visb_json_item(File,json(List)) :-
1826 del_attr_with_pos(id,List,string(ID),L1,File,PosStartOfItem),
1827 !,
1828 process_visb_json_item_id(File,L1,ID,PosStartOfItem).
1829 add_visb_json_item(File,Json) :-
1830 !,
1831 get_pos_from_list(Json,File,Pos),
1832 add_error(visb_visualiser,'VisB Item has no id attribute:',Json,Pos).
1833
1834 process_visb_json_item_id(File,L1,ID,PosStartOfItem) :-
1835 ? del_attr(attr,L1,string(Attr),L2), % VisB has attr and value infos
1836 force_del_attr_with_pos(value,L2,string(Formula),L3,File,PosFormula),
1837 !,
1838 ? (del_attr(comment,L3,string(Desc),L4) -> true ; Desc = '',L4=L3),
1839 debug_format(19,' Processing id:~w attr:~w : value:~w desc:~w~n',[ID,Attr,Formula,Desc]),
1840 actually_add_visb_json_item(ID,Attr,Formula,Desc,L4,PosStartOfItem,PosFormula,File).
1841 process_visb_json_item_id(File,L1,ID,PosStartOfItem) :-
1842 get_attr(SomeSVGAttr,L1,_V),
1843 ? is_svg_attribute(SomeSVGAttr),
1844 debug_format(19,'Detected new style VisB JSON declaration with id:~w and SVG attr:~w~n',[ID,SomeSVGAttr]),
1845 !,
1846 % object is in new format with multiple attributes "x":"0" rather than "attr":"x", "value":"0"
1847 (del_attr(comment,L1,string(Desc),L2) -> true ; Desc = '',L2=L1),
1848 ? (non_det_del_attr_with_pos(SVGATTR,L2,string(Formula),L3,File,PosFormula),
1849 is_visb_item_svg_attribute(PosFormula,SVGATTR,Formula),
1850 debug_format(19,' -> Processing new style id:~w attr:~w : value:~w desc:~n',[ID,SVGATTR,Formula,Desc]),
1851 actually_add_visb_json_item(ID,SVGATTR,Formula,Desc,L3,PosStartOfItem,PosFormula,File),
1852 fail
1853 ;
1854 true).
1855 process_visb_json_item_id(_File,_JsonList,ID,PosStartOfItem) :-
1856 !,
1857 add_error(visb_visualiser,'Illegal VisB Item without attr and value fields:',ID,PosStartOfItem).
1858
1859 is_visb_item_svg_attribute(Pos,Attr,Val) :-
1860 Attr \= override, % so we ignore a possible override attribute
1861 ? (is_svg_attribute(Attr) -> true
1862 ; add_warning(visb_visualiser,'Ignoring unknown attribute: ',Attr=Val,Pos),
1863 fail
1864 ).
1865
1866 :- use_module(probsrc(tools_strings),[safe_name/2]).
1867 actually_add_visb_json_item(ID,Attr,Formula,Desc,JsonList,PosStartOfItem,PosFormula,File) :-
1868 set_error_context(visb_error_context(item,ID,Attr,PosFormula)),
1869 atom_codes(Formula,FormulaC),
1870 (parse_expr_for_visb(FormulaC,JsonList,PosFormula,TypedExpr)
1871 % TO DO: if optional attribute present: avoid generating errors in b_parse_machine_expression_from_codes
1872 -> assert_visb_item(ID,Attr,TypedExpr,Desc,PosStartOfItem,JsonList,File)
1873 ; get_attr_with_pos(optional,JsonList,_,File,Pos)
1874 -> formatsilent('Ignoring optional VisB item for ~w (lines ~w) due to error in B formula~n',[ID,Pos])
1875 ; ajoin(['Cannot parse or typecheck VisB formula for ',ID,' and attribute ',Attr,':'],Msg),
1876 add_error(visb_visualiser,Msg,Formula,PosFormula)
1877 ), clear_error_context.
1878
1879
1880 :- use_module(probsrc(bsyntaxtree), [find_identifier_uses/3]).
1881 % assert a VISB item (aka VISB_SVG_UPDATE)
1882 assert_visb_item(ID,Attr,_TypedExpr,_Desc,PosStartOfItem,_,_) :-
1883 visb_item(ID,Attr,_,_,_,Pos2,Meta2),
1884 !,
1885 get_file_name_msg(PosStartOfItem,From1,File1),
1886 (member(override,Meta2)
1887 -> ajoin(['Overriding VisB item',From1,File1,' for same SVG ID ',ID,' and attribute '],Msg),
1888 add_debug_message(visb_visualiser,Msg,Attr,Pos2)
1889 ; ajoin(['Overriding VisB item',From1,File1,' for same SVG ID ',ID,
1890 '. Add an \"override\" attribute to remove this warning. Overriden attribute '],Msg),
1891 add_warning(visb_visualiser,Msg,Attr,Pos2),
1892 % error_context already includes attribute and ID
1893 add_message(visb_visualiser,'Overriding this stored formula for ',ID,PosStartOfItem) % provide detailed info
1894 ).
1895 assert_visb_item(ID,Attr,_TypedExpr,_Desc,PosStartOfItem,_JsonList,_File) :-
1896 illegal_attribute_for_visb_item(ID,Attr),!,
1897 add_warning(visb_visualiser,'This attribute cannot be modified in a VisB item: ',Attr,PosStartOfItem).
1898 assert_visb_item(ID,Attr,TypedExpr,Desc,PosStartOfItem,JsonList,File) :-
1899 (get_attr_true(override,JsonList,File) -> Meta = [override] ; Meta=[]),
1900 % determine_type_of_visb_formula(TypedExpr,_,Class) now does take definitions into account; TODO: save info
1901 find_identifier_uses(TypedExpr,[],UsedIds),
1902 assertz(visb_item(ID,Attr,TypedExpr,UsedIds,Desc,PosStartOfItem,Meta)).
1903
1904 illegal_attribute_for_visb_item(_,children).
1905 illegal_attribute_for_visb_item(_,group_id).
1906 illegal_attribute_for_visb_item(_,id).
1907 illegal_attribute_for_visb_item(_,svg_class).
1908
1909
1910 get_file_name_msg(Pos1,' from ',File1) :- extract_tail_file_name(Pos1,File1),!.
1911 get_file_name_msg(_,'',''). % no file info
1912
1913 % ----
1914
1915 get_attr_true(Attr,JsonList,File) :-
1916 get_attr_with_pos(Attr,JsonList,TRUE,File,Pos),
1917 (json_true_value(TRUE) -> true
1918 ; json_false_value(TRUE) -> fail
1919 ; ajoin(['Value for attribute ',Attr,' is not true or false: '],Msg),
1920 add_warning(visb_visualiser,Msg,TRUE,Pos)
1921 ).
1922
1923 json_true_value(@(true)).
1924 json_true_value(string(true)).
1925 json_true_value(number(1)).
1926
1927 json_false_value(@(false)).
1928 json_false_value(string(false)).
1929 json_false_value(number(0)).
1930
1931 % ----------------
1932 % FOR-LOOP / REPEAT processing
1933
1934 %process_repeat(RepCounter, Json, FinalCall to be executed repeatedly for each instance with File and Json, File)
1935 % RepCounter tells us which of %0, %1, ... should be replaced next
1936
1937 process_repeat(RepCount,json(JsonList),File,FinalCall) :-
1938 ? non_det_del_attr_with_pos(FOR_REP,JsonList,Value,RestJsonList,File,ForRepPos),
1939 % find first for or repeat and process it
1940 (FOR_REP=for ; FOR_REP=repeat),
1941 !,
1942 process_first_repeat(FOR_REP,Value,ForRepPos,RepCount,json(RestJsonList),File,FinalCall).
1943 process_repeat(_RepCount,Json,File,FinalCall) :-
1944 % we have processed all for/repeat loops: now perform the final call on the transformed codes
1945 call(FinalCall,File,Json).
1946
1947 process_first_repeat(for,json(ForList),ForPos,RepCount,JsonData,File,FinalCall) :-
1948 !, % we have a for loop like "for": {"from":1, "to":4}
1949 force_get_attr_nr(from,ForList,From,File),
1950 force_get_attr_nr(to,ForList,To,File),
1951 (get_attr_with_pos(step,ForList,StepAttrVal,File,StepPos),
1952 get_number_value(StepAttrVal,Step,step,StepPos)
1953 -> true % there is an explicit step attribute
1954 ; Step=1),
1955 debug_format(19,' -> Iterating %~w from ~w to ~w with step ~w~n',[RepCount,From,To,Step]),
1956 R1 is RepCount+1,
1957 number_codes(RepCount,Pat),
1958 check_between(From,To,Step,ForPos), % check whether step value makes sense
1959 ? ( between(From,To,Step,IterElem),
1960 number_codes(IterElem,IterElemC), % we will replace the text %Pat by the text of the number IterElem
1961 replace_in_json(Pat,IterElemC,JsonData,ReplacedJsonData), % replace within other for/repeat loops, but also other attributes
1962 process_repeat(R1,ReplacedJsonData,File,FinalCall), % now process next loop or finish
1963 fail
1964 ; true).
1965 process_first_repeat(repeat,array(RepList),RepPos,RepCount,JsonData,File,FinalCall) :-
1966 !, % we have a repetition like "repeat": ["tr1","tr2"] or "repeat": [ ["1","2"] , ...]
1967 (RepList=[array(L1)|_], length(L1,Len)
1968 -> NewRepCount is RepCount+Len, % we have a multi-repeat with list of values to be replaced
1969 LastRepCount is NewRepCount-1,
1970 debug_format(19,' -> Iterating repeat (%~w,...,%~w) over ~w~n',[RepCount,LastRepCount,RepList]),
1971 check_all_same_length_json(RepList,Len,RepPos)
1972 ; NewRepCount is RepCount+1, % next replacement starts at $(RepCount+1)
1973 debug_format(19,' -> Iterating repeat (%~w) over ~w~n',[RepCount,RepList])
1974 ),
1975 ? ( member(IterElem,RepList),
1976 multi_replace_in_json(IterElem,RepCount,JsonData,ReplacedJsonData), % replace within other for/repeat loops, but also other attributes
1977 process_repeat(NewRepCount,ReplacedJsonData,File,FinalCall), % now process next loop or finish
1978 fail
1979 ; true).
1980
1981 check_all_same_length_json(List,ExpectedLen,Pos) :-
1982 nth1(Nr,List,Json),
1983 (Json=array(SubList),length(SubList,Len) -> Len \= ExpectedLen ; Len='not a list'),
1984 !,
1985 ajoin(['The element number ',Nr,' of the repeat list has not the expected length of ',ExpectedLen,', length is: '],Msg),
1986 add_warning(visb_visualiser,Msg,Len,Pos).
1987 check_all_same_length_json(_,_,_).
1988
1989 json_value_to_codes(@(Literal), C) :- atom(Literal), !, atom_codes(Literal, C).
1990 json_value_to_codes(number(Number), C) :- number(Number), !, number_codes(Number, C).
1991 json_value_to_codes(string(String), C) :- atom(String), !, atom_codes(String, C).
1992 json_value_to_codes(Json, _) :- !, add_error(json_value_to_codes,'Cannot convert json term to codes:', Json), fail.
1993
1994 % replace (possibly) multiple patterns at once
1995 multi_replace_in_json(array([]),_RepCount,JsonIn,JsonOut) :- !, JsonOut=JsonIn.
1996 multi_replace_in_json(array([IterElem|TIT]),RepCount,JsonIn,JsonOut) :-
1997 !,
1998 number_codes(RepCount,Pat),
1999 json_value_to_codes(IterElem,IterElemC),
2000 %format('Replacing in JSON: ~s -> ~s~n',[Pat,IterElemC]),
2001 replace_in_json(Pat,IterElemC,JsonIn,Json),
2002 R1 is RepCount+1,
2003 multi_replace_in_json(array(TIT),R1,Json,JsonOut).
2004 multi_replace_in_json(IterElem,RepCount,JsonIn,JsonOut) :- % a value, not a list
2005 !,
2006 number_codes(RepCount,Pat),
2007 json_value_to_codes(IterElem,IterElemC),
2008 %format('Replacing in JSON: ~s -> ~s~n',[Pat,IterElemC]),
2009 replace_in_json(Pat,IterElemC,JsonIn,JsonOut).
2010
2011 check_between(_,_,Step,ForPos) :- Step =< 0, !,
2012 add_error(visb_visualiser,'The step of a for loop must be positive:',Step,ForPos),fail.
2013 check_between(From,To,Step,ForPos) :- Iters is (To-From)/Step,
2014 Iters > 100000,!,
2015 add_error(visb_visualiser,'Very large for loop:',Iters,ForPos),fail.
2016 check_between(_,_,_,_).
2017
2018
2019 % ----------------
2020
2021 % parse and load VisB events
2022 % A VisB Event looks like:
2023 % {
2024 % "id": "button",
2025 % "event": "toggle_button",
2026 % "hovers": [{ "attr":"stroke-width", "enter":"6", "leave":"1"},
2027 % { "attr":"opacity", "enter":"0.8", "leave":"1.0"}]
2028 % }
2029 process_json_event(File,Json) :-
2030 process_repeat(0,Json,File,add_visb_json_event).
2031
2032 add_visb_json_event(File,json(List)) :- get_attr_true(ignore,List,File), !. % ignore this item
2033 add_visb_json_event(File,json(List)) :-
2034 get_pos_from_list(List,File,Pos),
2035 force_del_attr(id,List,string(ID),L0,File), % for items it could make sense to not specify an id
2036 ? (del_attr(event,L0,string(Event),L1) -> true ; Event='', L1=L0),
2037 (del_attr_with_pos(predicates,L1,array(Preds),L2,File,PredPos) -> true
2038 ; del_attr_with_pos(preds,L1,array(Preds),L2,File,PredPos) -> true
2039 ; Preds=[], L2=L1, PredPos=unknown),
2040 ? (del_attr(hovers,L2,array(Hovers),L3) -> true ; Hovers=[],L3=L2),
2041 (del_attr(items,L3,array(EI),L4)
2042 -> (empty_b_event(Event)
2043 -> EnableItems=[],
2044 add_warning(visb_visualiser,'Ignoring enable items; you need to provide an event name:',ID,Pos)
2045 ; EnableItems=EI)
2046 ; EnableItems=[],L4=L3),
2047 debug_format(19,' Processing id:~w event:~w preds:~w enable:~w hovers:~w~n',[ID,Event,Preds,EnableItems,Hovers]),
2048 !,
2049 actually_add_visb_json_event(ID,Event,Preds,Hovers,EnableItems,L4,File,Pos,PredPos).
2050 add_visb_json_event(File,Json) :-
2051 !,
2052 get_pos_from_list(Json,File,Pos),
2053 add_error(visb_visualiser,'Illegal VisB Event:',Json,Pos).
2054
2055 actually_add_visb_json_event(ID,Event,JsonPreds,JsonHovers,JsonEnableItems,JsonList,File,Pos,PredPos) :-
2056 check_additional_args(JsonList,File),
2057 maplist(process_json_pred,JsonPreds,Preds),
2058 maplist(process_json_enabling_item(ID,Event,File),JsonEnableItems,EnableItems),
2059 maplist(process_json_hover(ID,File),JsonHovers,Hovers),
2060 add_visb_event(ID,Event,Preds,Hovers,EnableItems,File,Pos,PredPos,JsonList).
2061
2062 :- use_module(probsrc(tools_strings), [atom_prefix/2]).
2063 :- use_module(probsrc(bmachine), [b_is_operation_name/1]).
2064 add_visb_event(ID,Event,Preds,Hovers,EnableItems,File,Pos,PredPos,JsonList) :-
2065 (retract(visb_event(ID,OldEvent,OldPreds,OldTypedPred,OldFile,OldPos))
2066 -> (get_attr_true(override,JsonList,File)
2067 -> ajoin(['Overriding VisB event from file ',OldFile,' for ID: '],Msg),
2068 add_debug_message(visb_visualiser,Msg,ID,Pos),
2069 retractall(visb_hover(ID,_,_,_,_,_))
2070 ; (OldFile=File
2071 -> ajoin(['No override attribute: adding VisB event ',Event,
2072 ' (first event ',OldEvent,') for ID: '],Msg)
2073 ; ajoin(['No override attribute: adding VisB event ',Event,
2074 ' (first event ',OldEvent,' in file ',OldFile,') for ID: '],Msg)
2075 ),
2076 add_debug_message(visb_visualiser,Msg,ID,Pos),
2077 assertz(auxiliary_visb_event(ID,OldEvent,OldPreds,OldTypedPred,OldPos))
2078 ),
2079 assert_visb_event(ID,Event,Preds,Hovers,EnableItems,File,Pos,PredPos)
2080 % ProB2-UI cannot currently support multiple events associated with the same id
2081 % TODO: merge visb_events if we have no override attribute
2082 ? ; (xtl_mode ; b_is_operation_name_or_external_subst(Event)) ->
2083 assert_visb_event(ID,Event,Preds,Hovers,EnableItems,File,Pos,PredPos)
2084 ; (empty_b_event(Event) ; \+ b_or_z_mode)
2085 -> % for empty event we just want hovers
2086 (Preds = [] -> true
2087 ; add_warning(visb_visualiser,'Ignoring preds for VisB event for SVG ID: ',ID,Pos)
2088 ),
2089 assert_visb_event(ID,Event,[],Hovers,EnableItems,File,Pos,PredPos)
2090 ; get_attr_with_pos(optional,JsonList,_,File,Pos) ->
2091 formatsilent('Ignoring optional VisB event for ~w (lines ~w) due to unknown B operation ~w~n',[ID,Pos,Event])
2092 ; detect_op_call_with_paras(Event,OpName) ->
2093 add_warning(visb_visualiser,'Ignoring parameters provided in event; use predicate attribute to specify parameters: ',Event,Pos),
2094 assert_visb_event(ID,OpName,Preds,Hovers,EnableItems,File,Pos,PredPos)
2095 ; atom(Event), atom_prefix('{',Event) ->
2096 ajoin(['Unknown B operation ', Event, ' in VisB for SVG ID (be sure to use events attribute for multiple events): '],Msg),
2097 add_warning(visb_visualiser,Msg,ID,Pos)
2098 ; ajoin(['Unknown B operation ', Event, ' in VisB for SVG ID: '],Msg),
2099 add_warning(visb_visualiser,Msg,ID,Pos)
2100 ).
2101
2102 b_is_operation_name_or_external_subst(OpName) :- b_is_operation_name(OpName).
2103 b_is_operation_name_or_external_subst(Special) :- special_operation(Special).
2104
2105 % maybe we should provide those via the external substitution interface:
2106 % these are all schedulers which choose among existing enabled operations in some manner
2107 special_operation('MCTS_AUTO_PLAY').
2108 special_operation('RANDOM_ANIMATE').
2109 special_operation('RANDOM_ANIMATE_UNTIL_LTL').
2110 % maybe other special names like random_animate with nr of steps, LTL until, ...
2111 special_operation_enabled('MCTS_AUTO_PLAY',_,_,_) :- mcts_auto_play_available.
2112 special_operation_enabled('RANDOM_ANIMATE',_,_,_). % TODO: check if a transition exists
2113 special_operation_enabled('RANDOM_ANIMATE_UNTIL_LTL',_,_,_).
2114
2115 % detect operation call with parameters
2116 detect_op_call_with_paras(Event,OpName) :- atom(Event),
2117 atom_codes(Event,Codes), parse_op_call_name(OpC,Codes,_),!,
2118 atom_codes(OpName,OpC),
2119 b_is_operation_name(OpName).
2120
2121 parse_op_call_name([X|T]) --> alpha(X), parse_op_call_name2(T).
2122 parse_op_call_name2([]) --> "(".
2123 parse_op_call_name2([H|T]) --> alphadigit(H), parse_op_call_name2(T).
2124
2125 alpha(X) --> [X],{X>=97, X=<122}.
2126 alphadigit(X) --> [X], ({X>=97,X=<122} ; {X>=65, X=<90} ; {X=95} ; {X>=48, X=<57}).
2127
2128 empty_b_event('').
2129
2130 assert_visb_event(ID,Event,Preds,Hovers,EnableItems,File,Pos,PredPos) :-
2131 construct_pre_post_predicate(ID,Event,Preds,TypedPred,PredPos),
2132 assertz(visb_event(ID,Event,Preds,TypedPred,File,Pos)),
2133 % process hovers
2134 ? (member(HoverElement,Hovers),
2135 (HoverElement=visb_hover(HoverID,Attr,EnterVal,ExitVal) -> true ; add_error(visb_visualiser,'Illegal hover term:',HoverElement),fail),
2136 assert_visb_hover(ID,HoverID,Attr,EnterVal,ExitVal,Pos),fail
2137 ; true),
2138 % now process any additional items with disabled and enabled values
2139 assert_visb_enabling_item_list(Event,TypedPred,EnableItems,File,Pos).
2140
2141 process_json_pred(string(P),R) :- !, R=P.
2142 process_json_pred(Json,_) :- !, add_error(visb_visualiser,'Illegal json term for predicate:',Json), fail.
2143
2144 process_json_hover(OriginID,File,json(Hover),visb_hover(ID,Attr,EnterVal,LeaveVal)) :-
2145 force_del_attr(attr,Hover,string(Attr),H2,File),
2146 force_del_attr_with_pos(enter,H2,EV,H3,File,EnterPos),
2147 force_del_attr_with_pos(leave,H3,LV,H4,File,ExitPos),
2148 (is_svg_number_attribute(Attr) % we evaluate number attributes
2149 -> get_number_value(EV,EnterVal,Attr,EnterPos),
2150 get_number_value(LV,LeaveVal,Attr,ExitPos)
2151 ; string(EnterVal)=EV, string(LeaveVal)=LV % return string as is; TODO: also evaluate other attributes
2152 ),
2153 (get_attr(id,H4,string(ID)) -> true ; ID=OriginID).
2154
2155
2156 assert_visb_hover(TriggerID,SVG_ID,Attr,EnterVal,ExitVal,Pos) :-
2157 assert(visb_hover(TriggerID,SVG_ID,Attr,EnterVal,ExitVal,Pos)),
2158 (visb_has_hovers(TriggerID) -> true ; assert(visb_has_hovers(TriggerID))),
2159 (visb_has_visibility_hover(SVG_ID) -> true
2160 ; Attr=visibility -> assert(visb_has_visibility_hover(TriggerID)) % object can be made visible by hover
2161 ; true),
2162 debug_format(19,'Adding hover for ~w : ~w.~w -> ~w <- ~w~n',[TriggerID,SVG_ID,Attr,EnterVal,ExitVal]).
2163
2164
2165 % process items in event which get translated to enabling/disabling predicates
2166 % "items":[ {"attr":"stroke-width","enabled":"10", "disabled":"1"} ]
2167 process_json_enabling_item(ID,Event,File,json(JsonList),
2168 visb_enable_item(SvgID,Attr,EnabledValExpr,DisabledValExpr,PosAttr)) :-
2169 force_del_attr_with_pos(attr,JsonList,string(Attr),L2,File,PosAttr),
2170 force_del_attr_with_pos('enabled',L2,string(EnVal),L3,File,EPos),
2171 force_del_attr_with_pos('disabled',L3,string(DisVal),L4,File,DPos),
2172 (del_attr(id,L4,string(SvgID),L5) -> true ; SvgID=ID, L4=L5),
2173 atom_codes(EnVal,EC),
2174 parse_expr_for_visb(EC,L5,EPos,EnabledValExpr),
2175 atom_codes(DisVal,DC),
2176 parse_expr_for_visb(DC,L5,DPos,DisabledValExpr),
2177 (debug_mode(off) -> true
2178 ; translate_bexpression_with_limit(EnabledValExpr,30,EVS),
2179 translate_bexpression_with_limit(DisabledValExpr,30,DVS),
2180 formatsilent('Enabling item for event ~w and SVG ID ~w and attribute ~w : ~w <-> ~w~n',[Event,SvgID,Attr,EVS,DVS])
2181 ).
2182
2183 assert_visb_enabling_item_list(Event,TypedPred,EnableList,File,Pos) :-
2184 maplist(check_enabling_item(Event),EnableList),
2185 (EnableList \= []
2186 -> (debug_mode(off)
2187 -> true
2188 ; format('Associating enabling/disabling list with event ~w and predicate: ',[Event]), translate:print_bexpr(TypedPred),nl),
2189 assert(visb_event_enable_list(Event,TypedPred,EnableList,File,Pos))
2190 ; true).
2191
2192 check_enabling_item(Event,visb_enable_item(SvgID,Attr,_,_,PosAttr)) :-
2193 (visb_item(SvgID,Attr,_,_,_Desc,DuplicatePos,_)
2194 -> (extract_span_description(DuplicatePos,DuplPos) -> true; DuplPos=DuplicatePos),
2195 ajoin(['VisB conflict for SVG ID ',SvgID,' and attribute ',Attr,
2196 '. Conflict between VisB item (',DuplPos,') and VisB enable/disable entry for event: '],Msg),
2197 add_warning(visb_visualiser,Msg,Event,PosAttr)
2198 ; true).
2199
2200 valid_additional_attributes(comment).
2201 valid_additional_attributes(description).
2202 valid_additional_attributes(optional).
2203 valid_additional_attributes(override).
2204
2205 % check if there are additional unprocessed args and generate a warning
2206 check_additional_args(JsonList,File) :-
2207 get_attr_with_pos(Attr,JsonList,_,File,Pos),
2208 \+ valid_additional_attributes(Attr),
2209 add_warning(visb_visualiser,'Ignoring unknown JSON field: ',Attr,Pos),
2210 fail.
2211 check_additional_args(_,_).
2212
2213 :- use_module(probsrc(bsyntaxtree), [conjunct_predicates/2]).
2214 % construct a pre-post typed predicate for a VisB Event
2215 construct_pre_post_predicate(SvgID,OpName,Preds,TypedPred,Pos) :-
2216 set_error_context(visb_error_context(event,SvgID,OpName,Pos)),
2217 maplist(construct_pre_post_pred(OpName,Pos),Preds,TL),
2218 clear_error_context,
2219 conjunct_predicates(TL,TypedPred).
2220
2221 :- use_module(probsrc(bmachine), [b_parse_machine_operation_pre_post_predicate/5]).
2222 construct_pre_post_pred(OpName,Pos,PredStr,TypedPred) :- empty_b_event(OpName),!,
2223 add_error(visb_visualiser,'Cannot parse VisB event predicate without event name:',PredStr,Pos),
2224 TypedPred = b(truth,pred,[]).
2225 construct_pre_post_pred(OpName,Pos,String,TypedExpr) :- special_operation(OpName),!,
2226 % we have a special operation; allow to provide an expression with options/parameters
2227 atom_codes(String,Codes),
2228 GenParseErrors=gen_parse_errors_for(Pos),
2229 parse_expr(Codes,TypedExpr,GenParseErrors). % TODO: should we require a predicate instead, and provide arg names?
2230 construct_pre_post_pred(OpName,Pos,String,TypedPred) :-
2231 atom_codes(String,Codes), replace_special_patterns(Codes,RCodes,Pos), %format("Replaced : ~S~n",[RCodes]),
2232 get_visb_extra_scope([identifier(VisBExtraScope)]),
2233 visb_click_meta_b_type(MetaRecType),
2234 ExtraScope = [identifier([b(identifier('VISB_CLICK_META_INFOS'),MetaRecType,[visb_generated])|VisBExtraScope])],
2235 (b_parse_machine_operation_pre_post_predicate(RCodes,ExtraScope,TypedPred,OpName,gen_parse_errors_for(Pos))
2236 -> true
2237 ; add_error(visb_visualiser,'Error for VisB event predicate:',String,Pos),
2238 TypedPred = b(truth,pred,[])
2239 ).
2240
2241 % replace special patterns by dummy values to avoid error messages in ProB2-UI
2242 replace_special_patterns([],[],_Pos) :- !.
2243 replace_special_patterns([37|T],Res,Pos) :- !, % percentage sign %
2244 replace_aux(T,Res,Pos).
2245 replace_special_patterns([H|T],[H|RT],Pos) :- !, replace_special_patterns(T,RT,Pos).
2246
2247 replace_aux(Input,Res,Pos) :-
2248 replace_pat(PAT,Replacement),
2249 append(PAT,T,Input),
2250 !,
2251 atom_codes(PatAtom,PAT),
2252 ajoin(['The %',PatAtom,' pattern is obsolete. Please use VISB_CLICK_META_INFOS\'',PatAtom,' instead.'],Msg),
2253 add_warning(visb_visualiser,Msg,'',Pos),
2254 append(Replacement,ResT,Res),
2255 replace_special_patterns(T,ResT,Pos).
2256 replace_aux(Input,[37|Res],Pos) :- !, replace_special_patterns(Input,Res,Pos).
2257
2258 replace_pat("shiftKey","VISB_CLICK_META_INFOS'shiftKey").
2259 replace_pat("metaKey","VISB_CLICK_META_INFOS'metaKey").
2260 replace_pat("pageX","VISB_CLICK_META_INFOS'pageX").
2261 replace_pat("pageY","VISB_CLICK_META_INFOS'pageY").
2262
2263
2264
2265 % small utils:
2266 % ----------------
2267
2268 % a variation of between/3 with a step argument
2269 between(From,To,_,_) :- From > To, !,fail.
2270 between(From,_,_,From).
2271 ?between(From,To,Step,Elem) :- F1 is From+Step, between(F1,To,Step,Elem).
2272
2273 :- use_module(probsrc(tools_strings),[is_simple_classical_b_identifier_codes/1]).
2274 :- use_module(probsrc(preferences), [reset_temporary_preference/2,temporary_set_preference/3]).
2275 parse_expr(ExprCodes,TypedExpr,_GenParseErrors) :-
2276 is_simple_classical_b_identifier_codes(ExprCodes),
2277 atom_codes(DefID,ExprCodes),
2278 visb_definition(DefID,Type,_DefFormula,Class,_VPos,_),
2279 !,
2280 TypedExpr = b(identifier(DefID),Type,[type_of_formula(Class)]).
2281 parse_expr(ExprCodes,TypedExpr,GenParseErrors) :-
2282 temporary_set_preference(allow_arith_operators_on_reals,true,CHNG),
2283 get_visb_extra_scope(ExtraScope),
2284 % formatsilent('Parsing: ~s (extra ids: ~w)~n',[ExprCodes,ExtraScope]), start_ms_timer(T1),
2285 call_cleanup(bmachine:b_parse_machine_expression_from_codes_with_prob_ids(ExprCodes,ExtraScope,TypedExpr,
2286 GenParseErrors),
2287 reset_temporary_preference(allow_arith_operators_on_reals,CHNG)).
2288 %stop_ms_walltimer_with_msg(T1,'parsing: ').
2289 % TODO: we could share a machine parameter M like in prob2_interface
2290 % so that b_type_expression_for_full_b_machine will load machine only once
2291 % cf b_type_open_predicate_for_full_b_machine
2292
2293 determine_type_of_visb_formula(b(_,_,[type_of_formula(Class)]),all,Res) :- !,
2294 Res = Class. % generated by VisB, TODO: store UsedTIds in type_of_formula(.)
2295 determine_type_of_visb_formula(TypedExpr,TIds,Class) :-
2296 determine_type_of_formula_with_visb_defs(TypedExpr,TIds,Class).
2297
2298 %check for used_ids inside TypedExpr an see what type of visb_definition are used
2299 determine_type_of_formula_with_visb_defs(TypedExpr,TIds,ResClass) :-
2300 determine_type_of_formula(TypedExpr,TIds,Class1), % compute class w/o knowledge of VisB definitions
2301 ? (class_more_general_than(Class2,Class1),
2302 ? required_by_visb_def(TIds,Class2) -> Class=Class2
2303 ; Class=Class1),
2304 (Class=requires_variables -> ResClass=Class
2305 ; expression_requires_state(TypedExpr) -> ResClass = requires_variables
2306 ; ResClass=Class).
2307
2308 :- use_module(probsrc(bsyntaxtree),[map_over_bexpr/2]).
2309 :- use_module(probsrc(external_functions),[external_function_requires_state/1]).
2310 expression_requires_state(TypedExpr) :-
2311 (map_over_bexpr(sub_expression_requires_state,TypedExpr) -> true ; fail).
2312 % TODO: should we also check is_not_declarative/1 ? e.g., for RANDOM or CHANGED
2313 sub_expression_requires_state(external_pred_call(P,_)) :- external_function_requires_state(P).
2314 sub_expression_requires_state(external_function_call(P,_)) :- external_function_requires_state(P).
2315
2316
2317 class_more_general_than(requires_variables,requires_nothing).
2318 class_more_general_than(requires_variables,requires_constants).
2319 class_more_general_than(requires_constants,requires_nothing).
2320
2321 required_by_visb_def(TIds,Class) :-
2322 ? member(TID,TIds), get_texpr_id(TID,ID),visb_definition(ID,_,_,Class,_,_).
2323
2324
2325 get_visb_extra_scope([identifier(ExtraIDs)]) :-
2326 get_visb_extra_identifiers(ExtraIDs).
2327 get_visb_extra_identifiers(ExtraIDs) :-
2328 findall(b(identifier(ID),Type,[visb_generated]),visb_definition(ID,Type,_,_,_,_),ExtraIDs).
2329
2330 % replace a pattern code prefixed by % by another code list
2331 replace_in_json(Pattern,RepStr,string(Val),string(NewVal)) :- !, replace_atom(Pattern,RepStr,Val,NewVal).
2332 replace_in_json(Pattern,RepStr,array(Vals),array(NewVals)) :- !, maplist(replace_in_json(Pattern,RepStr),Vals,NewVals).
2333 replace_in_json(Pattern,RepStr,json(Vals),json(NewVals)) :- !, maplist(replace_in_json_pair(Pattern,RepStr),Vals,NewVals).
2334 replace_in_json(_,_,Val,Val). % number/literal (no replacement necessary)
2335
2336 replace_in_json_pair(Pattern,RepStr,'='(KIn,VIn,Pos),'='(KOut,VOut,Pos)) :-
2337 replace_atom(Pattern,RepStr,KIn,KOut),
2338 replace_in_json(Pattern,RepStr,VIn,VOut).
2339
2340 replace_atom(Pattern,RepStr,Val,NewVal) :-
2341 atom_codes(Val,Codes),
2342 replace_pat(Pattern,RepStr,NewCodes,Codes,[]),
2343 atom_codes(NewVal,NewCodes). % TO DO: keep as codes for efficiency
2344
2345 :- assert_must_succeed((visb_visualiser: replace_pat("0","_1_",Res,"ab%0cd",[]), Res == "ab_1_cd")).
2346 :- assert_must_succeed((visb_visualiser: replace_pat("0","",Res,"ab%0%0cd%0",[]), Res == "abcd")).
2347 % dcg utility to replace %Pat by NewStr constructing Res
2348 replace_pat(Pat,NewStr,Res) --> "%", Pat, !, {append(NewStr,TR,Res)}, replace_pat(Pat,NewStr,TR).
2349 replace_pat(Pat,RepStr,[H|T]) --> [H],!, replace_pat(Pat,RepStr,T).
2350 replace_pat(_,_,[]) --> [].
2351
2352
2353 % small JSON utils:
2354 % ----------------
2355
2356 ?get_attr(Attr,List,Val) :- member('='(Attr,Val,_),List).
2357 get_attr_with_pos(Attr,List,Val,File,Pos) :-
2358 El = '='(Attr,Val,_),
2359 ? member(El,List),
2360 get_pos_from_list([El],File,Pos).
2361
2362 ?del_attr(Attr,List,Val,Rest) :- select('='(Attr,Val,_Pos),List,Rest).
2363 %del_attr_with_pos(Attr,List,Val,Rest,Pos) :- select('='(Attr,Val,Pos),List,Rest).
2364 ?del_attr_with_pos(Attr,List,Val,Rest,File,PosTerm) :- select('='(Attr,Val,From-To),List,Rest),!,
2365 PosTerm = src_position_with_filename_and_ec(From,1,To,1,File).
2366 ?non_det_del_attr_with_pos(Attr,List,Val,Rest,File,PosTerm) :- select('='(Attr,Val,From-To),List,Rest),
2367 PosTerm = src_position_with_filename_and_ec(From,1,To,1,File).
2368
2369 force_del_attr(Attr,List,Val,Rest,File) :- force_del_attr_with_pos(Attr,List,Val,Rest,File,_).
2370
2371 ?force_del_attr_with_pos(Attr,List,Val,Rest,File,PosTerm) :- select('='(Attr,Val,From-To),List,Rest),!,
2372 %TODO: we would ideally want to extract the exact column position of Val, for this we need to extend the JSON parser first
2373 PosTerm = src_position_with_filename_and_ec(From,1,To,1,File).
2374 force_del_attr_with_pos(Attr,List,_,_,File,_) :- get_pos_from_list(List,File,Pos),!,
2375 add_error(visb_visualiser,'The JSON object has no attribute:',Attr,Pos),fail.
2376
2377 construct_prob_pos_term(From-To,File,PosTerm) :- !,
2378 PosTerm = src_position_with_filename_and_ec(From,1,To,1,File).
2379 construct_prob_pos_term(Pos,_,Pos).
2380
2381 force_get_attr_nr(Attr,List,Nr,File) :-
2382 force_del_attr_with_pos(Attr,List,AttrVal,_,File,Pos),!,
2383 get_number_value(AttrVal,Nr,Attr,Pos).
2384
2385 get_number_value(AttrVal,Nr,Attr,Pos) :-
2386 (AttrVal = number(Nr) -> true
2387 ; AttrVal = string(StrAttrVal),
2388 atom_codes(StrAttrVal,AttrValC),
2389 parse_expr(AttrValC,TypedExpr,gen_parse_errors_for(Pos)),
2390 determine_type_of_visb_formula(TypedExpr,UsedTIds,Class)
2391 % Class = requires_nothing, requires_constants, requires_variables
2392 ->
2393 (Class = requires_variables
2394 -> ajoin(['The JSON formula for the attribute"',Attr,
2395 '" must not depend on variables:'],Msg),
2396 add_error(visb_visualiser,Msg,StrAttrVal,Pos),fail
2397 ; Class = requires_constants,
2398 \+ is_concrete_constants_state_id(_)
2399 -> ajoin(['The JSON formula for the attribute"',Attr,
2400 '" depends on constants which have not been set up (via SETUP_CONSTANTS):'],Msg),
2401 add_error(visb_visualiser,Msg,StrAttrVal,Pos),fail
2402 ; Class = requires_constants,
2403 multiple_concrete_constants_exist,
2404 ajoin(['The JSON formula for the attribute"',Attr,
2405 '" depends on constants and multiple solutions for SETUP_CONSTANTS exist:'],Msg),
2406 add_warning(visb_visualiser,Msg,StrAttrVal,Pos),fail
2407 ; get_texpr_type(TypedExpr,Type),
2408 is_number_type(Type)
2409 -> eval_static_def(Class,'VisB attribute',Attr,TypedExpr,UsedTIds,ResVal,Pos),
2410 get_number_from_bvalue(ResVal,Nr)
2411 ; get_texpr_type(TypedExpr,Type),
2412 % it could produce a string which is a number; we could try and convert to a number
2413 ajoin(['The type ',Type,' of the JSON value formula for the attribute "',Attr,
2414 '" is not a number:'],Msg),
2415 add_error(visb_visualiser,Msg,StrAttrVal,Pos),fail
2416 )
2417 ; ajoin(['The JSON value for the attribute "',Attr,'" cannot be parsed as a number:'],Msg),
2418 add_error(visb_visualiser,Msg,AttrVal,Pos),fail).
2419
2420 is_number_type(integer).
2421 is_number_type(real).
2422 :- use_module(probsrc(kernel_reals),[is_real/2]).
2423 :- use_module(probsrc(custom_explicit_sets),[singleton_set/2]).
2424 get_number_from_bvalue(int(Nr),Res) :- !, Res=Nr.
2425 get_number_from_bvalue(Term,Res) :- is_real(Term,Nr),!,Res=Nr.
2426
2427 get_pos_from_list(json(List),File,Pos) :- !, get_pos_from_list(List,File,Pos).
2428 get_pos_from_list([H|T],File,RPos) :-
2429 H='='(_,_,From-_),
2430 last([H|T],
2431 '='(_,_,_-To)),
2432 !,
2433 RPos=src_position_with_filename_and_ec(From,1,To,1,File).
2434 get_pos_from_list(_,File,File). % should we provide another term?
2435
2436 % ----------------------------------
2437
2438 :- use_module(probsrc(b_global_sets),[add_prob_deferred_set_elements_to_store/3]).
2439 :- use_module(probsrc(tools),[b_string_escape_codes/2]).
2440
2441 % computing updates to SVG for a given StateId:
2442 % predicate to obtain required setAttribute changes to visualise StateId
2443 % looks up visb_item facts but also evaluates VISB_SVG_UPDATE definitions
2444 get_change_attribute_for_state(StateId,SvgID,SvgAttribute,Value) :-
2445 set_error_context(checking_context('VisB:','computing attributes for state')),
2446 get_expanded_bstate(StateId,ExpandedBState),
2447 set_context_state(StateId,get_change_attribute_for_state), % also sets it for external functions
2448 % TODO: also set history so that get_current_history in external_functions is more reliable
2449 ? call_cleanup(get_change_aux(StateId,ExpandedBState,SvgID,SvgAttribute,Value),
2450 (clear_context_state,clear_error_context)).
2451
2452 get_change_aux(StateId,ExpandedBState,SvgID,SvgAttribute,Value) :-
2453 ? get_aux2(StateId,ExpandedBState,SvgID0,SvgAttribute0,Value0,DefPos),
2454 post_process_visb_item(SvgID0,SvgAttribute0,Value0,DefPos,SvgID,SvgAttribute,Value).
2455 get_aux2(StateId,ExpandedBState,SvgID,SvgAttribute,Value,DefPos) :-
2456 % first get updates from DEFINITIONS which usually return sets of records
2457 ? get_svg_object_updates_from_definitions(ExpandedBState,SvgID,SvgAttribute,Value,DefPos),
2458 debug_format(19,' VISB_SVG_UPDATE ~w:~w = ~w (in state ~w)~n',[SvgID,SvgAttribute,Value,StateId]).
2459 get_aux2(StateId,ExpandedBState,SvgID,SvgAttribute,Value,Pos) :-
2460 % TODO: check if visibility item exists, and if value is false: do not compute the rest
2461 ? get_visb_item_formula(SvgID,SvgAttribute,Formula,Pos,ExpandedBState),
2462 % TODO: if UsedIds=[] only set attribute once, if it requires_only_constants : ditto
2463 evaluate_visb_formula(Formula,'VisB item',SvgID,ExpandedBState,FValue,Pos),
2464 %b_value_to_string(FValue,Value),
2465 extract_attr_value(SvgAttribute,FValue,Value,Pos),
2466 debug_format(19,' VisB item ~w:~w = ~w (in state ~w)~n',[SvgID,SvgAttribute,Value,StateId]).
2467
2468 % post-process certain items, like title to adapt the value and id:
2469 % SVG does not support a title attribute; we need a title child and set its text attribute
2470 post_process_visb_item(SvgID,title,Value,Pos,NewID,text,NewValue) :-
2471 visb_svg_object(SvgID,_SVG_Class,_RestAttrs,_Desc,_Pos1),
2472 (visb_svg_object_debug_info(SvgID,DebugInfo) -> ajoin([Value,'\n',DebugInfo],NewValue) ; NewValue=Value),
2473 ? (visb_svg_parent(SvgID,TitleID),
2474 visb_svg_object(TitleID,title,_,_,_)
2475 -> NewID=TitleID,
2476 debug_format(9,'Redirecting title update for ~w to child object ~w~n',[SvgID,TitleID])
2477 ; add_warning(visb_visualiser,'Could not find title child object, be sure to define a static title attribute for SVG object: ',SvgID,Pos),
2478 fail
2479 ),!.
2480 post_process_visb_item(SvgID,Attr,Value,_,SvgID,Attr,Value).
2481
2482 % ------------------
2483
2484 % convert B value to Json String
2485 b_value_to_string(string(SValue),Res) :- !, Res=SValue. % What about quoting,...?
2486 b_value_to_string(FValue,Res) :-
2487 translate_bvalue_to_codes(FValue,ValCodes),
2488 atom_codes(Res,ValCodes).
2489
2490 % attributes for which we convert pairs to the concatenation of strings
2491 is_id_or_text_attribute(id).
2492 is_id_or_text_attribute('group_id'). % works much like a parent_id; also can be used to attach animate to e.g. a rect
2493 is_id_or_text_attribute('trigger_id').
2494 is_id_or_text_attribute('trigger-id').
2495 is_id_or_text_attribute(A) :- is_text_attribute(A).
2496 % children
2497 is_text_attribute('text').
2498 is_text_attribute('transform').
2499 is_text_attribute('event'). % for VISB_SVG_EVENTS
2500 is_text_attribute('predicate'). % for VISB_SVG_EVENTS
2501 is_text_attribute('svg_class').
2502
2503
2504 b_value_to_id_string(Val,String) :- b_val_to_id_string_aux(Val,add_underscore,String).
2505 b_value_to_text_string(Val,String) :- b_val_to_id_string_aux(Val,no_underscore,String).
2506
2507 % a special string conversion which e.g., allows to use things like ("ab",2) as id which gets translated to ab2
2508 % also useful for text attributes
2509 b_val_to_id_string_aux(string(SValue),_,Res) :- !, Res=SValue.
2510 b_val_to_id_string_aux((A,B),Add,Res) :- !,
2511 b_val_to_id_string_aux(A,Add,VA), b_val_to_id_string_aux(B,Add,VB),
2512 (Add=add_underscore
2513 -> atom_concat('_',VB,VB1) % introduce separator; in case we have things like numbers so that (12,3) /= (1,23)
2514 ; VB1=VB % for fields like predicate, transform, ... we do not want additional underscores
2515 ),
2516 atom_concat(VA,VB1,Res).
2517 b_val_to_id_string_aux(Set,Add,Res) :- singleton_set(Set,El),!, b_val_to_id_string_aux(El,Add,Res).
2518 % TODO: maybe convert sequence of values using conc
2519 b_val_to_id_string_aux(FValue,_,Res) :-
2520 translate_bvalue_to_codes(FValue,ValCodes),
2521 atom_codes(Res,ValCodes).
2522
2523 % get either a regular VisB item or an item associated with a VisB event and its enabled status
2524 get_visb_item_formula(SvgID,SvgAttribute,Formula,Pos,_ExpandedBState) :-
2525 ? visb_item(SvgID,SvgAttribute,Formula,_UsedIds,_Desc,Pos,_). % regular VisB item
2526 get_visb_item_formula(SvgID,SvgAttribute,Formula,Pos,ExpandedBState) :- % item within VisB event
2527 visb_event_enable_list(OpName,TypedPred,EnableList,_,ItemPos),
2528 debug_format(19,'Checking enabledness of VisB event ~w~n',[OpName]),
2529 (check_enabled(OpName,TypedPred,ExpandedBState,ItemPos)
2530 -> Formula=EnabledValExpr
2531 ; Formula=DisabledValExpr
2532 ),
2533 member(visb_enable_item(SvgID,SvgAttribute,EnabledValExpr,DisabledValExpr,Pos), EnableList).
2534
2535 check_enabled(OpName,Pred,ExpandedBState,Pos) :-
2536 special_operation(OpName),!,
2537 special_operation_enabled(OpName,Pred,ExpandedBState,Pos).
2538 check_enabled(OpName,Pred,ExpandedBState,Pos) :-
2539 b_is_operation_name(OpName),
2540 % TODO: see if we can use GUARD without execution
2541 % TODO: not yet working for XTL mode
2542 execute_operation_by_predicate_in_state_with_pos(ExpandedBState,OpName,Pred,_OpTerm,_NewState,Pos).
2543
2544
2545 get_expanded_bstate(StateId,ExpandedBState) :-
2546 \+ b_or_z_mode,!,
2547 StateId \= root,
2548 % in XTL mode we need to access the state via external functions like STATE_PROPERTY
2549 get_static_visb_state([],ExpandedBState).
2550 get_expanded_bstate(StateId,ExpandedBState) :-
2551 visited_expression(StateId,State),
2552 state_corresponds_to_initialised_b_machine(State,BState),
2553 debug_format(19,'Adding VisB definitions to state: ~w~n',[StateId]),
2554 add_prob_deferred_set_elements_to_store(BState,BState2,visible), % add prob_ids
2555 findall(visb_definition(DefID,Type,DefFormula,Class,VPos,Special),
2556 visb_definition(DefID,Type,DefFormula,Class,VPos,Special),DefList),
2557 eval_defs(DefList,BState2,ExpandedBState).
2558
2559
2560 :- use_module(probsrc(b_interpreter), [ b_compute_expression_nowf/7,b_compute_explicit_epression_no_wf/7]).
2561
2562 evaluate_static_visb_formula(Formula,Kind,Nr,InState,ResValue,Pos) :-
2563 get_static_visb_state(InState,StaticState),
2564 evaluate_visb_formula(Formula,Kind,Nr,StaticState,ResValue,Pos).
2565
2566 evaluate_visb_formula(Formula,Kind,Nr,BState2,ResValue,Pos) :-
2567 % add_message(visb,'Evaluating: ',Kind:Nr,Pos), debug:nl_time, %set_prolog_flag(profiling,on), print_profile,
2568 ? (b_compute_explicit_epression_no_wf(Formula,[],BState2,ResValue,Kind,Nr,Pos) -> true
2569 ; add_error(visb_visualiser,'Evaluation of VisB formula failed:',Formula,Pos),
2570 fail).
2571
2572 % evaluate VisB definitions in order one by one, adding values to state
2573 eval_defs([],State,State).
2574 eval_defs([visb_definition(ID,_,TypedExpr,_Class,VPos,Special)|T],State0,State2) :-
2575 (Special \= regular_def
2576 -> State1=State0 % ignore special defs; they are processed separately
2577 ; b_compute_expression_nowf(TypedExpr,[],State0,ResValue,'VisB definition',ID,VPos),
2578 State1 = [bind(ID,ResValue)|State0], % store value for later definitions and VisB items
2579 (debug_mode(off) -> true
2580 ; translate_bvalue_to_codes_with_limit(ResValue,2000,RC),
2581 formatsilent(' VisB definition ~w == ~s~n',[ID,RC]))
2582 ),
2583 eval_defs(T,State1,State2).
2584
2585 % check if we have a static value for a VisB definition:
2586 visb_def_static_value(DefID,Value) :-
2587 ? visb_definition(DefID,_,b(value(Value),_,_),Class,_,SpecialClass),
2588 SpecialClass = regular_def,
2589 (Class = requires_nothing ; Class = requires_constants). % probably we do not need to check this, as we have value/1
2590
2591 get_static_visb_state(InState,FullState) :-
2592 findall(bind(DefID,Value),visb_def_static_value(DefID,Value),FullState,InState).
2593 % TO DO: get state with deferred_set_elements,...
2594
2595 % ----------------------------------
2596
2597 % generate a stand-alone HTML file with a visualisation for all states in the list
2598
2599 generate_visb_html(StateIds,File,Options) :-
2600 safe_open_file(File,write,Stream,[encoding(utf8)]),
2601 generate_html_to_stream(StateIds,Stream,[html_file/File|Options]),
2602 close(Stream).
2603
2604 generate_visb_html_to_codes(StateIds,Options,Codes) :-
2605 with_open_stream_to_codes(
2606 generate_html_to_stream(StateIds,Stream,Options),
2607 Stream,Codes,[]).
2608
2609
2610 % generate an HTML file to visualise the given StateId
2611 generate_html_to_stream(StateIds,Stream,Options) :-
2612 set_id_namespace_prefix_for_states(StateIds,Options),
2613 write_visb_template('visb_template_header.html',Stream),
2614 (member(show_svg_downloads,Options) -> write_visb_template('visb_template_svg_downloads.html',Stream) ; true),
2615 format(Stream,' <script>~n',[]),
2616 retractall(js_generated_function(_)),
2617 length(StateIds,Len),
2618 format(Stream,' const differences = [~n',[]),
2619 maplist(gen_visb_visualise_function(Stream,Options,Len,StateIds),StateIds),
2620 write_visb_template('visb_template_replayTrace.html',Stream),
2621 format(Stream,' </script>~n~n',[]),
2622 gen_registerHovers_scipt(Stream,Options),
2623 write_visb_template('visb_template_middle.html',Stream),
2624 (no_svg_available
2625 -> format(Stream,' <button type="button" class="collapsible-style">No SVG Visualisation Available</button>~n',[])
2626 ; % generate SVG section
2627 (member(no_header,Options) -> true
2628 ; format(Stream,' <button type="button" class="collapsible collapsible-style active">SVG Visualisation</button>~n',[])
2629 ),
2630 format(Stream,' <div style="position: relative;">~n',[]), % container for SVG download buttons
2631 format(Stream,' <div text-align="left" id="visb_svg_outer_container" class="svg-outer-container">~n',[]),
2632 format(Stream,' <div id="visb_svg_inner_container" class="svg-inner-container">~n',[]),
2633 %format(Stream,' <fieldset> <legend>Visualisation:</legend>~n',[]), % comment in to draw a border
2634 (StateIds = [SingleStateId] -> GenForState=SingleStateId ; GenForState=root),
2635 copy_svg_file_and_gen_objects(Stream,GenForState,_SVGinlined),
2636 % TO DO: avoid creating JS code below if _SVGinlined
2637 %format(Stream,' </fieldset>~n',[]),
2638 format(Stream,' </div>~n',[]), % inner container
2639 format(Stream,' </div>~n',[]), % outer container
2640 format(Stream,' <button id="btnResetScale" class="visualisation-button" onclick="resetScale()">Reset View</button>~n',[]),
2641 (member(show_svg_downloads,Options) ->
2642 format(Stream,' <button onclick="downloadSVG()">Save SVG (Current State)</button>~n',[]),
2643 format(Stream,' <button onclick="downloadAllSVGs()">Save all SVGs</button>~n',[])
2644 ; true),
2645 format(Stream,' </div>~n',[]) % container for SVG download buttons
2646 ),
2647 (Len>1, memberchk(show_sequence_chart,Options) % don't export PlantUML for list of state IDs (sequence chart depends on trace)
2648 -> (create_temp_puml_files(Len,Files),
2649 uml_generator:write_uml_sequence_chart_all_states(Files), % generate .puml files
2650 tools_commands:gen_plantuml_output(Files,svg,[]) % generate .svg files
2651 -> format(Stream,' <button type="button" class="collapsible collapsible-style active">Sequence Chart Visualisation</button>~n',[]),
2652 format(Stream,' <div class="seq-chart-container">~n',[]),
2653 reverse(Files,RFiles),
2654 write_temp_puml_outputs(1,RFiles,Stream), % write SVG contents to HTML
2655 format(Stream,' </div>~n',[])
2656 ; add_warning(visb_visualiser,'HTML export: did not write the Sequence Diagram Visualisation due to an error in the PlantUML call.'),
2657 format(Stream,' <button type="button" class="collapsible-style">No Sequence Chart Visualisation Available</button>~n',[])
2658 )
2659 ; true),
2660 (Len>1
2661 -> %format(Stream,'~n<h3>Run Trace</h3>~n',[]),
2662 format(Stream,' <button type="button" class="collapsible-style">Replay Trace</button>~n',[]),
2663 format(Stream,' <div class="coll-content-vis">~n',[]),
2664 format(Stream,' <button id="btnPrev" onclick="backStep()" title="Go back one step">« Back</button>~n',[]),
2665 format(Stream,' <button id="btnNext" onclick="forwardStep()" title="Go forward one step">Forward »</button>~n',[]),
2666 format(Stream,' <button onclick="runAll(10)" title="Fast replay of entire trace">Run Trace (10 ms delay)</button>~n',[]),
2667 format(Stream,' <button onclick="runAll(500)" title="Slow replay of entire trace">Run Trace (500 ms delay)</button>~n',[]),
2668 format(Stream,' <button onclick="runAll(parseInt(delayInput.value))" title="Custom replay of entire trace">Run Trace with Delay (ms):</button>~n',[]),
2669 format(Stream,' <input id="delayInput" type="number" value="1000" min="0" step="100" onkeydown="if(event.key===\'Enter\') runAll(parseInt(this.value))">~n',[]),
2670 % We could decide to provide an option/preference for generating the visb_debug_messages field:
2671 % (check that ProB2-UI also generates this text field)
2672 format(Stream,' <br><label id="visb_debug_messages" class="visb-messages"> </label>~n',[]),
2673 format(Stream,' </div>~n',[]),
2674 format(Stream,' <progress id="trace_meter" min="0" max="~w" value="0"></progress>~n',[Len]) % progress of trace replay; note <meter> element also works
2675 ; true
2676 ),
2677 % generate a table with variables, constants, ...
2678 gen_state_table(Stream,Options,StateIds),
2679 gen_source_code_section(Stream,Options),
2680 % generate a table with the saved trace steps:
2681 (Len>1 -> gen_trace_table(Stream,StateIds) ; true),
2682 write_version_info(Stream,Options),
2683 (last(StateIds,_)
2684 -> format(Stream,' <script> replayStep(~w); </script>~n',[Len])
2685 % show the visualisation of the last state by default
2686 ; true % trace is empty, there is no last item
2687 ),
2688 write_visb_template('visb_template_footer.html',Stream),
2689 clear_id_namespace_prefix.
2690
2691 write_file_to_stream(File,Stream) :-
2692 safe_open_file(File,read,StreamIn,[encoding(utf8)]),
2693 copy_stream(StreamIn,Stream),
2694 close(StreamIn).
2695
2696 create_temp_puml_files(Len,[]) :- Len<1, !.
2697 create_temp_puml_files(Len,[Path|T]) :-
2698 system_call:get_temporary_filename('for_html.puml',Path),
2699 NewLen is Len-1,
2700 create_temp_puml_files(NewLen,T).
2701
2702 write_temp_puml_outputs(_,[],_).
2703 write_temp_puml_outputs(Nr,[File|T],Stream) :-
2704 tools:split_filename(File,FileRoot,_Ext),
2705 ajoin([FileRoot,'.svg'],SvgFile),
2706 format(Stream,' <div id="seq_chart_~w" style="display:none">~n',[Nr]), % container for seq. charts
2707 write_file_to_stream(SvgFile,Stream),
2708 format(Stream,' </div>~n',[]), % container for seq. charts
2709 NNr is Nr+1,
2710 write_temp_puml_outputs(NNr,T,Stream).
2711
2712 % -----------------
2713
2714 :- use_module(library(system),[ datime/1]).
2715 :- use_module(probsrc(tools_strings),[number_codes_min_length/3]).
2716 :- use_module(probsrc(tools),[gen_relative_path/3]).
2717 :- use_module(probsrc(version),[version_str/1]).
2718 :- use_module(probsrc(specfile),[currently_opened_file/1, get_internal_representation/1]).
2719 write_version_info(_,Options) :-
2720 member(no_version_info,Options),!.
2721 write_version_info(Stream,Options) :-
2722 version_str(Str),datime(datime(Yr,Mon,Day,Hr,Min,_Sec)),
2723 number_codes_min_length(Min,2,MC),
2724 format(Stream,' <button type="button" class="collapsible-style" title="Information about ProB and model">Info</button>~n',[]),
2725 format(Stream,'<div class="coll-content-vis visb-messages">~n',[]),
2726 format(Stream,'Generated on ~w/~w/~w at ~w:~s using <a href="https://prob.hhu.de/">ProB</a> version ~w~n',[Day,Mon,Yr,Hr,MC,Str]),
2727 (currently_opened_file(File)
2728 -> (File=package(Type) ->
2729 format(Stream,'<br>Main specification package: ~w~n',[Type])
2730 ; atom(File), get_relative_path(File,Options,Suffix) ->
2731 format(Stream,'<br>Main specification file: ~w',[Suffix]),
2732 format_file_info(Stream,File)
2733 ; format(Stream,'<br>Unknown main specification file: ~w~n',[File])
2734 )
2735 ; true),
2736 (b_machine_name(MainName)
2737 -> format(Stream,'<br>Main specification name: ~w~n',[MainName]) ; true),
2738 (visb_file_loaded(JSONFile,_,ModLocTime),
2739 JSONFile \= ''
2740 -> get_relative_path(JSONFile,Options,JSuffix),
2741 format(Stream,'<br>Main VisB JSON file: ~w',[JSuffix]),
2742 format_modified_info(Stream,ModLocTime),
2743 (get_non_empty_svg_file(SVGFile,ModLocTime2)
2744 -> get_relative_path(SVGFile,Options,SSuffix),
2745 format(Stream,'<br>VisB SVG file: ~w',[SSuffix]),
2746 format_modified_info(Stream,ModLocTime2)
2747 ; true
2748 )
2749 ; true).
2750
2751 get_non_empty_svg_file(SVGFile,ModLocTime2) :-
2752 visb_svg_file(RelFile,SVGFile,_,_,ModLocTime2),
2753 RelFile \= ''.
2754
2755 format_file_info(Stream,File) :-
2756 catch(file_property(File, modify_localtime, ModLocTime),
2757 E,
2758 (add_message(visb_visualiser,'Could not obtain modification time for file: ',E), fail)),
2759 !,
2760 format_modified_info(Stream,ModLocTime).
2761 format_file_info(Stream,_) :- nl(Stream).
2762
2763 format_modified_info(Stream,ModLocTime) :-
2764 format(Stream,' (modified on ',[]),
2765 format_datime(Stream,ModLocTime),
2766 format(Stream,')~n',[]).
2767
2768 format_datime(Stream,datime(Yr,Mon,Day,Hr,Min,_Sec)) :-
2769 number_codes_min_length(Min,2,MC),
2770 format(Stream,'~w/~w/~w at ~w:~s',[Day,Mon,Yr,Hr,MC]).
2771
2772 get_relative_path(File,Options,RelPath) :-
2773 ? member(html_file/HF,Options),
2774 absolute_file_name(File,AF,[]),
2775 absolute_file_name(HF,AHF,[]),
2776 !,
2777 gen_relative_path(AF,AHF,RelPath). % only print relative information
2778 get_relative_path(File,_,File).
2779
2780
2781 % -----------------
2782
2783 % gen a table with all the individual steps of the trace
2784 gen_trace_table(Stream,StateIds) :-
2785 length(StateIds,Len),
2786 %format(Stream,'~n<h3>Trace (length=~w)</h3>~n',[Len]),
2787 format(Stream,' <button type="button" class="collapsible collapsible-style active">Trace (length=~w)</button>~n',[Len]),
2788 format(Stream,'<div class="coll-content-vis">~n',[]),
2789 ? (member(Obj,StateIds), get_state_and_action(Obj,_,_,DescStr), DescStr \= ''
2790 -> Opt=with_description ; Opt=no_description),
2791 gen_trace_table2(Stream,StateIds,Opt).
2792
2793 gen_trace_table2(Stream,StateIds,no_description) :-
2794 format(Stream,' <table> <tr> <th>Nr</th> <th>Event</th> <th>Target State ID</th> </tr>~n',[]),
2795 ? nth1(Nr,StateIds,Obj),
2796 get_state_and_action(Obj,StateId,ActionStr,_),
2797 ((visited_state_corresponds_to_initialised_b_machine(StateId) ; xtl_mode) % allow onclick to all rows in xtl_mode
2798 -> (invariant_violated(StateId) -> BtnStyle='style="background-color:rgb(255,179,179);border-radius:6px" ' ; BtnStyle=''),
2799 format(Stream,'~n <tr id="row~w" onclick="replayStep(~w)"><td>~w</td><td style="cursor:pointer">~w</td><td><button ~wonclick="replayStep(~w);">State ~w</button></td></tr>~n',
2800 [Nr,Nr,Nr,ActionStr,BtnStyle,Nr,StateId])
2801 ; format(Stream,'~n <tr id="row~w"><td>~w</td><td style="cursor:not-allowed">~w</td><td>State ~w</td></tr>~n',
2802 [Nr,Nr,ActionStr,StateId])
2803 ),
2804 fail.
2805 gen_trace_table2(Stream,StateIds,with_description) :-
2806 format(Stream,' <table> <tr> <th>Nr</th> <th>Event</th> <th>Description</th> <th>Target State ID</th> </tr>~n',[]),
2807 ? nth1(Nr,StateIds,Obj),
2808 get_state_and_action(Obj,StateId,ActionStr,DescStr),
2809 atom_codes(ActionStr,ActionCodes),html_escape_codes(ActionCodes,EAS),
2810 atom_codes(DescStr,DescCodes),html_escape_codes(DescCodes,EDS),
2811 ((visited_state_corresponds_to_initialised_b_machine(StateId) ; xtl_mode) % allow onclick to all rows in xtl_mode
2812 -> (invariant_violated(StateId) -> BtnStyle='style="background-color:rgb(255,179,179);border-radius:6px" ' ; BtnStyle=''),
2813 format(Stream,'~n <tr id="row~w" onclick="replayStep(~w)"><td>~w</td><td style="cursor:pointer">~s</td><td>~s</td><td><button ~wonclick="replayStep(~w);">State ~w</button></td></tr>~n',
2814 [Nr,Nr,Nr,EAS,EDS,BtnStyle, Nr,StateId])
2815 ; format(Stream,'~n <tr id="row~w"><td>~w</td><td style="cursor:not-allowed">~s</td><td>~s</td><td>State ~w</td></tr>~n',
2816 [Nr,Nr,EAS,EDS,StateId])
2817 ),
2818 fail.
2819 gen_trace_table2(Stream,_,_) :-
2820 format(Stream,' </table>~n </div>~n',[]).
2821
2822
2823 % utility to allow passing information about name of event/operation/action leading to state
2824 get_state_and_action(change_to_state_via_action(StateId,ActionStr,DescStr),StateId,ActionStr,DescStr) :- !.
2825 get_state_and_action(StateId,StateId,'','').
2826
2827 % -----------------
2828
2829 % inline provided svg file into html file:
2830 % second argument is either root or a particular state id for which the SVG file is to be created
2831 % the last argument is static_svg_inlined if all SVG objects were "inlined" into a single
2832 % SVG object (rather than via JavaScript functions to create the objects)
2833 copy_svg_file_and_gen_objects(Stream,_,static_svg_not_inlined) :- visb_svg_file(_,File,_,_,_), file_exists(File),
2834 !,
2835 write_file_to_stream(File,Stream),
2836 ( get_visb_contents_def(Contents,DefName,DefPos,static_svg_not_inlined),
2837 ajoin(['Copying ',DefName,' *after* SVG file: '],Msg),
2838 add_message(visb_visualiser,Msg,File,DefPos),
2839 format(Stream,'~w~n',[Contents]),
2840 fail
2841 ; true
2842 ),
2843 gen_new_svg_objects(Stream).
2844 copy_svg_file_and_gen_objects(_,_,_) :-
2845 visb_svg_file(File,AFile,_,Pos,_),
2846 File \= '',
2847 add_error(visb_visualiser,'The specified VisB SVG file does not exist:',AFile,Pos),
2848 fail.
2849 copy_svg_file_and_gen_objects(Stream,SingleStateId,static_svg_inlined) :- % copy an empty SVG stub
2850 visb_file_loaded(_,_,_),!,
2851 write_default_svg_contents(Stream,inline_objects(SingleStateId)).
2852 copy_svg_file_and_gen_objects(_,_,static_svg_not_inlined). % no SVG required; we have no items or events: probably just want HTML export of variables,...
2853
2854 % get_code is faster than get_char or read_line for larger SVG files
2855 copy_stream(StreamIn,StreamOut) :-
2856 get_code(StreamIn, Code),
2857 (Code = -1 -> true
2858 ; put_code(StreamOut,Code),
2859 copy_stream(StreamIn,StreamOut)
2860 ).
2861
2862 % TODO: precompile and always assert as visb_special_definition (we could also evaluate it; could use template strings):
2863 get_visb_contents_def(Contents,DefName,DefPos,InlineObjects) :-
2864 ? get_and_eval_special_definition('VISB_SVG_CONTENTS',DefName,visb_contents,DefPos,ResValue,InlineObjects),
2865 b_value_to_string(ResValue,Contents).
2866 get_visb_contents_def(Contents,default_svg_contents,unknown,_InlineObjects) :-
2867 % default content, for VISB_CLICK_META_INFOS'jsVars
2868 Contents = '<script>let visb_vars = {};</script>'.
2869
2870 % get a definition either from B DEFINITIONS section, or if not present from the VisB JSON special definition list
2871 get_and_eval_special_definition(Prefix,DefName,JSONBackup,DefPos,ResValue,InlineObjects) :-
2872 (b_sorted_b_definition_prefixed(expression,Prefix,DefName,DefPos),
2873 ? b_get_typed_definition(DefName,[variables_and_additional_defs],TBody)
2874 ;
2875 visb_special_definition(JSONBackup,DefName,_Type,TBody,_Class,DefPos)
2876 ),
2877 % TODO: warn if we use static SVG
2878 ? get_typed_static_definition_with_constants_state(DefName,TBody,
2879 Body,DefPos,ConstantsState,InlineObjects,no_separation),
2880 evaluate_visb_formula(Body,DefName,'',ConstantsState,ResValue,DefPos).
2881
2882 write_default_svg_contents(Stream,InlineObjects) :-
2883 (visb_empty_svg_box_height_width(H,W,ViewBox) -> true ; H=400, W=400, ViewBox=''),
2884 format(Stream,'<svg xmlns=\"http://www.w3.org/2000/svg\"~n',[]),
2885 (ViewBox=''
2886 -> format(Stream,' width="~w" height="~w" viewBox="0 0 ~w ~w" >~n',[W,H,W,H])
2887 ; format(Stream,' width="~w" height="~w" viewBox="~w" >~n',[W,H,ViewBox])
2888 ),
2889 ? ( get_visb_contents_def(Contents,_,_,InlineObjects),
2890 format(Stream,'~w~n',[Contents]),
2891 fail
2892 ; true),
2893 (InlineObjects=inline_objects(StateID) -> inline_new_svg_objects(Stream,StateID) ; true),
2894 format(Stream,'</svg>~n',[]).
2895
2896 % get SVG file contents in case no SVG file is provided by user
2897 get_visb_default_svg_file_contents(Codes) :-
2898 with_open_stream_to_codes(
2899 write_default_svg_contents(Stream,inline_objects(root)),
2900 % allow inlining for groups and title children in ProB2-UI
2901 Stream,
2902 Codes, []).
2903
2904 % -----------------
2905
2906 % create a script to add all additional SVG objects
2907 gen_new_svg_objects(_) :- \+ visb_svg_object(_,_,_,_,_),!.
2908 gen_new_svg_objects(Stream) :-
2909 format(Stream, '<script>~n',[]),
2910 format(Stream, ' const svg = document.querySelector("svg");~n',[]),
2911 format(Stream, ' const svgns = "http://www.w3.org/2000/svg";~n',[]),
2912 (gen_new_svg_object(Stream,svg_root,_),fail ; true),
2913 format(Stream, '</script>~n',[]).
2914
2915 % generate JS script to create an individual new object
2916 gen_new_svg_object(Stream,ParentID,SVGID) :-
2917 visb_svg_object(SVGID,SVG_Class,AttrList,_,_Pos),
2918 (ParentID=svg_root
2919 -> \+ visb_svg_child(SVGID,_) % only generate root svg objects that have no parents
2920 ; true),
2921 add_svg_id_prefix(SVGID,SVGID2),
2922 format(Stream,' if(document.getElementById("~w") == null) {~n',[SVGID2]),
2923 format(Stream,' var new___obj = document.createElementNS(svgns,"~w");~n',[SVG_Class]),
2924 format(Stream,' new___obj.setAttribute("~w","~w");~n',[id,SVGID2]),
2925 maplist(gen_new_svg_attr(Stream,SVGID2),AttrList),
2926 (ParentID \= svg_root
2927 -> format(Stream,' document.getElementById("~w").appendChild(new___obj);~n',[ParentID])
2928 ; format(Stream,' svg.appendChild(new___obj);~n',[])
2929 ),
2930 format(Stream,' }~n',[]),
2931 (visb_svg_parent(SVGID,ChildID), % we can now generate the children
2932 gen_new_svg_object(Stream,SVGID,ChildID),
2933 fail
2934 ; true).
2935
2936 gen_new_svg_attr(Stream,_SVGID,svg_attribute(text,Val)) :- !,
2937 format(Stream,' new___obj.textContent = "~w";~n',[Val]).
2938 gen_new_svg_attr(Stream,_SVGID,svg_attribute(Attr,Val)) :-
2939 format(Stream,' new___obj.setAttribute("~w","~w");~n',[Attr,Val]).
2940
2941 % instead of creating a script to create new SVG objects,
2942 % create an inlined textual XML representation of the objects
2943 % this can be used to obtain a static SVG file which can be modified in an editor
2944 % and then later used instead of the VISB_SVG_OBJECTS definitions
2945 inline_new_svg_objects(Stream,StateId) :-
2946 get_dynamic_svgid_attributes_for_state(StateId,DynUpdateList), % compute updates only once
2947 ? visb_svg_object(SVGID,_,_,_,_), % lookup static SVG object
2948 \+ visb_svg_child(SVGID,_), % children will be created in the scope of their parent
2949 inline_new_svg_object(Stream,StateId,DynUpdateList,0,unknown,SVGID),
2950 fail.
2951 inline_new_svg_objects(_,_).
2952
2953 inline_new_svg_object(Stream,StateId,DynUpdateList,IndentLevel,ParentPos,SVGID) :-
2954 (visb_svg_object(SVGID,SVG_Class,StaticAttrList,_,Pos) -> true % lookup static SVG object
2955 ; add_warning(visb_visualiser,'Unknown SVG child object: ',SVGID,ParentPos),fail
2956 ),
2957 add_svg_id_prefix(SVGID,SVGID2), % for Jupyter
2958 indent_ws(Stream,IndentLevel),
2959 format(Stream,' <~w id="~w"',[SVG_Class,SVGID2]),
2960 (member(svgid_updates(SVGID,DynAttrList),DynUpdateList) % TODO: use avl_fetch
2961 -> override_attributes(StaticAttrList,DynAttrList,AttrList)
2962 ; AttrList=StaticAttrList),
2963 maplist(format_new_svg_attr(Stream,SVGID,Pos,TextContent),AttrList),
2964 (TextContent=''
2965 -> EscapedTextContent="" % set Text variable to empty if unbound
2966 ; do_not_escape_text_for_class(SVG_Class) -> atom_codes(TextContent,EscapedTextContent)
2967 ; atom_codes(TextContent,TCC), html_escape_codes(TCC,EscapedTextContent)),
2968 format(Stream,'>~s',[EscapedTextContent]), % Note: this text is not inside quotes, we need HTML escape
2969 IL1 is IndentLevel+1,
2970 ? ( visb_svg_parent(SVGID,Child),
2971 nl(Stream),
2972 inline_new_svg_object(Stream,StateId,DynUpdateList,IL1,Pos,Child),
2973 fail
2974 ; true),
2975 format(Stream,'</~w>~n',[SVG_Class]), % end marker
2976 fail.
2977 inline_new_svg_object(_,_,_,_,_,_).
2978
2979 % for foreignObjects the text may contain HTML tags which should not be escaped:
2980 do_not_escape_text_for_class(foreignObject).
2981 do_not_escape_text_for_class(script). % otherwise " quotes will be escaped to "
2982
2983 indent_ws(_,X) :- X<1,!.
2984 indent_ws(Stream,X) :- write(Stream,' '), X1 is X-1, indent_ws(Stream,X1).
2985
2986 % combinde svg_attribute/2 terms from two sorted lists, giving precedence to second list
2987 override_attributes([],L,R) :- !, R=L.
2988 override_attributes(L,[],R) :- !, R=L.
2989 override_attributes([svg_attribute(Attr1,Val1)|T1],[svg_attribute(Attr2,Val2)|T2],[svg_attribute(Attr3,Val3)|T3]) :-
2990 (Attr1=Attr2
2991 -> Attr3=Attr1, Val3=Val2, % dynamic value Val2 takes precedence
2992 override_attributes(T1,T2,T3)
2993 ; Attr1 @< Attr2 -> Attr3=Attr1, Val3=Val1, override_attributes(T1,[svg_attribute(Attr2,Val2)|T2],T3)
2994 ; Attr3=Attr2, Val3=Val2, override_attributes([svg_attribute(Attr1,Val1)|T1],T2,T3)
2995 ).
2996
2997 % get dynamic svg_attribute/2 list for a given state and SVG ID
2998 get_dynamic_svgid_attributes_for_state(root,List) :- !, List=[].
2999 get_dynamic_svgid_attributes_for_state(StateId,UpdateList) :-
3000 get_visb_attributes_for_state(StateId,List),
3001 sort(List,SList),
3002 group_set_attr(SList,'$$UNKNOWN$$',_,UpdateList).
3003
3004 group_set_attr([],_,[],[]).
3005 group_set_attr([set_attr(SvgID,Attr,Val)|T],SvgID,[svg_attribute(Attr,Val)|T1],T2) :- !,
3006 group_set_attr(T,SvgID,T1,T2).
3007 group_set_attr([set_attr(SvgID,Attr,Val)|T],_OldID,[],[svgid_updates(SvgID,L)|T2]) :- % a new SVGId is encountered
3008 group_set_attr([set_attr(SvgID,Attr,Val)|T],SvgID,L,T2).
3009
3010 % print svg attribute and extract text attribute
3011 format_new_svg_attr(Stream,SVGID,Pos,TextContent,svg_attribute(Attr,Val)) :- % TODO: text content
3012 (Attr=text
3013 -> (TextContent=Val -> true % TextContent is inially a variable and can be unified once
3014 ; add_warning(inline_new_svg_objects,'Multiple text attributes for: ',SVGID,Pos),
3015 add_debug_message(inline_new_svg_objects,' * Using text 1: ',TextContent),
3016 add_debug_message(inline_new_svg_objects,' * Ignoring text 2: ',Val)
3017 )
3018 ; number(Val) ->
3019 format(Stream,' ~w="~w"',[Attr,Val])
3020 ; escape_value_to_codes_for_js(Val,ECodes) ->
3021 format(Stream,' ~w="~s"',[Attr,ECodes])
3022 ; compound(Val), functor(Val,F,N) ->
3023 ajoin(['Cannot escape ',Attr,' *compound* ',F,'/',N,' value for ', SVGID,': '],Msg),
3024 add_error(visb_visualiser,Msg,Val,Pos),
3025 format(Stream,' ~w="~w"',[Attr,Val])
3026 ; ajoin(['Cannot escape ',Attr,' value for ', SVGID,': '],Msg),
3027 add_error(visb_visualiser,Msg,Val,Pos),
3028 format(Stream,' ~w="~w"',[Attr,Val])
3029 ).
3030
3031
3032 :- dynamic id_namespace_prefix/1.
3033 % prefix that can be useful for Jupyter notebooks so that for each state we have a different namespace
3034 % can also be useful for exporting a trace into a single HTML
3035 % TODO: does not work with JSON and SVG files
3036
3037 :- use_module(probsrc(gensym),[gensym/2]).
3038 set_id_namespace_prefix_for_states(_,Options) :-
3039 member(id_namespace_prefix(Pre),Options),!,
3040 (Pre = auto
3041 -> gensym('visb',ID), % for Jupyter this relies on the fact the gensym is *not* reset when loading another spec
3042 atom_concat(ID,'.',Prefix)
3043 ; Prefix=Pre
3044 ), set_id_namespace_prefix(Prefix).
3045 set_id_namespace_prefix_for_states(_,_).
3046
3047 set_id_namespace_prefix(Prefix) :- clear_id_namespace_prefix,
3048 assert(id_namespace_prefix(Prefix)).
3049 clear_id_namespace_prefix :- retractall(id_namespace_prefix(_)).
3050
3051 % add a namespace prefix to an SVG ID
3052 add_svg_id_prefix(SvgID,Res) :- id_namespace_prefix(Prefix),!,
3053 % option where we prefix all Ids with a namespace for Jupyter to combine multiple SVGs in single HTML page
3054 atom_concat(Prefix,SvgID,Res).
3055 add_svg_id_prefix(SvgID,SvgID).
3056
3057 % only add for known objects
3058 opt_add_svg_id_prefix(SvgID,Res) :- id_namespace_prefix(Prefix),
3059 visb_svg_object(SvgID,_,_,_,_),!, % only add prefix for SVG objects we know about (that were created by VisB)
3060 % option where we prefix all Ids with a namespace for Jupyter to combine multiple SVGs in single HTML page
3061 atom_concat(Prefix,SvgID,Res).
3062 opt_add_svg_id_prefix(SvgID,SvgID).
3063
3064 % -----------------
3065
3066 :- dynamic js_generated_function/1.
3067 :- dynamic last_attribute_values/3.
3068
3069 % define a visualise JS function to set the attributes for the given StateId
3070 gen_visb_visualise_function(Stream,Options,Len,StateIds,Obj) :-
3071 get_state_and_action(Obj,StateId,ActionStr,DescStr),
3072 ? nth1(Nr,StateIds,Obj),
3073 \+ js_generated_function(Nr), !,
3074 assertz(js_generated_function(Nr)),
3075 (Nr > 1 ->
3076 PrevNr is Nr-1, nth1(PrevNr,StateIds,PrevObj), get_state_and_action(PrevObj,PrevStateId,_,_)
3077 ; PrevStateId = -1),
3078 visb_visualise_function_aux(Stream,Options,Len,StateId,PrevStateId,Nr,ActionStr,DescStr),
3079 (Nr == Len ->
3080 retractall(last_attribute_values(_,_,_)),
3081 format(Stream,' ]~n',[])
3082 ; true).
3083 gen_visb_visualise_function(_,_,_,_,_).
3084
3085 :- use_module(extrasrc(bvisual2), [bv_get_top_level/1,bv_get_value_unlimited/3]).
3086 :- use_module(probsrc(tools),[string_escape/2]).
3087 visb_visualise_function_aux(Stream,_,Len,StateId,_,Nr,ActionStr,DescStr) :-
3088 format(Stream,' [~n',[]),
3089 (Len>1 -> format(Stream,' {id: "trace_meter", attr: "value", val: "~w"},~n',[Nr]) ; true),
3090 (escape_value_to_codes_for_js(ActionStr,EAS), escape_value_to_codes_for_js(DescStr,EDS) ->
3091 % was only string_escape before; however, this turns e.g. |-> into ↦ which we don't want (we are in JS part here)
3092 format(Stream,' {id: "visb_debug_messages", attr: "text", val: "Step ~w/~w, State ID: ~w, Event: ~s ~s"},~n',[Nr,Len,StateId,EAS,EDS])
3093 ; string_escape(ActionStr,SEAS), string_escape(DescStr,SEDS), % fallback
3094 format(Stream,' {id: "visb_debug_messages", attr: "text", val: "Step ~w/~w, State ID: ~w, Event: ~w ~w"},~n',[Nr,Len,StateId,SEAS,SEDS])
3095 ),
3096 ? get_change_attribute_for_state(StateId,SvgID,SvgAttribute,Value),
3097 \+ last_attribute_values(SvgID,SvgAttribute,Value),
3098 retractall(last_attribute_values(SvgID,SvgAttribute,_)),
3099 assertz(last_attribute_values(SvgID,SvgAttribute,Value)),
3100 opt_add_svg_id_prefix(SvgID,SvgID2),
3101 (escape_value_to_codes_for_js(Value,ECodes)
3102 -> format(Stream,' {id: "~w", attr: "~w", val: "~s"},~n',[SvgID2,SvgAttribute,ECodes])
3103 ; format(Stream,' {id: "~w", attr: "~w", val: "~w"},~n',[SvgID2,SvgAttribute,Value])
3104 ),
3105 fail.
3106 visb_visualise_function_aux(Stream,Options,Len,StateId,PrevStateId,_,_,_) :-
3107 b_or_z_mode,
3108 member(show_variables(VarList),Options),
3109
3110 visited_expression(StateId,State),
3111 (visited_expression(PrevStateId,PrevState) -> true ; PrevState=root),
3112
3113 show_var_in_visb(VarList,ID),
3114 ? get_state_value_change(StateId,State,ID,Options,ResValCodes),
3115
3116 % current value:
3117 ajoin(['bVar_',ID],SvgID),
3118 change_svg_attribute_differences_aux(Stream,SvgID,'text',ResValCodes),
3119
3120 Len > 1, % don't add previous value and change markers for state-only HTML
3121 (state_corresponds_to_fully_setup_b_machine(PrevState,_), % don't show prev values before initialisation
3122 ? get_state_value_change(PrevStateId,PrevState,ID,Options,PrevResValCodes)
3123 -> true
3124 ; PrevResValCodes = "?"),
3125
3126 % mark row if value has changed in the last step
3127 ajoin(['row_bVar_',ID],SvgRowID),
3128 (ResValCodes = PrevResValCodes -> RowColor = white; RowColor = '#fffacd'),
3129 change_svg_attribute_differences_aux(Stream,SvgRowID,'bgcolor',RowColor),
3130
3131 % previous value:
3132 ajoin(['bVarPrev_',ID],SvgPrevID),
3133 change_svg_attribute_differences_aux(Stream,SvgPrevID,'text',PrevResValCodes),
3134
3135 fail.
3136 visb_visualise_function_aux(Stream,_Options,Len,StateId,PrevStateId,_,_,_) :-
3137 xtl_mode,
3138
3139 bv_get_top_level(IDs),
3140 member(ID,IDs),
3141 (bv_get_value_unlimited(ID,StateId,v(Val))
3142 -> atom_codes(Val,ResValCodes)
3143 ; ResValCodes = ""),
3144
3145 % current value:
3146 ajoin(['bVar_',ID],SvgID),
3147 change_svg_attribute_differences_aux(Stream,SvgID,'text',ResValCodes),
3148
3149 Len > 1, % don't add previous value and change markers for state-only HTML
3150 (PrevStateId \= root,
3151 bv_get_value_unlimited(ID,PrevStateId,v(PrevVal))
3152 -> atom_codes(PrevVal,PrevResValCodes)
3153 ; PrevResValCodes = ""),
3154
3155 % mark row if value has changed in the last step
3156 ajoin(['row_bVar_',ID],SvgRowID),
3157 (ResValCodes = PrevResValCodes -> RowColor = white; RowColor = '#fffacd'),
3158 change_svg_attribute_differences_aux(Stream,SvgRowID,'bgcolor',RowColor),
3159
3160 % previous value:
3161 ajoin(['bVarPrev_',ID],SvgPrevID),
3162 change_svg_attribute_differences_aux(Stream,SvgPrevID,'text',PrevResValCodes),
3163
3164 fail.
3165 visb_visualise_function_aux(Stream,Options,_,StateId,_,_,_,_) :-
3166 member(show_events(OpList),Options),
3167 get_state_value_enabled_operation_status(StateId,OpID,Enabled,ResValCodes,TransStr),
3168 show_var_in_visb(OpList,OpID),
3169 ajoin(['bOperation_',OpID],SvgID),
3170 \+ last_attribute_values(SvgID,'text',ResValCodes),
3171 retractall(last_attribute_values(SvgID,'text',_)),
3172 assertz(last_attribute_values(SvgID,'text',ResValCodes)),
3173 format(Stream,' {id: "~w", attr: "text", val: "~s"},~n',[SvgID,ResValCodes]),
3174 (Enabled=true -> BGCol=white ; BGCol='#f1f1f1'),
3175 format(Stream,' {id: "row_~w", attr: "bgcolor", val: "~s"},~n',[SvgID,BGCol]),
3176 escape_value_to_codes_for_js(TransStr,ETS),
3177 format(Stream,' {id: "name_~w", attr: "text", val: "~s"},~n',[SvgID,ETS]),
3178 % TO DO: highlight next event in trace, but then function needs one more parameter
3179 fail.
3180 visb_visualise_function_aux(Stream,Options,Len,_,_,Nr,_,_) :-
3181 (Len>1, member(show_sequence_chart,Options)
3182 -> format(Stream,' {id: "seq_chart_~w", attr: "style", val: "display:block"},~n',[Nr]),
3183 (Nr>1
3184 -> PNr is Nr-1, format(Stream,' {id: "seq_chart_~w", attr: "style", val: "display:none"},~n',[PNr])
3185 ; gen_seq_charts_setup(Stream,Len))), % all sequence charts except the first should be invisible
3186 fail.
3187 visb_visualise_function_aux(Stream,_,Len,_,_,Nr,_,_) :-
3188 Nr == Len ->
3189 format(Stream,' ]~n',[])
3190 ; format(Stream,' ],~n',[]).
3191
3192 gen_seq_charts_setup(_,Len) :- Len<2, !.
3193 gen_seq_charts_setup(Stream,Len) :-
3194 format(Stream,' {id: "seq_chart_~w", attr: "style", val: "display:none"},~n',[Len]),
3195 NLen is Len-1,
3196 gen_seq_charts_setup(Stream,NLen).
3197
3198 escape_value_to_codes_for_js(Atom,ECodes) :- atom(Atom),
3199 atom_codes(Atom,Codes), b_string_escape_codes(Codes,ECodes).
3200
3201 change_svg_attribute_differences_aux(Stream,ID,Attr,ValueCodes) :-
3202 (last_attribute_values(ID,Attr,ValueCodes)
3203 -> true
3204 ; retractall(last_attribute_values(ID,Attr,_)),
3205 assertz(last_attribute_values(ID,Attr,ValueCodes)),
3206 format(Stream,' {id: "~w", attr: "~w", val: "~s"},~n',[ID,Attr,ValueCodes])
3207 ).
3208
3209
3210
3211 % generate JS script to register hovers
3212 ?gen_registerHovers_scipt(Stream,Options) :- \+ visb_has_hovers(_),
3213 nonmember(debugging_hovers,Options),
3214 !, % no hover exists
3215 format(Stream,' <script> function registerHovers() {} </script>~n',[]).
3216 gen_registerHovers_scipt(Stream,Options) :-
3217 (member(debugging_hovers,Options) -> GenDebug=true ; GenDebug=false), % gen debugging hovers
3218 % Jquery is no longer required:
3219 %format(Stream,' <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>~n',[]),
3220 format(Stream,' <script>~n',[]),
3221 format(Stream,' function registerHovers() {~n',[]),
3222 format(Stream,' var obj;~n',[]),
3223 ? visb_has_hovers(SVGID), % only generate hover function if necessary; TODO: examine other IDs for GenDebug
3224 opt_add_svg_id_prefix(SVGID,SVGID2),
3225 format(Stream,' obj = document.getElementById("~w");~n',[SVGID2]),
3226 format(Stream,' obj.onmouseover = function(ev){~n',[]),
3227 ? (visb_hover(SVGID,ID,Attr,EnterVal,_,_),
3228 opt_add_svg_id_prefix(ID,ID2),
3229 (GenDebug=false -> true
3230 ; format(Stream,' setAttr("~w","~w","SVG ID: ~w")~n',[visb_debug_messages,text,SVGID2])),
3231 format(Stream,' setAttr("~w","~w","~w")~n',[ID2,Attr,EnterVal]), fail ;
3232 format(Stream,' };~n',[])
3233 ),
3234 format(Stream,' obj.onmouseout = function(){~n',[]),
3235 ? (visb_hover(SVGID,ID,Attr,_,LeaveVal,_),
3236 opt_add_svg_id_prefix(ID,ID2),
3237 (GenDebug=false -> true
3238 ; format(Stream,' setAttr("~w","~w","~w")~n',[visb_debug_messages,text,'...'])
3239 ),
3240 format(Stream,' setAttr("~w","~w","~w")~n',[ID2,Attr,LeaveVal]), fail ;
3241 format(Stream,' };~n',[])
3242 ),
3243 fail.
3244 gen_registerHovers_scipt(Stream,_) :-
3245 format(Stream,' }~n </script>~n',[]).
3246
3247
3248 % ----------------------------------
3249
3250 :- use_module(probsrc(translate),[set_unicode_mode/0, unset_unicode_mode/0]).
3251 :- use_module(probsrc(state_space), [get_action_trace_with_limit/2, get_state_id_trace/1]).
3252
3253 generate_visb_html_for_history_with_source(File) :-
3254 generate_visb_html_for_history(File,
3255 [show_constants(all),show_sets(all),show_variables(all),show_events(all),show_invariants,show_source]).
3256 generate_visb_html_for_history_with_vars(File) :-
3257 generate_visb_html_for_history(File,[show_constants(all),show_sets(all),show_variables(all),show_events(all)]).
3258 generate_visb_html_for_history(File) :-
3259 generate_visb_html_for_history(File,[]).
3260 generate_visb_html_for_history(File,Options) :-
3261 start_ms_timer(Timer),
3262 get_state_id_trace(T),
3263 T = [root|StateIds],
3264 set_unicode_mode,
3265 call_cleanup(get_action_trace_with_limit(120,Actions), % TODO: also get description of JSON traces
3266 unset_unicode_mode),
3267 reverse(Actions,FActions),
3268 combine_state_and_actions(StateIds,[root|StateIds],FActions,List),
3269 generate_visb_html(List,File,Options),
3270 stop_ms_walltimer_with_msg(Timer,'exporting history to VisB HTML file: ').
3271
3272 :- use_module(probsrc(specfile),[get_operation_description_for_transition/4]).
3273 combine_state_and_actions([],_,[],[]).
3274 combine_state_and_actions([StateId|TS],[PrevId|TP],[action(ActionStr,ATerm)|TA],
3275 [change_to_state_via_action(StateId,ActionStr,Desc)|TRes]) :-
3276 (get_operation_description_for_transition(PrevId,ATerm,StateId,D) -> Desc=D ; Desc=''),
3277 combine_state_and_actions(TS,TP,TA,TRes).
3278
3279 generate_visb_html_for_current_state(File) :-
3280 generate_visb_html_for_current_state(File,[show_variables(all)]).
3281 generate_visb_html_for_current_state(File,Options) :-
3282 start_ms_timer(Timer),
3283 current_state_id(ID),
3284 generate_visb_html([ID],File,Options),
3285 stop_ms_walltimer_with_msg(Timer,'exporting current state to VisB HTML file: ').
3286 generate_visb_html_codes_for_states(StateIds,Options,Codes) :-
3287 generate_visb_html_to_codes(StateIds,Options,Codes). % write to codes list
3288
3289 % ------------------------------
3290
3291 :- use_module(probsrc(specfile),[b_or_z_mode/0]).
3292 :- use_module(probsrc(bmachine), [b_get_machine_variables/1, b_get_machine_constants/1, b_top_level_operation/1]).
3293 :- use_module(probsrc(bsyntaxtree), [get_texpr_id/2]).
3294 :- use_module(extrasrc(bvisual2), [bv_top_level_set/2]).
3295 :- use_module(probsrc(specfile),[get_specification_description/2]).
3296 :- use_module(probsrc(tools_strings), [atom_tail_to_lower_case/2]).
3297
3298 show_typed_var_in_visb(all,_) :- !.
3299 show_typed_var_in_visb(VarList,b(identifier(ID),_,_)) :- !, show_var_in_visb(VarList,ID).
3300 show_var_in_visb(VarList,ID ) :- (VarList=all -> true ; member(ID,VarList) -> true).
3301
3302 % generate a table for the state (we could use bvisual2)
3303 gen_state_table(Stream,Options,StateIds) :-
3304 b_or_z_mode,
3305 member(show_variables(VarList),Options),
3306 b_get_machine_variables(TypedVars),
3307 % is this useful if Len > 1, but StateIds are not from a trace? (see also below for formulas)
3308 (length(StateIds,Len), Len > 1 -> NOptions = [show_prev_value|Options] ; NOptions = Options),
3309 gen_state_table_aux(Stream,NOptions,'Variables',TypedVars,VarList,[],'Value','bVar_'),fail.
3310 gen_state_table(Stream,Options,StateIds) :-
3311 b_or_z_mode,
3312 member(show_variables(VarList),Options),
3313 b_get_machine_expressions(AExprs,Options), AExprs \= [],
3314 (length(StateIds,Len), Len > 1 -> NOptions = [show_prev_value|Options] ; NOptions = Options),
3315 gen_state_table_aux(Stream,NOptions,'Formulas',AExprs,VarList,[],'Value','bVar_'),fail.
3316 gen_state_table(Stream,Options,StateIds) :-
3317 b_or_z_mode,
3318 ? member(show_constants(IDList),Options),
3319 b_get_machine_constants(TypedVars),
3320 last(StateIds,Last), % we assume there is only one constant valuation in the trace; TO DO: generalise
3321 get_state_and_action(Last,LastId,_,_),
3322 visited_expression(LastId,BState),
3323 expand_to_constants_and_variables(BState,ConstState,_),
3324 gen_state_table_aux(Stream,Options,'Constants',TypedVars,IDList,ConstState,'Value','bConstant_'),fail.
3325 gen_state_table(Stream,Options,_) :-
3326 b_or_z_mode,
3327 ? member(show_sets(IDList),Options),
3328 findall(TSet,bv_top_level_set(TSet,_),TypedVars),
3329 findall(bind(Set,Val),(bv_top_level_set(TSet,Val),get_texpr_id(TSet,Set)),BState),
3330 gen_state_table_aux(Stream,Options,'Sets',TypedVars,IDList,BState,'Value','bSet_'),fail.
3331 % TO DO: maybe show also top-level guards specfile_possible_trans_name or get_top_level_guard
3332 gen_state_table(Stream,Options,_StateIds) :-
3333 b_or_z_mode,
3334 member(show_events(IDList),Options),
3335 get_specification_description(operations,SN),
3336 atom_tail_to_lower_case(SN,SectionName),
3337 findall(b(identifier(OpName),subst,[]),b_top_level_operation(OpName),TypedVars),
3338 % TODO: op(Params,Results) instead of subst
3339 gen_state_table_aux(Stream,Options,SectionName,TypedVars,IDList,[],'Enabled','bOperation_'),fail.
3340 gen_state_table(Stream,Options,StateIds) :-
3341 xtl_mode,
3342 (length(StateIds,Len), Len > 1 -> NOptions = [show_prev_value|Options] ; NOptions = Options),
3343 bv_get_top_level(IDs),
3344 findall(b(identifier(ID),string,[]), member(ID,IDs), Props),
3345 gen_state_table_aux(Stream,NOptions,'Properties',Props,IDs,[],'Value','bVar_'), fail.
3346 gen_state_table(_Stream,_,_).
3347
3348
3349 gen_source_code_section(Stream,Options) :-
3350 member(show_source,Options), % we could also include original sources, rather than just internal rep.
3351 !,
3352 Section = 'Source',
3353 format(Stream,' <button type="button" class="collapsible collapsible-style" title="Inspect source code of internal representation of ProB of model">~w</button>~n',[Section]),
3354 format(Stream,'<div class="coll-content-hid">~n',[]),
3355 get_internal_representation(PP),
3356 format(Stream,'<pre>~s</pre>~n',[PP]),
3357 format(Stream,'</div>~n',[]).
3358 gen_source_code_section(_Stream,_).
3359
3360
3361 :- use_module(probsrc(bsyntaxtree),[get_texpr_description/2, get_texpr_type/2]).
3362 % creates a HTML table with header name Section and including one row per ID in TypedVars;
3363 % id of value for ID is prefixed with IDPrefix
3364 % VarListToShow is either all or a list of ids
3365 gen_state_table_aux(Stream,Options,Section,TypedVars,VarListToShow,BState,ValueStr,IDPrefix) :-
3366 include(show_typed_var_in_visb(VarListToShow),TypedVars,SVars), % check which ids should be shown
3367 length(SVars,SLen), SLen>0,
3368 length(TypedVars,Len),
3369 (SLen=Len
3370 -> format(Stream,' <button type="button" class="collapsible collapsible-style">~w (~w)</button>~n',[Section,SLen])
3371 ; format(Stream,' <button type="button" class="collapsible collapsible-style">~w (~w/~w)</button>~n',
3372 [Section,SLen,Len])
3373 ),
3374 format(Stream,'<div class="coll-content-hid">~n',[]),
3375 ? (member(show_prev_value,Options) % add extra column for previous value of variables (and animation expressions)
3376 -> format(Stream,' <table> <tr> <th>Nr</th> <th>Name</th> <th>Value</th> <th>Previous Value</th> </tr>~n',[])
3377 ; format(Stream,' <table> <tr> <th>Nr</th> <th>Name</th> <th>~w</th> </tr>~n',[ValueStr])),
3378 ? ( nth1(Nr,SVars,IDorExprToShow),
3379 get_state_table_name_and_expr(IDorExprToShow,ID,LongID,TExpr),
3380 ? (get_state_value_codes_for_id(BState,ID,Options,_,ValCodes)
3381 -> html_escape_codes(ValCodes,EVC) % Value provided in BState; may be overriden in trace export
3382 ; EVC = "?"),
3383 get_table_hover_message_codes(ID,TExpr,HoverMsgC),
3384 ? (member(show_prev_value,Options) % add previous value of variables (and animation expressions)
3385 -> % for variables the values are added later in JS
3386 % do we want to show the previous value in the state only HTML?
3387 format(Stream,'~n <tr id="row_~w~w" title="~s"> <td>~w</td> <td id="name_~w~w">~w</td> <td id="~w~w">?</td> <td id="bVarPrev_~w">?</td> </tr>~n',
3388 [IDPrefix,ID, HoverMsgC, Nr, IDPrefix,ID,LongID, IDPrefix,ID, ID ])
3389 ;
3390 format(Stream,'~n <tr id="row_~w~w" title="~s"> <td>~w</td> <td id="name_~w~w">~w</td> <td id="~w~w">~s</td> </tr>~n',
3391 [IDPrefix,ID, HoverMsgC, Nr, IDPrefix,ID,LongID, IDPrefix,ID,EVC])),
3392 fail
3393 ;
3394 format(Stream,' </table>~n </div>~n',[])
3395 ).
3396
3397 %get_state_table_name_and_expr(bexpr(Kind,TExpr),Name,LongName,Expr) :- !, % we have special expression to show
3398 % Name=Kind,LongName=Kind,Expr=TExpr.
3399 get_state_table_name_and_expr(bexpr(Kind,TExpr),ID,LongName,Expr) :- !, % we have special expression to show
3400 ID=Kind, % ID for SVG updates, ...
3401 translate_bexpression_with_limit(TExpr,200,TS),
3402 ajoin([Kind,' == ',TS],LongName),
3403 Expr=TExpr.
3404 get_state_table_name_and_expr(TID,ID,ID,TID) :- get_texpr_id(TID,ID). % normal case: variable name
3405
3406
3407 :- use_module(probsrc(bmachine),[b_get_machine_animation_expression/2, b_get_operation_variant/3, b_nth1_invariant/3]).
3408
3409 visb_machine_animation_expression(variant,AEName,Variant,_) :-
3410 b_get_operation_variant(Name,ConvOrAnt,Variant),
3411 ajoin(['Variant for ',Name, ' (',ConvOrAnt,')'],AEName).
3412 visb_machine_animation_expression(animation_expression,Name,TExpr,_) :-
3413 b_get_machine_animation_expression(Name,TExpr).
3414 visb_machine_animation_expression(invariant,Name,TPred,Options) :-
3415 member(show_invariants,Options),
3416 b_nth1_invariant(Nr,TPred,_),
3417 ajoin(['INVARIANT-',Nr],Name).
3418 % TODO: we should also adapt get_state_value_change to return true when invariant_violated is false for the state
3419 % we could also only include this section when there is an invariant violation in the trace?
3420
3421 b_get_machine_expressions(List,Options) :-
3422 findall(bexpr(AE_Name,AExpr),visb_machine_animation_expression(_,AE_Name,AExpr,Options),List).
3423 % 'ANIMATION_EXPRESSION' or invariants or variants
3424
3425 :- use_module(probsrc(bmachine),[b_get_machine_operation_signature/2]).
3426 % get hover message for entries in variables/constants/... rows:
3427 get_table_hover_message_codes(ID,TExpr,EscHoverMsg) :-
3428 get_texpr_type(TExpr,Type),
3429 (Type=subst,b_get_machine_operation_signature(ID,TS)
3430 -> ajoin(['Operation: ',TS],HoverMsg)
3431 ; pretty_type(Type,TS),
3432 (get_texpr_description(TExpr,Desc)
3433 -> ajoin(['Type: ',TS,'\nDesc: ',Desc],HoverMsg)
3434 ; ajoin(['Type: ',TS],HoverMsg)
3435 )
3436 ),
3437 atom_codes(HoverMsg,HoverCodes),
3438 html_escape_codes(HoverCodes,EscHoverMsg).
3439
3440 % get the values that should be displayed in the variables table
3441 get_state_value_change(StateId,State,ID,Options,ECodes) :-
3442 extract_variables_from_state(State,VariableBState),
3443 ? ( get_state_value_codes_for_id(VariableBState,ID,Options,Val,ValCodes) % look up variable values
3444 ; visb_machine_animation_expression(_,_,_,Options) ->
3445 state_corresponds_to_fully_setup_b_machine(State,FullState),
3446 get_state_value_codes_for_anim_expr(StateId,FullState,ID,Options,Val,ValCodes) % evaluate animation expressions
3447 ),
3448 escape_if_necessary(Val,ValCodes,ECodes). % change " to \" for JavaScript
3449 % formatsilent('Value for ~w~nunescaped: "~s",~n escaped: "~s"~n',[ID,ValCodes,ECodes]).
3450
3451 % avoid unnecessary escaping traversals:
3452 escape_if_necessary([],ValCodes,Res) :- !, Res=ValCodes.
3453 escape_if_necessary(int(_),ValCodes,Res) :- !, Res=ValCodes.
3454 escape_if_necessary(pred_true,ValCodes,Res) :- !, Res=ValCodes.
3455 escape_if_necessary(pred_false,ValCodes,Res) :- !, Res=ValCodes.
3456 escape_if_necessary(_,ValCodes,ECodes) :- b_string_escape_codes(ValCodes,ECodes).
3457
3458
3459 get_state_value_codes_for_id(BState,ID,Options,Val,ValCodes) :-
3460 ? member(bind(ID,Val),BState),
3461 translate_values_for_state_table(Val,Options,ValCodes).
3462
3463 % translate a value for display in state table (not yet escaped)
3464 translate_values_for_state_table(Val,Options,ValCodes) :-
3465 (member(limit_for_values(Nr),Options)
3466 -> translate_bvalue_to_codes_with_limit(Val,Nr,ValCodes)
3467 ; get_preference(expand_avl_upto,Max), Max<0
3468 -> translate_bvalue_to_codes(Val,ValCodes) % unlimited
3469 ; translate_bvalue_to_codes_with_limit(Val,10000,ValCodes)
3470 ).
3471
3472 :- use_module(probsrc(bsyntaxtree), [safe_create_texpr/3]).
3473 get_state_value_codes_for_anim_expr(StateId,BState,AE_Name,Options,ResValue,ValCodes) :-
3474 visb_machine_animation_expression(Kind,AE_Name,AExpr,Options),
3475 (Kind=invariant
3476 -> ((invariant_not_yet_checked(StateId) ; invariant_violated(StateId))
3477 -> (safe_create_texpr(convert_bool(AExpr),boolean,TExpr),
3478 evaluate_visb_formula(TExpr,AE_Name,'',BState,ResValue,unknown)
3479 -> translate_pred_val(ResValue,ValCodes)
3480 ; ResValue=pred_unknown, ValCodes = "?" % WD error?
3481 )
3482 ; ResValue=pred_true, translate_pred_val(pred_true,ValCodes) % no need to evaluate invariant
3483 )
3484 ; evaluate_visb_formula(AExpr,AE_Name,'',BState,ResValue,unknown),
3485 translate_values_for_state_table(ResValue,Options,ValCodes)
3486 ).
3487 translate_pred_val(pred_true,[8868]). % see translate:unicode_translation(truth,X).
3488 translate_pred_val(pred_false,[8869]). % see translate:unicode_translation(falsity,X).
3489
3490 :- use_module(probsrc(bmachine),[b_get_machine_operation_max/2]).
3491 :- use_module(probsrc(state_space),[time_out_for_node/3,max_reached_for_node/1]).
3492 :- use_module(probsrc(translate),[translate_event_with_src_and_target_id/5]).
3493 get_state_value_enabled_operation_status(StateId,OpName,Enabled,EnabledValue,TransStr) :-
3494 b_top_level_operation(OpName),
3495 findall(TransID, (transition(StateId,OpTerm,TransID,_NewStateId),
3496 match_operation(OpTerm,OpName)), TransList),
3497 length(TransList,Len),
3498 (Len>0
3499 -> Enabled=true,
3500 EnabledValue = "\x2705\", % green check mark, TRUE alternatives \x2705\ \x2713\ \x2714\
3501 (TransList=[TID], transition(StateId,OpTerm,TID,NewStateId),
3502 translate_event_with_src_and_target_id(OpTerm,StateId,NewStateId,200,TransStr)
3503 -> true
3504 ; ajoin([OpName,' (',Len,'\xd7\)'],TransStr) %
3505 )
3506 ; time_out_for_node(StateId,OpName,TypeOfTimeOut) ->
3507 Enabled=TypeOfTimeOut,
3508 EnabledValue = [8987], % four o'clock symbol
3509 TransStr = OpName
3510 %ajoin(['No transition found due to: ',TypeOfTimeOut],HoverMsg)
3511 ; get_preference(maxNrOfEnablingsPerOperation,0) ->
3512 Enabled=not_computed,
3513 EnabledValue = [10067], % red question mark
3514 TransStr = OpName
3515 %'No transitions were computed because MAX_OPERATIONS = 0' = HoverMsg
3516 ; b_get_machine_operation_max(OpName,0) ->
3517 Enabled=not_computed,
3518 EnabledValue = [10067], % red question mark
3519 TransStr = OpName
3520 %ajoin(['No transitions were computed because MAX_OPERATIONS_',OpName,' = 0'],HoverMsg)
3521 ; Enabled=false,
3522 EnabledValue = [9940], % stop sign, FALSE, alternatives \x10102\
3523 TransStr = OpName
3524 %ajoin(['Not enabled'],HoverMsg)
3525 ). % TO DO: show whether this is the next step in the trace
3526
3527 % --------------------------
3528
3529 % debugging features to inspect all created SVG objects
3530 tcltk_get_visb_objects(list([Header|AllObjects])) :-
3531 Header = list(['SVG-ID','svg_class','Attribute','Value']),
3532 findall(list([SvgID,SvgClass,Attr,Value]),
3533 (visb_svg_object(SvgID,SvgClass,AttrList,_Desc,_Pos),
3534 (member(svg_attribute(Attr,Value),AttrList) ;
3535 visb_svg_parent(SvgID,Value), Attr=children)
3536 ), AllObjects).
3537
3538 % debugging features to inspect all created SVG objects
3539 tcltk_get_visb_hovers(list([Header|AllObjects])) :-
3540 Header = list(['SVG-ID','ID','Attribute','EnterValue', 'ExitValue']),
3541 findall(list([SvgID,ID,Attr,EnterVal,ExitVal]),
3542 visb_hover(SvgID,ID,Attr,EnterVal,ExitVal,_Pos), AllObjects).
3543
3544 % debugging features to inspect items
3545 tcltk_get_visb_items(Res) :-
3546 current_state_id(ID),
3547 tcltk_get_visb_items(ID,Res).
3548 tcltk_get_visb_items(_StateId,Res) :-
3549 \+ visb_file_is_loaded(_),!,
3550 Res = list(['No VisB JSON file loaded']).
3551 tcltk_get_visb_items(StateId,list([Header|AllItems])) :-
3552 Header = list(['SVG-ID','Attribute','Value']),
3553 get_preference(translation_limit_for_table_commands,Limit),
3554 findall(list([SvgID,SvgAttribute,Val]),
3555 get_change_attribute_for_state(StateId,SvgID,SvgAttribute,Val),
3556 Items),
3557 findall(list([DefID,'VisB Definition',DValS]),
3558 (get_expanded_bstate(StateId,ExpandedBState),
3559 reverse(ExpandedBState,RS),
3560 member(bind(DefID,DVal),RS),
3561 visb_definition(DefID,_,_,_,_,_),
3562 translate_bvalue_with_limit(DVal,Limit,DValS)),
3563 AllItems, Items).
3564
3565 :- use_module(probsrc(translate),[translate_event_with_limit/3]).
3566 tcltk_get_visb_events(Res) :-
3567 current_state_id(ID),
3568 tcltk_get_visb_events(ID,Res).
3569 tcltk_get_visb_events(_StateId,Res) :-
3570 \+ visb_file_is_loaded(_),!,
3571 Res = list(['No VisB JSON file loaded']).
3572 tcltk_get_visb_events(StateId,list([Header|AllItems])) :-
3573 Header = list(['SVG-ID','Event','Target']),
3574 get_preference(translation_limit_for_table_commands,Limit),
3575 findall(list([SvgID,EventStr,NewStateId]),
3576 (perform_visb_click_event(SvgID,[],StateId,_Event,OpTerm,NewStateId,Res),
3577 (Res=[] -> EventStr='disabled' ; translate_event_with_limit(OpTerm,Limit,EventStr))
3578 ),
3579 AllItems).
3580 % --------------------------
3581
3582 % for ProB2-UI
3583
3584 :- use_module(probsrc(translate),[translate_bexpression_with_limit/3]).
3585 get_visb_items(List) :-
3586 findall(visb_item(SvgID,Attr,TS,Desc,Pos),
3587 (visb_item(SvgID,Attr,TypedExpr,_Used,Desc,Pos,_),
3588 translate_bexpression_with_limit(TypedExpr,1000,TS)), List).
3589
3590 get_visb_attributes_for_state(StateId,List) :-
3591 % some external functions like ENABLED are evaluated in current state; it might be useful to set_current_state
3592 (visb_file_is_loaded(_) -> true
3593 ; add_warning(visb_visualiser,'No VisB visualisation loaded, cannot get attributes for state: ',StateId)),
3594 findall(set_attr(SvgID,SvgAttribute,Val),
3595 get_change_attribute_for_state(StateId,SvgID,SvgAttribute,Val),
3596 List).
3597
3598 % for ProB2-UI
3599 get_visb_click_events(List) :-
3600 findall(execute_event(SvgID,Event,Preds),
3601 get_visb_event(SvgID,Event,Preds), List).
3602 get_visb_event(SvgID,Event,Preds) :- visb_event(SvgID,Event,Preds,_,_File,_Pos).
3603 get_visb_event(SvgID,'',[]) :- % add a virtual empty event for SVG Ids with hovers but no events
3604 visb_has_hovers(SvgID),
3605 \+ visb_event(SvgID,_,_,_,_File,_Pos).
3606
3607
3608 :- use_module(probsrc(state_space), [extend_trace_by_transition_ids/1]).
3609 % perform a click on a VisB SVG ID in the animator
3610 tcltk_perform_visb_click_event(SvgID) :- current_state_id(StateId),
3611 (perform_visb_click_event(SvgID,[],StateId,TransitionIDs)
3612 -> formatsilent('Clicking on ~w in state ~w resulted in transition id sequence ~w~n',[SvgID,StateId,TransitionIDs]),
3613 extend_trace_by_transition_ids(TransitionIDs)
3614 ; add_error(visb_visualiser,'Cannot perform VisB click on: ',SvgID)
3615 ).
3616
3617 % computes the effect of clicking on an SvgID in StateId
3618 % it returns either empty list if the visb_event is not feasible or a list of transition ids
3619 % it fails if SvgID has no events associated with it
3620 perform_visb_click_event(SvgID,MetaInfos,StateId,ResTransitionIds) :-
3621 perform_visb_click_event(SvgID,MetaInfos,StateId,_,_,_,ResTransitionIds).
3622 perform_visb_click_event(SvgID,MetaInfos,StateId,OpName,OpTerm,NewStateId,ResTransitionIds) :-
3623 get_expanded_bstate(StateId,ExpandedBState),
3624 set_error_context(checking_context('VisB:','performing click event')),
3625 set_context_state(StateId,perform_visb_click_event),
3626 get_svgid_with_events(SvgID,_),
3627 call_cleanup(perform_aux(SvgID,StateId,ExpandedBState,OpName,OpTerm,NewStateId,ResTransitionIds,MetaInfos),
3628 (clear_context_state,clear_error_context)).
3629
3630 get_svgid_with_events(SvgID,FirstOpName) :- visb_event(SvgID,FirstOpName,_,_,_File,_Pos).
3631
3632
3633 :- use_module(probsrc(tools),[safe_read_term_from_atom/2]).
3634 :- use_module(probsrc(state_space),[transition/4]).
3635 perform_aux(SvgID,StateId,_ExpandedBState,OpName,OpTerm,NewStateId,ResTransitionIds,_MetaInfos) :-
3636 \+ b_or_z_mode,
3637 % just look up transition/4 entries in state space
3638 % TODO: maybe provide this possibility for B models, even if using explicit parameter values is more robust
3639 get_visb_event_operation(SvgID,OpName,Preds,_Pred,Pos),
3640 safe_read_term_from_atom(OpName,OpTerm0),
3641 (xtl_mode -> check_xtl_direct_transition_candidate(OpTerm0,Preds,Pos), OpTerm=OpTerm0 ; true), !,
3642 % for XTL: use exec by pred for arity 0, otherwise try to find transition term in state space
3643 if((transition(StateId,OpTerm,TransID,NewStateId),
3644 match_operation(OpTerm,OpName)), % match is relevant if \+xtl_mode
3645 ResTransitionIds = [TransID],
3646 return_disabled(SvgID,StateId,OpName,OpTerm,NewStateId,ResTransitionIds)
3647 ).
3648 perform_aux(SvgID,StateId,ExpandedBState,OpName,OpTerm,NewStateId,ResTransitionIds,MetaInfos) :-
3649 %state_space:portray_state_space,
3650 if(execute_visb_event_by_predicate(SvgID,StateId,ExpandedBState,OpName,OpTerm,NewStateId,TransIds,MetaInfos),
3651 ResTransitionIds = TransIds,
3652 return_disabled(SvgID,StateId,OpName,OpTerm,NewStateId,ResTransitionIds)).
3653
3654 check_xtl_direct_transition_candidate(OpTerm,Preds,Pos) :-
3655 nonvar(OpTerm), % upper case event names are interpreted as Prolog variables -> use exec by pred (or FIXME)
3656 functor(OpTerm,_,Ar), Ar>0, % use exec by pred for arity 0, otherwise try to find transition term in state space
3657 (Preds \= []
3658 -> add_warning(visb_visualiser,'Ignoring predicates for VisB XTL event with explicit transition term (use predicate to provide parameter values): ',OpTerm,Pos)
3659 ; true).
3660
3661 return_disabled(SvgID,StateId,OpName,OpTerm,NewStateId,ResTransitionIds) :-
3662 OpTerm = disabled, NewStateId = StateId,
3663 get_svgid_with_events(SvgID,OpName),
3664 ResTransitionIds = []. % visb_event not enabled
3665
3666 :- use_module(probsrc(tools_strings),[match_atom/2]).
3667 :- use_module(probsrc(specfile),[get_operation_name/2]).
3668 match_operation(OpTerm,OpTerm) :- !.
3669 match_operation(OpTerm,OpName) :- atom(OpName),
3670 (get_operation_name(OpTerm,OpName)
3671 ; match_atom(OpName,OpTerm) % match an atom string with a compound term
3672 ),!.
3673
3674 execute_visb_event_by_predicate(SvgID,StateId,ExpandedBState,OpName,OpTerm,NewStateId,TransIds,MetaInfos) :-
3675 get_visb_event_operation(SvgID,OpName,_,Pred,Pos),
3676 build_visb_click_meta_object(MetaInfos,BMetaInfos),
3677 bsyntaxtree:replace_id_by_expr(Pred,'VISB_CLICK_META_INFOS',BMetaInfos,NPred),
3678 exec_aux(SvgID,StateId,ExpandedBState,OpName,NPred,Pos,OpTerm,NewStateId,TransIds).
3679
3680 build_visb_click_meta_object(MetaInfos,BMetaInfos) :-
3681 (member(alt_key,MetaInfos) -> AltKey = pred_true ; AltKey = pred_false),
3682 (member(ctrl_key,MetaInfos) -> CtrlKey = pred_true ; CtrlKey = pred_false),
3683 (member(meta_key,MetaInfos) -> MetaKey = pred_true ; MetaKey = pred_false),
3684 (member(pageX(PageX),MetaInfos) -> true ; PageX = 0), % fallback
3685 (member(pageY(PageY),MetaInfos) -> true ; PageY = 0), % fallback
3686 (member(shift_key,MetaInfos) -> ShiftKey = pred_true ; ShiftKey = pred_false),
3687 findall(','(string(Var),string(VarValue)), member(js_var(Var,VarValue), MetaInfos), JSVars),
3688
3689 visb_click_meta_b_type(BType),
3690 BMetaInfos = b(value(rec([
3691 field(altKey,AltKey),
3692 field(ctrlKey,CtrlKey),
3693 field(jsVars,JSVars),
3694 field(metaKey,MetaKey),
3695 field(pageX,int(PageX)),
3696 field(pageY,int(PageY)),
3697 field(shiftKey,ShiftKey)
3698 ])),BType,[visb_generated]).
3699
3700 visb_click_meta_b_type(record([
3701 field(altKey,boolean),
3702 field(ctrlKey,boolean),
3703 field(jsVars,set(couple(string,string))),
3704 field(metaKey,boolean),
3705 field(pageX,integer),
3706 field(pageY,integer),
3707 field(shiftKey,boolean)
3708 ])).
3709
3710 :- use_module(probsrc(tcltk_interface),[compute_all_transitions_if_necessary/2]).
3711 :- use_module(library(random),[random_member/2]).
3712 :- use_module(extrasrc(mcts_game_play), [mcts_auto_play/4, mcts_auto_play_available/0]).
3713 :- use_module(probsrc(tools_timeout), [time_out_with_factor_call/3]).
3714 exec_aux(SvgID,StateId,ExpandedBState,OpName,Pred,Pos,OpTerm,NewStateId,[TransId]) :-
3715 (b_or_z_mode -> b_is_operation_name(OpName) ; true), !, % note: ignores special definitions below if not B mode
3716 time_out_with_factor_call(
3717 exec_op_by_pred_aux(StateId,ExpandedBState,OpName,Pred,OpTerm,NewState,Pos),
3718 5, % min_max_time_out(10,100,15000)
3719 (ajoin(['TIME-OUT for VisB click on SVG ID ', SvgID,' while executing operation by predicate: '],Msg),
3720 add_warning(visb_visualiser,Msg,OpName,Pos),fail)),
3721 patch_state(NewState,StateId,PatchedNewState),
3722 tcltk_interface:add_trans_id(StateId,OpTerm,PatchedNewState,NewStateId,TransId).
3723 %translate:print_bstate(PatchedNewState),nl.
3724 exec_aux(SvgID,StateId,_ExpandedBState,'MCTS_AUTO_PLAY',_Pred,Pos,OpTerm,NewStateId,[TransId]) :- !,
3725 mcts_auto_play_available,
3726 % TODO: allow to set SimRuns, TimeOut in Pred
3727 add_debug_message(visb_visualiser,'Performing MCTS_AUTO_PLAY for click on: ',SvgID,Pos),
3728 mcts_auto_play(StateId,OpTerm,TransId,NewStateId).
3729 exec_aux(_SvgID,StateId,_ExpandedBState,'RANDOM_ANIMATE',_Pred,_Pos,OpTerm,NewStateId,[TransId]) :- !,
3730 compute_all_transitions_if_necessary(StateId,false),
3731 write(ra(_Pred)),nl,
3732 findall(rtr(OpTerm,TransId,NewStateId),transition(StateId,OpTerm,TransId,NewStateId),List),
3733 random_member(rtr(OpTerm,TransId,NewStateId),List).
3734 % see tcltk_interface:tcltk_random_perform2 and allow Kind: fully_random, no_self_loops, heuristics, ...
3735 % split with ; ?
3736 exec_aux(SvgID,StateId,ExpandedBState,'RANDOM_ANIMATE_UNTIL_LTL',LTLExpr,Pos,OpTerm,NewStateId,TransIds) :- !,
3737 OpTerm = 'RANDOM_ANIMATE_UNTIL_LTL',
3738 (get_texpr_type(LTLExpr,string),
3739 evaluate_visb_formula(LTLExpr,'RANDOM_ANIMATE_UNTIL_LTL',SvgID,ExpandedBState,Value,Pos),
3740 Value = string(LTLFormula)
3741 -> tcltk_interface:tcltk_animate_until(LTLFormula,StateId,1000,ltl_state_property,_Steps,_Res,NewStateId,TransIds)
3742 ; add_error(visb_visualiser,'Argument to RANDOM_ANIMATE_UNTIL_LTL must provide LTL formula as string:',StateId)
3743 ).
3744
3745 :- use_module(probsrc(b_state_model_check),[execute_operation_by_predicate_in_state_with_pos/6,
3746 xtl_execute_operation_by_predicate_in_state/7]).
3747 exec_op_by_pred_aux(StateId,ExpandedBState,OpName,Pred,OpTerm,NewState,Pos) :- xtl_mode,!,
3748 visited_expression(StateId,RawState),
3749 xtl_execute_operation_by_predicate_in_state(ExpandedBState,RawState,OpName,Pred,OpTerm,NewState,Pos).
3750 exec_op_by_pred_aux(_StateId,ExpandedBState,OpName,Pred,OpTerm,NewState,Pos) :-
3751 execute_operation_by_predicate_in_state_with_pos(ExpandedBState,OpName,Pred,OpTerm,NewState,Pos).
3752
3753 :- use_module(probsrc(bmachine), [b_is_variable/1,b_machine_has_constants/0]).
3754
3755 is_var_binding(bind(Var,_)) :- b_or_z_mode, b_is_variable(Var).
3756
3757
3758 % remove constants and VisB Definition entries from state:
3759 patch_state(NewState,_StateId,PatchedState) :-
3760 \+ b_or_z_mode, !, PatchedState=NewState. % XTL state is raw state
3761 patch_state(NewState,StateId,PatchedState) :-
3762 get_constants_id_for_state_id(StateId,ConstId),!,
3763 PatchedState = const_and_vars(ConstId,VarsState),
3764 include(is_var_binding,NewState,VarsState).
3765 patch_state(NewState,StateId,VarsState) :-
3766 (b_machine_has_constants
3767 -> add_error(visb_visualiser,'Could not extract constants id for state:',StateId),
3768 VarsState=NewState
3769 ; include(is_var_binding,NewState,VarsState)).
3770
3771 % the next predicate gets all operations/events associated with SvgID in the order in which they were found
3772 % note that there is only one visb_event (the last one); all others are auxiliary
3773 get_visb_event_operation(SvgID,OpName,Preds,TypedPred,Pos) :- % check if there are more events registered:
3774 auxiliary_visb_event(SvgID,OpName,Preds,TypedPred,Pos).
3775 get_visb_event_operation(SvgID,OpName,Preds,TypedPred,Pos) :-
3776 visb_event(SvgID,OpName,Preds,TypedPred,_File,Pos).
3777
3778 % ---------------
3779
3780 get_visb_hovers(List) :-
3781 findall(hover(SvgID,ID,Attr,EnterVal,ExitVal),
3782 visb_hover(SvgID,ID,Attr,EnterVal,ExitVal,_), List).
3783
3784 get_visb_svg_objects(List) :-
3785 % TODO: remove objects inlined in get_visb_default_svg_file_contents
3786 findall(visb_svg_object(SvgID,SvgClass,AttrList),
3787 visb_svg_object(SvgID,SvgClass,AttrList,_Desc,_Pos), List).
3788
3789 % ------------------
3790
3791 :- use_module(probsrc(bmachine),[b_absolute_file_name_relative_to_main_machine/2]).
3792 extended_static_check_default_visb_file :-
3793 (get_default_visb_file(VisBFile,Pos)
3794 % TODO: we could check if we have an visb_history(JSONFile,_,_) option
3795 -> extended_static_check_visb_file(VisBFile,Pos)
3796 ; true).
3797
3798 extended_static_check_visb_file('',_InclusionPos) :-
3799 load_visb_file('').
3800 extended_static_check_visb_file(VisBFile,InclusionPos) :-
3801 b_absolute_file_name_relative_to_main_machine(VisBFile,AFile),
3802 (file_exists(AFile)
3803 -> load_visb_file(AFile)
3804 ; add_warning(lint,'VISB_JSON_FILE does not exist: ',AFile,InclusionPos)
3805 ).
3806
3807 % ---------------------------
3808
3809 % portray all VisB items in DEFINITION B syntax
3810 get_visb_ids(SIds) :-
3811 findall(Id,visb_id(Id),Ids),
3812 sort(Ids,SIds).
3813
3814 visb_id(ID) :- visb_svg_object(ID,_,_,_,_). % see svg_id_exists
3815 visb_id(ID) :- visb_item(ID,_,_,_,_,_,_), \+ visb_svg_object(ID,_,_,_,_).
3816 visb_id(ID) :- visb_event(ID,_,_,_,_,_), \+ visb_svg_object(ID,_,_,_,_).
3817 visb_id(ID) :- visb_hover(ID,_,_,_,_,_), \+ visb_svg_object(ID,_,_,_,_).
3818
3819 :- public portray_visb/0.
3820 portray_visb:-
3821 get_visb_ids(SIds), nth1(Nr,SIds,ID),
3822 %visb_svg_object(ID,SVG_Class,NewRestAttrs,Desc,Pos1),
3823 findall(field(Attr,b(value(StaticVal),any,[])),
3824 (visb_svg_object(ID,SVG_Class,StaticAttrs,Desc,_Pos1),
3825 ( Attr=svg_class,StaticVal=string(SVG_Class)
3826 ; Attr=comment,StaticVal=string(Desc)
3827 ; member(svg_attribute(Attr,StaticVal),StaticAttrs))
3828 ),
3829 StaticValues),
3830 findall(field(Attr,TypedExpr),
3831 visb_item(ID,Attr,TypedExpr,_UsedIds,_Desc,_PosStartOfItem,_Meta), % meta can contain override
3832 Updates,StaticValues),
3833 % TODO: incorporate events and hovers
3834 UpdateRec = b(rec(Fields),any,[]),
3835 gen_string(ID,IDS),
3836 Fields = [field(id,IDS) | Updates],
3837 (StaticValues=[] -> format('~nVISB_SVG_UPDATES~w == ',[Nr]) ; format('~nVISB_SVG_OBJECTS~w == ',[Nr])),
3838 translate:print_bexpr(UpdateRec), write(';'), nl,
3839 fail.
3840 portray_visb.
3841 gen_string(ID,b(string(ID),string,[])).
3842 % use_module(visbsrc(visb_visualiser)), visb_visualiser:portray_visb.