Context Navigation

source: trunk/gui/scripts/flowvisviewer.tcl @ 2606

Last change on this file since 2606 was 2606, checked in by gah, 13 years ago

File size: 100.6 KB

Line
1	# ----------------------------------------------------------------------
2	# COMPONENT: flowvisviewer - 3D flow rendering
3	#
4	#
5	# This widget performs volume and flow rendering on 3D scalar/vector datasets.
6	# It connects to the Flowvis server running on a rendering farm, transmits
7	# data, and displays the results.
8	#
9	# ======================================================================
10	# AUTHOR: Michael McLennan, Purdue University
11	# Copyright (c) 2004-2005 Purdue Research Foundation
12	#
13	# See the file "license.terms" for information on usage and redistribution of
14	# this file, and for a DISCLAIMER OF ALL WARRANTIES.
15	# ======================================================================
16	package require Itk
17	package require BLT
18	package require Img
19
20	option add *FlowvisViewer.width 5i widgetDefault
21	option add FlowvisViewercursor crosshair widgetDefault
22	option add *FlowvisViewer.height 4i widgetDefault
23	option add *FlowvisViewer.foreground black widgetDefault
24	option add *FlowvisViewer.controlBackground gray widgetDefault
25	option add *FlowvisViewer.controlDarkBackground #999999 widgetDefault
26	option add *FlowvisViewer.plotBackground black widgetDefault
27	option add *FlowvisViewer.plotForeground white widgetDefault
28	option add *FlowvisViewer.plotOutline gray widgetDefault
29	option add *FlowvisViewer.font \
30	--helvetica-medium-r-normal--12-* widgetDefault
31
32	# must use this name -- plugs into Rappture::resources::load
33	proc FlowvisViewer_init_resources {} {
34	Rappture::resources::register \
35	nanovis_server Rappture::FlowvisViewer::SetServerList
36	}
37
38	itcl::class Rappture::FlowvisViewer {
39	inherit Rappture::VisViewer
40
41	itk_option define -plotforeground plotForeground Foreground ""
42	itk_option define -plotbackground plotBackground Background ""
43	itk_option define -plotoutline plotOutline PlotOutline ""
44
45	constructor { hostlist args } {
46	Rappture::VisViewer::constructor $hostlist
47	} {
48	# defined below
49	}
50	destructor {
51	# defined below
52	}
53	public proc SetServerList { namelist } {
54	Rappture::VisViewer::SetServerList "nanovis" $namelist
55	}
56	public method add {dataobj {settings ""}}
57	public method camera {option args}
58	public method delete {args}
59	public method disconnect {}
60	public method download {option args}
61	public method flow {option}
62	public method get {args}
63	public method isconnected {}
64	public method limits { tf }
65	public method overmarker { m x }
66	public method parameters {title args} {
67	# do nothing
68	}
69	public method rmdupmarker { m x }
70	public method scale {args}
71	public method sendto { cmd }
72	public method updatetransferfuncs {}
73
74	protected method Connect {}
75	protected method CurrentVolumeIds {{what -all}}
76	protected method Disconnect {}
77	protected method Resize {}
78	protected method ResizeLegend {}
79	protected method FixSettings {what {value ""}}
80	protected method Pan {option x y}
81	protected method Rebuild {}
82	protected method ReceiveData { args }
83	protected method ReceiveImage { args }
84	protected method ReceiveLegend { tf vmin vmax size }
85	protected method Rotate {option x y}
86	protected method SendCmd {string}
87	protected method SendDataObjs {}
88	protected method SendTransferFuncs {}
89	protected method Slice {option args}
90	protected method SlicerTip {axis}
91	protected method Zoom {option}
92
93	# soon to be removed.
94	protected method Flow {option args}
95	protected method Play {}
96	protected method Pause {}
97
98
99	# The following methods are only used by this class.
100
101	private method AddIsoMarker { x y }
102	private method BuildCameraTab {}
103	private method BuildCutplanesTab {}
104	private method BuildViewTab {}
105	private method BuildVolumeTab {}
106	private method ComputeTransferFunc { tf }
107	private method EventuallyResize { w h }
108	private method EventuallyGoto { nSteps }
109	private method EventuallyResizeLegend { }
110	private method FlowCmd { dataobj comp nbytes extents }
111	private method GetMovie { widget width height }
112	private method GetPngImage { widget width height }
113	private method NameTransferFunc { dataobj comp }
114	private method PanCamera {}
115	private method ParseLevelsOption { tf levels }
116	private method ParseMarkersOption { tf markers }
117	private method WaitIcon { option widget }
118	private method str2millisecs { value }
119	private method millisecs2str { value }
120	private method GetFlowInfo { widget }
121	private method particles { tag name }
122	private method box { tag name }
123	private method streams { tag name }
124	private method arrows { tag name }
125
126	private variable _outbuf ;# buffer for outgoing commands
127
128	private variable _dlist "" ;# list of data objects
129	private variable _allDataObjs
130	private variable _obj2ovride ;# maps dataobj => style override
131	private variable _serverObjs ;# maps dataobj-component to volume ID
132	# in the server
133	private variable _sendobjs "" ;# list of data objs to send to server
134	private variable _recvObjs ;# list of data objs to send to server
135	private variable _obj2style ;# maps dataobj-component to transfunc
136	private variable _style2objs ;# maps tf back to list of
137	# dataobj-components using the tf.
138	private variable _obj2flow; # Maps dataobj-component to a flow.
139
140	private variable _click ;# info used for rotate operations
141	private variable _limits ;# autoscale min/max for all axes
142	private variable _view ;# view params for 3D view
143	private variable _isomarkers ;# array of isosurface level values 0..1
144	private common _settings
145	private variable _activeTf "" ;# The currently active transfer function.
146	private variable _first "" ;# This is the topmost volume.
147	private variable _buffering 0
148	private variable _nextToken 0
149	private variable _icon 0
150	private variable _flow
151	# This
152	# indicates which isomarkers and transfer
153	# function to use when changing markers,
154	# opacity, or thickness.
155	private common _downloadPopup ;# download options from popup
156
157	private common _hardcopy
158	private variable _width 0
159	private variable _height 0
160	private variable _resizePending 0
161	private variable _resizeLegendPending 0
162	private variable _gotoPending 0
163	}
164
165	itk::usual FlowvisViewer {
166	keep -background -foreground -cursor -font
167	keep -plotbackground -plotforeground
168	}
169
170	# ----------------------------------------------------------------------
171	# CONSTRUCTOR
172	# ----------------------------------------------------------------------
173	itcl::body Rappture::FlowvisViewer::constructor { hostlist args } {
174
175	# Draw legend event
176	$_dispatcher register !legend
177	$_dispatcher dispatch $this !legend "[itcl::code $this ResizeLegend]; list"
178
179	# Send dataobjs event
180	$_dispatcher register !send_dataobjs
181	$_dispatcher dispatch $this !send_dataobjs \
182	"[itcl::code $this SendDataObjs]; list"
183
184	# Send transferfunctions event
185	$_dispatcher register !send_transfunc
186	$_dispatcher dispatch $this !send_transfunc \
187	"[itcl::code $this SendTransferFuncs]; list"
188
189	# Rebuild event.
190	$_dispatcher register !rebuild
191	$_dispatcher dispatch $this !rebuild "[itcl::code $this Rebuild]; list"
192
193	# Resize event.
194	$_dispatcher register !resize
195	$_dispatcher dispatch $this !resize "[itcl::code $this Resize]; list"
196
197	$_dispatcher register !play
198	$_dispatcher dispatch $this !play "[itcl::code $this flow next]; list"
199
200	# Draw legend event
201	$_dispatcher register !goto
202	$_dispatcher dispatch $this !goto "[itcl::code $this flow goto2]; list"
203
204	$_dispatcher register !movietimeout
205	$_dispatcher register !waiticon
206
207	set _flow(state) 0
208
209	set _outbuf ""
210
211	array set _downloadPopup {
212	format draft
213	}
214	#
215	# Populate parser with commands handle incoming requests
216	#
217	$_parser alias image [itcl::code $this ReceiveImage]
218	$_parser alias legend [itcl::code $this ReceiveLegend]
219	$_parser alias data [itcl::code $this ReceiveData]
220
221	# Initialize the view to some default parameters.
222	array set _view {
223	theta 45
224	phi 45
225	psi 0
226	zoom 1.0
227	pan-x 0
228	pan-y 0
229	}
230	set _limits(vmin) 0.0
231	set _limits(vmax) 1.0
232
233	array set _settings [subst {
234	$this-arrows 0
235	$this-currenttime 0
236	$this-duration 1:00
237	$this-loop 0
238	$this-pan-x $_view(pan-x)
239	$this-pan-y $_view(pan-y)
240	$this-phi $_view(phi)
241	$this-play 0
242	$this-psi $_view(psi)
243	$this-speed 500
244	$this-step 0
245	$this-streams 0
246	$this-theta $_view(theta)
247	$this-volume 1
248	$this-xcutplane 0
249	$this-xcutposition 0
250	$this-ycutplane 0
251	$this-ycutposition 0
252	$this-zcutplane 0
253	$this-zcutposition 0
254	$this-zoom $_view(zoom)
255	}]
256
257	itk_component add 3dview {
258	label $itk_component(plotarea).view -image $_image(plot) \
259	-highlightthickness 0 -borderwidth 0
260	} {
261	usual
262	ignore -highlightthickness -borderwidth -background
263	}
264	set f [$itk_component(main) component controls]
265	itk_component add reset {
266	button $f.reset -borderwidth 1 -padx 1 -pady 1 \
267	-highlightthickness 0 \
268	-image [Rappture::icon reset-view] \
269	-command [itcl::code $this Zoom reset]
270	} {
271	usual
272	ignore -highlightthickness
273	}
274	pack $itk_component(reset) -side top -padx 2 -pady 2
275	Rappture::Tooltip::for $itk_component(reset) "Reset the view to the default zoom level"
276
277	itk_component add zoomin {
278	button $f.zin -borderwidth 1 -padx 1 -pady 1 \
279	-highlightthickness 0 \
280	-image [Rappture::icon zoom-in] \
281	-command [itcl::code $this Zoom in]
282	} {
283	usual
284	ignore -highlightthickness
285	}
286	pack $itk_component(zoomin) -side top -padx 2 -pady 2
287	Rappture::Tooltip::for $itk_component(zoomin) "Zoom in"
288
289	itk_component add zoomout {
290	button $f.zout -borderwidth 1 -padx 1 -pady 1 \
291	-highlightthickness 0 \
292	-image [Rappture::icon zoom-out] \
293	-command [itcl::code $this Zoom out]
294	} {
295	usual
296	ignore -highlightthickness
297	}
298	pack $itk_component(zoomout) -side top -padx 2 -pady 2
299	Rappture::Tooltip::for $itk_component(zoomout) "Zoom out"
300
301	itk_component add volume {
302	Rappture::PushButton $f.volume \
303	-onimage [Rappture::icon volume-on] \
304	-offimage [Rappture::icon volume-off] \
305	-command [itcl::code $this FixSettings volume] \
306	-variable [itcl::scope _settings($this-volume)]
307	}
308	$itk_component(volume) select
309	Rappture::Tooltip::for $itk_component(volume) \
310	"Toggle the volume cloud on/off"
311	pack $itk_component(volume) -padx 2 -pady 2
312
313	BuildViewTab
314	BuildVolumeTab
315	BuildCutplanesTab
316	BuildCameraTab
317
318	bind $itk_component(3dview) <Configure> \
319	[itcl::code $this EventuallyResize %w %h]
320
321	# Legend
322	set _image(legend) [image create photo]
323	itk_component add legend {
324	canvas $itk_component(plotarea).legend -height 50 -highlightthickness 0
325	} {
326	usual
327	ignore -highlightthickness
328	rename -background -plotbackground plotBackground Background
329	}
330	bind $itk_component(legend) <Configure> \
331	[itcl::code $this EventuallyResizeLegend]
332
333	# Hack around the Tk panewindow. The problem is that the requested
334	# size of the 3d view isn't set until an image is retrieved from
335	# the server. So the panewindow uses the tiny size.
336	set w 10000
337	pack forget $itk_component(3dview)
338	blt::table $itk_component(plotarea) \
339	0,0 $itk_component(3dview) -fill both -reqwidth $w \
340	1,0 $itk_component(legend) -fill x
341	blt::table configure $itk_component(plotarea) r1 -resize none
342	# Create flow controls...
343
344	itk_component add flowcontrols {
345	frame $itk_interior.flowcontrols
346	} {
347	usual
348	rename -background -controlbackground controlBackground Background
349	}
350	pack forget $itk_component(main)
351	blt::table $itk_interior \
352	0,0 $itk_component(main) -fill both \
353	1,0 $itk_component(flowcontrols) -fill x
354	blt::table configure $itk_interior r1 -resize none
355
356	# Rewind
357	itk_component add rewind {
358	button $itk_component(flowcontrols).reset \
359	-borderwidth 1 -padx 1 -pady 1 \
360	-image [Rappture::icon flow-rewind] \
361	-command [itcl::code $this flow reset]
362	} {
363	usual
364	ignore -borderwidth
365	rename -highlightbackground -controlbackground controlBackground \
366	Background
367	}
368	Rappture::Tooltip::for $itk_component(rewind) \
369	"Rewind flow"
370
371	# Stop
372	itk_component add stop {
373	button $itk_component(flowcontrols).stop \
374	-borderwidth 1 -padx 1 -pady 1 \
375	-image [Rappture::icon flow-stop] \
376	-command [itcl::code $this flow stop]
377	} {
378	usual
379	ignore -borderwidth
380	rename -highlightbackground -controlbackground controlBackground \
381	Background
382	}
383	Rappture::Tooltip::for $itk_component(stop) \
384	"Stop flow"
385
386	# Play
387	itk_component add play {
388	Rappture::PushButton $itk_component(flowcontrols).play \
389	-onimage [Rappture::icon flow-pause] \
390	-offimage [Rappture::icon flow-play] \
391	-variable [itcl::scope _settings($this-play)] \
392	-command [itcl::code $this flow toggle]
393	}
394	set fg [option get $itk_component(hull) font Font]
395	Rappture::Tooltip::for $itk_component(play) \
396	"Play/Pause flow"
397
398	# Loop
399	itk_component add loop {
400	Rappture::PushButton $itk_component(flowcontrols).loop \
401	-onimage [Rappture::icon flow-loop] \
402	-offimage [Rappture::icon flow-loop] \
403	-variable [itcl::scope _settings($this-loop)]
404	}
405	Rappture::Tooltip::for $itk_component(loop) \
406	"Play continuously"
407
408	itk_component add dial {
409	Rappture::Flowdial $itk_component(flowcontrols).dial \
410	-length 10 -valuewidth 0 -valuepadding 0 -padding 6 \
411	-linecolor "" -activelinecolor "" \
412	-min 0.0 -max 1.0 \
413	-variable [itcl::scope _settings($this-currenttime)] \
414	-knobimage [Rappture::icon knob2] -knobposition center@middle
415	} {
416	usual
417	ignore -dialprogresscolor
418	rename -background -controlbackground controlBackground Background
419	}
420	$itk_component(dial) current 0.0
421	bind $itk_component(dial) <<Value>> [itcl::code $this flow goto]
422	# Duration
423	itk_component add duration {
424	entry $itk_component(flowcontrols).duration \
425	-textvariable [itcl::scope _settings($this-duration)] \
426	-bg white -width 6 -font "arial 9"
427	} {
428	usual
429	ignore -highlightthickness -background
430	}
431	bind $itk_component(duration) <Return> [itcl::code $this flow duration]
432	bind $itk_component(duration) <Tab> [itcl::code $this flow duration]
433	Rappture::Tooltip::for $itk_component(duration) \
434	"Set duration of flow (format is min:sec)"
435
436
437	itk_component add durationlabel {
438	label $itk_component(flowcontrols).durationl \
439	-text "Duration:" -font $fg \
440	-highlightthickness 0
441	} {
442	usual
443	ignore -highlightthickness
444	rename -background -controlbackground controlBackground Background
445	}
446
447	itk_component add speedlabel {
448	label $itk_component(flowcontrols).speedl -text "Speed:" -font $fg \
449	-highlightthickness 0
450	} {
451	usual
452	ignore -highlightthickness
453	rename -background -controlbackground controlBackground Background
454	}
455
456	# Speed
457	itk_component add speed {
458	Rappture::Flowspeed $itk_component(flowcontrols).speed \
459	-min 1 -max 10 -width 3 -font "arial 9"
460	} {
461	usual
462	ignore -highlightthickness
463	rename -background -controlbackground controlBackground Background
464	}
465	Rappture::Tooltip::for $itk_component(speed) \
466	"Change speed of flow"
467
468	$itk_component(speed) value 1
469	bind $itk_component(speed) <<Value>> [itcl::code $this flow speed]
470
471
472	blt::table $itk_component(flowcontrols) \
473	0,0 $itk_component(rewind) -padx {3 0} \
474	0,1 $itk_component(stop) -padx {2 0} \
475	0,2 $itk_component(play) -padx {2 0} \
476	0,3 $itk_component(loop) -padx {2 0} \
477	0,4 $itk_component(dial) -fill x -padx {2 0 } \
478	0,5 $itk_component(duration) -padx { 0 0} \
479	0,7 $itk_component(speed) -padx {2 3}
480
481	# 0,6 $itk_component(speedlabel) -padx {2 0}
482	blt::table configure $itk_component(flowcontrols) c* -resize none
483	blt::table configure $itk_component(flowcontrols) c4 -resize both
484	blt::table configure $itk_component(flowcontrols) r0 -pady 1
485	# Bindings for rotation via mouse
486	bind $itk_component(3dview) <ButtonPress-1> \
487	[itcl::code $this Rotate click %x %y]
488	bind $itk_component(3dview) <B1-Motion> \
489	[itcl::code $this Rotate drag %x %y]
490	bind $itk_component(3dview) <ButtonRelease-1> \
491	[itcl::code $this Rotate release %x %y]
492
493	bind $itk_component(3dview) <Configure> \
494	[itcl::code $this EventuallyResize %w %h]
495
496	# Bindings for panning via mouse
497	bind $itk_component(3dview) <ButtonPress-2> \
498	[itcl::code $this Pan click %x %y]
499	bind $itk_component(3dview) <B2-Motion> \
500	[itcl::code $this Pan drag %x %y]
501	bind $itk_component(3dview) <ButtonRelease-2> \
502	[itcl::code $this Pan release %x %y]
503
504	# Bindings for panning via keyboard
505	bind $itk_component(3dview) <KeyPress-Left> \
506	[itcl::code $this Pan set -10 0]
507	bind $itk_component(3dview) <KeyPress-Right> \
508	[itcl::code $this Pan set 10 0]
509	bind $itk_component(3dview) <KeyPress-Up> \
510	[itcl::code $this Pan set 0 -10]
511	bind $itk_component(3dview) <KeyPress-Down> \
512	[itcl::code $this Pan set 0 10]
513	bind $itk_component(3dview) <Shift-KeyPress-Left> \
514	[itcl::code $this Pan set -2 0]
515	bind $itk_component(3dview) <Shift-KeyPress-Right> \
516	[itcl::code $this Pan set 2 0]
517	bind $itk_component(3dview) <Shift-KeyPress-Up> \
518	[itcl::code $this Pan set 0 -2]
519	bind $itk_component(3dview) <Shift-KeyPress-Down> \
520	[itcl::code $this Pan set 0 2]
521
522	# Bindings for zoom via keyboard
523	bind $itk_component(3dview) <KeyPress-Prior> \
524	[itcl::code $this Zoom out]
525	bind $itk_component(3dview) <KeyPress-Next> \
526	[itcl::code $this Zoom in]
527
528	bind $itk_component(3dview) <Enter> "focus $itk_component(3dview)"
529
530	if {[string equal "x11" [tk windowingsystem]]} {
531	# Bindings for zoom via mouse
532	bind $itk_component(3dview) <4> [itcl::code $this Zoom out]
533	bind $itk_component(3dview) <5> [itcl::code $this Zoom in]
534	}
535
536	set _image(download) [image create photo]
537
538	eval itk_initialize $args
539
540	Connect
541	}
542
543	# ----------------------------------------------------------------------
544	# DESTRUCTOR
545	# ----------------------------------------------------------------------
546	itcl::body Rappture::FlowvisViewer::destructor {} {
547	set _sendobjs "" ;# stop any send in progress
548	$_dispatcher cancel !rebuild
549	$_dispatcher cancel !send_dataobjs
550	$_dispatcher cancel !send_transfunc
551	image delete $_image(plot)
552	image delete $_image(legend)
553	image delete $_image(download)
554	array unset _settings $this-*
555	}
556
557	# ----------------------------------------------------------------------
558	# USAGE: add <dataobj> ?<settings>?
559	#
560	# Clients use this to add a data object to the plot. The optional
561	# <settings> are used to configure the plot. Allowed settings are
562	# -color, -brightness, -width, -linestyle, and -raise.
563	# ----------------------------------------------------------------------
564	itcl::body Rappture::FlowvisViewer::add {dataobj {settings ""}} {
565	array set params {
566	-color auto
567	-width 1
568	-linestyle solid
569	-brightness 0
570	-raise 0
571	-description ""
572	-param ""
573	}
574	foreach {opt val} $settings {
575	if {![info exists params($opt)]} {
576	error "bad setting \"$opt\": should be [join [lsort [array names params]] {, }]"
577	}
578	set params($opt) $val
579	}
580	if {$params(-color) == "auto" \|\| $params(-color) == "autoreset"} {
581	# can't handle -autocolors yet
582	set params(-color) black
583	}
584	foreach comp [$dataobj components] {
585	set flowobj [$dataobj flowhints $comp]
586	if { $flowobj == "" } {
587	puts stderr "no flowhints $dataobj-$comp"
588	continue
589	}
590	set _obj2flow($dataobj-$comp) $flowobj
591	}
592	set pos [lsearch -exact $dataobj $_dlist]
593	if {$pos < 0} {
594	lappend _dlist $dataobj
595	set _allDataObjs($dataobj) 1
596	set _obj2ovride($dataobj-color) $params(-color)
597	set _obj2ovride($dataobj-width) $params(-width)
598	set _obj2ovride($dataobj-raise) $params(-raise)
599	$_dispatcher event -idle !rebuild
600	}
601	}
602
603	# ----------------------------------------------------------------------
604	# USAGE: get ?-objects?
605	# USAGE: get ?-image 3dview\|legend?
606	#
607	# Clients use this to query the list of objects being plotted, in
608	# order from bottom to top of this result. The optional "-image"
609	# flag can also request the internal images being shown.
610	# ----------------------------------------------------------------------
611	itcl::body Rappture::FlowvisViewer::get {args} {
612	if {[llength $args] == 0} {
613	set args "-objects"
614	}
615
616	set op [lindex $args 0]
617	switch -- $op {
618	-objects {
619	# put the dataobj list in order according to -raise options
620	set dlist $_dlist
621	foreach obj $dlist {
622	if {[info exists _obj2ovride($obj-raise)] && $_obj2ovride($obj-raise)} {
623	set i [lsearch -exact $dlist $obj]
624	if {$i >= 0} {
625	set dlist [lreplace $dlist $i $i]
626	lappend dlist $obj
627	}
628	}
629	}
630	return $dlist
631	}
632	-image {
633	if {[llength $args] != 2} {
634	error "wrong # args: should be \"get -image 3dview\|legend\""
635	}
636	switch -- [lindex $args end] {
637	3dview {
638	return $_image(plot)
639	}
640	legend {
641	return $_image(legend)
642	}
643	default {
644	error "bad image name \"[lindex $args end]\": should be 3dview or legend"
645	}
646	}
647	}
648	default {
649	error "bad option \"$op\": should be -objects or -image"
650	}
651	}
652	}
653
654	# ----------------------------------------------------------------------
655	# USAGE: delete ?<dataobj1> <dataobj2> ...?
656	#
657	# Clients use this to delete a dataobj from the plot. If no dataobjs
658	# are specified, then all dataobjs are deleted. No data objects are
659	# deleted. They are only removed from the display list.
660	#
661	# ----------------------------------------------------------------------
662	itcl::body Rappture::FlowvisViewer::delete {args} {
663	flow stop
664	if {[llength $args] == 0} {
665	set args $_dlist
666	}
667
668	# Delete all specified dataobjs
669	set changed 0
670	foreach dataobj $args {
671	set pos [lsearch -exact $_dlist $dataobj]
672	if { $pos >= 0 } {
673	foreach comp [$dataobj components] {
674	array unset _limits $dataobj-$comp-*
675	}
676	set _dlist [lreplace $_dlist $pos $pos]
677	array unset _obj2ovride $dataobj-*
678	array unset _obj2flow $dataobj-*
679	array unset _serverObjs $dataobj-*
680	array unset _obj2style $dataobj-*
681	set changed 1
682	}
683	}
684	# If anything changed, then rebuild the plot
685	if {$changed} {
686	# Repair the reverse lookup
687	foreach tf [array names _style2objs] {
688	set list {}
689	foreach {dataobj comp} $_style2objs($tf) break
690	if { [info exists _serverObjs($dataobj-$comp)] } {
691	lappend list $dataobj $comp
692	}
693	if { $list == "" } {
694	array unset _style2objs $tf
695	} else {
696	set _style2objs($tf) $list
697	}
698	}
699	$_dispatcher event -idle !rebuild
700	}
701	}
702
703	# ----------------------------------------------------------------------
704	# USAGE: scale ?<data1> <data2> ...?
705	#
706	# Sets the default limits for the overall plot according to the
707	# limits of the data for all of the given <data> objects. This
708	# accounts for all objects--even those not showing on the screen.
709	# Because of this, the limits are appropriate for all objects as
710	# the user scans through data in the ResultSet viewer.
711	# ----------------------------------------------------------------------
712	itcl::body Rappture::FlowvisViewer::scale {args} {
713	foreach val {xmin xmax ymin ymax zmin zmax vmin vmax} {
714	set _limits($val) ""
715	}
716	foreach obj $args {
717	foreach axis {x y z v} {
718
719	foreach { min max } [$obj limits $axis] break
720
721	if {"" != $min && "" != $max} {
722	if {"" == $_limits(${axis}min)} {
723	set _limits(${axis}min) $min
724	set _limits(${axis}max) $max
725	} else {
726	if {$min < $_limits(${axis}min)} {
727	set _limits(${axis}min) $min
728	}
729	if {$max > $_limits(${axis}max)} {
730	set _limits(${axis}max) $max
731	}
732	}
733	}
734	}
735	}
736	}
737
738	# ----------------------------------------------------------------------
739	# USAGE: download coming
740	# USAGE: download controls <downloadCommand>
741	# USAGE: download now
742	#
743	# Clients use this method to create a downloadable representation
744	# of the plot. Returns a list of the form {ext string}, where
745	# "ext" is the file extension (indicating the type of data) and
746	# "string" is the data itself.
747	# ----------------------------------------------------------------------
748	itcl::body Rappture::FlowvisViewer::download {option args} {
749	set popup .flowvisviewerdownload
750	switch $option {
751	coming {
752	if {[catch {
753	blt::winop snap $itk_component(plotarea) $_image(download)
754	}]} {
755	$_image(download) configure -width 1 -height 1
756	$_image(download) put #000000
757	}
758	}
759	controls {
760	if {![winfo exists $popup]} {
761	# if we haven't created the popup yet, do it now
762	Rappture::Balloon $popup \
763	-title "[Rappture::filexfer::label downloadWord] as..."
764	set inner [$popup component inner]
765	label $inner.summary -text "" -anchor w
766	pack $inner.summary -side top
767	set img $_image(plot)
768	set res "[image width $img]x[image height $img]"
769	radiobutton $inner.draft -text "Image (draft $res)" \
770	-variable Rappture::FlowvisViewer::_downloadPopup(format) \
771	-value draft
772	pack $inner.draft -anchor w
773
774	set res "640x480"
775	radiobutton $inner.medium -text "Movie (standard $res)" \
776	-variable Rappture::FlowvisViewer::_downloadPopup(format) \
777	-value $res
778	pack $inner.medium -anchor w
779
780	set res "1024x768"
781	radiobutton $inner.high -text "Movie (high quality $res)" \
782	-variable Rappture::FlowvisViewer::_downloadPopup(format) \
783	-value $res
784	pack $inner.high -anchor w
785	button $inner.go -text [Rappture::filexfer::label download] \
786	-command [lindex $args 0]
787	pack $inner.go -pady 4
788	$inner.draft select
789	} else {
790	set inner [$popup component inner]
791	}
792	set num [llength [get]]
793	set num [expr {($num == 1) ? "1 result" : "$num results"}]
794	set word [Rappture::filexfer::label downloadWord]
795	$inner.summary configure -text "$word $num in the following format:"
796	update idletasks ;# fix initial sizes
797	return $popup
798	}
799	now {
800	if { [winfo exists $popup] } {
801	$popup deactivate
802	}
803	switch -- $_downloadPopup(format) {
804	draft {
805	# Get the image data (as base64) and decode it back to
806	# binary. This is better than writing to temporary
807	# files. When we switch to the BLT picture image it
808	# won't be necessary to decode the image data.
809	set bytes [$_image(plot) data -format "jpeg -quality 100"]
810	set bytes [Rappture::encoding::decode -as b64 $bytes]
811	return [list .jpg $bytes]
812	}
813	"640x480" {
814	return [$this GetMovie [lindex $args 0] 640 480]
815	}
816	"1024x768" {
817	return [$this GetMovie [lindex $args 0] 1024 768]
818	}
819	default {
820	error "bad download format $_downloadPopup(format)"
821	}
822	}
823	}
824	default {
825	error "bad option \"$option\": should be coming, controls, now"
826	}
827	}
828	}
829
830	# ----------------------------------------------------------------------
831	# USAGE: Connect ?<host:port>,<host:port>...?
832	#
833	# Clients use this method to establish a connection to a new
834	# server, or to reestablish a connection to the previous server.
835	# Any existing connection is automatically closed.
836	# ----------------------------------------------------------------------
837	itcl::body Rappture::FlowvisViewer::Connect {} {
838	set _hosts [GetServerList "nanovis"]
839	if { "" == $_hosts } {
840	return 0
841	}
842	set result [VisViewer::Connect $_hosts]
843	if { $result } {
844	set w [winfo width $itk_component(3dview)]
845	set h [winfo height $itk_component(3dview)]
846	EventuallyResize $w $h
847	}
848	return $result
849	}
850
851	#
852	# isconnected --
853	#
854	# Indicates if we are currently connected to the visualization server.
855	#
856	itcl::body Rappture::FlowvisViewer::isconnected {} {
857	return [VisViewer::IsConnected]
858	}
859
860	#
861	# disconnect --
862	#
863	itcl::body Rappture::FlowvisViewer::disconnect {} {
864	Disconnect
865	}
866
867	#
868	# sendto --
869	#
870	itcl::body Rappture::FlowvisViewer::sendto { bytes } {
871	SendBytes "$bytes\n"
872	}
873
874	#
875	# Disconnect --
876	#
877	# Clients use this method to disconnect from the current rendering
878	# server.
879	#
880	itcl::body Rappture::FlowvisViewer::Disconnect {} {
881	VisViewer::Disconnect
882
883	# disconnected -- no more data sitting on server
884	set _outbuf ""
885	array unset _serverObjs
886	set _sendobjs ""
887	}
888
889	#
890	# SendCmd
891	#
892	# Send commands off to the rendering server. If we're currently
893	# sending data objects to the server, buffer the commands to be
894	# sent later.
895	#
896	itcl::body Rappture::FlowvisViewer::SendCmd { string } {
897	if { $_buffering } {
898	append _outbuf $string "\n"
899	} else {
900	foreach line [split $string \n] {
901	SendEcho >>line $line
902	}
903	SendBytes "$string\n"
904	}
905	}
906
907	# ----------------------------------------------------------------------
908	# USAGE: SendDataObjs
909	#
910	# Used internally to send a series of volume objects off to the
911	# server. Sends each object, a little at a time, with updates in
912	# between so the interface doesn't lock up.
913	# ----------------------------------------------------------------------
914	itcl::body Rappture::FlowvisViewer::SendDataObjs {} {
915	blt::busy hold $itk_component(hull)
916	foreach dataobj $_sendobjs {
917	foreach comp [$dataobj components] {
918	# Send the data as one huge base64-encoded mess -- yuck!
919	set data [$dataobj blob $comp]
920	set nbytes [string length $data]
921	set extents [$dataobj extents $comp]
922
923	# I have a field. Is a vector field or a volume field?
924	if { $extents == 1 } {
925	set cmd "volume data follows $nbytes $dataobj-$comp\n"
926	} else {
927	set cmd [FlowCmd $dataobj $comp $nbytes $extents]
928	if { $cmd == "" } {
929	puts stderr "no command"
930	continue
931	}
932	}
933	f { ![SendBytes $cmd] } {
934	puts stderr "can't send"
935	return
936	}
937	if { ![SendBytes $data] } {
938	puts stderr "can't send"
939	return
940	}
941	NameTransferFunc $dataobj $comp
942	set _recvObjs($dataobj-$comp) 1
943	}
944	}
945	set _sendobjs ""
946	blt::busy release $itk_component(hull)
947
948	# Turn on buffering of commands to the server. We don't want to
949	# be preempted by a server disconnect/reconnect (which automatically
950	# generates a new call to Rebuild).
951	set _buffering 1
952
953	# activate the proper volume
954	set _first [lindex [get] 0]
955	if { "" != $_first } {
956	set axis [$_first hints updir]
957	if {"" != $axis} {
958	SendCmd "up $axis"
959	}
960
961	if 0 {
962	set location [$_first hints camera]
963	if { $location != "" } {
964	array set _view $location
965	}
966	set _settings($this-theta) $_view(theta)
967	set _settings($this-phi) $_view(phi)
968	set _settings($this-psi) $_view(psi)
969	set _settings($this-pan-x) $_view(pan-x)
970	set _settings($this-pan-y) $_view(pan-y)
971	set _settings($this-zoom) $_view(zoom)
972	set xyz [Euler2XYZ $_view(theta) $_view(phi) $_view(psi)]
973	SendCmd "camera angle $xyz"
974	PanCamera
975	SendCmd "camera zoom $_view(zoom)"
976	}
977	# The active transfer function is by default the first component of
978	# the first data object. This assumes that the data is always
979	# successfully transferred.
980	set comp [lindex [$_first components] 0]
981	set _activeTf [lindex $_obj2style($_first-$comp) 0]
982	}
983
984	SendCmd "flow reset"
985
986	# Actually write the commands to the server socket. If it fails, we don't
987	# care. We're finished here.
988	SendBytes $_outbuf;
989	set _buffering 0; # Turn off buffering.
990	set _outbuf ""; # Clear the buffer.
991	}
992
993	# ----------------------------------------------------------------------
994	# USAGE: SendTransferFuncs
995	# ----------------------------------------------------------------------
996	itcl::body Rappture::FlowvisViewer::SendTransferFuncs {} {
997	if { $_activeTf == "" } {
998	puts stderr "no active tf"
999	return
1000	}
1001	set tf $_activeTf
1002	if { $_first == "" } {
1003	puts stderr "no first"
1004	return
1005	}
1006
1007	# Insure that the global opacity and thickness settings (in the slider
1008	# settings widgets) are used for the active transfer-function. Update the
1009	# values in the _settings varible.
1010	set value $_settings($this-opacity)
1011	set opacity [expr { double($value) * 0.01 }]
1012	set _settings($this-$tf-opacity) $opacity
1013	set value $_settings($this-thickness)
1014	# Scale values between 0.00001 and 0.01000
1015	set thickness [expr {double($value) * 0.0001}]
1016	set _settings($this-$tf-thickness) $thickness
1017
1018	foreach key [array names _obj2style $_first-*] {
1019	if { [info exists _obj2style($key)] } {
1020	foreach tf $_obj2style($key) {
1021	ComputeTransferFunc $tf
1022	}
1023	}
1024	}
1025	EventuallyResizeLegend
1026	}
1027
1028	# ----------------------------------------------------------------------
1029	# USAGE: ReceiveImage -bytes $size -type $type -token $token
1030	#
1031	# Invoked automatically whenever the "image" command comes in from
1032	# the rendering server. Indicates that binary image data with the
1033	# specified <size> will follow.
1034	# ----------------------------------------------------------------------
1035	itcl::body Rappture::FlowvisViewer::ReceiveImage { args } {
1036	array set info {
1037	-token "???"
1038	-bytes 0
1039	-type image
1040	}
1041	array set info $args
1042	set bytes [ReceiveBytes $info(-bytes)]
1043	ReceiveEcho <<line "<read $info(-bytes) bytes"
1044	switch -- $info(-type) {
1045	"image" {
1046	$_image(plot) configure -data $bytes
1047	#puts stderr "image received [image width $_image(plot)] by [image height $_image(plot)]"
1048	}
1049	"print" {
1050	set tag $this-$info(-token)
1051	set _hardcopy($tag) $bytes
1052	}
1053	"movie" {
1054	puts stderr "read [string length $bytes] bytes type=$info(-type) token=$info(-token)"
1055	set tag $this-$info(-token)
1056	set _hardcopy($tag) $bytes
1057	}
1058	default {
1059	puts stderr "unknown download type $info(-type)"
1060	}
1061	}
1062	}
1063
1064	#
1065	# ReceiveLegend --
1066	#
1067	# The procedure is the response from the render server to each "legend"
1068	# command. The server sends back a "legend" command invoked our
1069	# the slave interpreter. The purpose is to collect data of the image
1070	# representing the legend in the canvas. In addition, the isomarkers
1071	# of the active transfer function are displayed.
1072	#
1073	# I don't know is this is the right place to display the isomarkers.
1074	# I don't know all the different paths used to draw the plot. There's
1075	# "Rebuild", "add", etc.
1076	#
1077	itcl::body Rappture::FlowvisViewer::ReceiveLegend { tag vmin vmax size } {
1078	if { ![isconnected] } {
1079	return
1080	}
1081	#puts stderr "receive legend $tag $vmin $vmax $size"
1082	set bytes [ReceiveBytes $size]
1083	$_image(legend) configure -data $bytes
1084	ReceiveEcho <<line "<read $size bytes for [image width $_image(legend)]x[image height $_image(legend)] legend>"
1085
1086	set c $itk_component(legend)
1087	set w [winfo width $c]
1088	set h [winfo height $c]
1089	set lx 10
1090	set ly [expr {$h - 1}]
1091	if {"" == [$c find withtag transfunc]} {
1092	$c create image 10 10 -anchor nw \
1093	-image $_image(legend) -tags transfunc
1094	$c create text $lx $ly -anchor sw \
1095	-fill $itk_option(-plotforeground) -tags "limits vmin"
1096	$c create text [expr {$w-$lx}] $ly -anchor se \
1097	-fill $itk_option(-plotforeground) -tags "limits vmax"
1098	$c lower transfunc
1099	$c bind transfunc <ButtonRelease-1> \
1100	[itcl::code $this AddIsoMarker %x %y]
1101	}
1102	# Display the markers used by the active transfer function.
1103	set tf $_obj2style($tag)
1104	array set limits [limits $tf]
1105	$c itemconfigure vmin -text [format %.2g $limits(vmin)]
1106	$c coords vmin $lx $ly
1107
1108	$c itemconfigure vmax -text [format %.2g $limits(vmax)]
1109	$c coords vmax [expr {$w-$lx}] $ly
1110
1111	if { [info exists _isomarkers($tf)] } {
1112	foreach m $_isomarkers($tf) {
1113	$m visible yes
1114	}
1115	}
1116	}
1117
1118	#
1119	# ReceiveData --
1120	#
1121	# The procedure is the response from the render server to each "data
1122	# follows" command. The server sends back a "data" command invoked our
1123	# the slave interpreter. The purpose is to collect the min/max of the
1124	# volume sent to the render server. Since the client (flowvisviewer)
1125	# doesn't parse 3D data formats, we rely on the server (flowvis) to
1126	# tell us what the limits are. Once we've received the limits to all
1127	# the data we've sent (tracked by _recvObjs) we can then determine
1128	# what the transfer functions are for these # volumes.
1129	#
1130	# Note: There is a considerable tradeoff in having the server report
1131	# back what the data limits are. It means that much of the code
1132	# having to do with transfer-functions has to wait for the data
1133	# to come back, since the isomarkers are calculated based upon
1134	# the data limits. The client code is much messier because of
1135	# this. The alternative is to parse any of the 3D formats on the
1136	# client side.
1137	#
1138	itcl::body Rappture::FlowvisViewer::ReceiveData { args } {
1139	if { ![isconnected] } {
1140	return
1141	}
1142	# Arguments from server are name value pairs. Stuff them in an array.
1143	array set values $args
1144	set tag $values(tag)
1145	set parts [split $tag -]
1146	set dataobj [lindex $parts 0]
1147	set _serverObjs($tag) 0
1148	set _limits($tag-min) $values(min); # Minimum value of the volume.
1149	set _limits($tag-max) $values(max); # Maximum value of the volume.
1150	unset _recvObjs($tag)
1151	if { [array size _recvObjs] == 0 } {
1152	updatetransferfuncs
1153	}
1154	}
1155
1156	#
1157	# Rebuild --
1158	#
1159	# Called automatically whenever something changes that affects the data
1160	# in the widget. Clears any existing data and rebuilds the widget to
1161	# display new data.
1162	#
1163	itcl::body Rappture::FlowvisViewer::Rebuild {} {
1164
1165	# Hide all the isomarkers. Can't remove them. Have to remember the
1166	# settings since the user may have created/deleted/moved markers.
1167
1168	foreach tf [array names _isomarkers] {
1169	foreach m $_isomarkers($tf) {
1170	$m visible no
1171	}
1172	}
1173
1174	set _first ""
1175	# Turn on buffering of commands to the server. We don't want to
1176	# be preempted by a server disconnect/reconnect (which automatically
1177	# generates a new call to Rebuild).
1178	set _buffering 1
1179
1180	set w [winfo width $itk_component(3dview)]
1181	set h [winfo height $itk_component(3dview)]
1182	EventuallyResize $w $h
1183
1184	foreach dataobj [get] {
1185	foreach comp [$dataobj components] {
1186	# Send the data as one huge base64-encoded mess -- yuck!
1187	set data [$dataobj blob $comp]
1188	set nbytes [string length $data]
1189	set extents [$dataobj extents $comp]
1190	# I have a field. Is a vector field or a volume field?
1191	if { $extents == 1 } {
1192	set cmd "volume data follows $nbytes $dataobj-$comp\n"
1193	} else {
1194	set cmd [FlowCmd $dataobj $comp $nbytes $extents]
1195	if { $cmd == "" } {
1196	puts stderr "no command"
1197	continue
1198	}
1199	}
1200	append _outbuf $cmd
1201	append _outbuf $data
1202	NameTransferFunc $dataobj $comp
1203	set _recvObjs($dataobj-$comp) 1
1204	}
1205	}
1206
1207	set _first [lindex [get] 0]
1208
1209	# Reset the camera and other view parameters
1210	FixSettings isosurface
1211	FixSettings grid
1212	FixSettings axes
1213	FixSettings volume
1214	FixSettings outline
1215	FixSettings light
1216	FixSettings transp
1217
1218	# nothing to send -- activate the proper volume
1219	if {"" != $_first} {
1220	FixSettings light
1221	FixSettings transp
1222	set axis [$_first hints updir]
1223	if {"" != $axis} {
1224	SendCmd "up $axis"
1225	}
1226	set location [$_first hints camera]
1227	if { $location != "" } {
1228	array set _view $location
1229	}
1230	}
1231	set _settings($this-theta) $_view(theta)
1232	set _settings($this-phi) $_view(phi)
1233	set _settings($this-psi) $_view(psi)
1234	set _settings($this-pan-x) $_view(pan-x)
1235	set _settings($this-pan-y) $_view(pan-y)
1236	set _settings($this-zoom) $_view(zoom)
1237
1238	set xyz [Euler2XYZ $_view(theta) $_view(phi) $_view(psi)]
1239	SendCmd "camera angle $xyz"
1240	PanCamera
1241	SendCmd "camera zoom $_view(zoom)"
1242
1243	foreach dataobj [get] {
1244	foreach comp [$dataobj components] {
1245	NameTransferFunc $dataobj $comp
1246	}
1247	}
1248
1249	# nothing to send -- activate the proper ivol
1250	set _first [lindex [get] 0]
1251	if {"" != $_first} {
1252	set axis [$_first hints updir]
1253	if {"" != $axis} {
1254	SendCmd "up $axis"
1255	}
1256	set location [$_first hints camera]
1257	if { $location != "" } {
1258	array set _view $location
1259	}
1260	set comp [lindex [$_first components] 0]
1261	set _activeTf [lindex $_obj2style($_first-$comp) 0]
1262	}
1263
1264
1265	# sync the state of slicers
1266	set vols [CurrentVolumeIds -cutplanes]
1267	foreach axis {x y z} {
1268	SendCmd "cutplane state $_settings($this-${axis}cutplane) $axis $vols"
1269	set pos [expr {0.01*$_settings($this-${axis}cutposition)}]
1270	SendCmd "cutplane position $pos $axis $vols"
1271	}
1272	SendCmd "volume data state $_settings($this-volume)"
1273	EventuallyResizeLegend
1274
1275	# Actually write the commands to the server socket. If it fails, we don't
1276	# care. We're finished here.
1277	blt::busy hold $itk_component(hull)
1278	SendBytes $_outbuf
1279	blt::busy release $itk_component(hull)
1280	set _buffering 0; # Turn off buffering.
1281	set _outbuf ""; # Clear the buffer.
1282	}
1283
1284	# ----------------------------------------------------------------------
1285	# USAGE: CurrentVolumeIds ?-cutplanes?
1286	#
1287	# Returns a list of volume server IDs for the current volume being
1288	# displayed. This is normally a single ID, but it might be a list
1289	# of IDs if the current data object has multiple components.
1290	# ----------------------------------------------------------------------
1291	itcl::body Rappture::FlowvisViewer::CurrentVolumeIds {{what -all}} {
1292	return ""
1293	if { $_first == "" } {
1294	return
1295	}
1296	foreach key [array names _serverObjs -] {
1297	if {[string match $_first-* $key]} {
1298	array set style {
1299	-cutplanes 1
1300	}
1301	foreach {dataobj comp} [split $key -] break
1302	array set style [lindex [$dataobj components -style $comp] 0]
1303	if {$what != "-cutplanes" \|\| $style(-cutplanes)} {
1304	lappend rlist $_serverObjs($key)
1305	}
1306	}
1307	}
1308	return $rlist
1309	}
1310
1311	# ----------------------------------------------------------------------
1312	# USAGE: Zoom in
1313	# USAGE: Zoom out
1314	# USAGE: Zoom reset
1315	#
1316	# Called automatically when the user clicks on one of the zoom
1317	# controls for this widget. Changes the zoom for the current view.
1318	# ----------------------------------------------------------------------
1319	itcl::body Rappture::FlowvisViewer::Zoom {option} {
1320	switch -- $option {
1321	"in" {
1322	set _view(zoom) [expr {$_view(zoom)*1.25}]
1323	set _settings($this-zoom) $_view(zoom)
1324	}
1325	"out" {
1326	set _view(zoom) [expr {$_view(zoom)*0.8}]
1327	set _settings($this-zoom) $_view(zoom)
1328	}
1329	"reset" {
1330	array set _view {
1331	theta 45
1332	phi 45
1333	psi 0
1334	zoom 1.0
1335	pan-x 0
1336	pan-y 0
1337	}
1338	if { $_first != "" } {
1339	set location [$_first hints camera]
1340	if { $location != "" } {
1341	array set _view $location
1342	}
1343	}
1344	set xyz [Euler2XYZ $_view(theta) $_view(phi) $_view(psi)]
1345	SendCmd "camera angle $xyz"
1346	PanCamera
1347	set _settings($this-theta) $_view(theta)
1348	set _settings($this-phi) $_view(phi)
1349	set _settings($this-psi) $_view(psi)
1350	set _settings($this-pan-x) $_view(pan-x)
1351	set _settings($this-pan-y) $_view(pan-y)
1352	set _settings($this-zoom) $_view(zoom)
1353	}
1354	}
1355	SendCmd "camera zoom $_view(zoom)"
1356	}
1357
1358	itcl::body Rappture::FlowvisViewer::PanCamera {} {
1359	#set x [expr ($_view(pan-x)) / $_limits(xrange)]
1360	#set y [expr ($_view(pan-y)) / $_limits(yrange)]
1361	set x $_view(pan-x)
1362	set y $_view(pan-y)
1363	SendCmd "camera pan $x $y"
1364	}
1365
1366	# ----------------------------------------------------------------------
1367	# USAGE: Rotate click <x> <y>
1368	# USAGE: Rotate drag <x> <y>
1369	# USAGE: Rotate release <x> <y>
1370	#
1371	# Called automatically when the user clicks/drags/releases in the
1372	# plot area. Moves the plot according to the user's actions.
1373	# ----------------------------------------------------------------------
1374	itcl::body Rappture::FlowvisViewer::Rotate {option x y} {
1375	switch -- $option {
1376	click {
1377	$itk_component(3dview) configure -cursor fleur
1378	set _click(x) $x
1379	set _click(y) $y
1380	set _click(theta) $_view(theta)
1381	set _click(phi) $_view(phi)
1382	}
1383	drag {
1384	if {[array size _click] == 0} {
1385	Rotate click $x $y
1386	} else {
1387	set w [winfo width $itk_component(3dview)]
1388	set h [winfo height $itk_component(3dview)]
1389	if {$w <= 0 \|\| $h <= 0} {
1390	return
1391	}
1392
1393	if {[catch {
1394	# this fails sometimes for no apparent reason
1395	set dx [expr {double($x-$_click(x))/$w}]
1396	set dy [expr {double($y-$_click(y))/$h}]
1397	}]} {
1398	return
1399	}
1400
1401	#
1402	# Rotate the camera in 3D
1403	#
1404	if {$_view(psi) > 90 \|\| $_view(psi) < -90} {
1405	# when psi is flipped around, theta moves backwards
1406	set dy [expr {-$dy}]
1407	}
1408	set theta [expr {$_view(theta) - $dy*180}]
1409	while {$theta < 0} { set theta [expr {$theta+180}] }
1410	while {$theta > 180} { set theta [expr {$theta-180}] }
1411
1412	if {abs($theta) >= 30 && abs($theta) <= 160} {
1413	set phi [expr {$_view(phi) - $dx*360}]
1414	while {$phi < 0} { set phi [expr {$phi+360}] }
1415	while {$phi > 360} { set phi [expr {$phi-360}] }
1416	set psi $_view(psi)
1417	} else {
1418	set phi $_view(phi)
1419	set psi [expr {$_view(psi) - $dx*360}]
1420	while {$psi < -180} { set psi [expr {$psi+360}] }
1421	while {$psi > 180} { set psi [expr {$psi-360}] }
1422	}
1423
1424	set _view(theta) $theta
1425	set _view(phi) $phi
1426	set _view(psi) $psi
1427	set xyz [Euler2XYZ $theta $phi $psi]
1428	set _settings($this-theta) $_view(theta)
1429	set _settings($this-phi) $_view(phi)
1430	set _settings($this-psi) $_view(psi)
1431	SendCmd "camera angle $xyz"
1432	set _click(x) $x
1433	set _click(y) $y
1434	}
1435	}
1436	release {
1437	Rotate drag $x $y
1438	$itk_component(3dview) configure -cursor ""
1439	catch {unset _click}
1440	}
1441	default {
1442	error "bad option \"$option\": should be click, drag, release"
1443	}
1444	}
1445	}
1446
1447	# ----------------------------------------------------------------------
1448	# USAGE: $this Pan click x y
1449	# $this Pan drag x y
1450	# $this Pan release x y
1451	#
1452	# Called automatically when the user clicks on one of the zoom
1453	# controls for this widget. Changes the zoom for the current view.
1454	# ----------------------------------------------------------------------
1455	itcl::body Rappture::FlowvisViewer::Pan {option x y} {
1456	# Experimental stuff
1457	set w [winfo width $itk_component(3dview)]
1458	set h [winfo height $itk_component(3dview)]
1459	if { $option == "set" } {
1460	set x [expr $x / double($w)]
1461	set y [expr $y / double($h)]
1462	set _view(pan-x) [expr $_view(pan-x) + $x]
1463	set _view(pan-y) [expr $_view(pan-y) + $y]
1464	PanCamera
1465	set _settings($this-pan-x) $_view(pan-x)
1466	set _settings($this-pan-y) $_view(pan-y)
1467	return
1468	}
1469	if { $option == "click" } {
1470	set _click(x) $x
1471	set _click(y) $y
1472	$itk_component(3dview) configure -cursor hand1
1473	}
1474	if { $option == "drag" \|\| $option == "release" } {
1475	set dx [expr ($_click(x) - $x)/double($w)]
1476	set dy [expr ($_click(y) - $y)/double($h)]
1477	set _click(x) $x
1478	set _click(y) $y
1479	set _view(pan-x) [expr $_view(pan-x) - $dx]
1480	set _view(pan-y) [expr $_view(pan-y) - $dy]
1481	PanCamera
1482	set _settings($this-pan-x) $_view(pan-x)
1483	set _settings($this-pan-y) $_view(pan-y)
1484	}
1485	if { $option == "release" } {
1486	$itk_component(3dview) configure -cursor ""
1487	}
1488	}
1489
1490
1491	# ----------------------------------------------------------------------
1492	# USAGE: Flow movie record\|stop\|play ?on\|off\|toggle?
1493	#
1494	# Called when the user clicks on the record, stop or play buttons
1495	# for flow visualization.
1496	# ----------------------------------------------------------------------
1497	itcl::body Rappture::FlowvisViewer::Flow {option args} {
1498	switch -- $option {
1499	movie {
1500	if {[llength $args] < 1 \|\| [llength $args] > 2} {
1501	error "wrong # args: should be \"Flow movie record\|stop\|play ?on\|off\|toggle?\""
1502	}
1503	set action [lindex $args 0]
1504	set op [lindex $args 1]
1505	if {$op == ""} { set op "on" }
1506
1507	set current [State $action]
1508	if {$op == "toggle"} {
1509	if {$current == "on"} {
1510	set op "off"
1511	} else {
1512	set op "on"
1513	}
1514	}
1515	set cmds ""
1516	switch -- $action {
1517	record {
1518	if { [$itk_component(rewind) cget -relief] != "sunken" } {
1519	$itk_component(rewind) configure -relief sunken
1520	$itk_component(stop) configure -relief raised
1521	$itk_component(play) configure -relief raised
1522	set inner $itk_component(settingsFrame)
1523	set frames [$inner.framecnt value]
1524	set _settings(nsteps) $frames
1525	set cmds "flow capture $frames"
1526	SendCmd $cmds
1527	}
1528	}
1529	stop {
1530	if { [$itk_component(stop) cget -relief] != "sunken" } {
1531	$itk_component(rewind) configure -relief raised
1532	$itk_component(stop) configure -relief sunken
1533	$itk_component(play) configure -relief raised
1534	_pause
1535	set cmds "flow reset"
1536	SendCmd $cmds
1537	}
1538	}
1539	play {
1540	if { [$itk_component(play) cget -relief] != "sunken" } {
1541	$itk_component(rewind) configure -relief raised
1542	$itk_component(stop) configure -relief raised
1543	$itk_component(play) configure \
1544	-image [Rappture::icon flow-pause] \
1545	-relief sunken
1546	bind $itk_component(play) <ButtonPress> \
1547	[itcl::code $this _pause]
1548	flow next
1549	}
1550	}
1551	default {
1552	error "bad option \"$option\": should be one of record\|stop\|play"
1553	}
1554
1555	}
1556	}
1557	default {
1558	error "bad option \"$option\": should be movie"
1559	}
1560	}
1561	}
1562
1563	# ----------------------------------------------------------------------
1564	# USAGE: Play
1565	#
1566	# ----------------------------------------------------------------------
1567	itcl::body Rappture::FlowvisViewer::Play {} {
1568	SendCmd "flow next"
1569	set delay [expr {int(ceil(pow($_settings(speed)/10.0+2,2.0)*15))}]
1570	$_dispatcher event -after $delay !play
1571	}
1572
1573	# ----------------------------------------------------------------------
1574	# USAGE: Pause
1575	#
1576	# Invoked when the user hits the "pause" button to stop playing the
1577	# current sequence of frames as a movie.
1578	# ----------------------------------------------------------------------
1579	itcl::body Rappture::FlowvisViewer::Pause {} {
1580	$_dispatcher cancel !play
1581
1582	# Toggle the button to "play" mode
1583	$itk_component(play) configure \
1584	-image [Rappture::icon flow-start] \
1585	-relief raised
1586	bind $itk_component(play) <ButtonPress> \
1587	[itcl::code $this Flow movie play toggle]
1588	}
1589
1590	# ----------------------------------------------------------------------
1591	# USAGE: FixSettings <what> ?<value>?
1592	#
1593	# Used internally to update rendering settings whenever parameters
1594	# change in the popup settings panel. Sends the new settings off
1595	# to the back end.
1596	# ----------------------------------------------------------------------
1597	itcl::body Rappture::FlowvisViewer::FixSettings {what {value ""}} {
1598	switch -- $what {
1599	light {
1600	if { $_first != "" } {
1601	set comp [lindex [$_first components] 0]
1602	set tag $_first-$comp
1603	set diffuse [expr {0.1*$_settings($this-light)}]
1604	set specular [expr {sqrt($_settings($this-light)+1.0)}]
1605	SendCmd "$tag configure -diffuse $diffuse -specular $specular"
1606	}
1607	}
1608	transp {
1609	if { $_first != "" } {
1610	set comp [lindex [$_first components] 0]
1611	set tag $_first-$comp
1612	set opacity [expr {0.2*$_settings($this-transp)+1}]
1613	SendCmd "$tag configure -opacity $opacity"
1614	}
1615	}
1616	opacity {
1617	if { $_first != "" && $_activeTf != "" } {
1618	set opacity [expr { 0.01 * double($_settings($this-opacity)) }]
1619	set tf $_activeTf
1620	set _settings($this-$tf-opacity) $opacity
1621	updatetransferfuncs
1622	}
1623	}
1624
1625	thickness {
1626	if { $_first != "" && $_activeTf != "" } {
1627	set val $_settings($this-thickness)
1628	# Scale values between 0.00001 and 0.01000
1629	set sval [expr {0.0001*double($val)}]
1630	set tf $_activeTf
1631	set _settings($this-$tf-thickness) $sval
1632	updatetransferfuncs
1633	}
1634	}
1635	"outline" {
1636	if { $_first != "" } {
1637	set comp [lindex [$_first components] 0]
1638	set tag $_first-$comp
1639	SendCmd "$tag configure -outline $_settings($this-outline)"
1640	}
1641	}
1642	"isosurface" {
1643	if { [isconnected] } {
1644	SendCmd "volume shading isosurface $_settings($this-isosurface)"
1645	}
1646	}
1647	"grid" {
1648	if { [isconnected] } {
1649	SendCmd "grid visible $_settings($this-grid)"
1650	}
1651	}
1652	"axes" {
1653	if { [isconnected] } {
1654	SendCmd "axis visible $_settings($this-axes)"
1655	}
1656	}
1657	"legend" {
1658	if { $_settings($this-legend) } {
1659	blt::table $itk_component(plotarea) \
1660	0,0 $itk_component(3dview) -fill both \
1661	1,0 $itk_component(legend) -fill x
1662	blt::table configure $itk_component(plotarea) r1 -resize none
1663	} else {
1664	blt::table forget $itk_component(legend)
1665	}
1666	}
1667	"volume" {
1668	if { $_first != "" } {
1669	set comp [lindex [$_first components] 0]
1670	set tag $_first-$comp
1671	SendCmd "$tag configure -volume $_settings($this-volume)"
1672	}
1673	}
1674	"xcutplane" - "ycutplane" - "zcutplane" {
1675	set axis [string range $what 0 0]
1676	set bool $_settings($this-$what)
1677	if { [isconnected] } {
1678	set vols [CurrentVolumeIds -cutplanes]
1679	SendCmd "cutplane state $bool $axis $vols"
1680	}
1681	if { $bool } {
1682	$itk_component(${axis}CutScale) configure -state normal \
1683	-troughcolor white
1684	} else {
1685	$itk_component(${axis}CutScale) configure -state disabled \
1686	-troughcolor grey82
1687	}
1688	}
1689	default {
1690	error "don't know how to fix $what"
1691	}
1692	}
1693	}
1694
1695	# ----------------------------------------------------------------------
1696	# USAGE: ResizeLegend
1697	#
1698	# Used internally to update the legend area whenever it changes size
1699	# or when the field changes. Asks the server to send a new legend
1700	# for the current field.
1701	# ----------------------------------------------------------------------
1702	itcl::body Rappture::FlowvisViewer::ResizeLegend {} {
1703	set _resizeLegendPending 0
1704	set lineht [font metrics $itk_option(-font) -linespace]
1705	set w [expr {$_width-20}]
1706	set h [expr {[winfo height $itk_component(legend)]-20-$lineht}]
1707
1708	if { $_first == "" } {
1709	return
1710	}
1711	set comp [lindex [$_first components] 0]
1712	set tag $_first-$comp
1713	#set _activeTf [lindex $_obj2style($tag) 0]
1714	if {$w > 0 && $h > 0 && "" != $_activeTf} {
1715	#SendCmd "legend $_activeTf $w $h"
1716	SendCmd "$tag legend $w $h"
1717	} else {
1718	# Can't do this as this will remove the items associated with the
1719	# isomarkers.
1720
1721	#$itk_component(legend) delete all
1722	}
1723	}
1724
1725	#
1726	# NameTransferFunc --
1727	#
1728	# Creates a transfer function name based on the <style> settings in the
1729	# library run.xml file. This placeholder will be used later to create
1730	# and send the actual transfer function once the data info has been sent
1731	# to us by the render server. [We won't know the volume limits until the
1732	# server parses the 3D data and sends back the limits via ReceiveData.]
1733	#
1734	# FIXME: The current way we generate transfer-function names completely
1735	# ignores the -markers option. The problem is that we are forced
1736	# to compute the name from an increasing complex set of values:
1737	# color, levels, marker, opacity. I think we're stuck doing it
1738	# now.
1739	#
1740	itcl::body Rappture::FlowvisViewer::NameTransferFunc { dataobj comp } {
1741	array set style {
1742	-color rainbow
1743	-levels 6
1744	-opacity 1.0
1745	-light 40
1746	-transp 50
1747	}
1748	array set style [lindex [$dataobj components -style $comp] 0]
1749	set _settings($this-light) $style(-light)
1750	set _settings($this-transp) $style(-transp)
1751	set _settings($this-opacity) [expr $style(-opacity) * 100]
1752	set tf "$style(-color):$style(-levels):$style(-opacity)"
1753	set _obj2style($dataobj-$comp) $tf
1754	lappend _style2objs($tf) $dataobj $comp
1755	return $tf
1756	}
1757
1758	#
1759	# ComputeTransferFunc --
1760	#
1761	# Computes and sends the transfer function to the render server. It's
1762	# assumed that the volume data limits are known and that the global
1763	# transfer-functions slider values have be setup. Both parts are
1764	# needed to compute the relative value (location) of the marker, and
1765	# the alpha map of the transfer function.
1766	#
1767	itcl::body Rappture::FlowvisViewer::ComputeTransferFunc { tf } {
1768	array set style {
1769	-color rainbow
1770	-levels 6
1771	-opacity 1.0
1772	-light 40
1773	-transp 50
1774	}
1775	set dataobj ""; set comp ""
1776	foreach {dataobj comp} $_style2objs($tf) break
1777	if { $dataobj == "" } {
1778	return 0
1779	}
1780	array set style [lindex [$dataobj components -style $comp] 0]
1781
1782
1783	# We have to parse the style attributes for a volume using this
1784	# transfer-function once. This sets up the initial isomarkers for the
1785	# transfer function. The user may add/delete markers, so we have to
1786	# maintain a list of markers for each transfer-function. We use the one
1787	# of the volumes (the first in the list) using the transfer-function as a
1788	# reference.
1789	#
1790	# FIXME: The current way we generate transfer-function names completely
1791	# ignores the -markers option. The problem is that we are forced
1792	# to compute the name from an increasing complex set of values:
1793	# color, levels, marker, opacity. I think the cow's out of the
1794	# barn on this one.
1795
1796	if { ![info exists _isomarkers($tf)] } {
1797	# Have to defer creation of isomarkers until we have data limits
1798	if { [info exists style(-markers)] } {
1799	ParseMarkersOption $tf $style(-markers)
1800	} else {
1801	ParseLevelsOption $tf $style(-levels)
1802	}
1803	}
1804	if {$style(-color) == "rainbow"} {
1805	set style(-color) "white:yellow:green:cyan:blue:magenta"
1806	}
1807	if { [info exists style(-nonuniformcolors)] } {
1808	foreach { value color } $style(-nonuniformcolors) {
1809	append cmap "$value [Color2RGB $color] "
1810	}
1811	} else {
1812	set clist [split $style(-color) :]
1813	set cmap "0.0 [Color2RGB white] "
1814	for {set i 0} {$i < [llength $clist]} {incr i} {
1815	set x [expr {double($i+1)/([llength $clist]+1)}]
1816	set color [lindex $clist $i]
1817	append cmap "$x [Color2RGB $color] "
1818	}
1819	append cmap "1.0 [Color2RGB $color]"
1820	}
1821	set tag $this-$tf
1822	if { ![info exists _settings($tag-opacity)] } {
1823	set _settings($tag-opacity) $style(-opacity)
1824	}
1825	set max $_settings($tag-opacity)
1826
1827	set isovalues {}
1828	foreach m $_isomarkers($tf) {
1829	lappend isovalues [$m relval]
1830	}
1831	# Sort the isovalues
1832	set isovalues [lsort -real $isovalues]
1833
1834	if { ![info exists _settings($tag-thickness)]} {
1835	set _settings($tag-thickness) 0.05
1836	}
1837	set delta $_settings($tag-thickness)
1838
1839	set first [lindex $isovalues 0]
1840	set last [lindex $isovalues end]
1841	set wmap ""
1842	if { $first == "" \|\| $first != 0.0 } {
1843	lappend wmap 0.0 0.0
1844	}
1845	foreach x $isovalues {
1846	set x1 [expr {$x-$delta-0.00001}]
1847	set x2 [expr {$x-$delta}]
1848	set x3 [expr {$x+$delta}]
1849	set x4 [expr {$x+$delta+0.00001}]
1850	if { $x1 < 0.0 } {
1851	set x1 0.0
1852	} elseif { $x1 > 1.0 } {
1853	set x1 1.0
1854	}
1855	if { $x2 < 0.0 } {
1856	set x2 0.0
1857	} elseif { $x2 > 1.0 } {
1858	set x2 1.0
1859	}
1860	if { $x3 < 0.0 } {
1861	set x3 0.0
1862	} elseif { $x3 > 1.0 } {
1863	set x3 1.0
1864	}
1865	if { $x4 < 0.0 } {
1866	set x4 0.0
1867	} elseif { $x4 > 1.0 } {
1868	set x4 1.0
1869	}
1870	# add spikes in the middle
1871	lappend wmap $x1 0.0
1872	lappend wmap $x2 $max
1873	lappend wmap $x3 $max
1874	lappend wmap $x4 0.0
1875	}
1876	if { $last == "" \|\| $last != 1.0 } {
1877	lappend wmap 1.0 0.0
1878	}
1879	SendCmd "transfunc define $tf { $cmap } { $wmap }\n"
1880	return [SendCmd "$dataobj-$comp configure -transferfunction $tf\n"]
1881	}
1882
1883	# ----------------------------------------------------------------------
1884	# CONFIGURATION OPTION: -plotbackground
1885	# ----------------------------------------------------------------------
1886	itcl::configbody Rappture::FlowvisViewer::plotbackground {
1887	if { [isconnected] } {
1888	foreach {r g b} [Color2RGB $itk_option(-plotbackground)] break
1889	#fix this!
1890	#SendCmd "color background $r $g $b"
1891	}
1892	}
1893
1894	# ----------------------------------------------------------------------
1895	# CONFIGURATION OPTION: -plotforeground
1896	# ----------------------------------------------------------------------
1897	itcl::configbody Rappture::FlowvisViewer::plotforeground {
1898	if { [isconnected] } {
1899	foreach {r g b} [Color2RGB $itk_option(-plotforeground)] break
1900	#fix this!
1901	#SendCmd "color background $r $g $b"
1902	}
1903	}
1904
1905	# ----------------------------------------------------------------------
1906	# CONFIGURATION OPTION: -plotoutline
1907	# ----------------------------------------------------------------------
1908	itcl::configbody Rappture::FlowvisViewer::plotoutline {
1909	# Must check if we are connected because this routine is called from the
1910	# class body when the -plotoutline itk_option is defined. At that point
1911	# the FlowvisViewer class constructor hasn't been called, so we can't
1912	# start sending commands to visualization server.
1913	if { [isconnected] } {
1914	if {"" == $itk_option(-plotoutline)} {
1915	SendCmd "volume outline state off"
1916	} else {
1917	SendCmd "volume outline state on"
1918	SendCmd "volume outline color [Color2RGB $itk_option(-plotoutline)]"
1919	}
1920	}
1921	}
1922
1923	#
1924	# The -levels option takes a single value that represents the number
1925	# of evenly distributed markers based on the current data range. Each
1926	# marker is a relative value from 0.0 to 1.0.
1927	#
1928	itcl::body Rappture::FlowvisViewer::ParseLevelsOption { tf levels } {
1929	set c $itk_component(legend)
1930	regsub -all "," $levels " " levels
1931	if {[string is int $levels]} {
1932	for {set i 1} { $i <= $levels } {incr i} {
1933	set x [expr {double($i)/($levels+1)}]
1934	set m [Rappture::IsoMarker \#auto $c $this $tf]
1935	$m relval $x
1936	lappend _isomarkers($tf) $m
1937	}
1938	} else {
1939	foreach x $levels {
1940	set m [Rappture::IsoMarker \#auto $c $this $tf]
1941	$m relval $x
1942	lappend _isomarkers($tf) $m
1943	}
1944	}
1945	}
1946
1947	#
1948	# The -markers option takes a list of zero or more values (the values
1949	# may be separated either by spaces or commas) that have the following
1950	# format:
1951	#
1952	# N% Percent of current total data range. Converted to
1953	# to a relative value between 0.0 and 1.0.
1954	# N Absolute value of marker. If the marker is outside of
1955	# the current range, it will be displayed on the outer
1956	# edge of the legends, but it range it represents will
1957	# not be seen.
1958	#
1959	itcl::body Rappture::FlowvisViewer::ParseMarkersOption { tf markers } {
1960	set c $itk_component(legend)
1961	regsub -all "," $markers " " markers
1962	foreach marker $markers {
1963	set n [scan $marker "%g%s" value suffix]
1964	if { $n == 2 && $suffix == "%" } {
1965	# ${n}% : Set relative value.
1966	set value [expr {$value * 0.01}]
1967	set m [Rappture::IsoMarker \#auto $c $this $tf]
1968	$m relval $value
1969	lappend _isomarkers($tf) $m
1970	} else {
1971	# ${n} : Set absolute value.
1972	set m [Rappture::IsoMarker \#auto $c $this $tf]
1973	$m absval $value
1974	lappend _isomarkers($tf) $m
1975	}
1976	}
1977	}
1978
1979	# ----------------------------------------------------------------------
1980	# USAGE: UndateTransferFuncs
1981	# ----------------------------------------------------------------------
1982	itcl::body Rappture::FlowvisViewer::updatetransferfuncs {} {
1983	$_dispatcher event -after 100 !send_transfunc
1984	}
1985
1986	itcl::body Rappture::FlowvisViewer::AddIsoMarker { x y } {
1987	if { $_activeTf == "" } {
1988	error "active transfer function isn't set"
1989	}
1990	set tf $_activeTf
1991	set c $itk_component(legend)
1992	set m [Rappture::IsoMarker \#auto $c $this $tf]
1993	set w [winfo width $c]
1994	$m relval [expr {double($x-10)/($w-20)}]
1995	lappend _isomarkers($tf) $m
1996	updatetransferfuncs
1997	return 1
1998	}
1999
2000	itcl::body Rappture::FlowvisViewer::rmdupmarker { marker x } {
2001	set tf [$marker transferfunc]
2002	set bool 0
2003	if { [info exists _isomarkers($tf)] } {
2004	set list {}
2005	set marker [namespace tail $marker]
2006	foreach m $_isomarkers($tf) {
2007	set sx [$m screenpos]
2008	if { $m != $marker } {
2009	if { $x >= ($sx-3) && $x <= ($sx+3) } {
2010	$marker relval [$m relval]
2011	itcl::delete object $m
2012	bell
2013	set bool 1
2014	continue
2015	}
2016	}
2017	lappend list $m
2018	}
2019	set _isomarkers($tf) $list
2020	updatetransferfuncs
2021	}
2022	return $bool
2023	}
2024
2025	itcl::body Rappture::FlowvisViewer::overmarker { marker x } {
2026	set tf [$marker transferfunc]
2027	if { [info exists _isomarkers($tf)] } {
2028	set marker [namespace tail $marker]
2029	foreach m $_isomarkers($tf) {
2030	set sx [$m screenpos]
2031	if { $m != $marker } {
2032	set bool [expr { $x >= ($sx-3) && $x <= ($sx+3) }]
2033	$m activate $bool
2034	}
2035	}
2036	}
2037	return ""
2038	}
2039
2040	itcl::body Rappture::FlowvisViewer::limits { tf } {
2041	set _limits(vmin) 0.0
2042	set _limits(vmax) 1.0
2043	if { ![info exists _style2objs($tf)] } {
2044	puts stderr "no style2objs for $tf tf=($tf)"
2045	return [array get _limits]
2046	}
2047	set min ""; set max ""
2048	foreach {dataobj comp} $_style2objs($tf) {
2049	set tag $dataobj-$comp
2050	if { ![info exists _serverObjs($tag)] } {
2051	puts stderr "$tag not in serverObjs?"
2052	continue
2053	}
2054	if { ![info exists _limits($tag-min)] } {
2055	puts stderr "$tag no min?"
2056	continue
2057	}
2058	if { $min == "" \|\| $min > $_limits($tag-min) } {
2059	set min $_limits($tag-min)
2060	}
2061	if { $max == "" \|\| $max < $_limits($tag-max) } {
2062	set max $_limits($tag-max)
2063	}
2064	}
2065	if { $min != "" } {
2066	set _limits(vmin) $min
2067	}
2068	if { $max != "" } {
2069	set _limits(vmax) $max
2070	}
2071	return [array get _limits]
2072	}
2073
2074
2075
2076	itcl::body Rappture::FlowvisViewer::BuildViewTab {} {
2077	foreach { key value } {
2078	grid 0
2079	axes 0
2080	outline 1
2081	volume 1
2082	legend 1
2083	particles 1
2084	lic 1
2085	} {
2086	set _settings($this-$key) $value
2087	}
2088
2089	set fg [option get $itk_component(hull) font Font]
2090	#set bfg [option get $itk_component(hull) boldFont Font]
2091
2092	set inner [$itk_component(main) insert end \
2093	-title "View Settings" \
2094	-icon [Rappture::icon wrench]]
2095	$inner configure -borderwidth 4
2096
2097	set ::Rappture::FlowvisViewer::_settings($this-isosurface) 0
2098	checkbutton $inner.isosurface \
2099	-text "Isosurface shading" \
2100	-variable [itcl::scope _settings($this-isosurface)] \
2101	-command [itcl::code $this FixSettings isosurface] \
2102	-font "Arial 9"
2103
2104	checkbutton $inner.axes \
2105	-text "Axes" \
2106	-variable [itcl::scope _settings($this-axes)] \
2107	-command [itcl::code $this FixSettings axes] \
2108	-font "Arial 9"
2109
2110	checkbutton $inner.grid \
2111	-text "Grid" \
2112	-variable [itcl::scope _settings($this-grid)] \
2113	-command [itcl::code $this FixSettings grid] \
2114	-font "Arial 9"
2115
2116	checkbutton $inner.outline \
2117	-text "Outline" \
2118	-variable [itcl::scope _settings($this-outline)] \
2119	-command [itcl::code $this FixSettings outline] \
2120	-font "Arial 9"
2121
2122	checkbutton $inner.legend \
2123	-text "Legend" \
2124	-variable [itcl::scope _settings($this-legend)] \
2125	-command [itcl::code $this FixSettings legend] \
2126	-font "Arial 9"
2127
2128	checkbutton $inner.volume \
2129	-text "Volume" \
2130	-variable [itcl::scope _settings($this-volume)] \
2131	-command [itcl::code $this FixSettings volume] \
2132	-font "Arial 9"
2133
2134	checkbutton $inner.particles \
2135	-text "Particles" \
2136	-variable [itcl::scope _settings($this-particles)] \
2137	-command [itcl::code $this FixSettings particles] \
2138	-font "Arial 9"
2139
2140	checkbutton $inner.lic \
2141	-text "Lic" \
2142	-variable [itcl::scope _settings($this-lic)] \
2143	-command [itcl::code $this FixSettings lic] \
2144	-font "Arial 9"
2145
2146	frame $inner.frame
2147
2148	blt::table $inner \
2149	0,0 $inner.axes -columnspan 2 -anchor w \
2150	1,0 $inner.grid -columnspan 2 -anchor w \
2151	2,0 $inner.outline -columnspan 2 -anchor w \
2152	3,0 $inner.volume -columnspan 2 -anchor w \
2153	4,0 $inner.legend -columnspan 2 -anchor w
2154
2155	bind $inner <Map> [itcl::code $this GetFlowInfo $inner]
2156
2157	blt::table configure $inner r* -resize none
2158	blt::table configure $inner r5 -resize expand
2159	}
2160
2161	itcl::body Rappture::FlowvisViewer::BuildVolumeTab {} {
2162	foreach { key value } {
2163	light 40
2164	transp 50
2165	opacity 100
2166	thickness 350
2167	} {
2168	set _settings($this-$key) $value
2169	}
2170
2171	set inner [$itk_component(main) insert end \
2172	-title "Volume Settings" \
2173	-icon [Rappture::icon volume-on]]
2174	$inner configure -borderwidth 4
2175
2176	set fg [option get $itk_component(hull) font Font]
2177	#set bfg [option get $itk_component(hull) boldFont Font]
2178
2179	checkbutton $inner.vol -text "Show volume" -font $fg \
2180	-text "Volume" \
2181	-variable [itcl::scope _settings($this-volume)] \
2182	-command [itcl::code $this FixSettings volume] \
2183	-font "Arial 9"
2184
2185	label $inner.shading -text "Shading:" -font $fg
2186
2187	label $inner.dim -text "Dim" -font $fg
2188	::scale $inner.light -from 0 -to 100 -orient horizontal \
2189	-variable [itcl::scope _settings($this-light)] \
2190	-width 10 \
2191	-showvalue off -command [itcl::code $this FixSettings light]
2192	label $inner.bright -text "Bright" -font $fg
2193
2194	label $inner.fog -text "Fog" -font $fg
2195	::scale $inner.transp -from 0 -to 100 -orient horizontal \
2196	-variable [itcl::scope _settings($this-transp)] \
2197	-width 10 \
2198	-showvalue off -command [itcl::code $this FixSettings transp]
2199	label $inner.plastic -text "Plastic" -font $fg
2200
2201	label $inner.clear -text "Clear" -font $fg
2202	::scale $inner.opacity -from 0 -to 100 -orient horizontal \
2203	-variable [itcl::scope _settings($this-opacity)] \
2204	-width 10 \
2205	-showvalue off -command [itcl::code $this FixSettings opacity]
2206	label $inner.opaque -text "Opaque" -font $fg
2207
2208	label $inner.thin -text "Thin" -font $fg
2209	::scale $inner.thickness -from 0 -to 1000 -orient horizontal \
2210	-variable [itcl::scope _settings($this-thickness)] \
2211	-width 10 \
2212	-showvalue off -command [itcl::code $this FixSettings thickness]
2213	label $inner.thick -text "Thick" -font $fg
2214
2215	blt::table $inner \
2216	0,0 $inner.vol -columnspan 4 -anchor w -pady 2 \
2217	1,0 $inner.shading -columnspan 4 -anchor w -pady {10 2} \
2218	2,0 $inner.dim -anchor e -pady 2 \
2219	2,1 $inner.light -columnspan 2 -pady 2 -fill x \
2220	2,3 $inner.bright -anchor w -pady 2 \
2221	3,0 $inner.fog -anchor e -pady 2 \
2222	3,1 $inner.transp -columnspan 2 -pady 2 -fill x \
2223	3,3 $inner.plastic -anchor w -pady 2 \
2224	4,0 $inner.clear -anchor e -pady 2 \
2225	4,1 $inner.opacity -columnspan 2 -pady 2 -fill x\
2226	4,3 $inner.opaque -anchor w -pady 2 \
2227	5,0 $inner.thin -anchor e -pady 2 \
2228	5,1 $inner.thickness -columnspan 2 -pady 2 -fill x\
2229	5,3 $inner.thick -anchor w -pady 2
2230
2231	if 0 {
2232	0,0 $inner.dim -anchor e -pady 2 \
2233	0,1 $inner.light -columnspan 2 -pady 2 \
2234	0,3 $inner.bright -anchor w -pady 2 \
2235	1,0 $inner.fog -anchor e -pady 2 \
2236	1,1 $inner.transp -columnspan 2 -pady 2 \
2237	1,3 $inner.plastic -anchor w -pady 2 \
2238	2,0 $inner.clear -anchor e -pady 2 \
2239	2,1 $inner.opacity -columnspan 2 -pady 2 \
2240	2,3 $inner.opaque -anchor w -pady 2 \
2241	3,0 $inner.thin -anchor e -pady 2 \
2242	3,1 $inner.thickness -columnspan 2 -pady 2 \
2243	3,3 $inner.thick -anchor w -pady 2
2244	}
2245	blt::table configure $inner c0 c1 c3 r* -resize none
2246	blt::table configure $inner r6 -resize expand
2247	}
2248
2249	itcl::body Rappture::FlowvisViewer::BuildCutplanesTab {} {
2250	set inner [$itk_component(main) insert end \
2251	-title "Cutplane Settings" \
2252	-icon [Rappture::icon cutbutton]]
2253	$inner configure -borderwidth 4
2254
2255	# X-value slicer...
2256	itk_component add xCutButton {
2257	Rappture::PushButton $inner.xbutton \
2258	-onimage [Rappture::icon x-cutplane] \
2259	-offimage [Rappture::icon x-cutplane] \
2260	-command [itcl::code $this FixSettings xcutplane] \
2261	-variable [itcl::scope _settings($this-xcutplane)]
2262	}
2263	Rappture::Tooltip::for $itk_component(xCutButton) \
2264	"Toggle the X cut plane on/off"
2265
2266	itk_component add xCutScale {
2267	::scale $inner.xval -from 100 -to 0 \
2268	-width 10 -orient vertical -showvalue off \
2269	-borderwidth 1 -highlightthickness 0 \
2270	-command [itcl::code $this Slice move x] \
2271	-variable [itcl::scope _settings($this-xcutposition)]
2272	} {
2273	usual
2274	ignore -borderwidth -highlightthickness
2275	}
2276	# Set the default cutplane value before disabling the scale.
2277	$itk_component(xCutScale) set 50
2278	$itk_component(xCutScale) configure -state disabled
2279	Rappture::Tooltip::for $itk_component(xCutScale) \
2280	"@[itcl::code $this SlicerTip x]"
2281
2282	# Y-value slicer...
2283	itk_component add yCutButton {
2284	Rappture::PushButton $inner.ybutton \
2285	-onimage [Rappture::icon y-cutplane] \
2286	-offimage [Rappture::icon y-cutplane] \
2287	-command [itcl::code $this FixSettings ycutplane] \
2288	-variable [itcl::scope _settings($this-ycutplane)]
2289	}
2290	Rappture::Tooltip::for $itk_component(yCutButton) \
2291	"Toggle the Y cut plane on/off"
2292
2293	itk_component add yCutScale {
2294	::scale $inner.yval -from 100 -to 0 \
2295	-width 10 -orient vertical -showvalue off \
2296	-borderwidth 1 -highlightthickness 0 \
2297	-command [itcl::code $this Slice move y] \
2298	-variable [itcl::scope _settings($this-ycutposition)]
2299	} {
2300	usual
2301	ignore -borderwidth -highlightthickness
2302	}
2303	Rappture::Tooltip::for $itk_component(yCutScale) \
2304	"@[itcl::code $this SlicerTip y]"
2305	# Set the default cutplane value before disabling the scale.
2306	$itk_component(yCutScale) set 50
2307	$itk_component(yCutScale) configure -state disabled
2308
2309	# Z-value slicer...
2310	itk_component add zCutButton {
2311	Rappture::PushButton $inner.zbutton \
2312	-onimage [Rappture::icon z-cutplane] \
2313	-offimage [Rappture::icon z-cutplane] \
2314	-command [itcl::code $this FixSettings zcutplane] \
2315	-variable [itcl::scope _settings($this-zcutplane)]
2316	}
2317	Rappture::Tooltip::for $itk_component(zCutButton) \
2318	"Toggle the Z cut plane on/off"
2319
2320	itk_component add zCutScale {
2321	::scale $inner.zval -from 100 -to 0 \
2322	-width 10 -orient vertical -showvalue off \
2323	-borderwidth 1 -highlightthickness 0 \
2324	-command [itcl::code $this Slice move z] \
2325	-variable [itcl::scope _settings($this-zcutposition)]
2326	} {
2327	usual
2328	ignore -borderwidth -highlightthickness
2329	}
2330	$itk_component(zCutScale) set 50
2331	$itk_component(zCutScale) configure -state disabled
2332	#$itk_component(zCutScale) configure -state disabled
2333	Rappture::Tooltip::for $itk_component(zCutScale) \
2334	"@[itcl::code $this SlicerTip z]"
2335
2336	blt::table $inner \
2337	1,1 $itk_component(xCutButton) \
2338	1,2 $itk_component(yCutButton) \
2339	1,3 $itk_component(zCutButton) \
2340	0,1 $itk_component(xCutScale) \
2341	0,2 $itk_component(yCutScale) \
2342	0,3 $itk_component(zCutScale) \
2343
2344	blt::table configure $inner r0 r1 c* -resize none
2345	blt::table configure $inner r2 c4 -resize expand
2346	blt::table configure $inner c0 -width 2
2347	blt::table configure $inner c1 c2 c3 -padx 2
2348	}
2349
2350	itcl::body Rappture::FlowvisViewer::BuildCameraTab {} {
2351	set inner [$itk_component(main) insert end \
2352	-title "Camera Settings" \
2353	-icon [Rappture::icon camera]]
2354	$inner configure -borderwidth 4
2355
2356	set labels { phi theta psi pan-x pan-y zoom }
2357	set row 0
2358	foreach tag $labels {
2359	label $inner.${tag}label -text $tag -font "Arial 9"
2360	entry $inner.${tag} -font "Arial 9" -bg white \
2361	-textvariable [itcl::scope _settings($this-$tag)]
2362	bind $inner.${tag} <KeyPress-Return> \
2363	[itcl::code $this camera set ${tag}]
2364	blt::table $inner \
2365	$row,0 $inner.${tag}label -anchor e -pady 2 \
2366	$row,1 $inner.${tag} -anchor w -pady 2
2367	blt::table configure $inner r$row -resize none
2368	incr row
2369	}
2370	blt::table configure $inner c0 c1 -resize none
2371	blt::table configure $inner c2 -resize expand
2372	blt::table configure $inner r$row -resize expand
2373	}
2374
2375	itcl::body Rappture::FlowvisViewer::GetFlowInfo { w } {
2376	set flowobj ""
2377	foreach key [array names _obj2flow] {
2378	set flowobj $_obj2flow($key)
2379	break
2380	}
2381	if { $flowobj == "" } {
2382	return
2383	}
2384	if { [winfo exists $w.frame] } {
2385	destroy $w.frame
2386	}
2387	set inner [frame $w.frame]
2388	blt::table $w \
2389	5,0 $inner -fill both -columnspan 2 -anchor nw
2390	array set hints [$flowobj hints]
2391	checkbutton $inner.showstreams -text "Streams Plane" \
2392	-variable [itcl::scope _settings($this-streams)] \
2393	-command [itcl::code $this streams $key $hints(name)] \
2394	-font "Arial 9"
2395	Rappture::Tooltip::for $inner.showstreams $hints(description)
2396
2397	checkbutton $inner.showarrows -text "Arrows" \
2398	-variable [itcl::scope _settings($this-arrows)] \
2399	-command [itcl::code $this arrows $key $hints(name)] \
2400	-font "Arial 9"
2401
2402	label $inner.particles -text "Particles" -font "Arial 9 bold"
2403	label $inner.boxes -text "Boxes" -font "Arial 9 bold"
2404
2405	blt::table $inner \
2406	1,0 $inner.showstreams -anchor w \
2407	2,0 $inner.showarrows -anchor w
2408	blt::table configure $inner c0 c1 -resize none
2409	blt::table configure $inner c2 -resize expand
2410
2411	set row 3
2412	set particles [$flowobj particles]
2413	if { [llength $particles] > 0 } {
2414	blt::table $inner $row,0 $inner.particles -anchor w
2415	incr row
2416	}
2417	foreach part $particles {
2418	array unset info
2419	array set info $part
2420	set name $info(name)
2421	if { ![info exists _settings($this-particles-$name)] } {
2422	set _settings($this-particles-$name) $info(hide)
2423	}
2424	checkbutton $inner.part$row -text $info(label) \
2425	-variable [itcl::scope _settings($this-particles-$name)] \
2426	-onvalue 0 -offvalue 1 \
2427	-command [itcl::code $this particles $key $name] \
2428	-font "Arial 9"
2429	Rappture::Tooltip::for $inner.part$row $info(description)
2430	blt::table $inner $row,0 $inner.part$row -anchor w
2431	if { !$_settings($this-particles-$name) } {
2432	$inner.part$row select
2433	}
2434	incr row
2435	}
2436	set boxes [$flowobj boxes]
2437	if { [llength $boxes] > 0 } {
2438	blt::table $inner $row,0 $inner.boxes -anchor w
2439	incr row
2440	}
2441	foreach box $boxes {
2442	array unset info
2443	array set info $box
2444	set name $info(name)
2445	if { ![info exists _settings($this-box-$name)] } {
2446	set _settings($this-box-$name) $info(hide)
2447	}
2448	checkbutton $inner.box$row -text $info(label) \
2449	-variable [itcl::scope _settings($this-box-$name)] \
2450	-onvalue 0 -offvalue 1 \
2451	-command [itcl::code $this box $key $name] \
2452	-font "Arial 9"
2453	Rappture::Tooltip::for $inner.box$row $info(description)
2454	blt::table $inner $row,0 $inner.box$row -anchor w
2455	if { !$_settings($this-box-$name) } {
2456	$inner.box$row select
2457	}
2458	incr row
2459	}
2460	blt::table configure $inner r* -resize none
2461	blt::table configure $inner r$row -resize expand
2462	blt::table configure $inner c3 -resize expand
2463	event generate [winfo parent [winfo parent $w]] <Configure>
2464	}
2465
2466	itcl::body Rappture::FlowvisViewer::particles { tag name } {
2467	set bool $_settings($this-particles-$name)
2468	SendCmd "$tag particles configure {$name} -hide $bool"
2469	}
2470
2471	itcl::body Rappture::FlowvisViewer::box { tag name } {
2472	set bool $_settings($this-box-$name)
2473	SendCmd "$tag box configure {$name} -hide $bool"
2474	}
2475
2476	itcl::body Rappture::FlowvisViewer::streams { tag name } {
2477	set bool $_settings($this-streams)
2478	SendCmd "$tag configure -slice $bool"
2479	}
2480
2481	itcl::body Rappture::FlowvisViewer::arrows { tag name } {
2482	set bool $_settings($this-arrows)
2483	SendCmd "$tag configure -arrows no"
2484	}
2485
2486	# ----------------------------------------------------------------------
2487	# USAGE: Slice move x\|y\|z <newval>
2488	#
2489	# Called automatically when the user drags the slider to move the
2490	# cut plane that slices 3D data. Gets the current value from the
2491	# slider and moves the cut plane to the appropriate point in the
2492	# data set.
2493	# ----------------------------------------------------------------------
2494	itcl::body Rappture::FlowvisViewer::Slice {option args} {
2495	switch -- $option {
2496	move {
2497	if {[llength $args] != 2} {
2498	error "wrong # args: should be \"Slice move x\|y\|z newval\""
2499	}
2500	set axis [lindex $args 0]
2501	set newval [lindex $args 1]
2502	set newpos [expr {0.01*$newval}]
2503
2504	# show the current value in the readout
2505
2506	set ids [CurrentVolumeIds -cutplanes]
2507	SendCmd "cutplane position $newpos $axis $ids"
2508	}
2509	default {
2510	error "bad option \"$option\": should be axis, move, or volume"
2511	}
2512	}
2513	}
2514
2515	# ----------------------------------------------------------------------
2516	# USAGE: SlicerTip <axis>
2517	#
2518	# Used internally to generate a tooltip for the x/y/z slicer controls.
2519	# Returns a message that includes the current slicer value.
2520	# ----------------------------------------------------------------------
2521	itcl::body Rappture::FlowvisViewer::SlicerTip {axis} {
2522	set val [$itk_component(${axis}CutScale) get]
2523	# set val [expr {0.01*($val-50)
2524	# *($_limits(${axis}max)-$_limits(${axis}min))
2525	# + 0.5*($_limits(${axis}max)+$_limits(${axis}min))}]
2526	return "Move the [string toupper $axis] cut plane.\nCurrently: $axis = $val%"
2527	}
2528
2529
2530	itcl::body Rappture::FlowvisViewer::Resize {} {
2531	SendCmd "screen $_width $_height"
2532	set _resizePending 0
2533	}
2534
2535	itcl::body Rappture::FlowvisViewer::EventuallyResize { w h } {
2536	set _width $w
2537	set _height $h
2538	if { !$_resizePending } {
2539	$_dispatcher event -after 200 !resize
2540	set _resizePending 1
2541	}
2542	}
2543
2544	itcl::body Rappture::FlowvisViewer::EventuallyResizeLegend {} {
2545	if { !$_resizeLegendPending } {
2546	$_dispatcher event -after 100 !legend
2547	set _resizeLegendPending 1
2548	}
2549	}
2550
2551	itcl::body Rappture::FlowvisViewer::EventuallyGoto { nSteps } {
2552	set _flow(goto) $nSteps
2553	if { !$_gotoPending } {
2554	$_dispatcher event -after 1000 !goto
2555	set _gotoPending 1
2556	}
2557	}
2558
2559	# camera --
2560	itcl::body Rappture::FlowvisViewer::camera {option args} {
2561	switch -- $option {
2562	"show" {
2563	puts [array get _view]
2564	}
2565	"set" {
2566	set who [lindex $args 0]
2567	set x $_settings($this-$who)
2568	set code [catch { string is double $x } result]
2569	if { $code != 0 \|\| !$result } {
2570	set _settings($this-$who) $_view($who)
2571	return
2572	}
2573	switch -- $who {
2574	"pan-x" - "pan-y" {
2575	set _view($who) $_settings($this-$who)
2576	PanCamera
2577	}
2578	"phi" - "theta" - "psi" {
2579	set _view($who) $_settings($this-$who)
2580	set xyz [Euler2XYZ $_view(theta) $_view(phi) $_view(psi)]
2581	SendCmd "camera angle $xyz"
2582	}
2583	"zoom" {
2584	set _view($who) $_settings($this-$who)
2585	SendCmd "camera zoom $_view(zoom)"
2586	}
2587	}
2588	}
2589	}
2590	}
2591
2592	itcl::body Rappture::FlowvisViewer::FlowCmd { dataobj comp nbytes extents } {
2593	set tag "$dataobj-$comp"
2594	if { ![info exists _obj2flow($tag)] } {
2595	append cmd "flow add $tag\n"
2596	append cmd "$tag data follows $nbytes $extents\n"
2597	return $cmd
2598	}
2599	set flowobj $_obj2flow($tag)
2600	if { $flowobj == "" } {
2601	puts stderr "no flowobj"
2602	return ""
2603	}
2604	set cmd {}
2605	append cmd "if {\[flow exists $tag\]} {flow delete $tag}\n"
2606	array set info [$flowobj hints]
2607	set _settings($this-volume) $info(volume)
2608	set _settings($this-outline) $info(outline)
2609	set _settings($this-arrows) $info(arrows)
2610	set _settings($this-duration) $info(duration)
2611	$itk_component(speed) value $info(speed)
2612	append cmd "flow add $tag"
2613	append cmd " -position $info(position)"
2614	append cmd " -axis $info(axis)"
2615	append cmd " -volume $info(volume)"
2616	append cmd " -outline $info(outline)"
2617	append cmd " -slice $info(streams)"
2618	append cmd " -arrows $info(arrows)\n"
2619	foreach part [$flowobj particles] {
2620	array unset info
2621	array set info $part
2622	set color [Color2RGB $info(color)]
2623	append cmd "$tag particles add $info(name)"
2624	append cmd " -position $info(position)"
2625	append cmd " -hide $info(hide)"
2626	append cmd " -axis $info(axis)"
2627	append cmd " -color {$color}"
2628	append cmd " -size $info(size)\n"
2629	}
2630	foreach box [$flowobj boxes] {
2631	array unset info
2632	set info(corner1) ""
2633	set info(corner2) ""
2634	array set info $box
2635	if { $info(corner1) == "" \|\| $info(corner2) == "" } {
2636	continue
2637	}
2638	set color [Color2RGB $info(color)]
2639	append cmd "$tag box add $info(name)"
2640	append cmd " -color {$color}"
2641	append cmd " -hide $info(hide)"
2642	append cmd " -linewidth $info(linewidth) "
2643	append cmd " -corner1 {$info(corner1)} "
2644	append cmd " -corner2 {$info(corner2)}\n"
2645	}
2646	append cmd "$tag data follows $nbytes $extents\n"
2647	return $cmd
2648	}
2649
2650
2651	#
2652	# flow --
2653	#
2654	# Called when the user clicks on the stop or play buttons
2655	# for flow visualization.
2656	#
2657	# $this flow play
2658	# $this flow stop
2659	# $this flow toggle
2660	# $this flow reset
2661	# $this flow pause
2662	# $this flow next
2663	#
2664	itcl::body Rappture::FlowvisViewer::flow { args } {
2665	set option [lindex $args 0]
2666	switch -- $option {
2667	"goto2" {
2668	puts stderr "actually sending \"flow goto $_flow(goto)\""
2669	SendCmd "flow goto $_flow(goto)"
2670	set _gotoPending 0
2671	}
2672	"goto" {
2673	puts stderr "flow goto to $_settings($this-currenttime)"
2674	# Figure out how many steps to the current time based upon
2675	# the speed and duration.
2676	set current $_settings($this-currenttime)
2677	set speed [$itk_component(speed) value]
2678	set time [str2millisecs $_settings($this-duration)]
2679	$itk_component(dial) configure -max $time
2680	set delay [expr int(round(500.0/$speed))]
2681	set timePerStep [expr {double($time) / $delay}]
2682	set nSteps [expr {int(ceil($current/$timePerStep))}]
2683	EventuallyGoto $nSteps
2684	}
2685	"speed" {
2686	set speed [$itk_component(speed) value]
2687	set _flow(delay) [expr int(round(500.0/$speed))]
2688	}
2689	"duration" {
2690	set max [str2millisecs $_settings($this-duration)]
2691	if { $max < 0 } {
2692	bell
2693	return
2694	}
2695	set _flow(duration) $max
2696	set _settings($this-duration) [millisecs2str $max]
2697	$itk_component(dial) configure -max $max
2698	}
2699	"off" {
2700	set _flow(state) 0
2701	$_dispatcher cancel !play
2702	$itk_component(play) deselect
2703	}
2704	"on" {
2705	flow speed
2706	flow duration
2707	set _flow(state) 1
2708	set _settings($this-currenttime) 0
2709	$itk_component(play) select
2710	}
2711	"stop" {
2712	if { $_flow(state) } {
2713	flow off
2714	flow reset
2715	}
2716	}
2717	"pause" {
2718	if { $_flow(state) } {
2719	flow off
2720	}
2721	}
2722	"play" {
2723	# If the flow is currently off, then restart it.
2724	if { !$_flow(state) } {
2725	flow on
2726	# If we're at the end of the flow, reset the flow.
2727	set _settings($this-currenttime) \
2728	[expr {$_settings($this-currenttime) + $_flow(delay)}]
2729	if { $_settings($this-currenttime) >= $_flow(duration) } {
2730	set _settings($this-step) 1
2731	SendCmd "flow reset"
2732	}
2733	flow next
2734	}
2735	}
2736	"toggle" {
2737	if { $_settings($this-play) } {
2738	flow play
2739	} else {
2740	flow pause
2741	}
2742	}
2743	"reset" {
2744	set _settings($this-currenttime) 0
2745	SendCmd "flow reset"
2746	if { !$_flow(state) } {
2747	SendCmd "flow next"
2748	}
2749	}
2750	"next" {
2751	if { ![winfo viewable $itk_component(3dview)] } {
2752	flow stop
2753	return
2754	}
2755	set _settings($this-currenttime) \
2756	[expr {$_settings($this-currenttime) + $_flow(delay)}]
2757	if { $_settings($this-currenttime) >= $_flow(duration) } {
2758	if { !$_settings($this-loop) } {
2759	flow off
2760	return
2761	}
2762	flow reset
2763	} else {
2764	SendCmd "flow next"
2765	}
2766	$_dispatcher event -after $_flow(delay) !play
2767	}
2768	default {
2769	error "bad option \"$option\": should be play, stop, toggle, or reset."
2770	}
2771	}
2772	}
2773
2774	itcl::body Rappture::FlowvisViewer::WaitIcon { option widget } {
2775	switch -- $option {
2776	"start" {
2777	$_dispatcher dispatch $this !waiticon \
2778	"[itcl::code $this WaitIcon "next" $widget] ; list"
2779	set _icon 0
2780	$widget configure -image [Rappture::icon bigroller${_icon}]
2781	$_dispatcher event -after 100 !waiticon
2782	}
2783	"next" {
2784	incr _icon
2785	if { $_icon >= 8 } {
2786	set _icon 0
2787	}
2788	$widget configure -image [Rappture::icon bigroller${_icon}]
2789	$_dispatcher event -after 100 !waiticon
2790	}
2791	"stop" {
2792	$_dispatcher cancel !waiticon
2793	}
2794	}
2795	}
2796
2797	itcl::body Rappture::FlowvisViewer::GetPngImage { widget width height } {
2798	set token "print[incr _nextToken]"
2799	set var ::Rappture::FlowvisViewer::_hardcopy($this-$token)
2800	set $var ""
2801
2802	# Setup an automatic timeout procedure.
2803	$_dispatcher dispatch $this !pngtimeout "set $var {} ; list"
2804
2805	set popup .flowvisviewerprint
2806	if {![winfo exists $popup]} {
2807	Rappture::Balloon $popup -title "Generating file..."
2808	set inner [$popup component inner]
2809	label $inner.title -text "Generating hardcopy." -font "Arial 10 bold"
2810	label $inner.please -text "This may take a minute." -font "Arial 10"
2811	label $inner.icon -image [Rappture::icon bigroller0]
2812	button $inner.cancel -text "Cancel" -font "Arial 10 bold" \
2813	-command [list set $var ""]
2814	blt::table $inner \
2815	0,0 $inner.title -columnspan 2 \
2816	1,0 $inner.please -anchor w \
2817	1,1 $inner.icon -anchor e \
2818	2,0 $inner.cancel -columnspan 2
2819	blt::table configure $inner r0 -pady 4
2820	blt::table configure $inner r2 -pady 4
2821	bind $inner.cancel <KeyPress-Return> [list $inner.cancel invoke]
2822	} else {
2823	set inner [$popup component inner]
2824	}
2825
2826	$_dispatcher event -after 60000 !pngtimeout
2827	WaitIcon start $inner.icon
2828	grab set $inner
2829	focus $inner.cancel
2830
2831	SendCmd "print $token $width $height"
2832
2833	$popup activate $widget below
2834	update
2835	# We wait here for either
2836	# 1) the png to be delivered or
2837	# 2) timeout or
2838	# 3) user cancels the operation.
2839	tkwait variable $var
2840
2841	# Clean up.
2842	$_dispatcher cancel !pngtimeout
2843	WaitIcon stop $inner.icon
2844	grab release $inner
2845	$popup deactivate
2846	update
2847
2848	if { $_hardcopy($this-$token) != "" } {
2849	return [list .png $_hardcopy($this-$token)]
2850	}
2851	return ""
2852	}
2853
2854	itcl::body Rappture::FlowvisViewer::GetMovie { widget w h } {
2855	set token "movie[incr _nextToken]"
2856	set var ::Rappture::FlowvisViewer::_hardcopy($this-$token)
2857	set $var ""
2858
2859	# Setup an automatic timeout procedure.
2860	$_dispatcher dispatch $this !movietimeout "set $var {} ; list"
2861	set popup .flowvisviewermovie
2862	if {![winfo exists $popup]} {
2863	Rappture::Balloon $popup -title "Generating movie..."
2864	set inner [$popup component inner]
2865	label $inner.title -text "Generating movie for download" \
2866	-font "Arial 10 bold"
2867	label $inner.please -text "This may take a few minutes." \
2868	-font "Arial 10"
2869	label $inner.icon -image [Rappture::icon bigroller0]
2870	button $inner.cancel -text "Cancel" -font "Arial 10 bold" \
2871	-command [list set $var ""]
2872	blt::table $inner \
2873	0,0 $inner.title -columnspan 2 \
2874	1,0 $inner.please -anchor w \
2875	1,1 $inner.icon -anchor e \
2876	2,0 $inner.cancel -columnspan 2
2877	blt::table configure $inner r0 -pady 4
2878	blt::table configure $inner r2 -pady 4
2879	bind $inner.cancel <KeyPress-Return> [list $inner.cancel invoke]
2880	} else {
2881	set inner [$popup component inner]
2882	}
2883	# Timeout is set to 10 minutes.
2884	$_dispatcher event -after 600000 !movietimeout
2885	WaitIcon start $inner.icon
2886	grab set $inner
2887	focus $inner.cancel
2888
2889	flow duration
2890	flow speed
2891	set nframes [expr round($_flow(duration) / $_flow(delay))]
2892	set framerate [expr 1000.0 / $_flow(delay)]
2893
2894	# These are specific to MPEG1 video generation
2895	set framerate 25.0
2896	set bitrate 6.0e+6
2897
2898	set start [clock seconds]
2899	SendCmd "flow video $token -width $w -height $h -numframes $nframes "
2900
2901	$popup activate $widget below
2902	update
2903	# We wait here until
2904	# 1. the movie is delivered or
2905	# 2. we've timed out or
2906	# 3. the user has canceled the operation.b
2907	tkwait variable $var
2908
2909	puts stderr "Video generated in [expr [clock seconds] - $start] seconds."
2910
2911	# Clean up.
2912	$_dispatcher cancel !movietimeout
2913	WaitIcon stop $inner.icon
2914	grab release $inner
2915	$popup deactivate
2916	destroy $popup
2917	update
2918
2919	# This will both cancel the movie generation (if it hasn't already
2920	# completed) and reset the flow.
2921	SendCmd "flow reset"
2922	if { $_hardcopy($this-$token) != "" } {
2923	return [list .mpg $_hardcopy($this-$token)]
2924	}
2925	return ""
2926	}
2927
2928	itcl::body Rappture::FlowvisViewer::str2millisecs { value } {
2929	set parts [split $value :]
2930	set secs 0
2931	set mins 0
2932	if { [llength $parts] == 1 } {
2933	scan [lindex $parts 0] "%d" secs
2934	} else {
2935	scan [lindex $parts 1] "%d" secs
2936	scan [lindex $parts 0] "%d" mins
2937	}
2938	set ms [expr {(($mins * 60) + $secs) * 1000.0}]
2939	if { $ms > 600000.0 } {
2940	set ms 600000.0
2941	}
2942	if { $ms == 0.0 } {
2943	set ms 60000.0
2944	}
2945	return $ms
2946	}
2947
2948	itcl::body Rappture::FlowvisViewer::millisecs2str { value } {
2949	set min [expr floor($value / 60000.0)]
2950	set sec [expr ($value - ($min*60000.0)) / 1000.0]
2951	return [format %02d:%02d [expr round($min)] [expr round($sec)]]
2952	}
2953

Note: See TracBrowser for help on using the repository browser.

Download in other formats: