diff options
39 files changed, 52779 insertions, 0 deletions
diff --git a/library/graph.tcl b/library/graph.tcl new file mode 100644 index 0000000..8c4fd8d --- /dev/null +++ b/library/graph.tcl @@ -0,0 +1,842 @@ + +namespace eval ::blt::legend { + variable _private + array set _private { + afterId "" + scroll 0 + space off + drag 0 + x 0 + y 0 + } +} + +namespace eval ::blt::ZoomStack { + variable _private + array set _private { + afterId "" + scroll 0 + space off + drag 0 + x 0 + y 0 + } +} + +option add *zoomOutline.dashes 4 +option add *zoomOutline.lineWidth 2 +option add *zoomOutline.xor yes +option add *zoomTitle.anchor nw +option add *zoomTitle.coords "-Inf Inf" +option add *zoomTitle.font "Arial 14" +option add *zoomTitle.foreground yellow3 +option add *zoomTitle.shadow yellow4 + +# ---------------------------------------------------------------------- +# +# Initialize -- +# +# Invoked by internally by Treeview_Init routine. Initializes +# the default bindings for the treeview widget entries. These +# are local to the widget, so they can't be set through the +# widget's class bind tags. +# +# ---------------------------------------------------------------------- +proc blt::LegendSelections { w } { + if 0 { + # + # Active entry bindings + # + $w legend bind all <Enter> { + %W entry highlight current + } + $w legend bind all <Leave> { + %W entry highlight "" + } + } + + # + # ButtonPress-1 + # + # Performs the following operations: + # + # 1. Clears the previous selection. + # 2. Selects the current entry. + # 3. Sets the focus to this entry. + # 4. Scrolls the entry into view. + # 5. Sets the selection anchor to this entry, just in case + # this is "multiple" mode. + # + + $w legend bind all <ButtonPress-1> { + blt::legend::SetSelectionAnchor %W current + set blt::legend::_private(scroll) 1 + } + + # + # B1-Motion + # + # For "multiple" mode only. Saves the current location of the + # pointer for auto-scrolling. Resets the selection mark. + # + $w legend bind all <B1-Motion> { + set blt::legend::_private(x) %x + set blt::legend::_private(y) %y + set elem [%W legend get @%x,%y] + if { $elem != "" } { + if { [%W legend cget -selectmode] == "multiple" } { + %W legend selection mark $elem + } else { + blt::legend::SetSelectionAnchor %W $elem + } + } + } + + # + # ButtonRelease-1 + # + # For "multiple" mode only. + # + $w legend bind all <ButtonRelease-1> { + if { [%W legend cget -selectmode] == "multiple" } { + %W legend selection anchor current + } + after cancel $blt::legend::_private(afterId) + set blt::legend::_private(scroll) 0 + } + + # + # Shift-ButtonPress-1 + # + # For "multiple" mode only. + # + + $w legend bind all <Shift-ButtonPress-1> { + if { [%W legend cget -selectmode] == "multiple" && + [%W legend selection present] } { + if { [%W legend get anchor] == "" } { + %W legend selection anchor current + } + set elem [%W legend get anchor] + %W legend selection clearall + %W legend selection set $elem current + } else { + blt::legend::SetSelectionAnchor %W current + } + } + $w legend bind all <Shift-Double-ButtonPress-1> { + # do nothing + } + $w legend bind all <Shift-B1-Motion> { + # do nothing + } + $w legend bind all <Shift-ButtonRelease-1> { + after cancel $blt::legend::_private(afterId) + set blt::legend::_private(scroll) 0 + } + + # + # Control-ButtonPress-1 + # + # For "multiple" mode only. + # + $w legend bind all <Control-ButtonPress-1> { + if { [%W legend cget -selectmode] == "multiple" } { + set elem [%W legend get current] + %W legend selection toggle $elem + %W legend selection anchor $elem + } else { + blt::legend::SetSelectionAnchor %W current + } + } + $w legend bind all <Control-Double-ButtonPress-1> { + # do nothing + } + $w legend bind all <Control-B1-Motion> { + # do nothing + } + $w legend bind all <Control-ButtonRelease-1> { + after cancel $blt::legend::_private(afterId) + set blt::legend::_private(scroll) 0 + } + + $w legend bind all <Control-Shift-ButtonPress-1> { + if { [%W legend cget -selectmode] == "multiple" && + [%W legend selection present] } { + if { [%W legend get anchor] == "" } { + %W selection anchor current + } + if { [%W legend selection includes anchor] } { + %W legend selection set anchor current + } else { + %W legend selection clear anchor current + %W legend selection set current + } + } else { + blt::legend::SetSelectionAnchor %W current + } + } + $w legend bind all <Control-Shift-Double-ButtonPress-1> { + # do nothing + } + $w legend bind all <Control-Shift-B1-Motion> { + # do nothing + } + $w legend bind all <KeyPress-Up> { + blt::legend::MoveFocus %W previous.row + if { $blt::legend::_private(space) } { + %W legend selection toggle focus + } + } + $w legend bind all <KeyPress-Down> { + blt::legend::MoveFocus %W next.row + if { $blt::legend::_private(space) } { + %W legend selection toggle focus + } + } + $w legend bind all <KeyPress-Left> { + blt::legend::MoveFocus %W previous.column + if { $blt::legend::_private(space) } { + %W legend selection toggle focus + } + } + $w legend bind all <KeyPress-Right> { + blt::legend::MoveFocus %W next.column + if { $blt::legend::_private(space) } { + %W legend selection toggle focus + } + } + $w legend bind all <KeyPress-space> { + if { [%W legend cget -selectmode] == "single" } { + if { [%W legend selection includes focus] } { + %W legend selection clearall + } else { + %W legend selection clearall + %W legend selection set focus + } + } else { + %W legend selection toggle focus + } + set blt::legend::_private(space) on + } + + $w legend bind all <KeyRelease-space> { + set blt::legend::_private(space) off + } + $w legend bind all <KeyPress-Return> { + blt::legend::MoveFocus %W focus + set blt::legend::_private(space) on + } + $w legend bind all <KeyRelease-Return> { + set blt::legend::_private(space) off + } + $w legend bind all <KeyPress-Home> { + blt::legend::MoveFocus %W first + } + $w legend bind all <KeyPress-End> { + blt::tv::MoveFocus %W last + } +} + +proc blt::legend::SetSelectionAnchor { w tagOrId } { + set elem [$w legend get $tagOrId] + # If the anchor hasn't changed, don't do anything + if { $elem != [$w legend get anchor] } { + $w legend selection clearall + $w legend focus $elem + $w legend selection set $elem + $w legend selection anchor $elem + } +} + +# ---------------------------------------------------------------------- +# +# MoveFocus -- +# +# Invoked by KeyPress bindings. Moves the active selection to +# the entry <where>, which is an index such as "up", "down", +# "prevsibling", "nextsibling", etc. +# +# ---------------------------------------------------------------------- +proc blt::legend::MoveFocus { w elem } { + catch {$w legend focus $elem} result + puts stderr "result=$result elem=$elem" + if { [$w legend cget -selectmode] == "single" } { + $w legend selection clearall + $w legend selection set focus + $w legend selection anchor focus + } +} + + +proc Blt_ActiveLegend { g } { + $g legend bind all <Enter> [list blt::ActivateLegend $g ] + $g legend bind all <Leave> [list blt::DeactivateLegend $g] + $g legend bind all <ButtonPress-1> [list blt::HighlightLegend $g] +} + +proc Blt_Crosshairs { g } { + blt::Crosshairs $g +} + +proc Blt_ResetCrosshairs { g state } { + blt::Crosshairs $g "Any-Motion" $state +} + +proc Blt_ZoomStack { g args } { + array set params { + -mode click + } + array set params $args + if { $params(-mode) == "click" } { + blt::ZoomStack::ClickClick $g + } else { + blt::ZoomStack::ClickRelease $g + } +} + +proc Blt_PrintKey { g } { + blt::PrintKey $g +} + +proc Blt_ClosestPoint { g } { + blt::ClosestPoint $g +} + +# +# The following procedures that reside in the "blt" namespace are +# supposed to be private. +# + +proc blt::ActivateLegend { g } { + set elem [$g legend get current] + $g legend activate $elem +} +proc blt::DeactivateLegend { g } { + set elem [$g legend get current] + $g legend deactivate $elem +} + +proc blt::HighlightLegend { g } { + set elem [$g legend get current] + if { $elem != "" } { + set relief [$g element cget $elem -legendrelief] + if { $relief == "flat" } { + $g element configure $elem -legendrelief raised + $g element activate $elem + } else { + $g element configure $elem -legendrelief flat + $g element deactivate $elem + } + } +} + +proc blt::Crosshairs { g {event "Any-Motion"} {state "on"}} { + $g crosshairs $state + bind crosshairs-$g <$event> { + %W crosshairs configure -position @%x,%y + } + bind crosshairs-$g <Leave> { + %W crosshairs off + } + bind crosshairs-$g <Enter> { + %W crosshairs on + } + $g crosshairs configure -color red + if { $state == "on" } { + blt::AddBindTag $g crosshairs-$g + } elseif { $state == "off" } { + blt::RemoveBindTag $g crosshairs-$g + } +} + +proc blt::PrintKey { g {event "Shift-ButtonRelease-3"} } { + bind print-$g <$event> { Blt_PostScriptDialog %W } + blt::AddBindTag $g print-$g +} + +proc blt::ClosestPoint { g {event "Control-ButtonPress-2"} } { + bind closest-point-$g <$event> { + blt::FindElement %W %x %y + } + blt::AddBindTag $g closest-point-$g +} + +proc blt::AddBindTag { widget tag } { + set oldTagList [bindtags $widget] + if { [lsearch $oldTagList $tag] < 0 } { + bindtags $widget [linsert $oldTagList 0 $tag] + } +} + +proc blt::RemoveBindTag { widget tag } { + set oldTagList [bindtags $widget] + set index [lsearch $oldTagList $tag] + if { $index >= 0 } { + bindtags $widget [lreplace $oldTagList $index $index] + } +} + +proc blt::FindElement { g x y } { + array set info [$g element closest $x $y -interpolate yes] + if { ![info exists info(name)] } { + beep + return + } + # -------------------------------------------------------------- + # find(name) - element Id + # find(index) - index of closest point + # find(x) find(y) - coordinates of closest point + # or closest point on line segment. + # find(dist) - distance from sample coordinate + # -------------------------------------------------------------- + set markerName "bltClosest_$info(name)" + catch { $g marker delete $markerName } + $g marker create text -coords { $info(x) $info(y) } \ + -name $markerName \ + -text "$info(name): $info(dist)\nindex $info(index)" \ + -font "Arial 6" \ + -anchor center -justify left \ + -yoffset 0 -bg {} + + set coords [$g invtransform $x $y] + set nx [lindex $coords 0] + set ny [lindex $coords 1] + + $g marker create line -coords "$nx $ny $info(x) $info(y)" \ + -name line.$markerName + + blt::FlashPoint $g $info(name) $info(index) 10 + blt::FlashPoint $g $info(name) [expr $info(index) + 1] 10 +} + +proc blt::FlashPoint { g name index count } { + if { $count & 1 } { + $g element deactivate $name + } else { + $g element activate $name $index + } + incr count -1 + if { $count > 0 } { + after 200 blt::FlashPoint $g $name $index $count + update + } else { + eval $g marker delete [$g marker names "bltClosest_*"] + } +} + + +proc blt::ZoomStack::Init { g } { + variable _private + set _private($g,interval) 100 + set _private($g,afterId) 0 + set _private($g,A,x) {} + set _private($g,A,y) {} + set _private($g,B,x) {} + set _private($g,B,y) {} + set _private($g,stack) {} + set _private($g,corner) A +} + +proc blt::ZoomStack::ClickClick { g {start "ButtonPress-1"} {reset "ButtonPress-3"} } { + variable _private + + Init $g + + bind zoom-$g <Enter> "focus %W" + bind zoom-$g <KeyPress-Escape> { blt::ZoomStack::Reset %W } + bind zoom-$g <${start}> { blt::ZoomStack::SetPoint %W %x %y } + bind zoom-$g <${reset}> { + if { [%W inside %x %y] } { + blt::ZoomStack::Reset %W + } + } + blt::AddBindTag $g zoom-$g +} + +proc blt::ZoomStack::ClickRelease { g } { + variable _private + + Init $g + bind zoom-$g <Enter> "focus %W" + bind zoom-$g <KeyPress-Escape> { blt::ZoomStack::Reset %W } + bind zoom-$g <ButtonPress-1> { blt::ZoomStack::DragStart %W %x %y } + bind zoom-$g <B1-Motion> { blt::ZoomStack::DragMotion %W %x %y } + bind zoom-$g <ButtonRelease-1> { blt::ZoomStack::DragFinish %W %x %y } + bind zoom-$g <ButtonPress-3> { + if { [%W inside %x %y] } { + blt::ZoomStack::Reset %W + } + } + blt::AddBindTag $g zoom-$g +} + +proc blt::ZoomStack::GetCoords { g x y index } { + variable _private + if { [$g cget -invertxy] } { + set _private($g,$index,x) $y + set _private($g,$index,y) $x + } else { + set _private($g,$index,x) $x + set _private($g,$index,y) $y + } +} + +proc blt::ZoomStack::MarkPoint { g index } { + variable _private + + if { [llength [$g xaxis use]] > 0 } { + set x [$g xaxis invtransform $_private($g,$index,x)] + } else if { [llength [$g x2axis use]] > 0 } { + set x [$g x2axis invtransform $_private($g,$index,x)] + } + if { [llength [$g yaxis use]] > 0 } { + set y [$g yaxis invtransform $_private($g,$index,y)] + } else if { [llength [$g y2axis use]] > 0 } { + set y [$g y2axis invtransform $_private($g,$index,y)] + } + set marker "zoomText_$index" + set text [format "x=%.4g\ny=%.4g" $x $y] + + if [$g marker exists $marker] { + $g marker configure $marker -coords { $x $y } -text $text + } else { + $g marker create text -coords { $x $y } -name $marker \ + -font "mathmatica1 10" \ + -text $text -anchor center -bg {} -justify left + } +} + +proc blt::ZoomStack::DestroyTitle { g } { + variable _private + + if { $_private($g,corner) == "A" } { + catch { $g marker delete "zoomTitle" } + } +} + +proc blt::ZoomStack::Pop { g } { + variable _private + + set zoomStack $_private($g,stack) + if { [llength $zoomStack] > 0 } { + set cmd [lindex $zoomStack 0] + set _private($g,stack) [lrange $zoomStack 1 end] + eval $cmd + TitleLast $g + blt::busy hold $g + update + blt::busy release $g + after 2000 [list blt::ZoomStack::DestroyTitle $g] + } else { + catch { $g marker delete "zoomTitle" } + } +} + +# Push the old axis limits on the stack and set the new ones + +proc blt::ZoomStack::Push { g } { + variable _private + + eval $g marker delete [$g marker names "zoom*"] + if { [info exists _private($g,afterId)] } { + after cancel $_private($g,afterId) + } + set x1 $_private($g,A,x) + set y1 $_private($g,A,y) + set x2 $_private($g,B,x) + set y2 $_private($g,B,y) + + if { ($x1 == $x2) || ($y1 == $y2) } { + # No delta, revert to start + return + } + set cmd {} + foreach axis [$g axis names] { + if { [$g axis cget $axis -hide] } { + continue + } + set min [$g axis cget $axis -min] + set max [$g axis cget $axis -max] + set logscale [$g axis cget $axis -logscale] + # Save the current scale (log or linear) so that we can restore it. + # This is for the case where the user changes to logscale while + # zooming. A previously pushed axis limit could be negative. It + # seems better for popping the zoom stack to restore a previous view + # (not convert the ranges). + set c [list $g axis configure $axis] + lappend c -min $min -max $max -logscale $logscale + append cmd "$c\n" + } + + # This effectively pushes the command to reset the graph to the current + # zoom level onto the stack. This is useful if the new axis ranges are + # bad and we need to reset the zoom stack. + set _private($g,stack) [linsert $_private($g,stack) 0 $cmd] + foreach axis [$g axis names] { + if { [$g axis cget $axis -hide] } { + continue; # Don't set zoom on axes not displayed. + } + set type [$g axis type $axis] + if { $type == "x" } { + set min [$g axis invtransform $axis $x1] + set max [$g axis invtransform $axis $x2] + } elseif { $type == "y" } { + set min [$g axis invtransform $axis $y1] + set max [$g axis invtransform $axis $y2] + } else { + continue; # Axis is not bound to any margin. + } + if { ![SetAxisRanges $g $axis $min $max] } { + Pop $g + bell + return + } + } + blt::busy hold $g + update; # This "update" redraws the graph + blt::busy release $g +} + +proc blt::ZoomStack::SetAxisRanges { g axis min max } { + if { $min > $max } { + set tmp $max; set max $min; set min $tmp + } + if { [catch { $g axis configure $axis -min $min -max $max }] != 0 } { + return 0 + } + return 1 +} + +# +# This routine terminates either an existing zoom, or pops back to +# the previous zoom level (if no zoom is in progress). +# +proc blt::ZoomStack::Reset { g } { + variable _private + + if { ![info exists _private($g,corner)] } { + Init $g + } + eval $g marker delete [$g marker names "zoom*"] + + if { $_private($g,corner) == "A" } { + # Reset the whole axis + Pop $g + } else { + set _private($g,corner) A + blt::RemoveBindTag $g select-region-$g + } +} + +proc blt::ZoomStack::TitleNext { g } { + variable _private + + set level [expr [llength $_private($g,stack)] + 1] + if { [$g cget -invertxy] } { + set coords "Inf -Inf" + } else { + set coords "-Inf Inf" + } + $g marker create text -name "zoomTitle" -text "Zoom #$level" \ + -coords $coords -bindtags "" -anchor nw +} + +proc blt::ZoomStack::TitleLast { g } { + variable _private + + set level [llength $_private($g,stack)] + if { $level > 0 } { + $g marker create text -name "zoomTitle" -anchor nw \ + -text "Zoom #$level" + } +} + + +proc blt::ZoomStack::SetPoint { g x y } { + variable _private + if { ![info exists _private($g,corner)] } { + Init $g + } + GetCoords $g $x $y $_private($g,corner) + bind select-region-$g <Motion> { + blt::ZoomStack::GetCoords %W %x %y B + #blt::ZoomStack::MarkPoint $g B + blt::ZoomStack::Box %W + } + if { $_private($g,corner) == "A" } { + if { ![$g inside $x $y] } { + return + } + # First corner selected, start watching motion events + + #MarkPoint $g A + TitleNext $g + + blt::AddBindTag $g select-region-$g + set _private($g,corner) B + } else { + # Delete the modal binding + blt::RemoveBindTag $g select-region-$g + Push $g + set _private($g,corner) A + } +} + +proc blt::ZoomStack::DragStart { g x y } { + variable _private + if { ![info exists _private($g,corner)] } { + Init $g + } + GetCoords $g $x $y A + if { ![$g inside $x $y] } { + return + } + set _private(drag) 1 + TitleNext $g +} + +proc blt::ZoomStack::DragMotion { g x y } { + variable _private + + if { $_private(drag) } { + GetCoords $g $x $y B + set dx [expr abs($_private($g,B,x) - $_private($g,A,x))] + set dy [expr abs($_private($g,B,y) - $_private($g,A,y))] + Box $g + if { $dy > 10 && $dx > 10 } { + return 1 + } + } + return 0 +} + +proc blt::ZoomStack::DragFinish { g x y } { + variable _private + if { [DragMotion $g $x $y] } { + Push $g + } else { + eval $g marker delete [$g marker names "zoom*"] + if { [info exists _private($g,afterId)] } { + after cancel $_private($g,afterId) + } + } + set _private(drag) 0 +} + + +proc blt::ZoomStack::MarchingAnts { g offset } { + variable _private + + incr offset + # wrap the counter after 2^16 + set offset [expr $offset & 0xFFFF] + if { [$g marker exists zoomOutline] } { + $g marker configure zoomOutline -dashoffset $offset + set interval $_private($g,interval) + set id [after $interval [list blt::ZoomStack::MarchingAnts $g $offset]] + set _private($g,afterId) $id + } +} + +proc blt::ZoomStack::Box { g } { + variable _private + + if { $_private($g,A,x) > $_private($g,B,x) } { + set x1 [$g xaxis invtransform $_private($g,B,x)] + set y1 [$g yaxis invtransform $_private($g,B,y)] + set x2 [$g xaxis invtransform $_private($g,A,x)] + set y2 [$g yaxis invtransform $_private($g,A,y)] + } else { + set x1 [$g xaxis invtransform $_private($g,A,x)] + set y1 [$g yaxis invtransform $_private($g,A,y)] + set x2 [$g xaxis invtransform $_private($g,B,x)] + set y2 [$g yaxis invtransform $_private($g,B,y)] + } + set coords { $x1 $y1 $x2 $y1 $x2 $y2 $x1 $y2 $x1 $y1 } + if { [$g marker exists "zoomOutline"] } { + $g marker configure "zoomOutline" -coords $coords + } else { + set X [lindex [$g xaxis use] 0] + set Y [lindex [$g yaxis use] 0] + $g marker create line -coords $coords -name "zoomOutline" \ + -mapx $X -mapy $Y + set interval $_private($g,interval) + set id [after $interval [list blt::ZoomStack::MarchingAnts $g 0]] + set _private($g,afterId) $id + } +} + + +proc Blt_PostScriptDialog { g } { + set top $g.top + toplevel $top + + foreach var { center landscape maxpect preview decorations padx + pady paperwidth paperheight width height colormode } { + global $g.$var + set $g.$var [$g postscript cget -$var] + } + set row 1 + set col 0 + label $top.title -text "PostScript Options" + blt::table $top $top.title -cspan 7 + foreach bool { center landscape maxpect preview decorations } { + set w $top.$bool-label + label $w -text "-$bool" -font "courier 12" + blt::table $top $row,$col $w -anchor e -pady { 2 0 } -padx { 0 4 } + set w $top.$bool-yes + global $g.$bool + radiobutton $w -text "yes" -variable $g.$bool -value 1 + blt::table $top $row,$col+1 $w -anchor w + set w $top.$bool-no + radiobutton $w -text "no" -variable $g.$bool -value 0 + blt::table $top $row,$col+2 $w -anchor w + incr row + } + label $top.modes -text "-colormode" -font "courier 12" + blt::table $top $row,0 $top.modes -anchor e -pady { 2 0 } -padx { 0 4 } + set col 1 + foreach m { color greyscale } { + set w $top.$m + radiobutton $w -text $m -variable $g.colormode -value $m + blt::table $top $row,$col $w -anchor w + incr col + } + set row 1 + frame $top.sep -width 2 -bd 1 -relief sunken + blt::table $top $row,3 $top.sep -fill y -rspan 6 + set col 4 + foreach value { padx pady paperwidth paperheight width height } { + set w $top.$value-label + label $w -text "-$value" -font "courier 12" + blt::table $top $row,$col $w -anchor e -pady { 2 0 } -padx { 0 4 } + set w $top.$value-entry + global $g.$value + entry $w -textvariable $g.$value -width 8 + blt::table $top $row,$col+1 $w -cspan 2 -anchor w -padx 8 + incr row + } + blt::table configure $top c3 -width .125i + button $top.cancel -text "Cancel" -command "destroy $top" + blt::table $top $row,0 $top.cancel -width 1i -pady 2 -cspan 3 + button $top.reset -text "Reset" -command "destroy $top" + #blt::table $top $row,1 $top.reset -width 1i + button $top.print -text "Print" -command "blt::ResetPostScript $g" + blt::table $top $row,4 $top.print -width 1i -pady 2 -cspan 2 +} + +proc blt::ResetPostScript { g } { + foreach var { center landscape maxpect preview decorations padx + pady paperwidth paperheight width height colormode } { + global $g.$var + set old [$g postscript cget -$var] + if { [catch {$g postscript configure -$var [set $g.$var]}] != 0 } { + $g postscript configure -$var $old + set $g.$var $old + } + } + $g postscript output "out.ps" + puts stdout "wrote file \"out.ps\"." + flush stdout +} diff --git a/src/bltChain.C b/src/bltChain.C new file mode 100644 index 0000000..b6051b8 --- /dev/null +++ b/src/bltChain.C @@ -0,0 +1,518 @@ + +/* + * bltChain.c -- + * + * The module implements a generic linked list package. + * + * Copyright 1991-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltInt.h" +#include "bltChain.h" + +#ifndef ALIGN +#define ALIGN(a) \ + (((size_t)a + (sizeof(double) - 1)) & (~(sizeof(double) - 1))) +#endif /* ALIGN */ + +typedef struct _Blt_ChainLink ChainLink; +typedef struct _Blt_Chain Chain; + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_Create -- + * + * Creates a new linked list (chain) structure and initializes its + * pointers; + * + * Results: + * Returns a pointer to the newly created chain structure. + * + *--------------------------------------------------------------------------- + */ +Blt_Chain +Blt_Chain_Create(void) +{ + Chain *chainPtr; + + chainPtr = Blt_Malloc(sizeof(Chain)); + if (chainPtr != NULL) { + Blt_Chain_Init(chainPtr); + } + return chainPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_AllocLink -- + * + * Creates a new chain link. Unlink Blt_Chain_NewLink, this routine also + * allocates extra memory in the node for data. + * + * Results: + * The return value is the pointer to the newly created entry. + * + *--------------------------------------------------------------------------- + */ +Blt_ChainLink +Blt_Chain_AllocLink(size_t extraSize) +{ + ChainLink *linkPtr; + size_t linkSize; + + linkSize = ALIGN(sizeof(ChainLink)); + linkPtr = Blt_AssertCalloc(1, linkSize + extraSize); + if (extraSize > 0) { + /* Point clientData at the memory beyond the normal structure. */ + linkPtr->clientData = (ClientData)((char *)linkPtr + linkSize); + } + return linkPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_InitLink -- + * + * Initializes the new link. This routine is for applications that use + * their own memory allocation procedures to allocate links. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_InitLink(ChainLink *linkPtr) +{ + linkPtr->clientData = NULL; + linkPtr->next = linkPtr->prev = NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_NewLink -- + * + * Creates a new link. + * + * Results: + * The return value is the pointer to the newly created link. + * + *--------------------------------------------------------------------------- + */ +Blt_ChainLink +Blt_Chain_NewLink(void) +{ + ChainLink *linkPtr; + + linkPtr = Blt_AssertMalloc(sizeof(ChainLink)); + linkPtr->clientData = NULL; + linkPtr->next = linkPtr->prev = NULL; + return linkPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_Reset -- + * + * Removes all the links in the chain, freeing the memory used for each + * link. Memory pointed to by the link (clientData) is not freed. It's + * the caller's responsibility to deallocate it. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_Reset(Chain *chainPtr) /* Chain to clear */ +{ + if (chainPtr != NULL) { + ChainLink *oldPtr; + ChainLink *linkPtr = chainPtr->head; + + while (linkPtr != NULL) { + oldPtr = linkPtr; + linkPtr = linkPtr->next; + Blt_Free(oldPtr); + } + Blt_Chain_Init(chainPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_Destroy + * + * Frees all the nodes in the chain and deallocates the memory used for + * the chain structure itself. It's assumed that the chain was previously + * allocated by Blt_Chain_Create. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_Destroy(Chain *chainPtr) +{ + if (chainPtr != NULL) { + Blt_Chain_Reset(chainPtr); + Blt_Free(chainPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_Init -- + * + * Initializes a linked list. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_Init(Chain *chainPtr) +{ + chainPtr->nLinks = 0; + chainPtr->head = chainPtr->tail = NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_LinkAfter -- + * + * Inserts a link after another link. If afterPtr is NULL, then the new + * link is prepended to the beginning of the chain. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_LinkAfter(Chain *chainPtr, ChainLink *linkPtr, ChainLink *afterPtr) +{ + if (chainPtr->head == NULL) { + chainPtr->tail = chainPtr->head = linkPtr; + } else { + if (afterPtr == NULL) { + /* Append to the end of the chain. */ + linkPtr->next = NULL; + linkPtr->prev = chainPtr->tail; + chainPtr->tail->next = linkPtr; + chainPtr->tail = linkPtr; + } else { + linkPtr->next = afterPtr->next; + linkPtr->prev = afterPtr; + if (afterPtr == chainPtr->tail) { + chainPtr->tail = linkPtr; + } else { + afterPtr->next->prev = linkPtr; + } + afterPtr->next = linkPtr; + } + } + chainPtr->nLinks++; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_LinkBefore -- + * + * Inserts a new link preceding a given link in a chain. If beforePtr is + * NULL, then the new link is placed at the beginning of the list. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_LinkBefore(Chain *chainPtr, ChainLink *linkPtr, ChainLink *beforePtr) +{ + if (chainPtr->head == NULL) { + chainPtr->tail = chainPtr->head = linkPtr; + } else { + if (beforePtr == NULL) { + /* Prepend to the front of the chain */ + linkPtr->next = chainPtr->head; + linkPtr->prev = NULL; + chainPtr->head->prev = linkPtr; + chainPtr->head = linkPtr; + } else { + linkPtr->prev = beforePtr->prev; + linkPtr->next = beforePtr; + if (beforePtr == chainPtr->head) { + chainPtr->head = linkPtr; + } else { + beforePtr->prev->next = linkPtr; + } + beforePtr->prev = linkPtr; + } + } + chainPtr->nLinks++; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_UnlinkLink -- + * + * Unlinks a link from the chain. The link is not deallocated, but only + * removed from the chain. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_UnlinkLink(Chain *chainPtr, ChainLink *linkPtr) +{ + int unlinked; /* Indicates if the link is actually removed + * from the chain. */ + + unlinked = FALSE; + if (chainPtr->head == linkPtr) { + chainPtr->head = linkPtr->next; + unlinked = TRUE; + } + if (chainPtr->tail == linkPtr) { + chainPtr->tail = linkPtr->prev; + unlinked = TRUE; + } + if (linkPtr->next != NULL) { + linkPtr->next->prev = linkPtr->prev; + unlinked = TRUE; + } + if (linkPtr->prev != NULL) { + linkPtr->prev->next = linkPtr->next; + unlinked = TRUE; + } + if (unlinked) { + chainPtr->nLinks--; + } + linkPtr->prev = linkPtr->next = NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_DeleteLink -- + * + * Unlinks and frees the given link from the chain. It's assumed that + * the link belong to the chain. No error checking is performed to verify + * this. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_DeleteLink(Blt_Chain chain, Blt_ChainLink link) +{ + Blt_Chain_UnlinkLink(chain, link); + Blt_Free(link); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_Append + * + * Creates and new link with the given data and appends it to the end of + * the chain. + * + * Results: + * Returns a pointer to the link created. + * + *--------------------------------------------------------------------------- + */ +Blt_ChainLink +Blt_Chain_Append(Blt_Chain chain, ClientData clientData) +{ + Blt_ChainLink link; + + link = Blt_Chain_NewLink(); + Blt_Chain_LinkAfter(chain, link, (Blt_ChainLink)NULL); + Blt_Chain_SetValue(link, clientData); + return link; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_Prepend + * + * Creates and new link with the given data and prepends it to beginning + * of the chain. + * + * Results: + * Returns a pointer to the link created. + * + *--------------------------------------------------------------------------- + */ +Blt_ChainLink +Blt_Chain_Prepend(Blt_Chain chain, ClientData clientData) +{ + Blt_ChainLink link; + + link = Blt_Chain_NewLink(); + Blt_Chain_LinkBefore(chain, link, (Blt_ChainLink)NULL); + Blt_Chain_SetValue(link, clientData); + return link; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_GetNthLink -- + * + * Find the link at the given position in the chain. The position + * is number from 0. If position is negative is returns the nth + * link from the back of the chain. + * + * Results: + * Returns the pointer to the link, if that numbered link + * exists. Otherwise NULL. + * + *--------------------------------------------------------------------------- + */ +Blt_ChainLink +Blt_Chain_GetNthLink(Chain *chainPtr, long position) +{ + if (chainPtr != NULL) { + if (position < 0) { + ChainLink *linkPtr; + int i; + + position = -position; + for (i = 0, linkPtr = chainPtr->tail; linkPtr != NULL; + linkPtr = linkPtr->prev, i++) { + if (i == position) { + return linkPtr; + } + } + } else { + ChainLink *linkPtr; + int i; + + linkPtr = chainPtr->head; + for (i = 0, linkPtr = chainPtr->head; linkPtr != NULL; + linkPtr = linkPtr->next, i++) { + if (i == position) { + return linkPtr; + } + } + } + } + return NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_Sort -- + * + * Sorts the chain according to the given comparison routine. + * + * Results: + * None. + * + * Side Effects: + * The chain is reordered. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Chain_Sort(Chain *chainPtr, Blt_ChainCompareProc *proc) +{ + ChainLink **linkArr; + ChainLink *linkPtr; + long i; + + if (chainPtr->nLinks < 2) { + return; + } + linkArr = Blt_Malloc(sizeof(Blt_ChainLink) * (chainPtr->nLinks + 1)); + if (linkArr == NULL) { + return; /* Out of memory. */ + } + i = 0; + for (linkPtr = chainPtr->head; linkPtr != NULL; + linkPtr = linkPtr->next) { + linkArr[i++] = linkPtr; + } + qsort((char *)linkArr, chainPtr->nLinks, sizeof(Blt_ChainLink), + (QSortCompareProc *)proc); + + /* Rethread the chain. */ + linkPtr = linkArr[0]; + chainPtr->head = linkPtr; + linkPtr->prev = NULL; + for (i = 1; i < chainPtr->nLinks; i++) { + linkPtr->next = linkArr[i]; + linkPtr->next->prev = linkPtr; + linkPtr = linkPtr->next; + } + chainPtr->tail = linkPtr; + linkPtr->next = NULL; + Blt_Free(linkArr); +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_Chain_IsBefore -- + * + * + * Results: + * Return boolean value if the first link comes before the second. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Chain_IsBefore(ChainLink *firstPtr, ChainLink *lastPtr) +{ + ChainLink *linkPtr; + + for (linkPtr = firstPtr; linkPtr != NULL; linkPtr = linkPtr->next) { + if (linkPtr == lastPtr) { + return TRUE; + } + } + return FALSE; +} + diff --git a/src/bltChain.h b/src/bltChain.h new file mode 100644 index 0000000..e0b0259 --- /dev/null +++ b/src/bltChain.h @@ -0,0 +1,90 @@ + +/* + * bltChain.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +#ifndef _BLT_CHAIN_H +#define _BLT_CHAIN_H + +typedef struct _Blt_Chain *Blt_Chain; +typedef struct _Blt_ChainLink *Blt_ChainLink; + +/* + * A Blt_ChainLink is the container structure for the Blt_Chain. + */ + +struct _Blt_ChainLink { + Blt_ChainLink prev; /* Link to the previous link */ + Blt_ChainLink next; /* Link to the next link */ + ClientData clientData; /* Pointer to the data object */ +}; + +typedef int (Blt_ChainCompareProc)(Blt_ChainLink *l1Ptr, Blt_ChainLink *l2Ptr); + +/* + * A Blt_Chain is a doubly chained list structure. + */ +struct _Blt_Chain { + Blt_ChainLink head; /* Pointer to first element in chain */ + Blt_ChainLink tail; /* Pointer to last element in chain */ + long nLinks; /* Number of elements in chain */ +}; + +BLT_EXTERN void Blt_Chain_Init(Blt_Chain chain); +BLT_EXTERN Blt_Chain Blt_Chain_Create(void); +BLT_EXTERN void Blt_Chain_Destroy(Blt_Chain chain); +BLT_EXTERN Blt_ChainLink Blt_Chain_NewLink(void); +BLT_EXTERN Blt_ChainLink Blt_Chain_AllocLink(size_t size); +BLT_EXTERN Blt_ChainLink Blt_Chain_Append(Blt_Chain chain, + ClientData clientData); +BLT_EXTERN Blt_ChainLink Blt_Chain_Prepend(Blt_Chain chain, + ClientData clientData); +BLT_EXTERN void Blt_Chain_Reset(Blt_Chain chain); +BLT_EXTERN void Blt_Chain_InitLink(Blt_ChainLink link); +BLT_EXTERN void Blt_Chain_LinkAfter(Blt_Chain chain, Blt_ChainLink link, + Blt_ChainLink after); +BLT_EXTERN void Blt_Chain_LinkBefore(Blt_Chain chain, Blt_ChainLink link, + Blt_ChainLink before); +BLT_EXTERN void Blt_Chain_UnlinkLink(Blt_Chain chain, Blt_ChainLink link); +BLT_EXTERN void Blt_Chain_DeleteLink(Blt_Chain chain, Blt_ChainLink link); +BLT_EXTERN Blt_ChainLink Blt_Chain_GetNthLink(Blt_Chain chain, long position); +BLT_EXTERN void Blt_Chain_Sort(Blt_Chain chain, Blt_ChainCompareProc *proc); +BLT_EXTERN int Blt_Chain_IsBefore(Blt_ChainLink first, Blt_ChainLink last); + +#define Blt_Chain_GetLength(c) (((c) == NULL) ? 0 : (c)->nLinks) +#define Blt_Chain_FirstLink(c) (((c) == NULL) ? NULL : (c)->head) +#define Blt_Chain_LastLink(c) (((c) == NULL) ? NULL : (c)->tail) +#define Blt_Chain_PrevLink(l) ((l)->prev) +#define Blt_Chain_NextLink(l) ((l)->next) +#define Blt_Chain_GetValue(l) ((l)->clientData) +#define Blt_Chain_FirstValue(c) (((c)->head == NULL) ? NULL : (c)->head->clientData) +#define Blt_Chain_SetValue(l, value) ((l)->clientData = (ClientData)(value)) +#define Blt_Chain_AppendLink(c, l) \ + (Blt_Chain_LinkAfter((c), (l), (Blt_ChainLink)NULL)) +#define Blt_Chain_PrependLink(c, l) \ + (Blt_Chain_LinkBefore((c), (l), (Blt_ChainLink)NULL)) + +#endif /* _BLT_CHAIN_H */ diff --git a/src/bltConfig.C b/src/bltConfig.C new file mode 100644 index 0000000..cf67a23 --- /dev/null +++ b/src/bltConfig.C @@ -0,0 +1,2493 @@ + +/* + * bltConfig.c -- + * + * This file contains a Tcl_Obj based replacement for the widget + * configuration functions in Tk. + * + * Copyright (c) 1990-1994 The Regents of the University of California. + * Copyright (c) 1994-1997 Sun Microsystems, Inc. + * + * See the file "license.terms" for information on usage and redistribution + * of this file, and for a DISCLAIMER OF ALL WARRANTIES. + * + * Copyright 2003-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * This is a Tcl_Obj based replacement for the widget configuration + * functions in Tk. + * + * What not use the new Tk_Option interface? + * + * There were design changes in the new Tk_Option interface that + * make it unwieldy. + * + * o You have to dynamically allocate, store, and deallocate + * your option table. + * o The Tk_FreeConfigOptions routine requires a tkwin argument. + * Unfortunately, most widgets save the display pointer and + * de-reference their tkwin when the window is destroyed. + * o There's no TK_CONFIG_CUSTOM functionality. This means that + * save special options must be saved as strings by + * Tk_ConfigureWidget and processed later, thus losing the + * benefits of Tcl_Objs. It also make error handling + * problematic, since you don't pick up certain errors like + * + * .widget configure -myoption bad -myoption good + * + * You will never see the first "bad" value. + * o Especially compared to the former Tk_ConfigureWidget calls, + * the new interface is overly complex. If there was a big + * performance win, it might be worth the effort. But let's + * face it, this biggest wins are in processing custom options + * values with thousands of elements. Most common resources + * (font, color, etc) have string tokens anyways. + * + * On the other hand, the replacement functions in this file fell + * into place quite easily both from the aspect of API writer and + * user. The biggest benefit is that you don't need to change lots + * of working code just to get the benefits of Tcl_Objs. + * + */ + +#include "bltInt.h" + +#include <stdarg.h> +#include "bltFont.h" +#include "bltPicture.h" +#include "bltBgStyle.h" + +#if (_TK_VERSION < _VERSION(8,1,0)) +/* + *--------------------------------------------------------------------------- + * + * Tk_GetAnchorFromObj -- + * + * Return a Tk_Anchor value based on the value of the objPtr. + * + * Results: + * The return value is a standard TCL result. If an error occurs during + * conversion, an error message is left in the interpreter's result + * unless "interp" is NULL. + * + * Side effects: + * The object gets converted by Tcl_GetIndexFromObj. + * + *--------------------------------------------------------------------------- + */ +int +Tk_GetAnchorFromObj( + Tcl_Interp *interp, /* Used for error reporting. */ + Tcl_Obj *objPtr, /* The object we are trying to get the + * value from. */ + Tk_Anchor *anchorPtr) /* Where to place the Tk_Anchor that + * corresponds to the string value of + * objPtr. */ +{ + return Tk_GetAnchor(interp, Tcl_GetString(objPtr), anchorPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * Tk_GetJustifyFromObj -- + * + * Return a Tk_Justify value based on the value of the objPtr. + * + * Results: + * The return value is a standard TCL result. If an error occurs during + * conversion, an error message is left in the interpreter's result + * unless "interp" is NULL. + * + * Side effects: + * The object gets converted by Tcl_GetIndexFromObj. + * + *--------------------------------------------------------------------------- + */ +int +Tk_GetJustifyFromObj( + Tcl_Interp *interp, /* Used for error reporting. */ + Tcl_Obj *objPtr, /* The object we are trying to get the + * value from. */ + Tk_Justify *justifyPtr) /* Where to place the Tk_Justify that + * corresponds to the string value of + * objPtr. */ +{ + return Tk_GetJustify(interp, Tcl_GetString(objPtr), justifyPtr); +} +/* + *--------------------------------------------------------------------------- + * + * Tk_GetReliefFromObj -- + * + * Return an integer value based on the value of the objPtr. + * + * Results: + * The return value is a standard TCL result. If an error occurs during + * conversion, an error message is left in the interpreter's result + * unless "interp" is NULL. + * + * Side effects: + * The object gets converted by Tcl_GetIndexFromObj. + * + *--------------------------------------------------------------------------- + */ +int +Tk_GetReliefFromObj( + Tcl_Interp *interp, /* Used for error reporting. */ + Tcl_Obj *objPtr, /* The object we are trying to get the + * value from. */ + int *reliefPtr) /* Where to place the answer. */ +{ + return Tk_GetRelief(interp, Tcl_GetString(objPtr), reliefPtr); +} + + +/* + *--------------------------------------------------------------------------- + * + * Tk_Alloc3DBorderFromObj -- + * + * Given a Tcl_Obj *, map the value to a corresponding + * Tk_3DBorder structure based on the tkwin given. + * + * Results: + * The return value is a token for a data structure describing a + * 3-D border. This token may be passed to procedures such as + * Blt_Draw3DRectangle and Tk_Free3DBorder. If an error prevented + * the border from being created then NULL is returned and an error + * message will be left in the interp's result. + * + * Side effects: + * The border is added to an internal database with a reference + * count. For each call to this procedure, there should eventually + * be a call to FreeBorderObjProc so that the database is + * cleaned up when borders aren't in use anymore. + * + *--------------------------------------------------------------------------- + */ +Tk_3DBorder +Tk_Alloc3DBorderFromObj( + Tcl_Interp *interp, /* Interp for error results. */ + Tk_Window tkwin, /* Need the screen the border is used on.*/ + Tcl_Obj *objPtr) /* Object giving name of color for window + * background. */ +{ + return Tk_Get3DBorder(interp, tkwin, Tcl_GetString(objPtr)); +} +/* + *--------------------------------------------------------------------------- + * + * Tk_AllocBitmapFromObj -- + * + * Given a Tcl_Obj *, map the value to a corresponding + * Pixmap structure based on the tkwin given. + * + * Results: + * The return value is the X identifer for the desired bitmap + * (i.e. a Pixmap with a single plane), unless string couldn't be + * parsed correctly. In this case, None is returned and an error + * message is left in the interp's result. The caller should never + * modify the bitmap that is returned, and should eventually call + * Tk_FreeBitmapFromObj when the bitmap is no longer needed. + * + * Side effects: + * The bitmap is added to an internal database with a reference count. + * For each call to this procedure, there should eventually be a call + * to Tk_FreeBitmapFromObj, so that the database can be cleaned up + * when bitmaps aren't needed anymore. + * + *--------------------------------------------------------------------------- + */ +Pixmap +Tk_AllocBitmapFromObj( + Tcl_Interp *interp, /* Interp for error results. This may + * be NULL. */ + Tk_Window tkwin, /* Need the screen the bitmap is used on.*/ + Tcl_Obj *objPtr) /* Object describing bitmap; see manual + * entry for legal syntax of string value. */ +{ + return Tk_GetBitmap(interp, tkwin, Tcl_GetString(objPtr)); +} + +/* + *--------------------------------------------------------------------------- + * + * Tk_AllocFontFromObj -- + * + * Given a string description of a font, map the description to a + * corresponding Blt_Font that represents the font. + * + * Results: + * The return value is token for the font, or NULL if an error + * prevented the font from being created. If NULL is returned, an + * error message will be left in interp's result object. + * + * Side effects: + * The font is added to an internal database with a reference + * count. For each call to this procedure, there should eventually + * be a call to Blt_FreeFont() or Blt_FreeFontFromObj() so that the + * database is cleaned up when fonts aren't in use anymore. + * + *--------------------------------------------------------------------------- + */ +Tk_Font +Tk_AllocFontFromObj( + Tcl_Interp *interp, /* Interp for database and error return. */ + Tk_Window tkwin, /* For screen on which font will be used. */ + Tcl_Obj *objPtr) /* Object describing font, as: named font, + * native format, or parseable string. */ +{ + return Tk_GetFont(interp, tkwin, Tcl_GetString(objPtr)); +} + +/* + *--------------------------------------------------------------------------- + * + * Tk_AllocCursorFromObj -- + * + * Given a Tcl_Obj *, map the value to a corresponding + * Tk_Cursor structure based on the tkwin given. + * + * Results: + * The return value is the X identifer for the desired cursor, + * unless objPtr couldn't be parsed correctly. In this case, + * None is returned and an error message is left in the interp's result. + * The caller should never modify the cursor that is returned, and + * should eventually call Tk_FreeCursorFromObj when the cursor is no + * longer needed. + * + * Side effects: + * The cursor is added to an internal database with a reference count. + * For each call to this procedure, there should eventually be a call + * to Tk_FreeCursorFromObj, so that the database can be cleaned up + * when cursors aren't needed anymore. + * + *--------------------------------------------------------------------------- + */ +Tk_Cursor +Tk_AllocCursorFromObj( + Tcl_Interp *interp, /* Interp for error results. */ + Tk_Window tkwin, /* Window in which the cursor will be used.*/ + Tcl_Obj *objPtr) /* Object describing cursor; see manual + * entry for description of legal + * syntax of this obj's string rep. */ +{ + return Tk_GetCursor(interp, tkwin, Tcl_GetString(objPtr)); +} + +/* + *--------------------------------------------------------------------------- + * + * Tk_AllocColorFromObj -- + * + * Given a Tcl_Obj *, map the value to a corresponding + * XColor structure based on the tkwin given. + * + * Results: + * The return value is a pointer to an XColor structure that + * indicates the red, blue, and green intensities for the color + * given by the string in objPtr, and also specifies a pixel value + * to use to draw in that color. If an error occurs, NULL is + * returned and an error message will be left in interp's result + * (unless interp is NULL). + * + * Side effects: + * The color is added to an internal database with a reference count. + * For each call to this procedure, there should eventually be a call + * to Tk_FreeColorFromObj so that the database is cleaned up when colors + * aren't in use anymore. + * + *--------------------------------------------------------------------------- + */ +XColor * +Tk_AllocColorFromObj( + Tcl_Interp *interp, /* Used only for error reporting. If NULL, + * then no messages are provided. */ + Tk_Window tkwin, /* Window in which the color will be used.*/ + Tcl_Obj *objPtr) /* Object that describes the color; string + * value is a color name such as "red" or + * "#ff0000".*/ +{ + const char *string; + + string = Tcl_GetString(objPtr); + return Tk_GetColor(interp, tkwin, Tk_GetUid(string)); +} +#endif + + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetPositionFromObj -- + * + * Convert a string representing a numeric position. + * A position can be in one of the following forms. + * + * number - number of the item in the hierarchy, indexed + * from zero. + * "end" - last position in the hierarchy. + * + * Results: + * A standard TCL result. If "string" is a valid index, then + * *indexPtr is filled with the corresponding numeric index. + * If "end" was selected then *indexPtr is set to -1. + * Otherwise an error message is left in interp->result. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +int +Blt_GetPositionFromObj( + Tcl_Interp *interp, /* Interpreter to report results back + * to. */ + Tcl_Obj *objPtr, /* Tcl_Obj representation of the index. + * Can be an integer or "end" to refer + * to the last index. */ + long *indexPtr) /* Holds the converted index. */ +{ + const char *string; + + string = Tcl_GetString(objPtr); + if ((string[0] == 'e') && (strcmp(string, "end") == 0)) { + *indexPtr = -1; /* Indicates last position in hierarchy. */ + } else { + long position; + + if (Tcl_GetLongFromObj(interp, objPtr, &position) != TCL_OK) { + return TCL_ERROR; + } + if (position < 0) { + Tcl_AppendResult(interp, "bad position \"", string, "\"", + (char *)NULL); + return TCL_ERROR; + } + *indexPtr = position; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetPixelsFromObj -- + * + * Like Tk_GetPixelsFromObj, but checks for negative, zero. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +int +Blt_GetPixelsFromObj( + Tcl_Interp *interp, + Tk_Window tkwin, + Tcl_Obj *objPtr, + int check, /* Can be PIXELS_POS, PIXELS_NNEG, + * or PIXELS_ANY, */ + int *valuePtr) +{ + int length; + + if (Tk_GetPixelsFromObj(interp, tkwin, objPtr, &length) != TCL_OK) { + return TCL_ERROR; + } + if (length >= SHRT_MAX) { + Tcl_AppendResult(interp, "bad distance \"", Tcl_GetString(objPtr), + "\": too big to represent", (char *)NULL); + return TCL_ERROR; + } + switch (check) { + case PIXELS_NNEG: + if (length < 0) { + Tcl_AppendResult(interp, "bad distance \"", Tcl_GetString(objPtr), + "\": can't be negative", (char *)NULL); + return TCL_ERROR; + } + break; + + case PIXELS_POS: + if (length <= 0) { + Tcl_AppendResult(interp, "bad distance \"", Tcl_GetString(objPtr), + "\": must be positive", (char *)NULL); + return TCL_ERROR; + } + break; + + case PIXELS_ANY: + break; + } + *valuePtr = length; + return TCL_OK; +} + +int +Blt_GetPadFromObj( + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Window */ + Tcl_Obj *objPtr, /* Pixel value string */ + Blt_Pad *padPtr) +{ + int side1, side2; + int objc; + Tcl_Obj **objv; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if ((objc < 1) || (objc > 2)) { + Tcl_AppendResult(interp, "wrong # elements in padding list", + (char *)NULL); + return TCL_ERROR; + } + if (Blt_GetPixelsFromObj(interp, tkwin, objv[0], PIXELS_NNEG, + &side1) != TCL_OK) { + return TCL_ERROR; + } + side2 = side1; + if ((objc > 1) && + (Blt_GetPixelsFromObj(interp, tkwin, objv[1], PIXELS_NNEG, + &side2) != TCL_OK)) { + return TCL_ERROR; + } + /* Don't update the pad structure until we know both values are okay. */ + padPtr->side1 = side1; + padPtr->side2 = side2; + return TCL_OK; +} + +int +Blt_GetStateFromObj( + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tcl_Obj *objPtr, /* Pixel value string */ + int *statePtr) +{ + char c; + const char *string; + int length; + + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[0]; + if ((c == 'n') && (strncmp(string, "normal", length) == 0)) { + *statePtr = STATE_NORMAL; + } else if ((c == 'd') && (strncmp(string, "disabled", length) == 0)) { + *statePtr = STATE_DISABLED; + } else if ((c == 'a') && (strncmp(string, "active", length) == 0)) { + *statePtr = STATE_ACTIVE; + } else { + Tcl_AppendResult(interp, "bad state \"", string, + "\": should be normal, active, or disabled", (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +const char * +Blt_NameOfState(int state) +{ + switch (state) { + case STATE_ACTIVE: + return "active"; + case STATE_DISABLED: + return "disabled"; + case STATE_NORMAL: + return "normal"; + default: + return "???"; + } +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_NameOfFill -- + * + * Converts the integer representing the fill style into a string. + * + *--------------------------------------------------------------------------- + */ +const char * +Blt_NameOfFill(int fill) +{ + switch (fill) { + case FILL_X: + return "x"; + case FILL_Y: + return "y"; + case FILL_NONE: + return "none"; + case FILL_BOTH: + return "both"; + default: + return "unknown value"; + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetFillFromObj -- + * + * Converts the fill style string into its numeric representation. + * + * Valid style strings are: + * + * "none" Use neither plane. + * "x" X-coordinate plane. + * "y" Y-coordinate plane. + * "both" Use both coordinate planes. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +int +Blt_GetFillFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *fillPtr) +{ + char c; + const char *string; + int length; + + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[0]; + if ((c == 'n') && (strncmp(string, "none", length) == 0)) { + *fillPtr = FILL_NONE; + } else if ((c == 'x') && (strncmp(string, "x", length) == 0)) { + *fillPtr = FILL_X; + } else if ((c == 'y') && (strncmp(string, "y", length) == 0)) { + *fillPtr = FILL_Y; + } else if ((c == 'b') && (strncmp(string, "both", length) == 0)) { + *fillPtr = FILL_BOTH; + } else { + Tcl_AppendResult(interp, "bad argument \"", string, + "\": should be \"none\", \"x\", \"y\", or \"both\"", (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_NameOfResize -- + * + * Converts the resize value into its string representation. + * + * Results: + * Returns a pointer to the static name string. + * + *--------------------------------------------------------------------------- + */ +const char * +Blt_NameOfResize(int resize) +{ + switch (resize & RESIZE_BOTH) { + case RESIZE_NONE: + return "none"; + case RESIZE_EXPAND: + return "expand"; + case RESIZE_SHRINK: + return "shrink"; + case RESIZE_BOTH: + return "both"; + default: + return "unknown resize value"; + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetResizeFromObj -- + * + * Converts the resize string into its numeric representation. + * + * Valid style strings are: + * + * "none" + * "expand" + * "shrink" + * "both" + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +int +Blt_GetResizeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, int *resizePtr) +{ + char c; + const char *string; + int length; + + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[0]; + if ((c == 'n') && (strncmp(string, "none", length) == 0)) { + *resizePtr = RESIZE_NONE; + } else if ((c == 'b') && (strncmp(string, "both", length) == 0)) { + *resizePtr = RESIZE_BOTH; + } else if ((c == 'e') && (strncmp(string, "expand", length) == 0)) { + *resizePtr = RESIZE_EXPAND; + } else if ((c == 's') && (strncmp(string, "shrink", length) == 0)) { + *resizePtr = RESIZE_SHRINK; + } else { + Tcl_AppendResult(interp, "bad resize argument \"", string, + "\": should be \"none\", \"expand\", \"shrink\", or \"both\"", + (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetDashesFromObj -- + * + * Converts a TCL list of dash values into a dash list ready for + * use with XSetDashes. + * + * A valid list dash values can have zero through 11 elements + * (PostScript limit). Values must be between 1 and 255. Although + * a list of 0 (like the empty string) means no dashes. + * + * Results: + * A standard TCL result. If the list represented a valid dash + * list TCL_OK is returned and *dashesPtr* will contain the + * valid dash list. Otherwise, TCL_ERROR is returned and + * interp->result will contain an error message. + * + * + *--------------------------------------------------------------------------- + */ +int +Blt_GetDashesFromObj( + Tcl_Interp *interp, + Tcl_Obj *objPtr, + Blt_Dashes *dashesPtr) +{ + const char *string; + char c; + + string = Tcl_GetString(objPtr); + if (string == NULL) { + dashesPtr->values[0] = 0; + return TCL_OK; + } + c = string[0]; + if (c == '\0') { + dashesPtr->values[0] = 0; + } else if ((c == 'd') && (strcmp(string, "dot") == 0)) { + /* 1 */ + dashesPtr->values[0] = 1; + dashesPtr->values[1] = 0; + } else if ((c == 'd') && (strcmp(string, "dash") == 0)) { + /* 5 2 */ + dashesPtr->values[0] = 5; + dashesPtr->values[1] = 2; + dashesPtr->values[2] = 0; + } else if ((c == 'd') && (strcmp(string, "dashdot") == 0)) { + /* 2 4 2 */ + dashesPtr->values[0] = 2; + dashesPtr->values[1] = 4; + dashesPtr->values[2] = 2; + dashesPtr->values[3] = 0; + } else if ((c == 'd') && (strcmp(string, "dashdotdot") == 0)) { + /* 2 4 2 2 */ + dashesPtr->values[0] = 2; + dashesPtr->values[1] = 4; + dashesPtr->values[2] = 2; + dashesPtr->values[3] = 2; + dashesPtr->values[4] = 0; + } else { + int objc; + Tcl_Obj **objv; + int i; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if (objc > 11) { /* This is the postscript limit */ + Tcl_AppendResult(interp, "too many values in dash list \"", + string, "\"", (char *)NULL); + return TCL_ERROR; + } + for (i = 0; i < objc; i++) { + int value; + + if (Tcl_GetIntFromObj(interp, objv[i], &value) != TCL_OK) { + return TCL_ERROR; + } + /* + * Backward compatibility: + * Allow list of 0 to turn off dashes + */ + if ((value == 0) && (objc == 1)) { + break; + } + if ((value < 1) || (value > 255)) { + Tcl_AppendResult(interp, "dash value \"", + Tcl_GetString(objv[i]), "\" is out of range", + (char *)NULL); + return TCL_ERROR; + } + dashesPtr->values[i] = (unsigned char)value; + } + /* Make sure the array ends with a NUL byte */ + dashesPtr->values[i] = 0; + } + return TCL_OK; +} + +const char * +Blt_NameOfSide(int side) +{ + switch (side) { + case SIDE_LEFT: + return "left"; + case SIDE_RIGHT: + return "right"; + case SIDE_BOTTOM: + return "bottom"; + case SIDE_TOP: + return "top"; + } + return "unknown side value"; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetSideFromObj -- + * + * Converts the fill style string into its numeric representation. + * + * Valid style strings are "left", "right", "top", or "bottom". + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED */ +int +Blt_GetSideFromObj( + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tcl_Obj *objPtr, /* Value string */ + int *sidePtr) /* (out) Token representing side: + * either SIDE_LEFT, SIDE_RIGHT, + * SIDE_TOP, or SIDE_BOTTOM. */ +{ + char c; + const char *string; + int length; + + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[0]; + if ((c == 'l') && (strncmp(string, "left", length) == 0)) { + *sidePtr = SIDE_LEFT; + } else if ((c == 'r') && (strncmp(string, "right", length) == 0)) { + *sidePtr = SIDE_RIGHT; + } else if ((c == 't') && (strncmp(string, "top", length) == 0)) { + *sidePtr = SIDE_TOP; + } else if ((c == 'b') && (strncmp(string, "bottom", length) == 0)) { + *sidePtr = SIDE_BOTTOM; + } else { + Tcl_AppendResult(interp, "bad side \"", string, + "\": should be left, right, top, or bottom", (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ResetLimits -- + * + * Resets the limits to their default values. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_ResetLimits(Blt_Limits *limitsPtr) /* Limits to be imposed on the value */ +{ + limitsPtr->flags = 0; + limitsPtr->min = LIMITS_MIN; + limitsPtr->max = LIMITS_MAX; + limitsPtr->nom = LIMITS_NOM; +} + +int +Blt_GetLimitsFromObj(Tcl_Interp *interp, Tk_Window tkwin, Tcl_Obj *objPtr, + Blt_Limits *limitsPtr) +{ + int values[3]; + int nValues; + int limitsFlags; + + /* Initialize limits to default values */ + values[2] = LIMITS_NOM; + values[1] = LIMITS_MAX; + values[0] = LIMITS_MIN; + limitsFlags = 0; + nValues = 0; + if (objPtr != NULL) { + Tcl_Obj **objv; + int objc; + int i; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if (objc > 3) { + Tcl_AppendResult(interp, "wrong # limits \"", Tcl_GetString(objPtr), + "\"", (char *)NULL); + return TCL_ERROR; + } + for (i = 0; i < objc; i++) { + const char *string; + int size; + + string = Tcl_GetString(objv[i]); + if (string[0] == '\0') { + continue; /* Empty string: use default value */ + } + limitsFlags |= (1 << i); + if (Tk_GetPixelsFromObj(interp, tkwin, objv[i], &size) != TCL_OK) { + return TCL_ERROR; + } + if ((size < LIMITS_MIN) || (size > LIMITS_MAX)) { + Tcl_AppendResult(interp, "bad limit \"", string, "\"", + (char *)NULL); + return TCL_ERROR; + } + values[i] = size; + } + nValues = objc; + } + /* + * Check the limits specified. We can't check the requested size of + * widgets. + */ + switch (nValues) { + case 1: + limitsFlags |= (LIMITS_MIN_SET | LIMITS_MAX_SET); + values[1] = values[0]; /* Set minimum and maximum to value */ + break; + + case 2: + if (values[1] < values[0]) { + Tcl_AppendResult(interp, "bad range \"", Tcl_GetString(objPtr), + "\": min > max", (char *)NULL); + return TCL_ERROR; /* Minimum is greater than maximum */ + } + break; + + case 3: + if (values[1] < values[0]) { + Tcl_AppendResult(interp, "bad range \"", Tcl_GetString(objPtr), + "\": min > max", (char *)NULL); + return TCL_ERROR; /* Minimum is greater than maximum */ + } + if ((values[2] < values[0]) || (values[2] > values[1])) { + Tcl_AppendResult(interp, "nominal value \"", Tcl_GetString(objPtr), + "\" out of range", (char *)NULL); + return TCL_ERROR; /* Nominal is outside of range defined + * by minimum and maximum */ + } + break; + } + limitsPtr->min = values[0]; + limitsPtr->max = values[1]; + limitsPtr->nom = values[2]; + limitsPtr->flags = limitsFlags; + return TCL_OK; +} + +/* Configuration option helper routines */ + +/* + *--------------------------------------------------------------------------- + * + * DoConfig -- + * + * This procedure applies a single configuration option + * to a widget record. + * + * Results: + * A standard TCL return value. + * + * Side effects: + * WidgRec is modified as indicated by specPtr and value. + * The old value is recycled, if that is appropriate for + * the value type. + * + *--------------------------------------------------------------------------- + */ +static int +DoConfig( + Tcl_Interp *interp, /* Interpreter for error reporting. */ + Tk_Window tkwin, /* Window containing widget (needed to + * set up X resources). */ + Blt_ConfigSpec *sp, /* Specifier to apply. */ + Tcl_Obj *objPtr, /* Value to use to fill in widgRec. */ + char *widgRec) /* Record whose fields are to be + * modified. Values must be properly + * initialized. */ +{ + char *ptr; + int objIsEmpty; + + objIsEmpty = FALSE; + if (objPtr == NULL) { + objIsEmpty = TRUE; + } else if (sp->specFlags & BLT_CONFIG_NULL_OK) { + int length; + + if (objPtr->bytes != NULL) { + length = objPtr->length; + } else { + Tcl_GetStringFromObj(objPtr, &length); + } + objIsEmpty = (length == 0); + } + do { + ptr = widgRec + sp->offset; + switch (sp->type) { + case BLT_CONFIG_ANCHOR: + { + Tk_Anchor anchor; + + if (Tk_GetAnchorFromObj(interp, objPtr, &anchor) != TCL_OK) { + return TCL_ERROR; + } + *(Tk_Anchor *)ptr = anchor; + } + break; + + case BLT_CONFIG_BITMAP: + { + Pixmap bitmap; + + if (objIsEmpty) { + bitmap = None; + } else { + bitmap = Tk_AllocBitmapFromObj(interp, tkwin, objPtr); + if (bitmap == None) { + return TCL_ERROR; + } + } + if (*(Pixmap *)ptr != None) { + Tk_FreeBitmap(Tk_Display(tkwin), *(Pixmap *)ptr); + } + *(Pixmap *)ptr = bitmap; + } + break; + + case BLT_CONFIG_BOOLEAN: + { + int bool; + + if (Tcl_GetBooleanFromObj(interp, objPtr, &bool) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = bool; + } + break; + + case BLT_CONFIG_BORDER: + { + Tk_3DBorder border; + + if (objIsEmpty) { + border = NULL; + } else { + border = Tk_Alloc3DBorderFromObj(interp, tkwin, objPtr); + if (border == NULL) { + return TCL_ERROR; + } + } + if (*(Tk_3DBorder *)ptr != NULL) { + Tk_Free3DBorder(*(Tk_3DBorder *)ptr); + } + *(Tk_3DBorder *)ptr = border; + } + break; + + case BLT_CONFIG_CAP_STYLE: + { + int cap; + Tk_Uid uid; + + uid = Tk_GetUid(Tcl_GetString(objPtr)); + if (Tk_GetCapStyle(interp, uid, &cap) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = cap; + } + break; + + case BLT_CONFIG_COLOR: + { + XColor *color; + + if (objIsEmpty) { + color = NULL; + } else { + color = Tk_GetColor(interp, tkwin, + Tk_GetUid(Tcl_GetString(objPtr))); + if (color == NULL) { + return TCL_ERROR; + } + } + if (*(XColor **)ptr != NULL) { + Tk_FreeColor(*(XColor **)ptr); + } + *(XColor **)ptr = color; + } + break; + + case BLT_CONFIG_CURSOR: + case BLT_CONFIG_ACTIVE_CURSOR: + { + Tk_Cursor cursor; + + if (objIsEmpty) { + cursor = None; + } else { + cursor = Tk_AllocCursorFromObj(interp, tkwin, objPtr); + if (cursor == None) { + return TCL_ERROR; + } + } + if (*(Tk_Cursor *)ptr != None) { + Tk_FreeCursor(Tk_Display(tkwin), *(Tk_Cursor *)ptr); + } + *(Tk_Cursor *)ptr = cursor; + if (sp->type == BLT_CONFIG_ACTIVE_CURSOR) { + Tk_DefineCursor(tkwin, cursor); + } + } + break; + + case BLT_CONFIG_CUSTOM: + if ((*sp->customPtr->parseProc)(sp->customPtr->clientData, interp, + tkwin, objPtr, widgRec, sp->offset, sp->specFlags) != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_CONFIG_DOUBLE: + { + double value; + + if (Tcl_GetDoubleFromObj(interp, objPtr, &value) != TCL_OK) { + return TCL_ERROR; + } + *(double *)ptr = value; + } + break; + + case BLT_CONFIG_FONT: + { + Blt_Font font; + + if (objIsEmpty) { + font = NULL; + } else { + font = Blt_AllocFontFromObj(interp, tkwin, objPtr); + if (font == NULL) { + return TCL_ERROR; + } + } + if (*(Blt_Font *)ptr != NULL) { + Blt_FreeFont(*(Blt_Font *)ptr); + } + *(Blt_Font *)ptr = font; + } + break; + + case BLT_CONFIG_TK_FONT: + { + Tk_Font font; + + if (objIsEmpty) { + font = NULL; + } else { + font = Tk_AllocFontFromObj(interp, tkwin, objPtr); + if (font == NULL) { + return TCL_ERROR; + } + } + if (*(Tk_Font *)ptr != NULL) { + Tk_FreeFont(*(Tk_Font *)ptr); + } + *(Tk_Font *)ptr = font; + } + break; + + case BLT_CONFIG_INT: + { + int value; + + if (Tcl_GetIntFromObj(interp, objPtr, &value) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = value; + } + break; + + case BLT_CONFIG_JOIN_STYLE: + { + int join; + Tk_Uid uid; + + uid = Tk_GetUid(Tcl_GetString(objPtr)); + if (Tk_GetJoinStyle(interp, uid, &join) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = join; + } + break; + + case BLT_CONFIG_JUSTIFY: + { + Tk_Justify justify; + + if (Tk_GetJustifyFromObj(interp, objPtr, &justify) != TCL_OK) { + return TCL_ERROR; + } + *(Tk_Justify *)ptr = justify; + } + break; + + case BLT_CONFIG_MM: + { + double value; + + if (Tk_GetMMFromObj(interp, tkwin, objPtr, &value) != TCL_OK) { + return TCL_ERROR; + } + *(double *)ptr = value; + } + break; + + + case BLT_CONFIG_RELIEF: + { + int relief; + + if (Tk_GetReliefFromObj(interp, objPtr, &relief) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = relief; + } + break; + + case BLT_CONFIG_STRING: + { + char *value; + + value = (objIsEmpty) ? NULL : + Blt_AssertStrdup(Tcl_GetString(objPtr)); + if (*(char **)ptr != NULL) { + Blt_Free(*(char **)ptr); + } + *(char **)ptr = value; + } + break; + + case BLT_CONFIG_UID: + if (*(Blt_Uid *)ptr != NULL) { + Blt_FreeUid(*(Blt_Uid *)ptr); + } + if (objIsEmpty) { + *(Blt_Uid *)ptr = NULL; + } else { + *(Blt_Uid *)ptr = Blt_GetUid(Tcl_GetString(objPtr)); + } + break; + + case BLT_CONFIG_WINDOW: + { + Tk_Window tkwin2; + + if (objIsEmpty) { + tkwin2 = None; + } else { + const char *path; + + path = Tcl_GetString(objPtr); + tkwin2 = Tk_NameToWindow(interp, path, tkwin); + if (tkwin2 == NULL) { + return TCL_ERROR; + } + } + *(Tk_Window *)ptr = tkwin2; + } + break; + + case BLT_CONFIG_BITMASK: + { + int bool; + unsigned long mask, flags; + + if (Tcl_GetBooleanFromObj(interp, objPtr, &bool) != TCL_OK) { + return TCL_ERROR; + } + mask = (unsigned long)sp->customPtr; + flags = *(int *)ptr; + flags &= ~mask; + if (bool) { + flags |= mask; + } + *(int *)ptr = flags; + } + break; + + case BLT_CONFIG_BITMASK_INVERT: + { + int bool; + unsigned long mask, flags; + + if (Tcl_GetBooleanFromObj(interp, objPtr, &bool) != TCL_OK) { + return TCL_ERROR; + } + mask = (unsigned long)sp->customPtr; + flags = *(int *)ptr; + flags &= ~mask; + if (!bool) { + flags |= mask; + } + *(int *)ptr = flags; + } + break; + + case BLT_CONFIG_DASHES: + if (Blt_GetDashesFromObj(interp, objPtr, (Blt_Dashes *)ptr) + != TCL_OK) { + return TCL_ERROR; + } + break; + + + case BLT_CONFIG_FILL: + if (Blt_GetFillFromObj(interp, objPtr, (int *)ptr) != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_CONFIG_RESIZE: + if (Blt_GetResizeFromObj(interp, objPtr, (int *)ptr) != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_CONFIG_FLOAT: + { + double value; + + if (Tcl_GetDoubleFromObj(interp, objPtr, &value) != TCL_OK) { + return TCL_ERROR; + } + *(float *)ptr = (float)value; + } + break; + + case BLT_CONFIG_INT_NNEG: + { + long value; + + if (Blt_GetCountFromObj(interp, objPtr, COUNT_NNEG, + &value) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = (int)value; + } + break; + + + case BLT_CONFIG_INT_POS: + { + long value; + + if (Blt_GetCountFromObj(interp, objPtr, COUNT_POS, &value) + != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = (int)value; + } + break; + + + case BLT_CONFIG_LIST: + { + const char **argv; + int argc; + + if (Tcl_SplitList(interp, Tcl_GetString(objPtr), &argc, &argv) + != TCL_OK) { + return TCL_ERROR; + } + if (*(char ***)ptr != NULL) { + Blt_Free(*(char ***)ptr); + } + *(const char ***)ptr = argv; + } + break; + + case BLT_CONFIG_LONG: + { + long value; + + if (Tcl_GetLongFromObj(interp, objPtr, &value) != TCL_OK) { + return TCL_ERROR; + } + *(long *)ptr = value; + } + break; + + case BLT_CONFIG_LONG_NNEG: + { + long value; + + if (Blt_GetCountFromObj(interp, objPtr, COUNT_NNEG, + &value) != TCL_OK) { + return TCL_ERROR; + } + *(long *)ptr = value; + } + break; + + + case BLT_CONFIG_LONG_POS: + { + long value; + + if (Blt_GetCountFromObj(interp, objPtr, COUNT_POS, &value) + != TCL_OK) { + return TCL_ERROR; + } + *(long *)ptr = value; + } + break; + + case BLT_CONFIG_OBJ: + { + Tcl_IncrRefCount(objPtr); + if (*(Tcl_Obj **)ptr != NULL) { + Tcl_DecrRefCount(*(Tcl_Obj **)ptr); + } + *(Tcl_Obj **)ptr = objPtr; + } + break; + + case BLT_CONFIG_PAD: + if (Blt_GetPadFromObj(interp, tkwin, objPtr, (Blt_Pad *)ptr) + != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_CONFIG_PIXELS_NNEG: + { + int value; + + if (Blt_GetPixelsFromObj(interp, tkwin, objPtr, + PIXELS_NNEG, &value) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = value; + } + break; + + case BLT_CONFIG_PIXELS: + { + int value; + + if (Blt_GetPixelsFromObj(interp, tkwin, objPtr, PIXELS_ANY, + &value) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = value; + } + break; + + case BLT_CONFIG_PIXELS_POS: + { + int value; + + if (Blt_GetPixelsFromObj(interp, tkwin, objPtr, PIXELS_POS, + &value) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = value; + } + break; + + case BLT_CONFIG_STATE: + if (Blt_GetStateFromObj(interp, objPtr, (int *)ptr) != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_CONFIG_SIDE: + if (Blt_GetSideFromObj(interp, objPtr, (int *)ptr) != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_CONFIG_BACKGROUND: + { + Blt_Background style; + + if (objIsEmpty) { + style = NULL; + } else { + style = Blt_GetBackgroundFromObj(interp, tkwin, objPtr); + if (style == NULL) { + return TCL_ERROR; + } + } + if (*(Blt_Background *)ptr != NULL) { + Blt_FreeBackground(*(Blt_Background *)ptr); + } + *(Blt_Background *)ptr = style; + } + break; + + case BLT_CONFIG_PIX32: + if (Blt_GetPixelFromObj(interp, objPtr, (Blt_Pixel *)ptr)!=TCL_OK) { + return TCL_ERROR; + } + break; + + default: + Tcl_AppendResult(interp, "bad config table: unknown type ", + Blt_Itoa(sp->type), (char *)NULL); + return TCL_ERROR; + } + sp++; + } while ((sp->switchName == NULL) && (sp->type != BLT_CONFIG_END)); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * FormatConfigValue -- + * + * This procedure formats the current value of a configuration + * option. + * + * Results: + * The return value is the formatted value of the option given + * by specPtr and widgRec. If the value is static, so that it + * need not be freed, *freeProcPtr will be set to NULL; otherwise + * *freeProcPtr will be set to the address of a procedure to + * free the result, and the caller must invoke this procedure + * when it is finished with the result. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static Tcl_Obj * +FormatConfigValue( + Tcl_Interp *interp, /* Interpreter for use in real conversions. */ + Tk_Window tkwin, /* Window corresponding to widget. */ + Blt_ConfigSpec *sp, /* Pointer to information describing option. + * Must not point to a synonym option. */ + char *widgRec) /* Pointer to record holding current + * values of info for widget. */ +{ + char *ptr; + const char *string; + + ptr = widgRec + sp->offset; + string = ""; + switch (sp->type) { + case BLT_CONFIG_ANCHOR: + string = Tk_NameOfAnchor(*(Tk_Anchor *)ptr); + break; + + case BLT_CONFIG_BITMAP: + if (*(Pixmap *)ptr != None) { + string = Tk_NameOfBitmap(Tk_Display(tkwin), *(Pixmap *)ptr); + } + break; + + case BLT_CONFIG_BOOLEAN: + return Tcl_NewBooleanObj(*(int *)ptr); + + case BLT_CONFIG_BORDER: + if (*(Tk_3DBorder *)ptr != NULL) { + string = Tk_NameOf3DBorder(*(Tk_3DBorder *)ptr); + } + break; + + case BLT_CONFIG_CAP_STYLE: + string = Tk_NameOfCapStyle(*(int *)ptr); + break; + + case BLT_CONFIG_COLOR: + if (*(XColor **)ptr != NULL) { + string = Tk_NameOfColor(*(XColor **)ptr); + } + break; + + case BLT_CONFIG_CURSOR: + case BLT_CONFIG_ACTIVE_CURSOR: + if (*(Tk_Cursor *)ptr != None) { + string = Tk_NameOfCursor(Tk_Display(tkwin), *(Tk_Cursor *)ptr); + } + break; + + case BLT_CONFIG_CUSTOM: + return (*sp->customPtr->printProc) + (sp->customPtr->clientData, interp, tkwin, widgRec, + sp->offset, sp->specFlags); + + case BLT_CONFIG_DOUBLE: + return Tcl_NewDoubleObj(*(double *)ptr); + + case BLT_CONFIG_FONT: + if (*(Blt_Font *)ptr != NULL) { + string = Blt_NameOfFont(*(Blt_Font *)ptr); + } + break; + + case BLT_CONFIG_TK_FONT: + if (*(Tk_Font *)ptr != NULL) { + string = Tk_NameOfFont(*(Tk_Font *)ptr); + } + break; + + case BLT_CONFIG_INT: + return Tcl_NewIntObj(*(int *)ptr); + + case BLT_CONFIG_JOIN_STYLE: + string = Tk_NameOfJoinStyle(*(int *)ptr); + break; + + case BLT_CONFIG_JUSTIFY: + string = Tk_NameOfJustify(*(Tk_Justify *)ptr); + break; + + case BLT_CONFIG_MM: + return Tcl_NewDoubleObj(*(double *)ptr); + + case BLT_CONFIG_PIXELS: + case BLT_CONFIG_PIXELS_POS: + case BLT_CONFIG_PIXELS_NNEG: + return Tcl_NewIntObj(*(int *)ptr); + + case BLT_CONFIG_RELIEF: + string = Tk_NameOfRelief(*(int *)ptr); + break; + + case BLT_CONFIG_STRING: + case BLT_CONFIG_UID: + if (*(char **)ptr != NULL) { + string = *(char **)ptr; + } + break; + + case BLT_CONFIG_BITMASK: + { + unsigned long flag; + + flag = (*(unsigned long *)ptr) & (unsigned long)sp->customPtr; + return Tcl_NewBooleanObj((flag != 0)); + } + + case BLT_CONFIG_BITMASK_INVERT: + { + unsigned long flag; + + flag = (*(unsigned long *)ptr) & (unsigned long)sp->customPtr; + return Tcl_NewBooleanObj((flag == 0)); + } + + case BLT_CONFIG_DASHES: + { + unsigned char *p; + Tcl_Obj *listObjPtr; + Blt_Dashes *dashesPtr = (Blt_Dashes *)ptr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for(p = dashesPtr->values; *p != 0; p++) { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewIntObj(*p)); + } + return listObjPtr; + } + + case BLT_CONFIG_INT_NNEG: + case BLT_CONFIG_INT_POS: + return Tcl_NewIntObj(*(int *)ptr); + + case BLT_CONFIG_FILL: + string = Blt_NameOfFill(*(int *)ptr); + break; + + case BLT_CONFIG_RESIZE: + string = Blt_NameOfResize(*(int *)ptr); + break; + + case BLT_CONFIG_FLOAT: + { + double x = *(float *)ptr; + return Tcl_NewDoubleObj(x); + } + + case BLT_CONFIG_LIST: + { + Tcl_Obj *objPtr, *listObjPtr; + char *const *p; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (p = *(char ***)ptr; *p != NULL; p++) { + objPtr = Tcl_NewStringObj(*p, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + return listObjPtr; + } + + case BLT_CONFIG_LONG: + return Tcl_NewLongObj(*(long *)ptr); + + case BLT_CONFIG_LONG_NNEG: + case BLT_CONFIG_LONG_POS: + return Tcl_NewLongObj(*(long *)ptr); + + case BLT_CONFIG_OBJ: + if (*(Tcl_Obj **)ptr != NULL) { + return *(Tcl_Obj **)ptr; + } + break; + + case BLT_CONFIG_PAD: + { + Blt_Pad *padPtr = (Blt_Pad *)ptr; + Tcl_Obj *objPtr, *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + objPtr = Tcl_NewIntObj(padPtr->side1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + objPtr = Tcl_NewIntObj(padPtr->side2); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + return listObjPtr; + } + + case BLT_CONFIG_STATE: + string = Blt_NameOfState(*(int *)ptr); + break; + + case BLT_CONFIG_SIDE: + string = Blt_NameOfSide(*(int *)ptr); + break; + + case BLT_CONFIG_BACKGROUND: + if (*(Blt_Background *)ptr != NULL) { + string = Blt_NameOfBackground(*(Blt_Background *)ptr); + } + break; + + case BLT_CONFIG_PIX32: + string = Blt_NameOfPixel((Blt_Pixel *)ptr); + break; + + default: + string = "?? unknown type ??"; + } + return Tcl_NewStringObj(string, -1); +} + +/* + *--------------------------------------------------------------------------- + * + * FormatConfigInfo -- + * + * Create a valid TCL list holding the configuration information + * for a single configuration option. + * + * Results: + * A TCL list, dynamically allocated. The caller is expected to + * arrange for this list to be freed eventually. + * + * Side effects: + * Memory is allocated. + * + *--------------------------------------------------------------------------- + */ +static Tcl_Obj * +FormatConfigInfo( + Tcl_Interp *interp, /* Interpreter to use for things + * like floating-point precision. */ + Tk_Window tkwin, /* Window corresponding to widget. */ + Blt_ConfigSpec *sp, /* Pointer to information describing + * option. */ + char *widgRec) /* Pointer to record holding current + * values of info for widget. */ +{ + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (sp->switchName != NULL) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(sp->switchName, -1)); + } else { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("", -1)); + } + if (sp->dbName != NULL) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(sp->dbName, -1)); + } else { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("", -1)); + } + if (sp->type == BLT_CONFIG_SYNONYM) { + return listObjPtr; + } + if (sp->dbClass != NULL) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(sp->dbClass, -1)); + } else { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("", -1)); + } + if (sp->defValue != NULL) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(sp->defValue, -1)); + } else { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("", -1)); + } + Tcl_ListObjAppendElement(interp, listObjPtr, + FormatConfigValue(interp, tkwin, sp, widgRec)); + return listObjPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * FindConfigSpec -- + * + * Search through a table of configuration specs, looking for + * one that matches a given switchName. + * + * Results: + * The return value is a pointer to the matching entry, or NULL + * if nothing matched. In that case an error message is left + * in the interp's result. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static Blt_ConfigSpec * +FindConfigSpec( + Tcl_Interp *interp, /* Used for reporting errors. */ + Blt_ConfigSpec *specs, /* Pointer to table of configuration + * specifications for a widget. */ + Tcl_Obj *objPtr, /* Name (suitable for use in a "config" + * command) identifying particular option. */ + int needFlags, /* Flags that must be present in matching + * entry. */ + int hateFlags) /* Flags that must NOT be present in + * matching entry. */ +{ + Blt_ConfigSpec *matchPtr; /* Matching spec, or NULL. */ + Blt_ConfigSpec *sp; + const char *string; + char c; /* First character of current argument. */ + int length; + + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[1]; + matchPtr = NULL; + for (sp = specs; sp->type != BLT_CONFIG_END; sp++) { + if (sp->switchName == NULL) { + continue; + } + if ((sp->switchName[1] != c) || + (strncmp(sp->switchName, string, length) != 0)) { + continue; + } + if (((sp->specFlags & needFlags) != needFlags) || + (sp->specFlags & hateFlags)) { + continue; + } + if (sp->switchName[length] == 0) { + matchPtr = sp; + goto gotMatch; + } + if (matchPtr != NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "ambiguous option \"", string, "\"", + (char *)NULL); + } + return (Blt_ConfigSpec *)NULL; + } + matchPtr = sp; + } + + if (matchPtr == NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "unknown option \"", string, "\"", + (char *)NULL); + } + return (Blt_ConfigSpec *)NULL; + } + + /* + * Found a matching entry. If it's a synonym, then find the + * entry that it's a synonym for. + */ + + gotMatch: + sp = matchPtr; + if (sp->type == BLT_CONFIG_SYNONYM) { + for (sp = specs; /*empty*/; sp++) { + if (sp->type == BLT_CONFIG_END) { + if (interp != NULL) { + Tcl_AppendResult(interp, + "couldn't find synonym for option \"", string, "\"", + (char *)NULL); + } + return (Blt_ConfigSpec *) NULL; + } + if ((sp->dbName == matchPtr->dbName) && + (sp->type != BLT_CONFIG_SYNONYM) && + ((sp->specFlags & needFlags) == needFlags) && + !(sp->specFlags & hateFlags)) { + break; + } + } + } + return sp; +} + +/* Public routines */ + +/* + *--------------------------------------------------------------------------- + * + * Blt_ConfigureWidgetFromObj -- + * + * Process command-line options and database options to + * fill in fields of a widget record with resources and + * other parameters. + * + * Results: + * A standard TCL return value. In case of an error, + * the interp's result will hold an error message. + * + * Side effects: + * The fields of widgRec get filled in with information + * from argc/argv and the option database. Old information + * in widgRec's fields gets recycled. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ConfigureWidgetFromObj( + Tcl_Interp *interp, /* Interpreter for error reporting. */ + Tk_Window tkwin, /* Window containing widget (needed to + * set up X resources). */ + Blt_ConfigSpec *specs, /* Describes legal options. */ + int objc, /* Number of elements in argv. */ + Tcl_Obj *const *objv, /* Command-line options. */ + char *widgRec, /* Record whose fields are to be + * modified. Values must be properly + * initialized. */ + int flags) /* Used to specify additional flags + * that must be present in config specs + * for them to be considered. Also, + * may have BLT_CONFIG_OBJV_ONLY set. */ +{ + Blt_ConfigSpec *sp; + int needFlags; /* Specs must contain this set of flags + * or else they are not considered. */ + int hateFlags; /* If a spec contains any bits here, it's + * not considered. */ + int result; + + if (tkwin == NULL) { + /* + * Either we're not really in Tk, or the main window was destroyed and + * we're on our way out of the application + */ + Tcl_AppendResult(interp, "NULL main window", (char *)NULL); + return TCL_ERROR; + } + + needFlags = flags & ~(BLT_CONFIG_USER_BIT - 1); + if (Tk_Depth(tkwin) <= 1) { + hateFlags = BLT_CONFIG_COLOR_ONLY; + } else { + hateFlags = BLT_CONFIG_MONO_ONLY; + } + + /* + * Pass one: scan through all the option specs, replacing strings + * with Tk_Uid structs (if this hasn't been done already) and + * clearing the BLT_CONFIG_OPTION_SPECIFIED flags. + */ + + for (sp = specs; sp->type != BLT_CONFIG_END; sp++) { + if (!(sp->specFlags & INIT) && (sp->switchName != NULL)) { + if (sp->dbName != NULL) { + sp->dbName = Tk_GetUid(sp->dbName); + } + if (sp->dbClass != NULL) { + sp->dbClass = Tk_GetUid(sp->dbClass); + } + if (sp->defValue != NULL) { + sp->defValue = Tk_GetUid(sp->defValue); + } + } + sp->specFlags = (sp->specFlags & ~BLT_CONFIG_OPTION_SPECIFIED) | INIT; + } + + /* + * Pass two: scan through all of the arguments, processing those + * that match entries in the specs. + */ + while (objc > 0) { + sp = FindConfigSpec(interp, specs, objv[0], needFlags, hateFlags); + if (sp == NULL) { + return TCL_ERROR; + } + + /* Process the entry. */ + if (objc < 2) { + Tcl_AppendResult(interp, "value for \"", Tcl_GetString(objv[0]), + "\" missing", (char *)NULL); + return TCL_ERROR; + } + if (DoConfig(interp, tkwin, sp, objv[1], widgRec) != TCL_OK) { + char msg[100]; + + sprintf_s(msg, 100, "\n (processing \"%.40s\" option)", + sp->switchName); + Tcl_AddErrorInfo(interp, msg); + return TCL_ERROR; + } + sp->specFlags |= BLT_CONFIG_OPTION_SPECIFIED; + objc -= 2, objv += 2; + } + + /* + * Pass three: scan through all of the specs again; if no + * command-line argument matched a spec, then check for info + * in the option database. If there was nothing in the + * database, then use the default. + */ + + if ((flags & BLT_CONFIG_OBJV_ONLY) == 0) { + Tcl_Obj *objPtr; + + for (sp = specs; sp->type != BLT_CONFIG_END; sp++) { + if ((sp->specFlags & BLT_CONFIG_OPTION_SPECIFIED) || + (sp->switchName == NULL) || (sp->type == BLT_CONFIG_SYNONYM)) { + continue; + } + if (((sp->specFlags & needFlags) != needFlags) || + (sp->specFlags & hateFlags)) { + continue; + } + objPtr = NULL; + if (sp->dbName != NULL) { + Tk_Uid value; + + /* If a resource name was specified, check if there's + * also a value was associated with it. This + * overrides the default value. */ + value = Tk_GetOption(tkwin, sp->dbName, sp->dbClass); + if (value != NULL) { + objPtr = Tcl_NewStringObj(value, -1); + } + } + + if (objPtr != NULL) { + Tcl_IncrRefCount(objPtr); + result = DoConfig(interp, tkwin, sp, objPtr, widgRec); + Tcl_DecrRefCount(objPtr); + if (result != TCL_OK) { + char msg[200]; + + sprintf_s(msg, 200, + "\n (%s \"%.50s\" in widget \"%.50s\")", + "database entry for", sp->dbName, Tk_PathName(tkwin)); + Tcl_AddErrorInfo(interp, msg); + return TCL_ERROR; + } + } else if ((sp->defValue != NULL) && + ((sp->specFlags & BLT_CONFIG_DONT_SET_DEFAULT) == 0)) { + + /* No resource value is found, use the default value. */ + objPtr = Tcl_NewStringObj(sp->defValue, -1); + Tcl_IncrRefCount(objPtr); + result = DoConfig(interp, tkwin, sp, objPtr, widgRec); + Tcl_DecrRefCount(objPtr); + if (result != TCL_OK) { + char msg[200]; + + sprintf_s(msg, 200, + "\n (%s \"%.50s\" in widget \"%.50s\")", + "default value for", sp->dbName, Tk_PathName(tkwin)); + Tcl_AddErrorInfo(interp, msg); + return TCL_ERROR; + } + } + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ConfigureInfoFromObj -- + * + * Return information about the configuration options + * for a window, and their current values. + * + * Results: + * Always returns TCL_OK. The interp's result will be modified + * hold a description of either a single configuration option + * available for "widgRec" via "specs", or all the configuration + * options available. In the "all" case, the result will + * available for "widgRec" via "specs". The result will + * be a list, each of whose entries describes one option. + * Each entry will itself be a list containing the option's + * name for use on command lines, database name, database + * class, default value, and current value (empty string + * if none). For options that are synonyms, the list will + * contain only two values: name and synonym name. If the + * "name" argument is non-NULL, then the only information + * returned is that for the named argument (i.e. the corresponding + * entry in the overall list is returned). + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +int +Blt_ConfigureInfoFromObj( + Tcl_Interp *interp, /* Interpreter for error reporting. */ + Tk_Window tkwin, /* Window corresponding to widgRec. */ + Blt_ConfigSpec *specs, /* Describes legal options. */ + char *widgRec, /* Record whose fields contain current + * values for options. */ + Tcl_Obj *objPtr, /* If non-NULL, indicates a single option + * whose info is to be returned. Otherwise + * info is returned for all options. */ + int flags) /* Used to specify additional flags + * that must be present in config specs + * for them to be considered. */ +{ + Blt_ConfigSpec *sp; + Tcl_Obj *listObjPtr, *valueObjPtr; + const char *string; + int needFlags, hateFlags; + + needFlags = flags & ~(BLT_CONFIG_USER_BIT - 1); + if (Tk_Depth(tkwin) <= 1) { + hateFlags = BLT_CONFIG_COLOR_ONLY; + } else { + hateFlags = BLT_CONFIG_MONO_ONLY; + } + + /* + * If information is only wanted for a single configuration + * spec, then handle that one spec specially. + */ + + Tcl_SetResult(interp, (char *)NULL, TCL_STATIC); + if (objPtr != NULL) { + sp = FindConfigSpec(interp, specs, objPtr, needFlags, hateFlags); + if (sp == NULL) { + return TCL_ERROR; + } + valueObjPtr = FormatConfigInfo(interp, tkwin, sp, widgRec); + Tcl_SetObjResult(interp, valueObjPtr); + return TCL_OK; + } + + /* + * Loop through all the specs, creating a big list with all + * their information. + */ + string = NULL; /* Suppress compiler warning. */ + if (objPtr != NULL) { + string = Tcl_GetString(objPtr); + } + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (sp = specs; sp->type != BLT_CONFIG_END; sp++) { + if ((objPtr != NULL) && (sp->switchName != string)) { + continue; + } + if (((sp->specFlags & needFlags) != needFlags) || + (sp->specFlags & hateFlags)) { + continue; + } + if (sp->switchName == NULL) { + continue; + } + valueObjPtr = FormatConfigInfo(interp, tkwin, sp, widgRec); + Tcl_ListObjAppendElement(interp, listObjPtr, valueObjPtr); + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ConfigureValueFromObj -- + * + * This procedure returns the current value of a configuration + * option for a widget. + * + * Results: + * The return value is a standard TCL completion code (TCL_OK or + * TCL_ERROR). The interp's result will be set to hold either the value + * of the option given by objPtr (if TCL_OK is returned) or + * an error message (if TCL_ERROR is returned). + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ConfigureValueFromObj( + Tcl_Interp *interp, /* Interpreter for error reporting. */ + Tk_Window tkwin, /* Window corresponding to widgRec. */ + Blt_ConfigSpec *specs, /* Describes legal options. */ + char *widgRec, /* Record whose fields contain current + * values for options. */ + Tcl_Obj *objPtr, /* Gives the command-line name for the + * option whose value is to be returned. */ + int flags) /* Used to specify additional flags + * that must be present in config specs + * for them to be considered. */ +{ + Blt_ConfigSpec *sp; + int needFlags, hateFlags; + + needFlags = flags & ~(BLT_CONFIG_USER_BIT - 1); + if (Tk_Depth(tkwin) <= 1) { + hateFlags = BLT_CONFIG_COLOR_ONLY; + } else { + hateFlags = BLT_CONFIG_MONO_ONLY; + } + sp = FindConfigSpec(interp, specs, objPtr, needFlags, hateFlags); + if (sp == NULL) { + return TCL_ERROR; + } + objPtr = FormatConfigValue(interp, tkwin, sp, widgRec); + Tcl_SetObjResult(interp, objPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_FreeOptions -- + * + * Free up all resources associated with configuration options. + * + * Results: + * None. + * + * Side effects: + * Any resource in widgRec that is controlled by a configuration + * option (e.g. a Tk_3DBorder or XColor) is freed in the appropriate + * fashion. + * + *--------------------------------------------------------------------------- + */ +void +Blt_FreeOptions( + Blt_ConfigSpec *specs, /* Describes legal options. */ + char *widgRec, /* Record whose fields contain current + * values for options. */ + Display *display, /* X display; needed for freeing some + * resources. */ + int needFlags) /* Used to specify additional flags + * that must be present in config specs + * for them to be considered. */ +{ + Blt_ConfigSpec *sp; + + for (sp = specs; sp->type != BLT_CONFIG_END; sp++) { + char *ptr; + + if ((sp->specFlags & needFlags) != needFlags) { + continue; + } + ptr = widgRec + sp->offset; + switch (sp->type) { + case BLT_CONFIG_STRING: + if (*((char **) ptr) != NULL) { + Blt_Free(*((char **) ptr)); + *((char **) ptr) = NULL; + } + break; + + case BLT_CONFIG_COLOR: + if (*((XColor **) ptr) != NULL) { + Tk_FreeColor(*((XColor **) ptr)); + *((XColor **) ptr) = NULL; + } + break; + + case BLT_CONFIG_FONT: + if (*((Blt_Font *) ptr) != None) { + Blt_FreeFont(*((Blt_Font *) ptr)); + *((Blt_Font *) ptr) = NULL; + } + break; + + case BLT_CONFIG_TK_FONT: + if (*((Tk_Font *) ptr) != None) { + Tk_FreeFont(*((Tk_Font *) ptr)); + *((Tk_Font *) ptr) = NULL; + } + break; + + case BLT_CONFIG_BITMAP: + if (*((Pixmap *) ptr) != None) { + Tk_FreeBitmap(display, *((Pixmap *) ptr)); + *((Pixmap *) ptr) = None; + } + break; + + case BLT_CONFIG_BORDER: + if (*((Tk_3DBorder *) ptr) != NULL) { + Tk_Free3DBorder(*((Tk_3DBorder *) ptr)); + *((Tk_3DBorder *) ptr) = NULL; + } + break; + + case BLT_CONFIG_CURSOR: + case BLT_CONFIG_ACTIVE_CURSOR: + if (*((Tk_Cursor *) ptr) != None) { + Tk_FreeCursor(display, *((Tk_Cursor *) ptr)); + *((Tk_Cursor *) ptr) = None; + } + break; + + case BLT_CONFIG_OBJ: + if (*(Tcl_Obj **)ptr != NULL) { + Tcl_DecrRefCount(*(Tcl_Obj **)ptr); + *(Tcl_Obj **)ptr = NULL; + } + break; + + case BLT_CONFIG_LIST: + if (*((char ***) ptr) != NULL) { + Blt_Free(*((char ***) ptr)); + *((char ***) ptr) = NULL; + } + break; + + case BLT_CONFIG_UID: + if (*(Blt_Uid *)ptr != NULL) { + Blt_FreeUid(*(Blt_Uid *)ptr); + *(Blt_Uid *)ptr = NULL; + } + break; + + case BLT_CONFIG_BACKGROUND: + if (*((Blt_Background *)ptr) != NULL) { + Blt_FreeBackground(*((Blt_Background *)ptr)); + *((Blt_Background *)ptr) = NULL; + } + break; + + case BLT_CONFIG_CUSTOM: + if ((sp->customPtr->freeProc != NULL) && (*(char **)ptr != NULL)) { + (*sp->customPtr->freeProc)(sp->customPtr->clientData, + display, widgRec, sp->offset); + } + break; + + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ConfigModified -- + * + * Given the configuration specifications and one or more option + * patterns (terminated by a NULL), indicate if any of the matching + * configuration options has been reset. + * + * Results: + * Returns 1 if one of the options has changed, 0 otherwise. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ConfigModified TCL_VARARGS_DEF(Blt_ConfigSpec *, arg1) +{ + va_list argList; + Blt_ConfigSpec *specs; + Blt_ConfigSpec *sp; + const char *option; + + specs = TCL_VARARGS_START(Blt_ConfigSpec *, arg1, argList); + while ((option = va_arg(argList, const char *)) != NULL) { + for (sp = specs; sp->type != BLT_CONFIG_END; sp++) { + if ((Tcl_StringMatch(sp->switchName, option)) && + (sp->specFlags & BLT_CONFIG_OPTION_SPECIFIED)) { + va_end(argList); + return 1; + } + } + } + va_end(argList); + return 0; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ConfigureComponentFromObj -- + * + * Configures a component of a widget. This is useful for + * widgets that have multiple components which aren't uniquely + * identified by a Tk_Window. It allows us, for example, set + * resources for axes of the graph widget. The graph really has + * only one window, but its convenient to specify components in a + * hierarchy of options. + * + * *graph.x.logScale yes + * *graph.Axis.logScale yes + * *graph.temperature.scaleSymbols yes + * *graph.Element.scaleSymbols yes + * + * This is really a hack to work around the limitations of the Tk + * resource database. It creates a temporary window, needed to + * call Tk_ConfigureWidget, using the name of the component. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * A temporary window is created merely to pass to Tk_ConfigureWidget. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ConfigureComponentFromObj( + Tcl_Interp *interp, + Tk_Window parent, /* Window to associate with component */ + const char *name, /* Name of component */ + const char *className, + Blt_ConfigSpec *sp, + int objc, + Tcl_Obj *const *objv, + char *widgRec, + int flags) +{ + Tk_Window tkwin; + int result; + char *tmpName; + int isTemporary = FALSE; + + tmpName = Blt_AssertStrdup(name); + + /* Window name can't start with an upper case letter */ + tmpName[0] = tolower(name[0]); + + /* + * Create component if a child window by the component's name + * doesn't already exist. + */ + tkwin = Blt_FindChild(parent, tmpName); + if (tkwin == NULL) { + tkwin = Tk_CreateWindow(interp, parent, tmpName, (char *)NULL); + isTemporary = TRUE; + } + if (tkwin == NULL) { + Tcl_AppendResult(interp, "can't find window in \"", + Tk_PathName(parent), "\"", (char *)NULL); + return TCL_ERROR; + } + assert(Tk_Depth(tkwin) == Tk_Depth(parent)); + Blt_Free(tmpName); + + Tk_SetClass(tkwin, className); + result = Blt_ConfigureWidgetFromObj(interp, tkwin, sp, objc, objv, widgRec, + flags); + if (isTemporary) { + Tk_DestroyWindow(tkwin); + } + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ObjIsOption -- + * + * Indicates whether objPtr is a valid configuration option + * such as -background. + * + * Results: + * Returns 1 is a matching option is found and 0 otherwise. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ObjIsOption( + Blt_ConfigSpec *specs, /* Describes legal options. */ + Tcl_Obj *objPtr, /* Command-line option name. */ + int flags) /* Used to specify additional flags + * that must be present in config specs + * for them to be considered. Also, + * may have BLT_CONFIG_OBJV_ONLY set. */ +{ + Blt_ConfigSpec *sp; + int needFlags; /* Specs must contain this set of flags + * or else they are not considered. */ + + needFlags = flags & ~(BLT_CONFIG_USER_BIT - 1); + sp = FindConfigSpec((Tcl_Interp *)NULL, specs, objPtr, needFlags, 0); + return (sp != NULL); +} diff --git a/src/bltConfig.h b/src/bltConfig.h new file mode 100644 index 0000000..7a19e9d --- /dev/null +++ b/src/bltConfig.h @@ -0,0 +1,406 @@ + +/* + * bltConfig.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef BLT_CONFIG_H +#define BLT_CONFIG_H + +#ifdef HAVE_STDDEF_H +# include <stddef.h> +#endif /* HAVE_STDDEF_H */ + +#ifndef Blt_Offset +#ifdef offsetof +#define Blt_Offset(type, field) ((int) offsetof(type, field)) +#else +#define Blt_Offset(type, field) ((int) ((char *) &((type *) 0)->field)) +#endif +#endif /* Blt_Offset */ + + +typedef int (Blt_OptionParseProc)(ClientData clientData, Tcl_Interp *interp, + Tk_Window tkwin, Tcl_Obj *objPtr, char *widgRec, int offset, int flags); +typedef Tcl_Obj *(Blt_OptionPrintProc)(ClientData clientData, + Tcl_Interp *interp, Tk_Window tkwin, char *widgRec, int offset, + int flags); +typedef void (Blt_OptionFreeProc)(ClientData clientData, Display *display, + char *widgRec, int offset); + +typedef struct Blt_CustomOption { + Blt_OptionParseProc *parseProc; /* Procedure to call to parse + * an option and store it in + * converted form. */ + + Blt_OptionPrintProc *printProc; /* Procedure to return a + * Tcl_Obj representing an + * existing option value. */ + + Blt_OptionFreeProc *freeProc; /* Procedure used to free the + * value. */ + + ClientData clientData; /* Arbitrary one-word value + * used by option parser: + * passed to parseProc and + * printProc. */ +} Blt_CustomOption; + +/* + * Structure used to specify information for Tk_ConfigureWidget. Each + * structure gives complete information for one option, including + * how the option is specified on the command line, where it appears + * in the option database, etc. + */ + +typedef struct { + int type; /* Type of option, such as + * BLT_CONFIG_COLOR; see definitions + * below. Last option in table must + * have type BLT_CONFIG_END. */ + + const char *switchName; /* Switch used to specify option in + * argv. NULL means this spec is part + * of a group. */ + + Tk_Uid dbName; /* Name for option in option + * database. */ + + Tk_Uid dbClass; /* Class for option in database. */ + + Tk_Uid defValue; /* Default value for option if not + * specified in command line or + * database. */ + + int offset; /* Where in widget record to store + * value; use Blt_Offset macro to + * generate values for this. */ + + int specFlags; /* Any combination of the values + * defined below; other bits are used + * internally by tkConfig.c. */ + + Blt_CustomOption *customPtr; /* If type is BLT_CONFIG_CUSTOM then + * this is a pointer to info about how + * to parse and print the option. + * Otherwise it is irrelevant. */ +} Blt_ConfigSpec; + +/* + * Type values for Blt_ConfigSpec structures. See the user + * documentation for details. + */ +typedef enum { + BLT_CONFIG_ACTIVE_CURSOR, + BLT_CONFIG_ANCHOR, + BLT_CONFIG_BITMAP, + BLT_CONFIG_BOOLEAN, + BLT_CONFIG_BORDER, + BLT_CONFIG_CAP_STYLE, + BLT_CONFIG_COLOR, + BLT_CONFIG_CURSOR, + BLT_CONFIG_CUSTOM, + BLT_CONFIG_DOUBLE, + BLT_CONFIG_FONT, + BLT_CONFIG_INT, + BLT_CONFIG_JOIN_STYLE, + BLT_CONFIG_JUSTIFY, + BLT_CONFIG_MM, + BLT_CONFIG_RELIEF, + BLT_CONFIG_STRING, + BLT_CONFIG_SYNONYM, + BLT_CONFIG_UID, + BLT_CONFIG_WINDOW, + + BLT_CONFIG_BITMASK, + BLT_CONFIG_BITMASK_INVERT, + BLT_CONFIG_DASHES, + BLT_CONFIG_FILL, + BLT_CONFIG_FLOAT, + BLT_CONFIG_INT_NNEG, /* 0..N */ + BLT_CONFIG_INT_POS, /* 1..N */ + BLT_CONFIG_LIST, + BLT_CONFIG_LONG, + BLT_CONFIG_LONG_NNEG, /* 0..N */ + BLT_CONFIG_LONG_POS, /* 1..N */ + BLT_CONFIG_OBJ, + BLT_CONFIG_PAD, + BLT_CONFIG_PIXELS_NNEG, /* 1.1c 2m 3.2i excluding negative + values. */ + BLT_CONFIG_PIXELS_POS, /* 1.1c 2m 3.2i excluding negative + * values and zero. */ + BLT_CONFIG_PIXELS, /* 1.1c 2m 3.2i. */ + BLT_CONFIG_RESIZE, + BLT_CONFIG_SIDE, + BLT_CONFIG_STATE, + BLT_CONFIG_BACKGROUND, + BLT_CONFIG_PIX32, + + BLT_CONFIG_TK_FONT, + BLT_CONFIG_END +} Blt_ConfigTypes; + +/* + * Possible values for flags argument to Tk_ConfigureWidget: + */ +#define BLT_CONFIG_OBJV_ONLY 1 + +/* + * Possible flag values for Blt_ConfigSpec structures. Any bits at or + * above BLT_CONFIG_USER_BIT may be used by clients for selecting + * certain entries. Before changing any values here, coordinate with + * tkOldConfig.c (internal-use-only flags are defined there). + */ +/* + * Values for "flags" field of Blt_ConfigSpec structures. Be sure to + * coordinate these values with those defined in tk.h + * (BLT_CONFIG_COLOR_ONLY, etc.). There must not be overlap! + * + * INIT - Non-zero means (char *) things have been + * converted to Tk_Uid's. + */ +#define INIT (1<<0) +#define BLT_CONFIG_NULL_OK (1<<1) +#define BLT_CONFIG_COLOR_ONLY (1<<2) +#define BLT_CONFIG_MONO_ONLY (1<<3) +#define BLT_CONFIG_DONT_SET_DEFAULT (1<<4) +#define BLT_CONFIG_OPTION_SPECIFIED (1<<5) +#define BLT_CONFIG_USER_BIT (1<<8) + + +#define SIDE_LEFT (1<<0) +#define SIDE_TOP (1<<1) +#define SIDE_RIGHT (1<<2) +#define SIDE_BOTTOM (1<<3) + +#define STATE_NORMAL (0) +#define STATE_ACTIVE (1<<0) +#define STATE_DISABLED (1<<1) +#define STATE_EMPHASIS (1<<2) + +/* + *--------------------------------------------------------------------------- + * + * Blt_Pad -- + * + * Specifies vertical and horizontal padding. + * + * Padding can be specified on a per side basis. The fields + * side1 and side2 refer to the opposite sides, either + * horizontally or vertically. + * + * side1 side2 + * ----- ----- + * x | left right + * y | top bottom + * + *--------------------------------------------------------------------------- + */ +typedef struct { + unsigned short int side1, side2; +} Blt_Pad; + +#define padLeft xPad.side1 +#define padRight xPad.side2 +#define padTop yPad.side1 +#define padBottom yPad.side2 +#define PADDING(x) ((x).side1 + (x).side2) + +/* + *--------------------------------------------------------------------------- + * + * The following enumerated values are used as bit flags. + * FILL_NONE Neither coordinate plane is specified + * FILL_X Horizontal plane. + * FILL_Y Vertical plane. + * FILL_BOTH Both vertical and horizontal planes. + * + *--------------------------------------------------------------------------- + */ +#define FILL_NONE 0 +#define FILL_X 1 +#define FILL_Y 2 +#define FILL_BOTH 3 + +/* + * Resize -- + * + * These flags indicate in what ways each partition in a table can be + * resized from its default dimensions. The normal size of a row/column + * is the minimum amount of space needed to hold the widgets that span + * it. The table may then be stretched or shrunk depending if the + * container is larger or smaller than the table. This can occur if 1) + * the user resizes the toplevel widget, or 2) the container is in turn + * packed into a larger widget and the "fill" option is set. + * + * RESIZE_NONE - No resizing from normal size. + * RESIZE_EXPAND - Do not allow the size to decrease. + * The size may increase however. + * RESIZE_SHRINK - Do not allow the size to increase. + * The size may decrease however. + * RESIZE_BOTH - Allow the size to increase or + * decrease from the normal size. + * RESIZE_VIRGIN - Special case of the resize flag. Used to + * indicate the initial state of the flag. + * Empty rows/columns are treated differently + * if this row/column is set. + */ + +#define RESIZE_NONE 0 +#define RESIZE_EXPAND (1<<0) +#define RESIZE_SHRINK (1<<1) +#define RESIZE_BOTH (RESIZE_EXPAND | RESIZE_SHRINK) + +/* + *--------------------------------------------------------------------------- + * + * Blt_Dashes -- + * + * List of dash values (maximum 11 based upon PostScript limit). + * + *--------------------------------------------------------------------------- + */ +typedef struct { + unsigned char values[12]; + int offset; +} Blt_Dashes; + +#define LineIsDashed(d) ((d).values[0] != 0) + +/* + * Blt_Limits -- + * + * Defines the bounding of a size (width or height) in the paneset. It may + * be related to the widget, pane or paneset size. + */ +typedef struct { + int flags; /* Flags indicate whether using default + * values for limits or not. See flags + * below. */ + int max, min; /* Values for respective limits. */ + int nom; /* Nominal starting value. */ +} Blt_Limits; + +#define LIMITS_MIN_SET (1<<0) +#define LIMITS_MAX_SET (1<<1) +#define LIMITS_NOM_SET (1<<2) + +#define LIMITS_MIN 0 /* Default minimum limit */ +#define LIMITS_MAX SHRT_MAX /* Default maximum limit */ +#define LIMITS_NOM -1000 /* Default nomimal value. Indicates + * if a pane has received any space + * yet */ + +BLT_EXTERN void Blt_SetDashes (Display *display, GC gc, Blt_Dashes *dashesPtr); +BLT_EXTERN Blt_Dashes *Blt_GetDashes (GC gc); + +BLT_EXTERN void Blt_ResetLimits(Blt_Limits *limitsPtr); +BLT_EXTERN int Blt_GetLimitsFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr, Blt_Limits *limitsPtr); + +BLT_EXTERN int Blt_ConfigureInfoFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Blt_ConfigSpec *specs, char *widgRec, Tcl_Obj *objPtr, int flags); + +BLT_EXTERN int Blt_ConfigureValueFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Blt_ConfigSpec *specs, char *widgRec, Tcl_Obj *objPtr, int flags); + +BLT_EXTERN int Blt_ConfigureWidgetFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Blt_ConfigSpec *specs, int objc, Tcl_Obj *const *objv, char *widgRec, + int flags); + +BLT_EXTERN int Blt_ConfigureComponentFromObj(Tcl_Interp *interp, + Tk_Window tkwin, const char *name, const char *className, + Blt_ConfigSpec *specs, int objc, Tcl_Obj *const *objv, char *widgRec, + int flags); + +BLT_EXTERN int Blt_ConfigModified TCL_VARARGS(Blt_ConfigSpec *, specs); + +BLT_EXTERN const char *Blt_NameOfState(int state); +BLT_EXTERN const char *Blt_NameOfSide(int side); + +BLT_EXTERN void Blt_FreeOptions(Blt_ConfigSpec *specs, char *widgRec, + Display *display, int needFlags); + +BLT_EXTERN int Blt_ObjIsOption(Blt_ConfigSpec *specs, Tcl_Obj *objPtr, + int flags); + +BLT_EXTERN int Blt_GetSideFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + int *sidePtr); + +BLT_EXTERN int Blt_GetPositionFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + long *indexPtr); + +BLT_EXTERN int Blt_GetPixelsFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr, int flags, int *valuePtr); + +BLT_EXTERN int Blt_GetPadFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr, Blt_Pad *padPtr); + +BLT_EXTERN int Blt_GetStateFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + int *statePtr); + +BLT_EXTERN int Blt_GetFillFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + int *fillPtr); + +BLT_EXTERN int Blt_GetResizeFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + int *fillPtr); + +BLT_EXTERN int Blt_GetDashesFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + Blt_Dashes *dashesPtr); + +#if (_TK_VERSION < _VERSION(8,1,0)) +BLT_EXTERN int Tk_GetAnchorFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + Tk_Anchor *anchorPtr); + +BLT_EXTERN int Tk_GetJustifyFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + Tk_Justify *justifyPtr); + +BLT_EXTERN int Tk_GetReliefFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + int *reliefPtr); + +BLT_EXTERN int Tk_GetMMFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr, double *doublePtr); + +BLT_EXTERN int Tk_GetPixelsFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr, int *intPtr); + +BLT_EXTERN Tk_3DBorder Tk_Alloc3DBorderFromObj(Tcl_Interp *interp, + Tk_Window tkwin, Tcl_Obj *objPtr); + +BLT_EXTERN Pixmap Tk_AllocBitmapFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr); + +BLT_EXTERN Tk_Font Tk_AllocFontFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr); + +BLT_EXTERN Tk_Cursor Tk_AllocCursorFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr); + +BLT_EXTERN XColor *Tk_AllocColorFromObj(Tcl_Interp *interp, Tk_Window tkwin, + Tcl_Obj *objPtr); +#endif /* < 8.1 */ + +#endif /* BLT_CONFIG_H */ diff --git a/src/bltGrAxis.C b/src/bltGrAxis.C new file mode 100644 index 0000000..f6f54e9 --- /dev/null +++ b/src/bltGrAxis.C @@ -0,0 +1,5765 @@ + +/* + * bltGrAxis.c -- + * + * This module implements coordinate axes for the BLT graph widget. + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include "bltOp.h" +#include "bltGrElem.h" +#include <X11/Xutil.h> + +#define MAXTICKS 10001 + +#define FCLAMP(x) ((((x) < 0.0) ? 0.0 : ((x) > 1.0) ? 1.0 : (x))) + +/* + * Round x in terms of units + */ +#define UROUND(x,u) (Round((x)/(u))*(u)) +#define UCEIL(x,u) (ceil((x)/(u))*(u)) +#define UFLOOR(x,u) (floor((x)/(u))*(u)) + +#define NUMDIGITS 15 /* Specifies the number of digits of + * accuracy used when outputting axis + * tick labels. */ +enum TickRange { + AXIS_TIGHT, AXIS_LOOSE, AXIS_ALWAYS_LOOSE +}; + +#define AXIS_PAD_TITLE 2 /* Padding for axis title. */ + +/* Axis flags: */ + +#define AXIS_AUTO_MAJOR (1<<16) /* Auto-generate major ticks. */ +#define AXIS_AUTO_MINOR (1<<17) /* Auto-generate minor ticks. */ +#define AXIS_USE (1<<18) /* Axis is displayed on the screen via + * the "use" operation */ +#define AXIS_GRID (1<<19) /* Display grid lines. */ +#define AXIS_GRIDMINOR (1<<20) /* Display grid lines for minor + * ticks. */ +#define AXIS_SHOWTICKS (1<<21) /* Display axis ticks. */ +#define AXIS_EXTERIOR (1<<22) /* Axis is exterior to the plot. */ +#define AXIS_CHECK_LIMITS (1<<23) /* Validate user-defined axis limits. */ + +#define HORIZMARGIN(m) (!((m)->site & 0x1)) /* Even sites are horizontal */ + +typedef struct { + int axis; /* Length of the axis. */ + int t1; /* Length of a major tick (in + * pixels). */ + int t2; /* Length of a minor tick (in + * pixels). */ + int label; /* Distance from axis to tick label. */ +} AxisInfo; + +typedef struct { + const char *name; + ClassId classId; + int margin, invertMargin; +} AxisName; + +static AxisName axisNames[] = { + { "x", CID_AXIS_X, MARGIN_BOTTOM, MARGIN_LEFT }, + { "y", CID_AXIS_Y, MARGIN_LEFT, MARGIN_BOTTOM }, + { "x2", CID_AXIS_X, MARGIN_TOP, MARGIN_RIGHT }, + { "y2", CID_AXIS_Y, MARGIN_RIGHT, MARGIN_TOP } +} ; +static int nAxisNames = sizeof(axisNames) / sizeof(AxisName); + +static Blt_OptionParseProc ObjToLimitProc; +static Blt_OptionPrintProc LimitToObjProc; +static Blt_CustomOption limitOption = { + ObjToLimitProc, LimitToObjProc, NULL, (ClientData)0 +}; + +static Blt_OptionFreeProc FreeTicksProc; +static Blt_OptionParseProc ObjToTicksProc; +static Blt_OptionPrintProc TicksToObjProc; +static Blt_CustomOption majorTicksOption = { + ObjToTicksProc, TicksToObjProc, FreeTicksProc, (ClientData)AXIS_AUTO_MAJOR, +}; +static Blt_CustomOption minorTicksOption = { + ObjToTicksProc, TicksToObjProc, FreeTicksProc, (ClientData)AXIS_AUTO_MINOR, +}; +static Blt_OptionFreeProc FreeAxisProc; +static Blt_OptionPrintProc AxisToObjProc; +static Blt_OptionParseProc ObjToAxisProc; +Blt_CustomOption bltXAxisOption = { + ObjToAxisProc, AxisToObjProc, FreeAxisProc, (ClientData)CID_AXIS_X +}; +Blt_CustomOption bltYAxisOption = { + ObjToAxisProc, AxisToObjProc, FreeAxisProc, (ClientData)CID_AXIS_Y +}; + +static Blt_OptionFreeProc FreeFormatProc; +static Blt_OptionParseProc ObjToFormatProc; +static Blt_OptionPrintProc FormatToObjProc; +static Blt_CustomOption formatOption = { + ObjToFormatProc, FormatToObjProc, FreeFormatProc, (ClientData)0, +}; +static Blt_OptionParseProc ObjToLooseProc; +static Blt_OptionPrintProc LooseToObjProc; +static Blt_CustomOption looseOption = { + ObjToLooseProc, LooseToObjProc, NULL, (ClientData)0, +}; + +static Blt_OptionParseProc ObjToUseProc; +static Blt_OptionPrintProc UseToObjProc; +static Blt_CustomOption useOption = { + ObjToUseProc, UseToObjProc, NULL, (ClientData)0 +}; + +#define DEF_AXIS_ACTIVEBACKGROUND STD_ACTIVE_BACKGROUND +#define DEF_AXIS_ACTIVEFOREGROUND STD_ACTIVE_FOREGROUND +#define DEF_AXIS_ACTIVERELIEF "flat" +#define DEF_AXIS_ANGLE "0.0" +#define DEF_AXIS_BACKGROUND (char *)NULL +#define DEF_AXIS_BORDERWIDTH "0" +#define DEF_AXIS_CHECKLIMITS "0" +#define DEF_AXIS_COMMAND (char *)NULL +#define DEF_AXIS_DESCENDING "0" +#define DEF_AXIS_FOREGROUND RGB_BLACK +#define DEF_AXIS_GRID_BARCHART "1" +#define DEF_AXIS_GRIDCOLOR RGB_GREY64 +#define DEF_AXIS_GRIDDASHES "dot" +#define DEF_AXIS_GRID_GRAPH "0" +#define DEF_AXIS_GRIDLINEWIDTH "0" +#define DEF_AXIS_GRIDMINOR "1" +#define DEF_AXIS_GRIDMINOR_COLOR RGB_GREY64 +#define DEF_AXIS_HIDE "0" +#define DEF_AXIS_JUSTIFY "c" +#define DEF_AXIS_LIMITS_FORMAT (char *)NULL +#define DEF_AXIS_LINEWIDTH "1" +#define DEF_AXIS_LOGSCALE "0" +#define DEF_AXIS_LOOSE "0" +#define DEF_AXIS_RANGE "0.0" +#define DEF_AXIS_RELIEF "flat" +#define DEF_AXIS_SCROLL_INCREMENT "10" +#define DEF_AXIS_SHIFTBY "0.0" +#define DEF_AXIS_SHOWTICKS "1" +#define DEF_AXIS_STEP "0.0" +#define DEF_AXIS_STEP "0.0" +#define DEF_AXIS_SUBDIVISIONS "2" +#define DEF_AXIS_TAGS "all" +#define DEF_AXIS_EXTERIOR "1" +#define DEF_AXIS_TICK_ANCHOR "c" +#define DEF_AXIS_LIMITS_FONT STD_FONT_NUMBERS +#define DEF_AXIS_TICKFONT_GRAPH STD_FONT_NUMBERS +#define DEF_AXIS_TICKFONT_BARCHART STD_FONT_SMALL +#define DEF_AXIS_TICKLENGTH "4" +#define DEF_AXIS_DIVISIONS "10" +#define DEF_AXIS_TITLE_ALTERNATE "0" +#define DEF_AXIS_TITLE_FG RGB_BLACK +#define DEF_AXIS_TITLE_FONT "{Sans Serif} 10" +#define DEF_AXIS_X_STEP_BARCHART "1.0" +#define DEF_AXIS_X_SUBDIVISIONS_BARCHART "0" + +static Blt_ConfigSpec configSpecs[] = +{ + {BLT_CONFIG_BACKGROUND, "-activebackground", "activeBackground", + "ActiveBackground", DEF_AXIS_ACTIVEBACKGROUND, + Blt_Offset(Axis, activeBg), ALL_GRAPHS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-activeforeground", "activeForeground", + "ActiveForeground", DEF_AXIS_ACTIVEFOREGROUND, + Blt_Offset(Axis, activeFgColor), ALL_GRAPHS}, + {BLT_CONFIG_RELIEF, "-activerelief", "activeRelief", "Relief", + DEF_AXIS_ACTIVERELIEF, Blt_Offset(Axis, activeRelief), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_DOUBLE, "-autorange", "autoRange", "AutoRange", + DEF_AXIS_RANGE, Blt_Offset(Axis, windowSize), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BACKGROUND, "-background", "background", "Background", + DEF_AXIS_BACKGROUND, Blt_Offset(Axis, normalBg), + ALL_GRAPHS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-bg", "background", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_AXIS_TAGS, + Blt_Offset(Axis, obj.tags), ALL_GRAPHS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-bd", "borderWidth", (char *)NULL, (char *)NULL, + 0, ALL_GRAPHS}, + {BLT_CONFIG_PIXELS_NNEG, "-borderwidth", "borderWidth", "BorderWidth", + DEF_AXIS_BORDERWIDTH, Blt_Offset(Axis, borderWidth), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-checklimits", "checkLimits", "CheckLimits", + DEF_AXIS_CHECKLIMITS, Blt_Offset(Axis, flags), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)AXIS_CHECK_LIMITS}, + {BLT_CONFIG_COLOR, "-color", "color", "Color", + DEF_AXIS_FOREGROUND, Blt_Offset(Axis, tickColor), ALL_GRAPHS}, + {BLT_CONFIG_STRING, "-command", "command", "Command", + DEF_AXIS_COMMAND, Blt_Offset(Axis, formatCmd), + BLT_CONFIG_NULL_OK | ALL_GRAPHS}, + {BLT_CONFIG_BOOLEAN, "-descending", "descending", "Descending", + DEF_AXIS_DESCENDING, Blt_Offset(Axis, descending), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-exterior", "exterior", "exterior", DEF_AXIS_EXTERIOR, + Blt_Offset(Axis, flags), ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)AXIS_EXTERIOR}, + {BLT_CONFIG_SYNONYM, "-fg", "color", (char *)NULL, + (char *)NULL, 0, ALL_GRAPHS}, + {BLT_CONFIG_SYNONYM, "-foreground", "color", (char *)NULL, + (char *)NULL, 0, ALL_GRAPHS}, + {BLT_CONFIG_BITMASK, "-grid", "grid", "Grid", DEF_AXIS_GRID_BARCHART, + Blt_Offset(Axis, flags), BARCHART, (Blt_CustomOption *)AXIS_GRID}, + {BLT_CONFIG_BITMASK, "-grid", "grid", "Grid", DEF_AXIS_GRID_GRAPH, + Blt_Offset(Axis, flags), GRAPH | STRIPCHART, + (Blt_CustomOption *)AXIS_GRID}, + {BLT_CONFIG_COLOR, "-gridcolor", "gridColor", "GridColor", + DEF_AXIS_GRIDCOLOR, Blt_Offset(Axis, major.color), ALL_GRAPHS}, + {BLT_CONFIG_DASHES, "-griddashes", "gridDashes", "GridDashes", + DEF_AXIS_GRIDDASHES, Blt_Offset(Axis, major.dashes), + BLT_CONFIG_NULL_OK | ALL_GRAPHS}, + {BLT_CONFIG_PIXELS_NNEG, "-gridlinewidth", "gridLineWidth", + "GridLineWidth", DEF_AXIS_GRIDLINEWIDTH, + Blt_Offset(Axis, major.lineWidth), + BLT_CONFIG_DONT_SET_DEFAULT | ALL_GRAPHS}, + {BLT_CONFIG_BITMASK, "-gridminor", "gridMinor", "GridMinor", + DEF_AXIS_GRIDMINOR, Blt_Offset(Axis, flags), + BLT_CONFIG_DONT_SET_DEFAULT | ALL_GRAPHS, + (Blt_CustomOption *)AXIS_GRIDMINOR}, + {BLT_CONFIG_COLOR, "-gridminorcolor", "gridMinorColor", "GridColor", + DEF_AXIS_GRIDMINOR_COLOR, Blt_Offset(Axis, minor.color), ALL_GRAPHS}, + {BLT_CONFIG_DASHES, "-gridminordashes", "gridMinorDashes", "GridDashes", + DEF_AXIS_GRIDDASHES, Blt_Offset(Axis, minor.dashes), + BLT_CONFIG_NULL_OK | ALL_GRAPHS}, + {BLT_CONFIG_PIXELS_NNEG, "-gridminorlinewidth", "gridMinorLineWidth", + "GridLineWidth", DEF_AXIS_GRIDLINEWIDTH, + Blt_Offset(Axis, minor.lineWidth), + BLT_CONFIG_DONT_SET_DEFAULT | ALL_GRAPHS}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_AXIS_HIDE, + Blt_Offset(Axis, flags), ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_JUSTIFY, "-justify", "justify", "Justify", + DEF_AXIS_JUSTIFY, Blt_Offset(Axis, titleJustify), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-labeloffset", "labelOffset", "LabelOffset", + (char *)NULL, Blt_Offset(Axis, labelOffset), ALL_GRAPHS}, + {BLT_CONFIG_COLOR, "-limitscolor", "limitsColor", "Color", + DEF_AXIS_FOREGROUND, Blt_Offset(Axis, limitsTextStyle.color), + ALL_GRAPHS}, + {BLT_CONFIG_FONT, "-limitsfont", "limitsFont", "Font", DEF_AXIS_LIMITS_FONT, + Blt_Offset(Axis, limitsTextStyle.font), ALL_GRAPHS}, + {BLT_CONFIG_CUSTOM, "-limitsformat", "limitsFormat", "LimitsFormat", + (char *)NULL, Blt_Offset(Axis, limitsFormats), + BLT_CONFIG_NULL_OK | ALL_GRAPHS, &formatOption}, + {BLT_CONFIG_PIXELS_NNEG, "-linewidth", "lineWidth", "LineWidth", + DEF_AXIS_LINEWIDTH, Blt_Offset(Axis, lineWidth), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-logscale", "logScale", "LogScale", + DEF_AXIS_LOGSCALE, Blt_Offset(Axis, logScale), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-loose", "loose", "Loose", DEF_AXIS_LOOSE, 0, + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT, &looseOption}, + {BLT_CONFIG_CUSTOM, "-majorticks", "majorTicks", "MajorTicks", + (char *)NULL, Blt_Offset(Axis, t1Ptr), + BLT_CONFIG_NULL_OK | ALL_GRAPHS, &majorTicksOption}, + {BLT_CONFIG_CUSTOM, "-max", "max", "Max", (char *)NULL, + Blt_Offset(Axis, reqMax), ALL_GRAPHS, &limitOption}, + {BLT_CONFIG_CUSTOM, "-min", "min", "Min", (char *)NULL, + Blt_Offset(Axis, reqMin), ALL_GRAPHS, &limitOption}, + {BLT_CONFIG_CUSTOM, "-minorticks", "minorTicks", "MinorTicks", + (char *)NULL, Blt_Offset(Axis, t2Ptr), + BLT_CONFIG_NULL_OK | ALL_GRAPHS, &minorTicksOption}, + {BLT_CONFIG_RELIEF, "-relief", "relief", "Relief", + DEF_AXIS_RELIEF, Blt_Offset(Axis, relief), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FLOAT, "-rotate", "rotate", "Rotate", DEF_AXIS_ANGLE, + Blt_Offset(Axis, tickAngle), ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_OBJ, "-scrollcommand", "scrollCommand", "ScrollCommand", + (char *)NULL, Blt_Offset(Axis, scrollCmdObjPtr), + ALL_GRAPHS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_PIXELS_POS, "-scrollincrement", "scrollIncrement", + "ScrollIncrement", DEF_AXIS_SCROLL_INCREMENT, + Blt_Offset(Axis, scrollUnits), ALL_GRAPHS|BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-scrollmax", "scrollMax", "ScrollMax", (char *)NULL, + Blt_Offset(Axis, reqScrollMax), ALL_GRAPHS, &limitOption}, + {BLT_CONFIG_CUSTOM, "-scrollmin", "scrollMin", "ScrollMin", (char *)NULL, + Blt_Offset(Axis, reqScrollMin), ALL_GRAPHS, &limitOption}, + {BLT_CONFIG_DOUBLE, "-shiftby", "shiftBy", "ShiftBy", + DEF_AXIS_SHIFTBY, Blt_Offset(Axis, shiftBy), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-showticks", "showTicks", "ShowTicks", + DEF_AXIS_SHOWTICKS, Blt_Offset(Axis, flags), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)AXIS_SHOWTICKS}, + {BLT_CONFIG_DOUBLE, "-stepsize", "stepSize", "StepSize", + DEF_AXIS_STEP, Blt_Offset(Axis, reqStep), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_INT, "-subdivisions", "subdivisions", "Subdivisions", + DEF_AXIS_SUBDIVISIONS, Blt_Offset(Axis, reqNumMinorTicks), ALL_GRAPHS}, + {BLT_CONFIG_ANCHOR, "-tickanchor", "tickAnchor", "Anchor", + DEF_AXIS_TICK_ANCHOR, Blt_Offset(Axis, reqTickAnchor), ALL_GRAPHS}, + {BLT_CONFIG_FONT, "-tickfont", "tickFont", "Font", + DEF_AXIS_TICKFONT_GRAPH, Blt_Offset(Axis, tickFont), + GRAPH | STRIPCHART}, + {BLT_CONFIG_FONT, "-tickfont", "tickFont", "Font", + DEF_AXIS_TICKFONT_BARCHART, Blt_Offset(Axis, tickFont), BARCHART}, + {BLT_CONFIG_PIXELS_NNEG, "-ticklength", "tickLength", "TickLength", + DEF_AXIS_TICKLENGTH, Blt_Offset(Axis, tickLength), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_INT, "-tickdefault", "tickDefault", "TickDefault", + DEF_AXIS_DIVISIONS, Blt_Offset(Axis, reqNumMajorTicks), + ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-title", "title", "Title", + (char *)NULL, Blt_Offset(Axis, title), + BLT_CONFIG_DONT_SET_DEFAULT | BLT_CONFIG_NULL_OK | ALL_GRAPHS}, + {BLT_CONFIG_BOOLEAN, "-titlealternate", "titleAlternate", "TitleAlternate", + DEF_AXIS_TITLE_ALTERNATE, Blt_Offset(Axis, titleAlternate), + BLT_CONFIG_DONT_SET_DEFAULT | ALL_GRAPHS}, + {BLT_CONFIG_COLOR, "-titlecolor", "titleColor", "Color", + DEF_AXIS_FOREGROUND, Blt_Offset(Axis, titleColor), + ALL_GRAPHS}, + {BLT_CONFIG_FONT, "-titlefont", "titleFont", "Font", DEF_AXIS_TITLE_FONT, + Blt_Offset(Axis, titleFont), ALL_GRAPHS}, + {BLT_CONFIG_CUSTOM, "-use", "use", "Use", (char *)NULL, 0, ALL_GRAPHS, + &useOption}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +/* Forward declarations */ +static void DestroyAxis(Axis *axisPtr); +static Tcl_FreeProc FreeAxis; +static int GetAxisByClass(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, + ClassId classId, Axis **axisPtrPtr); +static void TimeScaleAxis(Axis *axisPtr, double min, double max); + +static int lastMargin; +typedef int (GraphAxisProc)(Tcl_Interp *interp, Axis *axisPtr, int objc, + Tcl_Obj *const *objv); +typedef int (GraphVirtualAxisProc)(Tcl_Interp *interp, Graph *graphPtr, + int objc, Tcl_Obj *const *objv); + +INLINE static double +Clamp(double x) +{ + return (x < 0.0) ? 0.0 : (x > 1.0) ? 1.0 : x; +} + +INLINE static int +Round(double x) +{ + return (int) (x + ((x < 0.0) ? -0.5 : 0.5)); +} + +static void +SetAxisRange(AxisRange *rangePtr, double min, double max) +{ + rangePtr->min = min; + rangePtr->max = max; + rangePtr->range = max - min; + if (FABS(rangePtr->range) < DBL_EPSILON) { + rangePtr->range = 1.0; + } + rangePtr->scale = 1.0 / rangePtr->range; +} + +/* + *--------------------------------------------------------------------------- + * + * InRange -- + * + * Determines if a value lies within a given range. + * + * The value is normalized and compared against the interval [0..1], + * where 0.0 is the minimum and 1.0 is the maximum. DBL_EPSILON is the + * smallest number that can be represented on the host machine, such that + * (1.0 + epsilon) != 1.0. + * + * Please note, *max* can't equal *min*. + * + * Results: + * If the value is within the interval [min..max], 1 is returned; 0 + * otherwise. + * + *--------------------------------------------------------------------------- + */ +INLINE static int +InRange(double x, AxisRange *rangePtr) +{ + if (rangePtr->range < DBL_EPSILON) { + return (FABS(rangePtr->max - x) >= DBL_EPSILON); + } else { + double norm; + + norm = (x - rangePtr->min) * rangePtr->scale; + return ((norm >= -DBL_EPSILON) && ((norm - 1.0) < DBL_EPSILON)); + } +} + +INLINE static int +AxisIsHorizontal(Axis *axisPtr) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + + return ((axisPtr->obj.classId == CID_AXIS_Y) == graphPtr->inverted); +} + + +static void +ReleaseAxis(Axis *axisPtr) +{ + if (axisPtr != NULL) { + axisPtr->refCount--; + assert(axisPtr->refCount >= 0); + if (axisPtr->refCount == 0) { + axisPtr->flags |= DELETE_PENDING; + Tcl_EventuallyFree(axisPtr, FreeAxis); + } + } +} + +/* + *----------------------------------------------------------------------------- + * Custom option parse and print procedures + *----------------------------------------------------------------------------- + */ + +/*ARGSUSED*/ +static void +FreeAxisProc( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + Axis **axisPtrPtr = (Axis **)(widgRec + offset); + + if (*axisPtrPtr != NULL) { + ReleaseAxis(*axisPtrPtr); + *axisPtrPtr = NULL; + } +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToAxisProc -- + * + * Converts the name of an axis to a pointer to its axis structure. + * + * Results: + * The return value is a standard TCL result. The axis flags are written + * into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToAxisProc( + ClientData clientData, /* Class identifier of the type of + * axis we are looking for. */ + Tcl_Interp *interp, /* Interpreter to report results. */ + Tk_Window tkwin, /* Used to look up pointer to graph. */ + Tcl_Obj *objPtr, /* String representing new value. */ + char *widgRec, /* Pointer to structure record. */ + int offset, /* Offset to field in structure */ + int flags) +{ + ClassId classId = (ClassId)clientData; + Axis **axisPtrPtr = (Axis **)(widgRec + offset); + Axis *axisPtr; + Graph *graphPtr; + + if (flags & BLT_CONFIG_NULL_OK) { + const char *string; + + string = Tcl_GetString(objPtr); + if (string[0] == '\0') { + ReleaseAxis(*axisPtrPtr); + *axisPtrPtr = NULL; + return TCL_OK; + } + } + graphPtr = Blt_GetGraphFromWindowData(tkwin); + assert(graphPtr); + if (GetAxisByClass(interp, graphPtr, objPtr, classId, &axisPtr) + != TCL_OK) { + return TCL_ERROR; + } + ReleaseAxis(*axisPtrPtr); + *axisPtrPtr = axisPtr; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * AxisToObjProc -- + * + * Convert the window coordinates into a string. + * + * Results: + * The string representing the coordinate position is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +AxisToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Pointer to structure record .*/ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Axis *axisPtr = *(Axis **)(widgRec + offset); + const char *name; + + name = (axisPtr == NULL) ? "" : axisPtr->obj.name; + return Tcl_NewStringObj(name, -1); +} + +/*ARGSUSED*/ +static void +FreeFormatProc( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) /* Not used. */ +{ + Axis *axisPtr = (Axis *)(widgRec); + + if (axisPtr->limitsFormats != NULL) { + Blt_Free(axisPtr->limitsFormats); + axisPtr->limitsFormats = NULL; + } + axisPtr->nFormats = 0; +} + + +/* + *--------------------------------------------------------------------------- + * + * ObjToFormatProc -- + * + * Convert the name of virtual axis to an pointer. + * + * Results: + * The return value is a standard TCL result. The axis flags are written + * into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToFormatProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to report results. */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing new value. */ + char *widgRec, /* Pointer to structure record. */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Axis *axisPtr = (Axis *)(widgRec); + const char **argv; + int argc; + + if (Tcl_SplitList(interp, Tcl_GetString(objPtr), &argc, &argv) != TCL_OK) { + return TCL_ERROR; + } + if (argc > 2) { + Tcl_AppendResult(interp, "too many elements in limits format list \"", + Tcl_GetString(objPtr), "\"", (char *)NULL); + Blt_Free(argv); + return TCL_ERROR; + } + if (axisPtr->limitsFormats != NULL) { + Blt_Free(axisPtr->limitsFormats); + } + axisPtr->limitsFormats = argv; + axisPtr->nFormats = argc; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * FormatToObjProc -- + * + * Convert the window coordinates into a string. + * + * Results: + * The string representing the coordinate position is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +FormatToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Widget record */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Axis *axisPtr = (Axis *)(widgRec); + Tcl_Obj *objPtr; + + if (axisPtr->nFormats == 0) { + objPtr = Tcl_NewStringObj("", -1); + } else { + const char *string; + + string = Tcl_Merge(axisPtr->nFormats, axisPtr->limitsFormats); + objPtr = Tcl_NewStringObj(string, -1); + Blt_Free(string); + } + return objPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToLimitProc -- + * + * Convert the string representation of an axis limit into its numeric + * form. + * + * Results: + * The return value is a standard TCL result. The symbol type is written + * into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToLimitProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back + * to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing new value. */ + char *widgRec, /* Pointer to structure record. */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + double *limitPtr = (double *)(widgRec + offset); + const char *string; + + string = Tcl_GetString(objPtr); + if (string[0] == '\0') { + *limitPtr = Blt_NaN(); + } else if (Blt_ExprDoubleFromObj(interp, objPtr, limitPtr) != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * LimitToObjProc -- + * + * Convert the floating point axis limits into a string. + * + * Results: + * The string representation of the limits is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +LimitToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + double limit = *(double *)(widgRec + offset); + Tcl_Obj *objPtr; + + if (DEFINED(limit)) { + objPtr = Tcl_NewDoubleObj(limit); + } else { + objPtr = Tcl_NewStringObj("", -1); + } + return objPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToUseProc -- + * + * Convert the string representation of the margin to use into its + * numeric form. + * + * Results: + * The return value is a standard TCL result. The use type is written + * into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToUseProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results. */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing new value. */ + char *widgRec, /* Pointer to structure record. */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Axis *axisPtr = (Axis *)(widgRec); + AxisName *p, *pend; + Blt_Chain chain; + Graph *graphPtr; + const char *string; + int margin; + + graphPtr = axisPtr->obj.graphPtr; + if (axisPtr->refCount == 0) { + /* Clear the axis class if it's not currently used by an element.*/ + Blt_GraphSetObjectClass(&axisPtr->obj, CID_NONE); + } + /* Remove the axis from the margin's use list and clear its use flag. */ + if (axisPtr->link != NULL) { + Blt_Chain_UnlinkLink(axisPtr->chain, axisPtr->link); + } + axisPtr->flags &= ~AXIS_USE; + string = Tcl_GetString(objPtr); + if ((string == NULL) || (string[0] == '\0')) { + goto done; + } + for (p = axisNames, pend = axisNames + nAxisNames; p < pend; p++) { + if (strcmp(p->name, string) == 0) { + break; /* Found the axis name. */ + } + } + if (p == pend) { + Tcl_AppendResult(interp, "unknown axis type \"", string, "\": " + "should be x, y, x1, y2, or \"\".", (char *)NULL); + return TCL_ERROR; + } + /* Check the axis class. Can't use the axis if it's already being used as + * another type. */ + if (axisPtr->obj.classId == CID_NONE) { + Blt_GraphSetObjectClass(&axisPtr->obj, p->classId); + } else if (axisPtr->obj.classId != p->classId) { + Tcl_AppendResult(interp, "wrong type for axis \"", + axisPtr->obj.name, "\": can't use ", + axisPtr->obj.className, " type axis.", (char *)NULL); + return TCL_ERROR; + } + margin = (graphPtr->inverted) ? p->invertMargin : p->margin; + chain = graphPtr->margins[margin].axes; + if (axisPtr->link != NULL) { + /* Move the axis from the old margin's "use" list to the new. */ + Blt_Chain_AppendLink(chain, axisPtr->link); + } else { + axisPtr->link = Blt_Chain_Append(chain, axisPtr); + } + axisPtr->chain = chain; + axisPtr->flags |= AXIS_USE; + axisPtr->margin = margin; + done: + graphPtr->flags |= (GET_AXIS_GEOMETRY | LAYOUT_NEEDED | RESET_AXES); + /* When any axis changes, we need to layout the entire graph. */ + graphPtr->flags |= (MAP_WORLD | REDRAW_WORLD); + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * UseToObjProc -- + * + * Convert the floating point axis limits into a string. + * + * Results: + * The string representation of the limits is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +UseToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Axis *axisPtr = (Axis *)(widgRec); + + if (axisPtr->margin == MARGIN_NONE) { + return Tcl_NewStringObj("", -1); + } + return Tcl_NewStringObj(axisNames[axisPtr->margin].name, -1); +} + +/*ARGSUSED*/ +static void +FreeTicksProc( + ClientData clientData, /* Either AXIS_AUTO_MAJOR or + * AXIS_AUTO_MINOR. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + Axis *axisPtr = (Axis *)widgRec; + Ticks **ticksPtrPtr = (Ticks **) (widgRec + offset); + unsigned long mask = (unsigned long)clientData; + + axisPtr->flags |= mask; + if (*ticksPtrPtr != NULL) { + Blt_Free(*ticksPtrPtr); + } + *ticksPtrPtr = NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToTicksProc -- + * + * + * Results: + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToTicksProc( + ClientData clientData, /* Either AXIS_AUTO_MAJOR or + * AXIS_AUTO_MINOR. */ + Tcl_Interp *interp, /* Interpreter to send results. */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing new value. */ + char *widgRec, /* Pointer to structure record. */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Axis *axisPtr = (Axis *)widgRec; + Tcl_Obj **objv; + Ticks **ticksPtrPtr = (Ticks **) (widgRec + offset); + Ticks *ticksPtr; + int objc; + unsigned long mask = (unsigned long)clientData; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + axisPtr->flags |= mask; + ticksPtr = NULL; + if (objc > 0) { + int i; + + ticksPtr = Blt_AssertMalloc(sizeof(Ticks) + (objc*sizeof(double))); + for (i = 0; i < objc; i++) { + double value; + + if (Blt_ExprDoubleFromObj(interp, objv[i], &value) != TCL_OK) { + Blt_Free(ticksPtr); + return TCL_ERROR; + } + ticksPtr->values[i] = value; + } + ticksPtr->nTicks = objc; + axisPtr->flags &= ~mask; + } + FreeTicksProc(clientData, Tk_Display(tkwin), widgRec, offset); + *ticksPtrPtr = ticksPtr; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * TicksToObjProc -- + * + * Convert array of tick coordinates to a list. + * + * Results: + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +TicksToObjProc( + ClientData clientData, /* Either AXIS_AUTO_MAJOR or + * AXIS_AUTO_MINOR. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Axis *axisPtr; + Tcl_Obj *listObjPtr; + Ticks *ticksPtr; + unsigned long mask; + + axisPtr = (Axis *)widgRec; + ticksPtr = *(Ticks **) (widgRec + offset); + mask = (unsigned long)clientData; + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if ((ticksPtr != NULL) && ((axisPtr->flags & mask) == 0)) { + unsigned int i; + + for (i = 0; i < ticksPtr->nTicks; i++) { + Tcl_Obj *objPtr; + + objPtr = Tcl_NewDoubleObj(ticksPtr->values[i]); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + } + return listObjPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToLooseProc -- + * + * Convert a string to one of three values. + * 0 - false, no, off + * 1 - true, yes, on + * 2 - always + * Results: + * If the string is successfully converted, TCL_OK is returned. + * Otherwise, TCL_ERROR is returned and an error message is left in + * interpreter's result field. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToLooseProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results. */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing new value. */ + char *widgRec, /* Pointer to structure record. */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Axis *axisPtr = (Axis *)(widgRec); + Tcl_Obj **objv; + int i; + int objc; + int values[2]; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if ((objc < 1) || (objc > 2)) { + Tcl_AppendResult(interp, "wrong # elements in loose value \"", + Tcl_GetString(objPtr), "\"", (char *)NULL); + return TCL_ERROR; + } + for (i = 0; i < objc; i++) { + const char *string; + + string = Tcl_GetString(objv[i]); + if ((string[0] == 'a') && (strcmp(string, "always") == 0)) { + values[i] = AXIS_ALWAYS_LOOSE; + } else { + int bool; + + if (Tcl_GetBooleanFromObj(interp, objv[i], &bool) != TCL_OK) { + return TCL_ERROR; + } + values[i] = bool; + } + } + axisPtr->looseMin = axisPtr->looseMax = values[0]; + if (objc > 1) { + axisPtr->looseMax = values[1]; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * LooseToObjProc -- + * + * Results: + * The string representation of the auto boolean is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +LooseToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Widget record */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Axis *axisPtr = (Axis *)widgRec; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (axisPtr->looseMin == AXIS_TIGHT) { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewBooleanObj(FALSE)); + } else if (axisPtr->looseMin == AXIS_LOOSE) { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewBooleanObj(TRUE)); + } else if (axisPtr->looseMin == AXIS_ALWAYS_LOOSE) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj("always", 6)); + } + if (axisPtr->looseMin != axisPtr->looseMax) { + if (axisPtr->looseMax == AXIS_TIGHT) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewBooleanObj(FALSE)); + } else if (axisPtr->looseMax == AXIS_LOOSE) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewBooleanObj(TRUE)); + } else if (axisPtr->looseMax == AXIS_ALWAYS_LOOSE) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj("always", 6)); + } + } + return listObjPtr; +} + +static void +FreeTickLabels(Blt_Chain chain) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(chain); link != NULL; + link = Blt_Chain_NextLink(link)) { + TickLabel *labelPtr; + + labelPtr = Blt_Chain_GetValue(link); + Blt_Free(labelPtr); + } + Blt_Chain_Reset(chain); +} + +/* + *--------------------------------------------------------------------------- + * + * MakeLabel -- + * + * Converts a floating point tick value to a string to be used as its + * label. + * + * Results: + * None. + * + * Side Effects: + * Returns a new label in the string character buffer. The formatted + * tick label will be displayed on the graph. + * + * -------------------------------------------------------------------------- + */ +static TickLabel * +MakeLabel(Axis *axisPtr, double value) +{ +#define TICK_LABEL_SIZE 200 + char string[TICK_LABEL_SIZE + 1]; + TickLabel *labelPtr; + + /* Generate a default tick label based upon the tick value. */ + if (axisPtr->logScale) { + sprintf_s(string, TICK_LABEL_SIZE, "1E%d", ROUND(value)); + } else { + sprintf_s(string, TICK_LABEL_SIZE, "%.*G", NUMDIGITS, value); + } + + if (axisPtr->formatCmd != NULL) { + Graph *graphPtr; + Tcl_Interp *interp; + Tk_Window tkwin; + + graphPtr = axisPtr->obj.graphPtr; + interp = graphPtr->interp; + tkwin = graphPtr->tkwin; + /* + * A TCL proc was designated to format tick labels. Append the path + * name of the widget and the default tick label as arguments when + * invoking it. Copy and save the new label from interp->result. + */ + Tcl_ResetResult(interp); + if (Tcl_VarEval(interp, axisPtr->formatCmd, " ", Tk_PathName(tkwin), + " ", string, (char *)NULL) != TCL_OK) { + Tcl_BackgroundError(interp); + } else { + /* + * The proc could return a string of any length, so arbitrarily + * limit it to what will fit in the return string. + */ + strncpy(string, Tcl_GetStringResult(interp), TICK_LABEL_SIZE); + string[TICK_LABEL_SIZE] = '\0'; + + Tcl_ResetResult(interp); /* Clear the interpreter's result. */ + } + } + labelPtr = Blt_AssertMalloc(sizeof(TickLabel) + strlen(string)); + strcpy(labelPtr->string, string); + labelPtr->anchorPos.x = labelPtr->anchorPos.y = DBL_MAX; + return labelPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_InvHMap -- + * + * Maps the given screen coordinate back to a graph coordinate. Called + * by the graph locater routine. + * + * Results: + * Returns the graph coordinate value at the given window + * y-coordinate. + * + *--------------------------------------------------------------------------- + */ +double +Blt_InvHMap(Axis *axisPtr, double x) +{ + double value; + + x = (double)(x - axisPtr->screenMin) * axisPtr->screenScale; + if (axisPtr->descending) { + x = 1.0 - x; + } + value = (x * axisPtr->axisRange.range) + axisPtr->axisRange.min; + if (axisPtr->logScale) { + value = EXP10(value); + } + return value; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_InvVMap -- + * + * Maps the given screen y-coordinate back to the graph coordinate + * value. Called by the graph locater routine. + * + * Results: + * Returns the graph coordinate value for the given screen + * coordinate. + * + *--------------------------------------------------------------------------- + */ +double +Blt_InvVMap(Axis *axisPtr, double y) /* Screen coordinate */ +{ + double value; + + y = (double)(y - axisPtr->screenMin) * axisPtr->screenScale; + if (axisPtr->descending) { + y = 1.0 - y; + } + value = ((1.0 - y) * axisPtr->axisRange.range) + axisPtr->axisRange.min; + if (axisPtr->logScale) { + value = EXP10(value); + } + return value; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_HMap -- + * + * Map the given graph coordinate value to its axis, returning a window + * position. + * + * Results: + * Returns a double precision number representing the window coordinate + * position on the given axis. + * + *--------------------------------------------------------------------------- + */ +double +Blt_HMap(Axis *axisPtr, double x) +{ + if ((axisPtr->logScale) && (x != 0.0)) { + x = log10(FABS(x)); + } + /* Map graph coordinate to normalized coordinates [0..1] */ + x = (x - axisPtr->axisRange.min) * axisPtr->axisRange.scale; + if (axisPtr->descending) { + x = 1.0 - x; + } + return (x * axisPtr->screenRange + axisPtr->screenMin); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_VMap -- + * + * Map the given graph coordinate value to its axis, returning a window + * position. + * + * Results: + * Returns a double precision number representing the window coordinate + * position on the given axis. + * + *--------------------------------------------------------------------------- + */ +double +Blt_VMap(Axis *axisPtr, double y) +{ + if ((axisPtr->logScale) && (y != 0.0)) { + y = log10(FABS(y)); + } + /* Map graph coordinate to normalized coordinates [0..1] */ + y = (y - axisPtr->axisRange.min) * axisPtr->axisRange.scale; + if (axisPtr->descending) { + y = 1.0 - y; + } + return ((1.0 - y) * axisPtr->screenRange + axisPtr->screenMin); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Map2D -- + * + * Maps the given graph x,y coordinate values to a window position. + * + * Results: + * Returns a XPoint structure containing the window coordinates of + * the given graph x,y coordinate. + * + *--------------------------------------------------------------------------- + */ +Point2d +Blt_Map2D( + Graph *graphPtr, + double x, double y, /* Graph x and y coordinates */ + Axis2d *axesPtr) /* Specifies which axes to use */ +{ + Point2d point; + + if (graphPtr->inverted) { + point.x = Blt_HMap(axesPtr->y, y); + point.y = Blt_VMap(axesPtr->x, x); + } else { + point.x = Blt_HMap(axesPtr->x, x); + point.y = Blt_VMap(axesPtr->y, y); + } + return point; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_InvMap2D -- + * + * Maps the given window x,y coordinates to graph values. + * + * Results: + * Returns a structure containing the graph coordinates of the given + * window x,y coordinate. + * + *--------------------------------------------------------------------------- + */ +Point2d +Blt_InvMap2D( + Graph *graphPtr, + double x, double y, /* Window x and y coordinates */ + Axis2d *axesPtr) /* Specifies which axes to use */ +{ + Point2d point; + + if (graphPtr->inverted) { + point.x = Blt_InvVMap(axesPtr->x, y); + point.y = Blt_InvHMap(axesPtr->y, x); + } else { + point.x = Blt_InvHMap(axesPtr->x, x); + point.y = Blt_InvVMap(axesPtr->y, y); + } + return point; +} + + +static void +GetDataLimits(Axis *axisPtr, double min, double max) +{ + if (axisPtr->valueRange.min > min) { + axisPtr->valueRange.min = min; + } + if (axisPtr->valueRange.max < max) { + axisPtr->valueRange.max = max; + } +} + +static void +FixAxisRange(Axis *axisPtr) +{ + double min, max; + + /* + * When auto-scaling, the axis limits are the bounds of the element data. + * If no data exists, set arbitrary limits (wrt to log/linear scale). + */ + min = axisPtr->valueRange.min; + max = axisPtr->valueRange.max; + + /* Check the requested axis limits. Can't allow -min to be greater + * than -max, or have undefined log scale limits. */ + if (((DEFINED(axisPtr->reqMin)) && (DEFINED(axisPtr->reqMax))) && + (axisPtr->reqMin >= axisPtr->reqMax)) { + axisPtr->reqMin = axisPtr->reqMax = Blt_NaN(); + } + if (axisPtr->logScale) { + if ((DEFINED(axisPtr->reqMin)) && (axisPtr->reqMin <= 0.0)) { + axisPtr->reqMin = Blt_NaN(); + } + if ((DEFINED(axisPtr->reqMax)) && (axisPtr->reqMax <= 0.0)) { + axisPtr->reqMax = Blt_NaN(); + } + } + + if (min == DBL_MAX) { + if (DEFINED(axisPtr->reqMin)) { + min = axisPtr->reqMin; + } else { + min = (axisPtr->logScale) ? 0.001 : 0.0; + } + } + if (max == -DBL_MAX) { + if (DEFINED(axisPtr->reqMax)) { + max = axisPtr->reqMax; + } else { + max = 1.0; + } + } + if (min >= max) { + /* + * There is no range of data (i.e. min is not less than max), so + * manufacture one. + */ + if (min == 0.0) { + min = 0.0, max = 1.0; + } else { + max = min + (FABS(min) * 0.1); + } + } + SetAxisRange(&axisPtr->valueRange, min, max); + + /* + * The axis limits are either the current data range or overridden by the + * values selected by the user with the -min or -max options. + */ + axisPtr->min = min; + axisPtr->max = max; + if (DEFINED(axisPtr->reqMin)) { + axisPtr->min = axisPtr->reqMin; + } + if (DEFINED(axisPtr->reqMax)) { + axisPtr->max = axisPtr->reqMax; + } + if (axisPtr->max < axisPtr->min) { + /* + * If the limits still don't make sense, it's because one limit + * configuration option (-min or -max) was set and the other default + * (based upon the data) is too small or large. Remedy this by making + * up a new min or max from the user-defined limit. + */ + if (!DEFINED(axisPtr->reqMin)) { + axisPtr->min = axisPtr->max - (FABS(axisPtr->max) * 0.1); + } + if (!DEFINED(axisPtr->reqMax)) { + axisPtr->max = axisPtr->min + (FABS(axisPtr->max) * 0.1); + } + } + /* + * If a window size is defined, handle auto ranging by shifting the axis + * limits. + */ + if ((axisPtr->windowSize > 0.0) && + (!DEFINED(axisPtr->reqMin)) && (!DEFINED(axisPtr->reqMax))) { + if (axisPtr->shiftBy < 0.0) { + axisPtr->shiftBy = 0.0; + } + max = axisPtr->min + axisPtr->windowSize; + if (axisPtr->max >= max) { + if (axisPtr->shiftBy > 0.0) { + max = UCEIL(axisPtr->max, axisPtr->shiftBy); + } + axisPtr->min = max - axisPtr->windowSize; + } + axisPtr->max = max; + } + if ((axisPtr->max != axisPtr->prevMax) || + (axisPtr->min != axisPtr->prevMin)) { + /* Indicate if the axis limits have changed */ + axisPtr->flags |= DIRTY; + /* and save the previous minimum and maximum values */ + axisPtr->prevMin = axisPtr->min; + axisPtr->prevMax = axisPtr->max; + } +} + +/* + *--------------------------------------------------------------------------- + * + * NiceNum -- + * + * Reference: Paul Heckbert, "Nice Numbers for Graph Labels", + * Graphics Gems, pp 61-63. + * + * Finds a "nice" number approximately equal to x. + * + *--------------------------------------------------------------------------- + */ +static double +NiceNum(double x, int round) /* If non-zero, round. Otherwise take + * ceiling of value. */ +{ + double expt; /* Exponent of x */ + double frac; /* Fractional part of x */ + double nice; /* Nice, rounded fraction */ + + expt = floor(log10(x)); + frac = x / EXP10(expt); /* between 1 and 10 */ + if (round) { + if (frac < 1.5) { + nice = 1.0; + } else if (frac < 3.0) { + nice = 2.0; + } else if (frac < 7.0) { + nice = 5.0; + } else { + nice = 10.0; + } + } else { + if (frac <= 1.0) { + nice = 1.0; + } else if (frac <= 2.0) { + nice = 2.0; + } else if (frac <= 5.0) { + nice = 5.0; + } else { + nice = 10.0; + } + } + return nice * EXP10(expt); +} + +static Ticks * +GenerateTicks(TickSweep *sweepPtr) +{ + Ticks *ticksPtr; + + ticksPtr = Blt_AssertMalloc(sizeof(Ticks) + + (sweepPtr->nSteps * sizeof(double))); + ticksPtr->nTicks = 0; + + if (sweepPtr->step == 0.0) { + /* Hack: A zero step indicates to use log values. */ + int i; + /* Precomputed log10 values [1..10] */ + static double logTable[] = { + 0.0, + 0.301029995663981, + 0.477121254719662, + 0.602059991327962, + 0.698970004336019, + 0.778151250383644, + 0.845098040014257, + 0.903089986991944, + 0.954242509439325, + 1.0 + }; + for (i = 0; i < sweepPtr->nSteps; i++) { + ticksPtr->values[i] = logTable[i]; + } + } else { + double value; + int i; + + value = sweepPtr->initial; /* Start from smallest axis tick */ + for (i = 0; i < sweepPtr->nSteps; i++) { + value = UROUND(value, sweepPtr->step); + ticksPtr->values[i] = value; + value += sweepPtr->step; + } + } + ticksPtr->nTicks = sweepPtr->nSteps; + return ticksPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * LogScaleAxis -- + * + * Determine the range and units of a log scaled axis. + * + * Unless the axis limits are specified, the axis is scaled + * automatically, where the smallest and largest major ticks encompass + * the range of actual data values. When an axis limit is specified, + * that value represents the smallest(min)/largest(max) value in the + * displayed range of values. + * + * Both manual and automatic scaling are affected by the step used. By + * default, the step is the largest power of ten to divide the range in + * more than one piece. + * + * Automatic scaling: + * Find the smallest number of units which contain the range of values. + * The minimum and maximum major tick values will be represent the + * range of values for the axis. This greatest number of major ticks + * possible is 10. + * + * Manual scaling: + * Make the minimum and maximum data values the represent the range of + * the values for the axis. The minimum and maximum major ticks will be + * inclusive of this range. This provides the largest area for plotting + * and the expected results when the axis min and max values have be set + * by the user (.e.g zooming). The maximum number of major ticks is 20. + * + * For log scale, there's the possibility that the minimum and + * maximum data values are the same magnitude. To represent the + * points properly, at least one full decade should be shown. + * However, if you zoom a log scale plot, the results should be + * predictable. Therefore, in that case, show only minor ticks. + * Lastly, there should be an appropriate way to handle numbers + * <=0. + * + * maxY + * | units = magnitude (of least significant digit) + * | high = largest unit tick < max axis value + * high _| low = smallest unit tick > min axis value + * | + * | range = high - low + * | # ticks = greatest factor of range/units + * _| + * U | + * n | + * i | + * t _| + * | + * | + * | + * low _| + * | + * |_minX________________maxX__ + * | | | | | + * minY low high + * minY + * + * + * numTicks = Number of ticks + * min = Minimum value of axis + * max = Maximum value of axis + * range = Range of values (max - min) + * + * If the number of decades is greater than ten, it is assumed + * that the full set of log-style ticks can't be drawn properly. + * + * Results: + * None + * + * -------------------------------------------------------------------------- */ +static void +LogScaleAxis(Axis *axisPtr, double min, double max) +{ + double range; + double tickMin, tickMax; + double majorStep, minorStep; + int nMajor, nMinor; + + nMajor = nMinor = 0; + /* Suppress compiler warnings. */ + majorStep = minorStep = 0.0; + tickMin = tickMax = Blt_NaN(); + if (min < max) { + min = (min != 0.0) ? log10(FABS(min)) : 0.0; + max = (max != 0.0) ? log10(FABS(max)) : 1.0; + + tickMin = floor(min); + tickMax = ceil(max); + range = tickMax - tickMin; + + if (range > 10) { + /* There are too many decades to display a major tick at every + * decade. Instead, treat the axis as a linear scale. */ + range = NiceNum(range, 0); + majorStep = NiceNum(range / axisPtr->reqNumMajorTicks, 1); + tickMin = UFLOOR(tickMin, majorStep); + tickMax = UCEIL(tickMax, majorStep); + nMajor = (int)((tickMax - tickMin) / majorStep) + 1; + minorStep = EXP10(floor(log10(majorStep))); + if (minorStep == majorStep) { + nMinor = 4, minorStep = 0.2; + } else { + nMinor = Round(majorStep / minorStep) - 1; + } + } else { + if (tickMin == tickMax) { + tickMax++; + } + majorStep = 1.0; + nMajor = (int)(tickMax - tickMin + 1); /* FIXME: Check this. */ + + minorStep = 0.0; /* This is a special hack to pass + * information to the GenerateTicks + * routine. An interval of 0.0 tells 1) + * this is a minor sweep and 2) the axis + * is log scale. */ + nMinor = 10; + } + if ((axisPtr->looseMin == AXIS_TIGHT) || + ((axisPtr->looseMin == AXIS_LOOSE) && + (DEFINED(axisPtr->reqMin)))) { + tickMin = min; + nMajor++; + } + if ((axisPtr->looseMax == AXIS_TIGHT) || + ((axisPtr->looseMax == AXIS_LOOSE) && + (DEFINED(axisPtr->reqMax)))) { + tickMax = max; + } + } + axisPtr->majorSweep.step = majorStep; + axisPtr->majorSweep.initial = floor(tickMin); + axisPtr->majorSweep.nSteps = nMajor; + axisPtr->minorSweep.initial = axisPtr->minorSweep.step = minorStep; + axisPtr->minorSweep.nSteps = nMinor; + + SetAxisRange(&axisPtr->axisRange, tickMin, tickMax); +} + +/* + *--------------------------------------------------------------------------- + * + * LinearScaleAxis -- + * + * Determine the units of a linear scaled axis. + * + * The axis limits are either the range of the data values mapped + * to the axis (autoscaled), or the values specified by the -min + * and -max options (manual). + * + * If autoscaled, the smallest and largest major ticks will + * encompass the range of data values. If the -loose option is + * selected, the next outer ticks are choosen. If tight, the + * ticks are at or inside of the data limits are used. + * + * If manually set, the ticks are at or inside the data limits + * are used. This makes sense for zooming. You want the + * selected range to represent the next limit, not something a + * bit bigger. + * + * Note: I added an "always" value to the -loose option to force + * the manually selected axes to be loose. It's probably + * not a good idea. + * + * maxY + * | units = magnitude (of least significant digit) + * | high = largest unit tick < max axis value + * high _| low = smallest unit tick > min axis value + * | + * | range = high - low + * | # ticks = greatest factor of range/units + * _| + * U | + * n | + * i | + * t _| + * | + * | + * | + * low _| + * | + * |_minX________________maxX__ + * | | | | | + * minY low high + * minY + * + * numTicks = Number of ticks + * min = Minimum value of axis + * max = Maximum value of axis + * range = Range of values (max - min) + * + * Results: + * None. + * + * Side Effects: + * The axis tick information is set. The actual tick values will + * be generated later. + * + *--------------------------------------------------------------------------- + */ +static void +LinearScaleAxis(Axis *axisPtr, double min, double max) +{ + double step; + double tickMin, tickMax; + double axisMin, axisMax; + unsigned int nTicks; + + nTicks = 0; + step = 1.0; + /* Suppress compiler warning. */ + axisMin = axisMax = tickMin = tickMax = Blt_NaN(); + if (min < max) { + double range; + + range = max - min; + /* Calculate the major tick stepping. */ + if (axisPtr->reqStep > 0.0) { + /* An interval was designated by the user. Keep scaling it until + * it fits comfortably within the current range of the axis. */ + step = axisPtr->reqStep; + while ((2 * step) >= range) { + step *= 0.5; + } + } else { + range = NiceNum(range, 0); + step = NiceNum(range / axisPtr->reqNumMajorTicks, 1); + } + + /* Find the outer tick values. Add 0.0 to prevent getting -0.0. */ + axisMin = tickMin = floor(min / step) * step + 0.0; + axisMax = tickMax = ceil(max / step) * step + 0.0; + + nTicks = Round((tickMax - tickMin) / step) + 1; + } + axisPtr->majorSweep.step = step; + axisPtr->majorSweep.initial = tickMin; + axisPtr->majorSweep.nSteps = nTicks; + + /* + * The limits of the axis are either the range of the data ("tight") or at + * the next outer tick interval ("loose"). The looseness or tightness has + * to do with how the axis fits the range of data values. This option is + * overridden when the user sets an axis limit (by either -min or -max + * option). The axis limit is always at the selected limit (otherwise we + * assume that user would have picked a different number). + */ + if ((axisPtr->looseMin == AXIS_TIGHT) || + ((axisPtr->looseMin == AXIS_LOOSE) && + (DEFINED(axisPtr->reqMin)))) { + axisMin = min; + } + if ((axisPtr->looseMax == AXIS_TIGHT) || + ((axisPtr->looseMax == AXIS_LOOSE) && + (DEFINED(axisPtr->reqMax)))) { + axisMax = max; + } + SetAxisRange(&axisPtr->axisRange, axisMin, axisMax); + + /* Now calculate the minor tick step and number. */ + + if ((axisPtr->reqNumMinorTicks > 0) && (axisPtr->flags & AXIS_AUTO_MAJOR)) { + nTicks = axisPtr->reqNumMinorTicks - 1; + step = 1.0 / (nTicks + 1); + } else { + nTicks = 0; /* No minor ticks. */ + step = 0.5; /* Don't set the minor tick interval to + * 0.0. It makes the GenerateTicks + * routine * create minor log-scale tick + * marks. */ + } + axisPtr->minorSweep.initial = axisPtr->minorSweep.step = step; + axisPtr->minorSweep.nSteps = nTicks; +} + + +static void +SweepTicks(Axis *axisPtr) +{ + if (axisPtr->flags & AXIS_AUTO_MAJOR) { + if (axisPtr->t1Ptr != NULL) { + Blt_Free(axisPtr->t1Ptr); + } + axisPtr->t1Ptr = GenerateTicks(&axisPtr->majorSweep); + } + if (axisPtr->flags & AXIS_AUTO_MINOR) { + if (axisPtr->t2Ptr != NULL) { + Blt_Free(axisPtr->t2Ptr); + } + axisPtr->t2Ptr = GenerateTicks(&axisPtr->minorSweep); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ResetAxes -- + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_ResetAxes(Graph *graphPtr) +{ + Blt_ChainLink link; + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + /* FIXME: This should be called whenever the display list of + * elements change. Maybe yet another flag INIT_STACKS to + * indicate that the element display list has changed. + * Needs to be done before the axis limits are set. + */ + Blt_InitBarSetTable(graphPtr); + if ((graphPtr->mode == BARS_STACKED) && (graphPtr->nBarGroups > 0)) { + Blt_ComputeBarStacks(graphPtr); + } + /* + * Step 1: Reset all axes. Initialize the data limits of the axis to + * impossible values. + */ + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + + axisPtr = Blt_GetHashValue(hPtr); + axisPtr->min = axisPtr->valueRange.min = DBL_MAX; + axisPtr->max = axisPtr->valueRange.max = -DBL_MAX; + } + + /* + * Step 2: For each element that's to be displayed, get the smallest + * and largest data values mapped to each X and Y-axis. This + * will be the axis limits if the user doesn't override them + * with -min and -max options. + */ + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + Region2d exts; + + elemPtr = Blt_Chain_GetValue(link); + if ((graphPtr->flags & UNMAP_HIDDEN) && (elemPtr->flags & HIDE)) { + continue; + } + (*elemPtr->procsPtr->extentsProc) (elemPtr, &exts); + GetDataLimits(elemPtr->axes.x, exts.left, exts.right); + GetDataLimits(elemPtr->axes.y, exts.top, exts.bottom); + } + /* + * Step 3: Now that we know the range of data values for each axis, + * set axis limits and compute a sweep to generate tick values. + */ + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + double min, max; + + axisPtr = Blt_GetHashValue(hPtr); + FixAxisRange(axisPtr); + + /* Calculate min/max tick (major/minor) layouts */ + min = axisPtr->min; + max = axisPtr->max; + if ((DEFINED(axisPtr->scrollMin)) && (min < axisPtr->scrollMin)) { + min = axisPtr->scrollMin; + } + if ((DEFINED(axisPtr->scrollMax)) && (max > axisPtr->scrollMax)) { + max = axisPtr->scrollMax; + } + if (axisPtr->logScale) { + LogScaleAxis(axisPtr, min, max); + } else if (axisPtr->timeScale) { + TimeScaleAxis(axisPtr, min, max); + } else { + LinearScaleAxis(axisPtr, min, max); + } + + if ((axisPtr->flags & (DIRTY|AXIS_USE)) == (DIRTY|AXIS_USE)) { + graphPtr->flags |= CACHE_DIRTY; + } + } + + graphPtr->flags &= ~RESET_AXES; + + /* + * When any axis changes, we need to layout the entire graph. + */ + graphPtr->flags |= (GET_AXIS_GEOMETRY | LAYOUT_NEEDED | MAP_ALL | + REDRAW_WORLD); +} + +/* + *--------------------------------------------------------------------------- + * + * ResetTextStyles -- + * + * Configures axis attributes (font, line width, label, etc) and + * allocates a new (possibly shared) graphics context. Line cap style is + * projecting. This is for the problem of when a tick sits directly at + * the end point of the axis. + * + * Results: + * The return value is a standard TCL result. + * + * Side Effects: + * Axis resources are allocated (GC, font). Axis layout is deferred until + * the height and width of the window are known. + * + *--------------------------------------------------------------------------- + */ +static void +ResetTextStyles(Axis *axisPtr) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + GC newGC; + XGCValues gcValues; + unsigned long gcMask; + + Blt_Ts_ResetStyle(graphPtr->tkwin, &axisPtr->limitsTextStyle); + + gcMask = (GCForeground | GCLineWidth | GCCapStyle); + gcValues.foreground = axisPtr->tickColor->pixel; + gcValues.font = Blt_FontId(axisPtr->tickFont); + gcValues.line_width = LineWidth(axisPtr->lineWidth); + gcValues.cap_style = CapProjecting; + + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (axisPtr->tickGC != NULL) { + Tk_FreeGC(graphPtr->display, axisPtr->tickGC); + } + axisPtr->tickGC = newGC; + + /* Assuming settings from above GC */ + gcValues.foreground = axisPtr->activeFgColor->pixel; + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (axisPtr->activeTickGC != NULL) { + Tk_FreeGC(graphPtr->display, axisPtr->activeTickGC); + } + axisPtr->activeTickGC = newGC; + + gcValues.background = gcValues.foreground = axisPtr->major.color->pixel; + gcValues.line_width = LineWidth(axisPtr->major.lineWidth); + gcMask = (GCForeground | GCBackground | GCLineWidth); + if (LineIsDashed(axisPtr->major.dashes)) { + gcValues.line_style = LineOnOffDash; + gcMask |= GCLineStyle; + } + newGC = Blt_GetPrivateGC(graphPtr->tkwin, gcMask, &gcValues); + if (LineIsDashed(axisPtr->major.dashes)) { + Blt_SetDashes(graphPtr->display, newGC, &axisPtr->major.dashes); + } + if (axisPtr->major.gc != NULL) { + Blt_FreePrivateGC(graphPtr->display, axisPtr->major.gc); + } + axisPtr->major.gc = newGC; + + gcValues.background = gcValues.foreground = axisPtr->minor.color->pixel; + gcValues.line_width = LineWidth(axisPtr->minor.lineWidth); + gcMask = (GCForeground | GCBackground | GCLineWidth); + if (LineIsDashed(axisPtr->minor.dashes)) { + gcValues.line_style = LineOnOffDash; + gcMask |= GCLineStyle; + } + newGC = Blt_GetPrivateGC(graphPtr->tkwin, gcMask, &gcValues); + if (LineIsDashed(axisPtr->minor.dashes)) { + Blt_SetDashes(graphPtr->display, newGC, &axisPtr->minor.dashes); + } + if (axisPtr->minor.gc != NULL) { + Blt_FreePrivateGC(graphPtr->display, axisPtr->minor.gc); + } + axisPtr->minor.gc = newGC; +} + +/* + *--------------------------------------------------------------------------- + * + * DestroyAxis -- + * + * Results: + * None. + * + * Side effects: + * Resources (font, color, gc, labels, etc.) associated with the axis are + * deallocated. + * + *--------------------------------------------------------------------------- + */ +static void +DestroyAxis(Axis *axisPtr) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + int flags; + + flags = Blt_GraphType(graphPtr); + Blt_FreeOptions(configSpecs, (char *)axisPtr, graphPtr->display, flags); + if (graphPtr->bindTable != NULL) { + Blt_DeleteBindings(graphPtr->bindTable, axisPtr); + } + if (axisPtr->link != NULL) { + Blt_Chain_DeleteLink(axisPtr->chain, axisPtr->link); + } + if (axisPtr->obj.name != NULL) { + Blt_Free(axisPtr->obj.name); + } + if (axisPtr->hashPtr != NULL) { + Blt_DeleteHashEntry(&graphPtr->axes.table, axisPtr->hashPtr); + } + Blt_Ts_FreeStyle(graphPtr->display, &axisPtr->limitsTextStyle); + + if (axisPtr->tickGC != NULL) { + Tk_FreeGC(graphPtr->display, axisPtr->tickGC); + } + if (axisPtr->activeTickGC != NULL) { + Tk_FreeGC(graphPtr->display, axisPtr->activeTickGC); + } + if (axisPtr->major.gc != NULL) { + Blt_FreePrivateGC(graphPtr->display, axisPtr->major.gc); + } + if (axisPtr->minor.gc != NULL) { + Blt_FreePrivateGC(graphPtr->display, axisPtr->minor.gc); + } + FreeTickLabels(axisPtr->tickLabels); + Blt_Chain_Destroy(axisPtr->tickLabels); + if (axisPtr->segments != NULL) { + Blt_Free(axisPtr->segments); + } + Blt_Free(axisPtr); +} + +static void +FreeAxis(DestroyData data) +{ + Axis *axisPtr = (Axis *)data; + DestroyAxis(axisPtr); +} + +static float titleAngle[4] = /* Rotation for each axis title */ +{ + 0.0, 90.0, 0.0, 270.0 +}; + +/* + *--------------------------------------------------------------------------- + * + * AxisOffsets -- + * + * Determines the sites of the axis, major and minor ticks, and title of + * the axis. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +AxisOffsets( + Axis *axisPtr, + int margin, + int offset, + AxisInfo *infoPtr) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + Margin *marginPtr; + int pad; /* Offset of axis from interior + * region. This includes a possible + * border and the axis line width. */ + int axisLine; + int t1, t2, labelOffset; + int tickLabel, axisPad; + int inset, mark; + int x, y; + float fangle; + + axisPtr->titleAngle = titleAngle[margin]; + marginPtr = graphPtr->margins + margin; + + tickLabel = axisLine = t1 = t2 = 0; + labelOffset = AXIS_PAD_TITLE; + if (axisPtr->lineWidth > 0) { + if (axisPtr->flags & AXIS_SHOWTICKS) { + t1 = axisPtr->tickLength; + t2 = (t1 * 10) / 15; + } + labelOffset = t1 + AXIS_PAD_TITLE; + if (axisPtr->flags & AXIS_EXTERIOR) { + labelOffset += axisPtr->lineWidth; + } + } + axisPad = 0; + if (graphPtr->plotRelief != TK_RELIEF_SOLID) { + axisPad = 0; + } + /* Adjust offset for the interior border width and the line width */ + pad = 1; + if (graphPtr->plotBW > 0) { + pad += graphPtr->plotBW + 1; + } + pad = 0; /* FIXME: test */ + /* + * Pre-calculate the x-coordinate positions of the axis, tick labels, and + * the individual major and minor ticks. + */ + inset = pad + axisPtr->lineWidth / 2; + switch (margin) { + case MARGIN_TOP: + axisLine = graphPtr->top; + if (axisPtr->flags & AXIS_EXTERIOR) { + axisLine -= graphPtr->plotBW + axisPad + axisPtr->lineWidth / 2; + tickLabel = axisLine - 2; + if (axisPtr->lineWidth > 0) { + tickLabel -= axisPtr->tickLength; + } +#ifdef notdef + fprintf(stderr, "axisLine=%d, axisPad=%d plotBW=%d axisPtr->lineWidth/2=%d\n", axisLine, axisPad, graphPtr->plotBW, axisPtr->lineWidth /2 ); +#endif + } else { + if (graphPtr->plotRelief == TK_RELIEF_SOLID) { + axisLine--; + } + axisLine -= axisPad + axisPtr->lineWidth / 2; + tickLabel = graphPtr->top - graphPtr->plotBW - 2; +#ifdef notdef + fprintf(stderr, "axisLine=%d, axisPad=%d plotBW=%d axisPtr->lineWidth/2=%d\n", axisLine, axisPad, graphPtr->plotBW, axisPtr->lineWidth /2 ); +#endif + } + mark = graphPtr->top - offset - pad; + axisPtr->tickAnchor = TK_ANCHOR_S; + axisPtr->left = axisPtr->screenMin - inset - 2; + axisPtr->right = axisPtr->screenMin + axisPtr->screenRange + inset - 1; + if (graphPtr->stackAxes) { + axisPtr->top = mark - marginPtr->axesOffset; + } else { + axisPtr->top = mark - axisPtr->height; + } + axisPtr->bottom = mark; + if (axisPtr->titleAlternate) { + x = graphPtr->right + AXIS_PAD_TITLE; + y = mark - (axisPtr->height / 2); + axisPtr->titleAnchor = TK_ANCHOR_W; + } else { + x = (axisPtr->right + axisPtr->left) / 2; + if (graphPtr->stackAxes) { + y = mark - marginPtr->axesOffset + AXIS_PAD_TITLE; + } else { + y = mark - axisPtr->height + AXIS_PAD_TITLE; + } + axisPtr->titleAnchor = TK_ANCHOR_N; + } + axisPtr->titlePos.x = x; + axisPtr->titlePos.y = y; + break; + + case MARGIN_BOTTOM: + /* + * ----------- bottom + plot borderwidth + * mark -------------------------------------------- + * ===================== axisLine (linewidth) + * tick + * title + * + * ===================== axisLine (linewidth) + * ----------- bottom + plot borderwidth + * mark -------------------------------------------- + * tick + * title + */ + axisLine = graphPtr->bottom; + if (graphPtr->plotRelief == TK_RELIEF_SOLID) { + axisLine++; + } + if (axisPtr->flags & AXIS_EXTERIOR) { + axisLine += graphPtr->plotBW + axisPad + axisPtr->lineWidth / 2; + tickLabel = axisLine + 2; + if (axisPtr->lineWidth > 0) { + tickLabel += axisPtr->tickLength; + } + } else { + axisLine -= axisPad + axisPtr->lineWidth / 2; + tickLabel = graphPtr->bottom + graphPtr->plotBW + 2; + } + mark = graphPtr->bottom + offset; + fangle = FMOD(axisPtr->tickAngle, 90.0); + if (fangle == 0.0) { + axisPtr->tickAnchor = TK_ANCHOR_N; + } else { + int quadrant; + + quadrant = (int)(axisPtr->tickAngle / 90.0); + if ((quadrant == 0) || (quadrant == 2)) { + axisPtr->tickAnchor = TK_ANCHOR_NE; + } else { + axisPtr->tickAnchor = TK_ANCHOR_NW; + } + } + axisPtr->left = axisPtr->screenMin - inset - 2; + axisPtr->right = axisPtr->screenMin + axisPtr->screenRange + inset - 1; + axisPtr->top = graphPtr->bottom + labelOffset - t1; + if (graphPtr->stackAxes) { + axisPtr->bottom = mark + marginPtr->axesOffset - 1; + } else { + axisPtr->bottom = mark + axisPtr->height - 1; + } + if (axisPtr->titleAlternate) { + x = graphPtr->right + AXIS_PAD_TITLE; + y = mark + (axisPtr->height / 2); + axisPtr->titleAnchor = TK_ANCHOR_W; + } else { + x = (axisPtr->right + axisPtr->left) / 2; + if (graphPtr->stackAxes) { + y = mark + marginPtr->axesOffset - AXIS_PAD_TITLE; + } else { + y = mark + axisPtr->height - AXIS_PAD_TITLE; + } + axisPtr->titleAnchor = TK_ANCHOR_S; + } + axisPtr->titlePos.x = x; + axisPtr->titlePos.y = y; + break; + + case MARGIN_LEFT: + /* + * mark + * | : + * | : + * | : + * | : + * | : + * axisLine + */ + /* + * Exterior axis + * + plotarea right + * |A|B|C|D|E|F|G|H + * |right + * A = plot pad + * B = plot border width + * C = axis pad + * D = axis line + * E = tick length + * F = tick label + * G = graph border width + * H = highlight thickness + */ + /* + * Interior axis + * + plotarea right + * |A|B|C|D|E|F|G|H + * |right + * A = plot pad + * B = tick length + * C = axis line width + * D = axis pad + * E = plot border width + * F = tick label + * G = graph border width + * H = highlight thickness + */ + axisLine = graphPtr->left; + if (axisPtr->flags & AXIS_EXTERIOR) { + axisLine -= graphPtr->plotBW + axisPad + axisPtr->lineWidth / 2; + tickLabel = axisLine - 2; + if (axisPtr->lineWidth > 0) { + tickLabel -= axisPtr->tickLength; + } + } else { + if (graphPtr->plotRelief == TK_RELIEF_SOLID) { + axisLine--; + } + axisLine += axisPad + axisPtr->lineWidth / 2; + tickLabel = graphPtr->left - graphPtr->plotBW - 2; + } + mark = graphPtr->left - offset; + axisPtr->tickAnchor = TK_ANCHOR_E; + if (graphPtr->stackAxes) { + axisPtr->left = mark - marginPtr->axesOffset; + } else { + axisPtr->left = mark - axisPtr->width; + } + axisPtr->right = mark - 3; + axisPtr->top = axisPtr->screenMin - inset - 2; + axisPtr->bottom = axisPtr->screenMin + axisPtr->screenRange + inset - 1; + if (axisPtr->titleAlternate) { + x = mark - (axisPtr->width / 2); + y = graphPtr->top - AXIS_PAD_TITLE; + axisPtr->titleAnchor = TK_ANCHOR_SW; + } else { + if (graphPtr->stackAxes) { + x = mark - marginPtr->axesOffset; + } else { + x = mark - axisPtr->width + AXIS_PAD_TITLE; + } + y = (axisPtr->bottom + axisPtr->top) / 2; + axisPtr->titleAnchor = TK_ANCHOR_W; + } + axisPtr->titlePos.x = x; + axisPtr->titlePos.y = y; + break; + + case MARGIN_RIGHT: + axisLine = graphPtr->right; + if (graphPtr->plotRelief == TK_RELIEF_SOLID) { + axisLine++; /* Draw axis line within solid plot + * border. */ + } + if (axisPtr->flags & AXIS_EXTERIOR) { + axisLine += graphPtr->plotBW + axisPad + axisPtr->lineWidth / 2; + tickLabel = axisLine + 2; + if (axisPtr->lineWidth > 0) { + tickLabel += axisPtr->tickLength; + } + } else { + axisLine -= axisPad + axisPtr->lineWidth / 2; + tickLabel = graphPtr->right + graphPtr->plotBW + 2; + } + mark = graphPtr->right + offset + pad; + axisPtr->tickAnchor = TK_ANCHOR_W; + axisPtr->left = mark; + if (graphPtr->stackAxes) { + axisPtr->right = mark + marginPtr->axesOffset - 1; + } else { + axisPtr->right = mark + axisPtr->width - 1; + } + axisPtr->top = axisPtr->screenMin - inset - 2; + axisPtr->bottom = axisPtr->screenMin + axisPtr->screenRange + inset -1; + if (axisPtr->titleAlternate) { + x = mark + (axisPtr->width / 2); + y = graphPtr->top - AXIS_PAD_TITLE; + axisPtr->titleAnchor = TK_ANCHOR_SE; + } else { + if (graphPtr->stackAxes) { + x = mark + marginPtr->axesOffset - AXIS_PAD_TITLE; + } else { + x = mark + axisPtr->width - AXIS_PAD_TITLE; + } + y = (axisPtr->bottom + axisPtr->top) / 2; + axisPtr->titleAnchor = TK_ANCHOR_E; + } + axisPtr->titlePos.x = x; + axisPtr->titlePos.y = y; + break; + + case MARGIN_NONE: + axisLine = 0; + break; + } + if ((margin == MARGIN_LEFT) || (margin == MARGIN_TOP)) { + t1 = -t1, t2 = -t2; + labelOffset = -labelOffset; + } + infoPtr->axis = axisLine; + infoPtr->t1 = axisLine + t1; + infoPtr->t2 = axisLine + t2; + if (tickLabel > 0) { + infoPtr->label = tickLabel; + } else { + infoPtr->label = axisLine + labelOffset; + } + if ((axisPtr->flags & AXIS_EXTERIOR) == 0) { + /*infoPtr->label = axisLine + labelOffset - t1; */ + infoPtr->t1 = axisLine - t1; + infoPtr->t2 = axisLine - t2; + } +} + +static void +MakeAxisLine(Axis *axisPtr, int line, Segment2d *sp) +{ + double min, max; + + min = axisPtr->axisRange.min; + max = axisPtr->axisRange.max; + if (axisPtr->logScale) { + min = EXP10(min); + max = EXP10(max); + } + if (AxisIsHorizontal(axisPtr)) { + sp->p.x = Blt_HMap(axisPtr, min); + sp->q.x = Blt_HMap(axisPtr, max); + sp->p.y = sp->q.y = line; + } else { + sp->q.x = sp->p.x = line; + sp->p.y = Blt_VMap(axisPtr, min); + sp->q.y = Blt_VMap(axisPtr, max); + } +} + + +static void +MakeTick(Axis *axisPtr, double value, int tick, int line, Segment2d *sp) +{ + if (axisPtr->logScale) { + value = EXP10(value); + } + if (AxisIsHorizontal(axisPtr)) { + sp->p.x = sp->q.x = Blt_HMap(axisPtr, value); + sp->p.y = line; + sp->q.y = tick; + } else { + sp->p.x = line; + sp->p.y = sp->q.y = Blt_VMap(axisPtr, value); + sp->q.x = tick; + } +} + +static void +MakeSegments(Axis *axisPtr, AxisInfo *infoPtr) +{ + int arraySize; + int nMajorTicks, nMinorTicks; + Segment2d *segments; + Segment2d *sp; + + if (axisPtr->segments != NULL) { + Blt_Free(axisPtr->segments); + } + nMajorTicks = nMinorTicks = 0; + if (axisPtr->t1Ptr != NULL) { + nMajorTicks = axisPtr->t1Ptr->nTicks; + } + if (axisPtr->t2Ptr != NULL) { + nMinorTicks = axisPtr->t2Ptr->nTicks; + } + arraySize = 1 + (nMajorTicks * (nMinorTicks + 1)); + segments = Blt_AssertMalloc(arraySize * sizeof(Segment2d)); + sp = segments; + if (axisPtr->lineWidth > 0) { + /* Axis baseline */ + MakeAxisLine(axisPtr, infoPtr->axis, sp); + sp++; + } + if (axisPtr->flags & AXIS_SHOWTICKS) { + Blt_ChainLink link; + double labelPos; + int i; + int isHoriz; + + isHoriz = AxisIsHorizontal(axisPtr); + for (i = 0; i < nMajorTicks; i++) { + double t1, t2; + int j; + + t1 = axisPtr->t1Ptr->values[i]; + /* Minor ticks */ + for (j = 0; j < nMinorTicks; j++) { + t2 = t1 + (axisPtr->majorSweep.step * + axisPtr->t2Ptr->values[j]); + if (InRange(t2, &axisPtr->axisRange)) { + MakeTick(axisPtr, t2, infoPtr->t2, infoPtr->axis, sp); + sp++; + } + } + if (!InRange(t1, &axisPtr->axisRange)) { + continue; + } + /* Major tick */ + MakeTick(axisPtr, t1, infoPtr->t1, infoPtr->axis, sp); + sp++; + } + + link = Blt_Chain_FirstLink(axisPtr->tickLabels); + labelPos = (double)infoPtr->label; + + for (i = 0; i < nMajorTicks; i++) { + double t1; + TickLabel *labelPtr; + Segment2d seg; + + t1 = axisPtr->t1Ptr->values[i]; + if (axisPtr->labelOffset) { + t1 += axisPtr->majorSweep.step * 0.5; + } + if (!InRange(t1, &axisPtr->axisRange)) { + continue; + } + labelPtr = Blt_Chain_GetValue(link); + link = Blt_Chain_NextLink(link); + MakeTick(axisPtr, t1, infoPtr->t1, infoPtr->axis, &seg); + /* Save tick label X-Y position. */ + if (isHoriz) { + labelPtr->anchorPos.x = seg.p.x; + labelPtr->anchorPos.y = labelPos; + } else { + labelPtr->anchorPos.x = labelPos; + labelPtr->anchorPos.y = seg.p.y; + } + } + } + axisPtr->segments = segments; + axisPtr->nSegments = sp - segments; + assert(axisPtr->nSegments <= arraySize); +} + +/* + *--------------------------------------------------------------------------- + * + * MapAxis -- + * + * Pre-calculates positions of the axis, ticks, and labels (to be used + * later when displaying the axis). Calculates the values for each major + * and minor tick and checks to see if they are in range (the outer ticks + * may be outside of the range of plotted values). + * + * Line segments for the minor and major ticks are saved into one + * XSegment array so that they can be drawn by a single XDrawSegments + * call. The positions of the tick labels are also computed and saved. + * + * Results: + * None. + * + * Side Effects: + * Line segments and tick labels are saved and used later to draw the + * axis. + * + *--------------------------------------------------------------------------- + */ +static void +MapAxis(Axis *axisPtr, int offset, int margin) +{ + AxisInfo info; + Graph *graphPtr = axisPtr->obj.graphPtr; + + if (AxisIsHorizontal(axisPtr)) { + axisPtr->screenMin = graphPtr->hOffset; + axisPtr->width = graphPtr->right - graphPtr->left; + axisPtr->screenRange = graphPtr->hRange; + } else { + axisPtr->screenMin = graphPtr->vOffset; + axisPtr->height = graphPtr->bottom - graphPtr->top; + axisPtr->screenRange = graphPtr->vRange; + } + axisPtr->screenScale = 1.0 / axisPtr->screenRange; + AxisOffsets(axisPtr, margin, offset, &info); + MakeSegments(axisPtr, &info); +} + +/* + *--------------------------------------------------------------------------- + * + * MapStackedAxis -- + * + * Pre-calculates positions of the axis, ticks, and labels (to be used + * later when displaying the axis). Calculates the values for each major + * and minor tick and checks to see if they are in range (the outer ticks + * may be outside of the range of plotted values). + * + * Line segments for the minor and major ticks are saved into one XSegment + * array so that they can be drawn by a single XDrawSegments call. The + * positions of the tick labels are also computed and saved. + * + * Results: + * None. + * + * Side Effects: + * Line segments and tick labels are saved and used later to draw the + * axis. + * + *--------------------------------------------------------------------------- + */ +static void +MapStackedAxis(Axis *axisPtr, int count, int margin) +{ + AxisInfo info; + Graph *graphPtr = axisPtr->obj.graphPtr; + unsigned int slice, w, h; + + if ((graphPtr->margins[axisPtr->margin].axes->nLinks > 1) || + (axisPtr->reqNumMajorTicks <= 0)) { + axisPtr->reqNumMajorTicks = 4; + } + if (AxisIsHorizontal(axisPtr)) { + slice = graphPtr->hRange / graphPtr->margins[margin].axes->nLinks; + axisPtr->screenMin = graphPtr->hOffset; + axisPtr->width = slice; + } else { + slice = graphPtr->vRange / graphPtr->margins[margin].axes->nLinks; + axisPtr->screenMin = graphPtr->vOffset; + axisPtr->height = slice; + } +#define AXIS_PAD 2 + Blt_GetTextExtents(axisPtr->tickFont, 0, "0", 1, &w, &h); + axisPtr->screenMin += (slice * count) + AXIS_PAD + h / 2; + axisPtr->screenRange = slice - 2 * AXIS_PAD - h; + axisPtr->screenScale = 1.0f / axisPtr->screenRange; + AxisOffsets(axisPtr, margin, 0, &info); + MakeSegments(axisPtr, &info); +} + +/* + *--------------------------------------------------------------------------- + * + * AdjustViewport -- + * + * Adjusts the offsets of the viewport according to the scroll mode. This + * is to accommodate both "listbox" and "canvas" style scrolling. + * + * "canvas" The viewport scrolls within the range of world + * coordinates. This way the viewport always displays + * a full page of the world. If the world is smaller + * than the viewport, then (bizarrely) the world and + * viewport are inverted so that the world moves up + * and down within the viewport. + * + * "listbox" The viewport can scroll beyond the range of world + * coordinates. Every entry can be displayed at the + * top of the viewport. This also means that the + * scrollbar thumb weirdly shrinks as the last entry + * is scrolled upward. + * + * Results: + * The corrected offset is returned. + * + *--------------------------------------------------------------------------- + */ +static double +AdjustViewport(double offset, double windowSize) +{ + /* + * Canvas-style scrolling allows the world to be scrolled within the window. + */ + if (windowSize > 1.0) { + if (windowSize < (1.0 - offset)) { + offset = 1.0 - windowSize; + } + if (offset > 0.0) { + offset = 0.0; + } + } else { + if ((offset + windowSize) > 1.0) { + offset = 1.0 - windowSize; + } + if (offset < 0.0) { + offset = 0.0; + } + } + return offset; +} + +static int +GetAxisScrollInfo( + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv, + double *offsetPtr, + double windowSize, + double scrollUnits, + double scale) +{ + const char *string; + char c; + double offset; + int length; + + offset = *offsetPtr; + string = Tcl_GetStringFromObj(objv[0], &length); + c = string[0]; + scrollUnits *= scale; + if ((c == 's') && (strncmp(string, "scroll", length) == 0)) { + int count; + double fract; + + assert(objc == 3); + /* Scroll number unit/page */ + if (Tcl_GetIntFromObj(interp, objv[1], &count) != TCL_OK) { + return TCL_ERROR; + } + string = Tcl_GetStringFromObj(objv[2], &length); + c = string[0]; + if ((c == 'u') && (strncmp(string, "units", length) == 0)) { + fract = count * scrollUnits; + } else if ((c == 'p') && (strncmp(string, "pages", length) == 0)) { + /* A page is 90% of the view-able window. */ + fract = (int)(count * windowSize * 0.9 + 0.5); + } else if ((c == 'p') && (strncmp(string, "pixels", length) == 0)) { + fract = count * scale; + } else { + Tcl_AppendResult(interp, "unknown \"scroll\" units \"", string, + "\"", (char *)NULL); + return TCL_ERROR; + } + offset += fract; + } else if ((c == 'm') && (strncmp(string, "moveto", length) == 0)) { + double fract; + + assert(objc == 2); + /* moveto fraction */ + if (Blt_GetDoubleFromObj(interp, objv[1], &fract) != TCL_OK) { + return TCL_ERROR; + } + offset = fract; + } else { + int count; + double fract; + + /* Treat like "scroll units" */ + if (Tcl_GetIntFromObj(interp, objv[0], &count) != TCL_OK) { + return TCL_ERROR; + } + fract = (double)count * scrollUnits; + offset += fract; + /* CHECK THIS: return TCL_OK; */ + } + *offsetPtr = AdjustViewport(offset, windowSize); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DrawAxis -- + * + * Draws the axis, ticks, and labels onto the canvas. + * + * Initializes and passes text attribute information through TextStyle + * structure. + * + * Results: + * None. + * + * Side Effects: + * Axis gets drawn on window. + * + *--------------------------------------------------------------------------- + */ +static void +DrawAxis(Axis *axisPtr, Drawable drawable) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + + if (axisPtr->normalBg != NULL) { + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, + axisPtr->normalBg, + axisPtr->left, axisPtr->top, + axisPtr->right - axisPtr->left, + axisPtr->bottom - axisPtr->top, axisPtr->borderWidth, + axisPtr->relief); + } + if (axisPtr->title != NULL) { + TextStyle ts; + + Blt_Ts_InitStyle(ts); + Blt_Ts_SetAngle(ts, axisPtr->titleAngle); + Blt_Ts_SetFont(ts, axisPtr->titleFont); + Blt_Ts_SetPadding(ts, 1, 2, 0, 0); + Blt_Ts_SetAnchor(ts, axisPtr->titleAnchor); + Blt_Ts_SetJustify(ts, axisPtr->titleJustify); + if (axisPtr->flags & ACTIVE) { + Blt_Ts_SetForeground(ts, axisPtr->activeFgColor); + } else { + Blt_Ts_SetForeground(ts, axisPtr->titleColor); + } + Blt_Ts_SetForeground(ts, axisPtr->titleColor); + if ((axisPtr->titleAngle == 90.0) || (axisPtr->titleAngle == 270.0)) { + Blt_Ts_SetMaxLength(ts, axisPtr->height); + } else { + Blt_Ts_SetMaxLength(ts, axisPtr->width); + } + Blt_Ts_DrawText(graphPtr->tkwin, drawable, axisPtr->title, -1, &ts, + (int)axisPtr->titlePos.x, (int)axisPtr->titlePos.y); + } + if (axisPtr->scrollCmdObjPtr != NULL) { + double viewWidth, viewMin, viewMax; + double worldWidth, worldMin, worldMax; + double fract; + int isHoriz; + + worldMin = axisPtr->valueRange.min; + worldMax = axisPtr->valueRange.max; + if (DEFINED(axisPtr->scrollMin)) { + worldMin = axisPtr->scrollMin; + } + if (DEFINED(axisPtr->scrollMax)) { + worldMax = axisPtr->scrollMax; + } + viewMin = axisPtr->min; + viewMax = axisPtr->max; + if (viewMin < worldMin) { + viewMin = worldMin; + } + if (viewMax > worldMax) { + viewMax = worldMax; + } + if (axisPtr->logScale) { + worldMin = log10(worldMin); + worldMax = log10(worldMax); + viewMin = log10(viewMin); + viewMax = log10(viewMax); + } + worldWidth = worldMax - worldMin; + viewWidth = viewMax - viewMin; + isHoriz = AxisIsHorizontal(axisPtr); + + if (isHoriz != axisPtr->descending) { + fract = (viewMin - worldMin) / worldWidth; + } else { + fract = (worldMax - viewMax) / worldWidth; + } + fract = AdjustViewport(fract, viewWidth / worldWidth); + + if (isHoriz != axisPtr->descending) { + viewMin = (fract * worldWidth); + axisPtr->min = viewMin + worldMin; + axisPtr->max = axisPtr->min + viewWidth; + viewMax = viewMin + viewWidth; + if (axisPtr->logScale) { + axisPtr->min = EXP10(axisPtr->min); + axisPtr->max = EXP10(axisPtr->max); + } + Blt_UpdateScrollbar(graphPtr->interp, axisPtr->scrollCmdObjPtr, + viewMin, viewMax, worldWidth); + } else { + viewMax = (fract * worldWidth); + axisPtr->max = worldMax - viewMax; + axisPtr->min = axisPtr->max - viewWidth; + viewMin = viewMax + viewWidth; + if (axisPtr->logScale) { + axisPtr->min = EXP10(axisPtr->min); + axisPtr->max = EXP10(axisPtr->max); + } + Blt_UpdateScrollbar(graphPtr->interp, axisPtr->scrollCmdObjPtr, + viewMax, viewMin, worldWidth); + } + } + if (axisPtr->flags & AXIS_SHOWTICKS) { + Blt_ChainLink link; + TextStyle ts; + + Blt_Ts_InitStyle(ts); + Blt_Ts_SetAngle(ts, axisPtr->tickAngle); + Blt_Ts_SetFont(ts, axisPtr->tickFont); + Blt_Ts_SetPadding(ts, 2, 0, 0, 0); + Blt_Ts_SetAnchor(ts, axisPtr->tickAnchor); + if (axisPtr->flags & ACTIVE) { + Blt_Ts_SetForeground(ts, axisPtr->activeFgColor); + } else { + Blt_Ts_SetForeground(ts, axisPtr->tickColor); + } + for (link = Blt_Chain_FirstLink(axisPtr->tickLabels); link != NULL; + link = Blt_Chain_NextLink(link)) { + TickLabel *labelPtr; + + labelPtr = Blt_Chain_GetValue(link); + /* Draw major tick labels */ + Blt_DrawText(graphPtr->tkwin, drawable, labelPtr->string, &ts, + (int)labelPtr->anchorPos.x, (int)labelPtr->anchorPos.y); + } + } + if ((axisPtr->nSegments > 0) && (axisPtr->lineWidth > 0)) { + GC gc; + + if (axisPtr->flags & ACTIVE) { + gc = axisPtr->activeTickGC; + } else { + gc = axisPtr->tickGC; + } + /* Draw the tick marks and axis line. */ + Blt_Draw2DSegments(graphPtr->display, drawable, gc, axisPtr->segments, + axisPtr->nSegments); + } +} + +/* + *--------------------------------------------------------------------------- + * + * AxisToPostScript -- + * + * Generates PostScript output to draw the axis, ticks, and labels. + * + * Initializes and passes text attribute information through TextStyle + * structure. + * + * Results: + * None. + * + * Side Effects: + * PostScript output is left in graphPtr->interp->result; + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static void +AxisToPostScript(Blt_Ps ps, Axis *axisPtr) +{ + Blt_Ps_Format(ps, "%% Axis \"%s\"\n", axisPtr->obj.name); + if (axisPtr->normalBg != NULL) { + Tk_3DBorder border; + + border = Blt_BackgroundBorder(axisPtr->normalBg); + Blt_Ps_Fill3DRectangle(ps, border, + (double)axisPtr->left, (double)axisPtr->top, + axisPtr->right - axisPtr->left, axisPtr->bottom - axisPtr->top, + axisPtr->borderWidth, axisPtr->relief); + } + if (axisPtr->title != NULL) { + TextStyle ts; + + Blt_Ts_InitStyle(ts); + Blt_Ts_SetAngle(ts, axisPtr->titleAngle); + Blt_Ts_SetFont(ts, axisPtr->titleFont); + Blt_Ts_SetPadding(ts, 1, 2, 0, 0); + Blt_Ts_SetAnchor(ts, axisPtr->titleAnchor); + Blt_Ts_SetJustify(ts, axisPtr->titleJustify); + Blt_Ts_SetForeground(ts, axisPtr->titleColor); + Blt_Ps_DrawText(ps, axisPtr->title, &ts, axisPtr->titlePos.x, + axisPtr->titlePos.y); + } + if (axisPtr->flags & AXIS_SHOWTICKS) { + Blt_ChainLink link; + TextStyle ts; + + Blt_Ts_InitStyle(ts); + Blt_Ts_SetAngle(ts, axisPtr->tickAngle); + Blt_Ts_SetFont(ts, axisPtr->tickFont); + Blt_Ts_SetPadding(ts, 2, 0, 0, 0); + Blt_Ts_SetAnchor(ts, axisPtr->tickAnchor); + Blt_Ts_SetForeground(ts, axisPtr->tickColor); + + for (link = Blt_Chain_FirstLink(axisPtr->tickLabels); link != NULL; + link = Blt_Chain_NextLink(link)) { + TickLabel *labelPtr; + + labelPtr = Blt_Chain_GetValue(link); + Blt_Ps_DrawText(ps, labelPtr->string, &ts, labelPtr->anchorPos.x, + labelPtr->anchorPos.y); + } + } + if ((axisPtr->nSegments > 0) && (axisPtr->lineWidth > 0)) { + Blt_Ps_XSetLineAttributes(ps, axisPtr->tickColor, axisPtr->lineWidth, + (Blt_Dashes *)NULL, CapButt, JoinMiter); + Blt_Ps_Draw2DSegments(ps, axisPtr->segments, axisPtr->nSegments); + } +} + +static void +MakeGridLine(Axis *axisPtr, double value, Segment2d *sp) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + + if (axisPtr->logScale) { + value = EXP10(value); + } + /* Grid lines run orthogonally to the axis */ + if (AxisIsHorizontal(axisPtr)) { + sp->p.y = graphPtr->top; + sp->q.y = graphPtr->bottom; + sp->p.x = sp->q.x = Blt_HMap(axisPtr, value); + } else { + sp->p.x = graphPtr->left; + sp->q.x = graphPtr->right; + sp->p.y = sp->q.y = Blt_VMap(axisPtr, value); + } +} + +/* + *--------------------------------------------------------------------------- + * + * MapGridlines -- + * + * Assembles the grid lines associated with an axis. Generates tick + * positions if necessary (this happens when the axis is not a logical axis + * too). + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +MapGridlines(Axis *axisPtr) +{ + Segment2d *s1, *s2; + Ticks *t1Ptr, *t2Ptr; + int needed; + int i; + + if (axisPtr == NULL) { + return; + } + t1Ptr = axisPtr->t1Ptr; + if (t1Ptr == NULL) { + t1Ptr = GenerateTicks(&axisPtr->majorSweep); + } + t2Ptr = axisPtr->t2Ptr; + if (t2Ptr == NULL) { + t2Ptr = GenerateTicks(&axisPtr->minorSweep); + } + needed = t1Ptr->nTicks; + if (axisPtr->flags & AXIS_GRIDMINOR) { + needed += (t1Ptr->nTicks * t2Ptr->nTicks); + } + if (needed == 0) { + return; + } + needed = t1Ptr->nTicks; + if (needed != axisPtr->major.nAllocated) { + if (axisPtr->major.segments != NULL) { + Blt_Free(axisPtr->major.segments); + } + axisPtr->major.segments = Blt_AssertMalloc(sizeof(Segment2d) * needed); + axisPtr->major.nAllocated = needed; + } + needed = (t1Ptr->nTicks * t2Ptr->nTicks); + if (needed != axisPtr->minor.nAllocated) { + if (axisPtr->minor.segments != NULL) { + Blt_Free(axisPtr->minor.segments); + } + axisPtr->minor.segments = Blt_AssertMalloc(sizeof(Segment2d) * needed); + axisPtr->minor.nAllocated = needed; + } + s1 = axisPtr->major.segments, s2 = axisPtr->minor.segments; + for (i = 0; i < t1Ptr->nTicks; i++) { + double value; + + value = t1Ptr->values[i]; + if (axisPtr->flags & AXIS_GRIDMINOR) { + int j; + + for (j = 0; j < t2Ptr->nTicks; j++) { + double subValue; + + subValue = value + (axisPtr->majorSweep.step * + t2Ptr->values[j]); + if (InRange(subValue, &axisPtr->axisRange)) { + MakeGridLine(axisPtr, subValue, s2); + s2++; + } + } + } + if (InRange(value, &axisPtr->axisRange)) { + MakeGridLine(axisPtr, value, s1); + s1++; + } + } + if (t1Ptr != axisPtr->t1Ptr) { + Blt_Free(t1Ptr); /* Free generated ticks. */ + } + if (t2Ptr != axisPtr->t2Ptr) { + Blt_Free(t2Ptr); /* Free generated ticks. */ + } + axisPtr->major.nUsed = s1 - axisPtr->major.segments; + axisPtr->minor.nUsed = s2 - axisPtr->minor.segments; +} + +/* + *--------------------------------------------------------------------------- + * + * GetAxisGeometry -- + * + * Results: + * None. + * + * Exterior axis: + * l r + * |a|b|c|d|e|f|g|h|i| j |i|h|g|f|e|d|c|d|a| + * + * Interior axis: + * l r + * |a|b|c|d|h|g|f|e| j |e|f|g|h|d|c|b|a| + * i.. ..i + * a = highlight thickness + * b = graph borderwidth + * c = axis title + * d = tick label + * e = tick + * f = axis line + * g = 1 pixel pad + * h = plot borderwidth + * i = plot pad + * j = plot area + *--------------------------------------------------------------------------- + */ +static void +GetAxisGeometry(Graph *graphPtr, Axis *axisPtr) +{ + unsigned int y; + + FreeTickLabels(axisPtr->tickLabels); + y = 0; + + if ((axisPtr->flags & AXIS_EXTERIOR) && + (graphPtr->plotRelief != TK_RELIEF_SOLID)) { + /* Leave room for axis baseline and padding */ + y += axisPtr->lineWidth + 2; + } + + axisPtr->maxTickHeight = axisPtr->maxTickWidth = 0; + if (axisPtr->flags & AXIS_SHOWTICKS) { + unsigned int pad; + unsigned int i, nLabels, nTicks; + + SweepTicks(axisPtr); + + nTicks = 0; + if (axisPtr->t1Ptr != NULL) { + nTicks = axisPtr->t1Ptr->nTicks; + } + assert(nTicks <= MAXTICKS); + + nLabels = 0; + for (i = 0; i < nTicks; i++) { + TickLabel *labelPtr; + double x, x2; + unsigned int lw, lh; /* Label width and height. */ + + x2 = x = axisPtr->t1Ptr->values[i]; + if (axisPtr->labelOffset) { + x2 += axisPtr->majorSweep.step * 0.5; + } + if (!InRange(x2, &axisPtr->axisRange)) { + continue; + } + labelPtr = MakeLabel(axisPtr, x); + Blt_Chain_Append(axisPtr->tickLabels, labelPtr); + nLabels++; + /* + * Get the dimensions of each tick label. Remember tick labels + * can be multi-lined and/or rotated. + */ + Blt_GetTextExtents(axisPtr->tickFont, 0, labelPtr->string, -1, + &lw, &lh); + labelPtr->width = lw; + labelPtr->height = lh; + + if (axisPtr->tickAngle != 0.0f) { + double rlw, rlh; /* Rotated label width and height. */ + Blt_GetBoundingBox(lw, lh, axisPtr->tickAngle, &rlw, &rlh,NULL); + lw = ROUND(rlw), lh = ROUND(rlh); + } + if (axisPtr->maxTickWidth < lw) { + axisPtr->maxTickWidth = lw; + } + if (axisPtr->maxTickHeight < lh) { + axisPtr->maxTickHeight = lh; + } + } + assert(nLabels <= nTicks); + + pad = 0; + if (axisPtr->flags & AXIS_EXTERIOR) { + /* Because the axis cap style is "CapProjecting", we need to + * account for an extra 1.5 linewidth at the end of each line. */ + pad = ((axisPtr->lineWidth * 12) / 8); + } + if (AxisIsHorizontal(axisPtr)) { + y += axisPtr->maxTickHeight + pad; + } else { + y += axisPtr->maxTickWidth + pad; + if (axisPtr->maxTickWidth > 0) { + y += 5; /* Pad either size of label. */ + } + } + y += 2 * AXIS_PAD_TITLE; + if ((axisPtr->lineWidth > 0) && (axisPtr->flags & AXIS_EXTERIOR)) { + /* Distance from axis line to tick label. */ + y += axisPtr->tickLength; + } + } + + if (axisPtr->title != NULL) { + if (axisPtr->titleAlternate) { + if (y < axisPtr->titleHeight) { + y = axisPtr->titleHeight; + } + } else { + y += axisPtr->titleHeight + AXIS_PAD_TITLE; + } + } + + /* Correct for orientation of the axis. */ + if (AxisIsHorizontal(axisPtr)) { + axisPtr->height = y; + } else { + axisPtr->width = y; + } +} + +/* + *--------------------------------------------------------------------------- + * + * GetMarginGeometry -- + * + * Examines all the axes in the given margin and determines the area + * required to display them. + * + * Note: For multiple axes, the titles are displayed in another + * margin. So we must keep track of the widest title. + * + * Results: + * Returns the width or height of the margin, depending if it runs + * horizontally along the graph or vertically. + * + * Side Effects: + * The area width and height set in the margin. Note again that this may + * be corrected later (mulitple axes) to adjust for the longest title in + * another margin. + * + *--------------------------------------------------------------------------- + */ +static int +GetMarginGeometry(Graph *graphPtr, Margin *marginPtr) +{ + Blt_ChainLink link; + unsigned int l, w, h; /* Length, width, and height. */ + int isHoriz; + unsigned int nVisible; + + isHoriz = HORIZMARGIN(marginPtr); + + /* Count the visible axes. */ + nVisible = 0; + l = w = h = 0; + marginPtr->maxTickWidth = marginPtr->maxTickHeight = 0; + if (graphPtr->stackAxes) { + for (link = Blt_Chain_FirstLink(marginPtr->axes); link != NULL; + link = Blt_Chain_NextLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + if ((axisPtr->flags & (HIDE|AXIS_USE)) == AXIS_USE) { + nVisible++; + if (graphPtr->flags & GET_AXIS_GEOMETRY) { + GetAxisGeometry(graphPtr, axisPtr); + } + if (isHoriz) { + if (h < axisPtr->height) { + h = axisPtr->height; + } + } else { + if (w < axisPtr->width) { + w = axisPtr->width; + } + } + if (axisPtr->maxTickWidth > marginPtr->maxTickWidth) { + marginPtr->maxTickWidth = axisPtr->maxTickWidth; + } + if (axisPtr->maxTickHeight > marginPtr->maxTickHeight) { + marginPtr->maxTickHeight = axisPtr->maxTickHeight; + } + } + } + } else { + for (link = Blt_Chain_FirstLink(marginPtr->axes); link != NULL; + link = Blt_Chain_NextLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + if ((axisPtr->flags & (HIDE|AXIS_USE)) == AXIS_USE) { + nVisible++; + if (graphPtr->flags & GET_AXIS_GEOMETRY) { + GetAxisGeometry(graphPtr, axisPtr); + } + if ((axisPtr->titleAlternate) && (l < axisPtr->titleWidth)) { + l = axisPtr->titleWidth; + } + if (isHoriz) { + h += axisPtr->height; + } else { + w += axisPtr->width; + } + if (axisPtr->maxTickWidth > marginPtr->maxTickWidth) { + marginPtr->maxTickWidth = axisPtr->maxTickWidth; + } + if (axisPtr->maxTickHeight > marginPtr->maxTickHeight) { + marginPtr->maxTickHeight = axisPtr->maxTickHeight; + } + } + } + } + /* Enforce a minimum size for margins. */ + if (w < 3) { + w = 3; + } + if (h < 3) { + h = 3; + } + marginPtr->nAxes = nVisible; + marginPtr->axesTitleLength = l; + marginPtr->width = w; + marginPtr->height = h; + marginPtr->axesOffset = (isHoriz) ? h : w; + return marginPtr->axesOffset; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_LayoutGraph -- + * + * Calculate the layout of the graph. Based upon the data, axis limits, + * X and Y titles, and title height, determine the cavity left which is + * the plotting surface. The first step get the data and axis limits for + * calculating the space needed for the top, bottom, left, and right + * margins. + * + * 1) The LEFT margin is the area from the left border to the Y axis + * (not including ticks). It composes the border width, the width an + * optional Y axis label and its padding, and the tick numeric labels. + * The Y axis label is rotated 90 degrees so that the width is the + * font height. + * + * 2) The RIGHT margin is the area from the end of the graph + * to the right window border. It composes the border width, + * some padding, the font height (this may be dubious. It + * appears to provide a more even border), the max of the + * legend width and 1/2 max X tick number. This last part is + * so that the last tick label is not clipped. + * + * Window Width + * ___________________________________________________________ + * | | | | + * | | TOP height of title | | + * | | | | + * | | x2 title | | + * | | | | + * | | height of x2-axis | | + * |__________|_______________________________|_______________| W + * | | -plotpady | | i + * |__________|_______________________________|_______________| n + * | | top right | | d + * | | | | o + * | LEFT | | RIGHT | w + * | | | | + * | y | Free area = 104% | y2 | H + * | | Plotting surface = 100% | | e + * | t | Tick length = 2 + 2% | t | i + * | i | | i | g + * | t | | t legend| h + * | l | | l width| t + * | e | | e | + * | height| |height | + * | of | | of | + * | y-axis| |y2-axis | + * | | | | + * | |origin 0,0 | | + * |__________|_left_________________bottom___|_______________| + * | |-plotpady | | + * |__________|_______________________________|_______________| + * | | (xoffset, yoffset) | | + * | | | | + * | | height of x-axis | | + * | | | | + * | | BOTTOM x title | | + * |__________|_______________________________|_______________| + * + * 3) The TOP margin is the area from the top window border to the top + * of the graph. It composes the border width, twice the height of + * the title font (if one is given) and some padding between the + * title. + * + * 4) The BOTTOM margin is area from the bottom window border to the + * X axis (not including ticks). It composes the border width, the height + * an optional X axis label and its padding, the height of the font + * of the tick labels. + * + * The plotting area is between the margins which includes the X and Y axes + * including the ticks but not the tick numeric labels. The length of the + * ticks and its padding is 5% of the entire plotting area. Hence the entire + * plotting area is scaled as 105% of the width and height of the area. + * + * The axis labels, ticks labels, title, and legend may or may not be + * displayed which must be taken into account. + * + * if reqWidth > 0 : set outer size + * if reqPlotWidth > 0 : set plot size + *--------------------------------------------------------------------------- + */ +void +Blt_LayoutGraph(Graph *graphPtr) +{ + unsigned int titleY; + unsigned int left, right, top, bottom; + unsigned int plotWidth, plotHeight; + unsigned int inset, inset2; + int width, height; + int pad; + + width = graphPtr->width; + height = graphPtr->height; + + /* + * Step 1: Compute the amount of space needed to display the axes + * associated with each margin. They can be overridden by + * -leftmargin, -rightmargin, -bottommargin, and -topmargin + * graph options, respectively. + */ + left = GetMarginGeometry(graphPtr, &graphPtr->leftMargin); + right = GetMarginGeometry(graphPtr, &graphPtr->rightMargin); + top = GetMarginGeometry(graphPtr, &graphPtr->topMargin); + bottom = GetMarginGeometry(graphPtr, &graphPtr->bottomMargin); + + pad = graphPtr->bottomMargin.maxTickWidth; + if (pad < graphPtr->topMargin.maxTickWidth) { + pad = graphPtr->topMargin.maxTickWidth; + } + pad = pad / 2 + 3; + if (right < pad) { + right = pad; + } + if (left < pad) { + left = pad; + } + pad = graphPtr->leftMargin.maxTickHeight; + if (pad < graphPtr->rightMargin.maxTickHeight) { + pad = graphPtr->rightMargin.maxTickHeight; + } + pad = pad / 2; + if (top < pad) { + top = pad; + } + if (bottom < pad) { + bottom = pad; + } + + if (graphPtr->leftMargin.reqSize > 0) { + left = graphPtr->leftMargin.reqSize; + } + if (graphPtr->rightMargin.reqSize > 0) { + right = graphPtr->rightMargin.reqSize; + } + if (graphPtr->topMargin.reqSize > 0) { + top = graphPtr->topMargin.reqSize; + } + if (graphPtr->bottomMargin.reqSize > 0) { + bottom = graphPtr->bottomMargin.reqSize; + } + + /* + * Step 2: Add the graph title height to the top margin. + */ + if (graphPtr->title != NULL) { + top += graphPtr->titleHeight + 6; + } + inset = (graphPtr->inset + graphPtr->plotBW); + inset2 = 2 * inset; + + /* + * Step 3: Estimate the size of the plot area from the remaining + * space. This may be overridden by the -plotwidth and + * -plotheight graph options. We use this to compute the + * size of the legend. + */ + if (width == 0) { + width = 400; + } + if (height == 0) { + height = 400; + } + plotWidth = (graphPtr->reqPlotWidth > 0) ? graphPtr->reqPlotWidth : + width - (inset2 + left + right); /* Plot width. */ + plotHeight = (graphPtr->reqPlotHeight > 0) ? graphPtr->reqPlotHeight : + height - (inset2 + top + bottom); /* Plot height. */ + Blt_MapLegend(graphPtr, plotWidth, plotHeight); + + /* + * Step 2: Add the legend to the appropiate margin. + */ + if (!Blt_Legend_IsHidden(graphPtr)) { + switch (Blt_Legend_Site(graphPtr)) { + case LEGEND_RIGHT: + right += Blt_Legend_Width(graphPtr) + 2; + break; + case LEGEND_LEFT: + left += Blt_Legend_Width(graphPtr) + 2; + break; + case LEGEND_TOP: + top += Blt_Legend_Height(graphPtr) + 2; + break; + case LEGEND_BOTTOM: + bottom += Blt_Legend_Height(graphPtr) + 2; + break; + case LEGEND_XY: + case LEGEND_PLOT: + case LEGEND_WINDOW: + /* Do nothing. */ + break; + } + } + + /* + * Recompute the plotarea or graph size, now accounting for the legend. + */ + if (graphPtr->reqPlotWidth == 0) { + plotWidth = width - (inset2 + left + right); + if (plotWidth < 1) { + plotWidth = 1; + } + } + if (graphPtr->reqPlotHeight == 0) { + plotHeight = height - (inset2 + top + bottom); + if (plotHeight < 1) { + plotHeight = 1; + } + } + + /* + * Step 5: If necessary, correct for the requested plot area aspect + * ratio. + */ + if ((graphPtr->reqPlotWidth == 0) && (graphPtr->reqPlotHeight == 0) && + (graphPtr->aspect > 0.0f)) { + float ratio; + + /* + * Shrink one dimension of the plotarea to fit the requested + * width/height aspect ratio. + */ + ratio = (float)plotWidth / (float)plotHeight; + if (ratio > graphPtr->aspect) { + int scaledWidth; + + /* Shrink the width. */ + scaledWidth = (int)(plotHeight * graphPtr->aspect); + if (scaledWidth < 1) { + scaledWidth = 1; + } + /* Add the difference to the right margin. */ + /* CHECK THIS: w = scaledWidth; */ + right += (plotWidth - scaledWidth); + } else { + int scaledHeight; + + /* Shrink the height. */ + scaledHeight = (int)(plotWidth / graphPtr->aspect); + if (scaledHeight < 1) { + scaledHeight = 1; + } + /* Add the difference to the top margin. */ + /* CHECK THIS: h = scaledHeight; */ + top += (plotHeight - scaledHeight); + } + } + + /* + * Step 6: If there's multiple axes in a margin, the axis titles will be + * displayed in the adjoining margins. Make sure there's room + * for the longest axis titles. + */ + + if (top < graphPtr->leftMargin.axesTitleLength) { + top = graphPtr->leftMargin.axesTitleLength; + } + if (right < graphPtr->bottomMargin.axesTitleLength) { + right = graphPtr->bottomMargin.axesTitleLength; + } + if (top < graphPtr->rightMargin.axesTitleLength) { + top = graphPtr->rightMargin.axesTitleLength; + } + if (right < graphPtr->topMargin.axesTitleLength) { + right = graphPtr->topMargin.axesTitleLength; + } + + /* + * Step 7: Override calculated values with requested margin sizes. + */ + if (graphPtr->leftMargin.reqSize > 0) { + left = graphPtr->leftMargin.reqSize; + } + if (graphPtr->rightMargin.reqSize > 0) { + right = graphPtr->rightMargin.reqSize; + } + if (graphPtr->topMargin.reqSize > 0) { + top = graphPtr->topMargin.reqSize; + } + if (graphPtr->bottomMargin.reqSize > 0) { + bottom = graphPtr->bottomMargin.reqSize; + } + if (graphPtr->reqPlotWidth > 0) { + int w; + + /* + * Width of plotarea is constained. If there's extra space, add it to + * th left and/or right margins. If there's too little, grow the + * graph width to accomodate it. + */ + w = plotWidth + inset2 + left + right; + if (width > w) { /* Extra space in window. */ + int extra; + + extra = (width - w) / 2; + if (graphPtr->leftMargin.reqSize == 0) { + left += extra; + if (graphPtr->rightMargin.reqSize == 0) { + right += extra; + } else { + left += extra; + } + } else if (graphPtr->rightMargin.reqSize == 0) { + right += extra + extra; + } + } else if (width < w) { + width = w; + } + } + if (graphPtr->reqPlotHeight > 0) { /* Constrain the plotarea height. */ + int h; + + /* + * Height of plotarea is constained. If there's extra space, + * add it to th top and/or bottom margins. If there's too little, + * grow the graph height to accomodate it. + */ + h = plotHeight + inset2 + top + bottom; + if (height > h) { /* Extra space in window. */ + int extra; + + extra = (height - h) / 2; + if (graphPtr->topMargin.reqSize == 0) { + top += extra; + if (graphPtr->bottomMargin.reqSize == 0) { + bottom += extra; + } else { + top += extra; + } + } else if (graphPtr->bottomMargin.reqSize == 0) { + bottom += extra + extra; + } + } else if (height < h) { + height = h; + } + } + graphPtr->width = width; + graphPtr->height = height; + graphPtr->left = left + inset; + graphPtr->top = top + inset; + graphPtr->right = width - right - inset; + graphPtr->bottom = height - bottom - inset; + + graphPtr->leftMargin.width = left + graphPtr->inset; + graphPtr->rightMargin.width = right + graphPtr->inset; + graphPtr->topMargin.height = top + graphPtr->inset; + graphPtr->bottomMargin.height = bottom + graphPtr->inset; + + graphPtr->vOffset = graphPtr->top + graphPtr->padTop; + graphPtr->vRange = plotHeight - PADDING(graphPtr->yPad); + graphPtr->hOffset = graphPtr->left + graphPtr->padLeft; + graphPtr->hRange = plotWidth - PADDING(graphPtr->xPad); + + if (graphPtr->vRange < 1) { + graphPtr->vRange = 1; + } + if (graphPtr->hRange < 1) { + graphPtr->hRange = 1; + } + graphPtr->hScale = 1.0f / (float)graphPtr->hRange; + graphPtr->vScale = 1.0f / (float)graphPtr->vRange; + + /* + * Calculate the placement of the graph title so it is centered within the + * space provided for it in the top margin + */ + titleY = graphPtr->titleHeight; + graphPtr->titleY = 3 + graphPtr->inset; + graphPtr->titleX = (graphPtr->right + graphPtr->left) / 2; + +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureAxis -- + * + * Configures axis attributes (font, line width, label, etc). + * + * Results: + * The return value is a standard TCL result. + * + * Side Effects: + * Axis layout is deferred until the height and width of the window are + * known. + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureAxis(Axis *axisPtr) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + float angle; + + /* Check the requested axis limits. Can't allow -min to be greater than + * -max. Do this regardless of -checklimits option. We want to always + * detect when the user has zoomed in beyond the precision of the data.*/ + if (((DEFINED(axisPtr->reqMin)) && (DEFINED(axisPtr->reqMax))) && + (axisPtr->reqMin >= axisPtr->reqMax)) { + char msg[200]; + sprintf_s(msg, 200, + "impossible axis limits (-min %g >= -max %g) for \"%s\"", + axisPtr->reqMin, axisPtr->reqMax, axisPtr->obj.name); + Tcl_AppendResult(graphPtr->interp, msg, (char *)NULL); + return TCL_ERROR; + } + axisPtr->scrollMin = axisPtr->reqScrollMin; + axisPtr->scrollMax = axisPtr->reqScrollMax; + if (axisPtr->logScale) { + if (axisPtr->flags & AXIS_CHECK_LIMITS) { + /* Check that the logscale limits are positive. */ + if ((DEFINED(axisPtr->reqMin)) && (axisPtr->reqMin <= 0.0)) { + Tcl_AppendResult(graphPtr->interp,"bad logscale -min limit \"", + Blt_Dtoa(graphPtr->interp, axisPtr->reqMin), + "\" for axis \"", axisPtr->obj.name, "\"", + (char *)NULL); + return TCL_ERROR; + } + } + if ((DEFINED(axisPtr->scrollMin)) && (axisPtr->scrollMin <= 0.0)) { + axisPtr->scrollMin = Blt_NaN(); + } + if ((DEFINED(axisPtr->scrollMax)) && (axisPtr->scrollMax <= 0.0)) { + axisPtr->scrollMax = Blt_NaN(); + } + } + angle = FMOD(axisPtr->tickAngle, 360.0); + if (angle < 0.0f) { + angle += 360.0f; + } + if (axisPtr->normalBg != NULL) { + Blt_SetBackgroundChangedProc(axisPtr->normalBg, Blt_UpdateGraph, + graphPtr); + } + if (axisPtr->activeBg != NULL) { + Blt_SetBackgroundChangedProc(axisPtr->activeBg, Blt_UpdateGraph, + graphPtr); + } + axisPtr->tickAngle = angle; + ResetTextStyles(axisPtr); + + axisPtr->titleWidth = axisPtr->titleHeight = 0; + if (axisPtr->title != NULL) { + unsigned int w, h; + + Blt_GetTextExtents(axisPtr->titleFont, 0, axisPtr->title, -1, &w, &h); + axisPtr->titleWidth = (unsigned short int)w; + axisPtr->titleHeight = (unsigned short int)h; + } + + /* + * Don't bother to check what configuration options have changed. Almost + * every option changes the size of the plotting area (except for -color + * and -titlecolor), requiring the graph and its contents to be completely + * redrawn. + * + * Recompute the scale and offset of the axis in case -min, -max options + * have changed. + */ + graphPtr->flags |= REDRAW_WORLD; + graphPtr->flags |= MAP_WORLD | RESET_AXES | CACHE_DIRTY; + axisPtr->flags |= DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NewAxis -- + * + * Create and initialize a structure containing information to display + * a graph axis. + * + * Results: + * The return value is a pointer to an Axis structure. + * + *--------------------------------------------------------------------------- + */ +static Axis * +NewAxis(Graph *graphPtr, const char *name, int margin) +{ + Axis *axisPtr; + Blt_HashEntry *hPtr; + int isNew; + + if (name[0] == '-') { + Tcl_AppendResult(graphPtr->interp, "name of axis \"", name, + "\" can't start with a '-'", (char *)NULL); + return NULL; + } + hPtr = Blt_CreateHashEntry(&graphPtr->axes.table, name, &isNew); + if (!isNew) { + axisPtr = Blt_GetHashValue(hPtr); + if ((axisPtr->flags & DELETE_PENDING) == 0) { + Tcl_AppendResult(graphPtr->interp, "axis \"", name, + "\" already exists in \"", Tk_PathName(graphPtr->tkwin), "\"", + (char *)NULL); + return NULL; + } + axisPtr->flags &= ~DELETE_PENDING; + } else { + axisPtr = Blt_Calloc(1, sizeof(Axis)); + if (axisPtr == NULL) { + Tcl_AppendResult(graphPtr->interp, + "can't allocate memory for axis \"", name, "\"", (char *)NULL); + return NULL; + } + axisPtr->obj.name = Blt_AssertStrdup(name); + axisPtr->hashPtr = hPtr; + Blt_GraphSetObjectClass(&axisPtr->obj, CID_NONE); + axisPtr->obj.graphPtr = graphPtr; + axisPtr->looseMin = axisPtr->looseMax = AXIS_TIGHT; + axisPtr->reqNumMinorTicks = 2; + axisPtr->reqNumMajorTicks = 4 /*10*/; + axisPtr->margin = MARGIN_NONE; + axisPtr->tickLength = 8; + axisPtr->scrollUnits = 10; + axisPtr->reqMin = axisPtr->reqMax = Blt_NaN(); + axisPtr->reqScrollMin = axisPtr->reqScrollMax = Blt_NaN(); + axisPtr->flags = (AXIS_SHOWTICKS|AXIS_GRIDMINOR|AXIS_AUTO_MAJOR| + AXIS_AUTO_MINOR | AXIS_EXTERIOR); + if (graphPtr->classId == CID_ELEM_BAR) { + axisPtr->flags |= AXIS_GRID; + } + if ((graphPtr->classId == CID_ELEM_BAR) && + ((margin == MARGIN_TOP) || (margin == MARGIN_BOTTOM))) { + axisPtr->reqStep = 1.0; + axisPtr->reqNumMinorTicks = 0; + } + if ((margin == MARGIN_RIGHT) || (margin == MARGIN_TOP)) { + axisPtr->flags |= HIDE; + } + Blt_Ts_InitStyle(axisPtr->limitsTextStyle); + axisPtr->tickLabels = Blt_Chain_Create(); + axisPtr->lineWidth = 1; + Blt_SetHashValue(hPtr, axisPtr); + } + return axisPtr; +} + +static int +GetAxisFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, + Axis **axisPtrPtr) +{ + Blt_HashEntry *hPtr; + const char *name; + + *axisPtrPtr = NULL; + name = Tcl_GetString(objPtr); + hPtr = Blt_FindHashEntry(&graphPtr->axes.table, name); + if (hPtr != NULL) { + Axis *axisPtr; + + axisPtr = Blt_GetHashValue(hPtr); + if ((axisPtr->flags & DELETE_PENDING) == 0) { + *axisPtrPtr = axisPtr; + return TCL_OK; + } + } + if (interp != NULL) { + Tcl_AppendResult(interp, "can't find axis \"", name, "\" in \"", + Tk_PathName(graphPtr->tkwin), "\"", (char *)NULL); + } + return TCL_ERROR; +} + +static int +GetAxisByClass(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, + ClassId classId, Axis **axisPtrPtr) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objPtr, &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + if (classId != CID_NONE) { + if ((axisPtr->refCount == 0) || (axisPtr->obj.classId == CID_NONE)) { + /* Set the axis type on the first use of it. */ + Blt_GraphSetObjectClass(&axisPtr->obj, classId); + } else if (axisPtr->obj.classId != classId) { + if (interp != NULL) { + Tcl_AppendResult(interp, "axis \"", Tcl_GetString(objPtr), + "\" is already in use on an opposite ", + axisPtr->obj.className, "-axis", + (char *)NULL); + } + return TCL_ERROR; + } + axisPtr->refCount++; + } + *axisPtrPtr = axisPtr; + return TCL_OK; +} + +void +Blt_DestroyAxes(Graph *graphPtr) +{ + { + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + + axisPtr = Blt_GetHashValue(hPtr); + axisPtr->hashPtr = NULL; + DestroyAxis(axisPtr); + } + } + Blt_DeleteHashTable(&graphPtr->axes.table); + { + int i; + + for (i = 0; i < 4; i++) { + Blt_Chain_Destroy(graphPtr->axisChain[i]); + } + } + Blt_DeleteHashTable(&graphPtr->axes.tagTable); + Blt_Chain_Destroy(graphPtr->axes.displayList); +} + +void +Blt_ConfigureAxes(Graph *graphPtr) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + + axisPtr = Blt_GetHashValue(hPtr); + ConfigureAxis(axisPtr); + } +} + +int +Blt_DefaultAxes(Graph *graphPtr) +{ + int i; + int flags; + + flags = Blt_GraphType(graphPtr); + for (i = 0; i < 4; i++) { + Blt_Chain chain; + Axis *axisPtr; + + chain = Blt_Chain_Create(); + graphPtr->axisChain[i] = chain; + + /* Create a default axis for each chain. */ + axisPtr = NewAxis(graphPtr, axisNames[i].name, i); + if (axisPtr == NULL) { + return TCL_ERROR; + } + axisPtr->refCount = 1; /* Default axes are assumed in use. */ + axisPtr->margin = i; + axisPtr->flags |= AXIS_USE; + Blt_GraphSetObjectClass(&axisPtr->obj, axisNames[i].classId); + /* + * Blt_ConfigureComponentFromObj creates a temporary child window + * by the name of the axis. It's used so that the Tk routines + * that access the X resource database can describe a single + * component and not the entire graph. + */ + if (Blt_ConfigureComponentFromObj(graphPtr->interp, graphPtr->tkwin, + axisPtr->obj.name, "Axis", configSpecs, 0, (Tcl_Obj **)NULL, + (char *)axisPtr, flags) != TCL_OK) { + return TCL_ERROR; + } + if (ConfigureAxis(axisPtr) != TCL_OK) { + return TCL_ERROR; + } + axisPtr->link = Blt_Chain_Append(chain, axisPtr); + axisPtr->chain = chain; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ActivateOp -- + * + * Activates the axis, drawing the axis with its -activeforeground, + * -activebackgound, -activerelief attributes. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new axis attributes. + * + *--------------------------------------------------------------------------- + */ +static int +ActivateOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + const char *string; + + string = Tcl_GetString(objv[2]); + if (string[0] == 'a') { + axisPtr->flags |= ACTIVE; + } else { + axisPtr->flags &= ~ACTIVE; + } + if ((axisPtr->flags & (AXIS_USE|HIDE)) == AXIS_USE) { + graphPtr->flags |= DRAW_MARGINS | CACHE_DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); + } + return TCL_OK; +} + +/*------------------------------------------------------------------------------- + * + * BindOp -- + * + * .g axis bind axisName sequence command + * + *--------------------------------------------------------------------------- + */ +static int +BindOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + + return Blt_ConfigureBindingsFromObj(interp, graphPtr->bindTable, + Blt_MakeAxisTag(graphPtr, axisPtr->obj.name), objc, objv); +} + +/* + *--------------------------------------------------------------------------- + * + * CgetOp -- + * + * Queries axis attributes (font, line width, label, etc). + * + * Results: + * Return value is a standard TCL result. If querying configuration + * values, interp->result will contain the results. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static int +CgetOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + + return Blt_ConfigureValueFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)axisPtr, objv[0], Blt_GraphType(graphPtr)); +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureOp -- + * + * Queries or resets axis attributes (font, line width, label, etc). + * + * Results: + * Return value is a standard TCL result. If querying configuration + * values, interp->result will contain the results. + * + * Side Effects: + * Axis resources are possibly allocated (GC, font). Axis layout is + * deferred until the height and width of the window are known. + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + int flags; + + flags = BLT_CONFIG_OBJV_ONLY | Blt_GraphType(graphPtr); + if (objc == 0) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)axisPtr, (Tcl_Obj *)NULL, flags); + } else if (objc == 1) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)axisPtr, objv[0], flags); + } + if (Blt_ConfigureWidgetFromObj(interp, graphPtr->tkwin, configSpecs, + objc, objv, (char *)axisPtr, flags) != TCL_OK) { + return TCL_ERROR; + } + if (ConfigureAxis(axisPtr) != TCL_OK) { + return TCL_ERROR; + } + if (axisPtr->flags & AXIS_USE) { + if (!Blt_ConfigModified(configSpecs, "-*color", "-background", "-bg", + (char *)NULL)) { + graphPtr->flags |= CACHE_DIRTY; + } + Blt_EventuallyRedrawGraph(graphPtr); + } + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * LimitsOp -- + * + * This procedure returns a string representing the axis limits + * of the graph. The format of the string is { left top right bottom}. + * + * Results: + * Always returns TCL_OK. The interp->result field is + * a list of the graph axis limits. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +LimitsOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + Tcl_Obj *listObjPtr; + double min, max; + + if (graphPtr->flags & RESET_AXES) { + Blt_ResetAxes(graphPtr); + } + if (axisPtr->logScale) { + min = EXP10(axisPtr->axisRange.min); + max = EXP10(axisPtr->axisRange.max); + } else { + min = axisPtr->axisRange.min; + max = axisPtr->axisRange.max; + } + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(min)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(max)); + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * InvTransformOp -- + * + * Maps the given window coordinate into an axis-value. + * + * Results: + * Returns a standard TCL result. interp->result contains + * the axis value. If an error occurred, TCL_ERROR is returned + * and interp->result will contain an error message. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +InvTransformOp(Tcl_Interp *interp, Axis *axisPtr, int objc, + Tcl_Obj *const *objv) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + double y; /* Real graph coordinate */ + int sy; /* Integer window coordinate*/ + + if (graphPtr->flags & RESET_AXES) { + Blt_ResetAxes(graphPtr); + } + if (Tcl_GetIntFromObj(interp, objv[0], &sy) != TCL_OK) { + return TCL_ERROR; + } + /* + * Is the axis vertical or horizontal? + * + * Check the site where the axis was positioned. If the axis is + * virtual, all we have to go on is how it was mapped to an + * element (using either -mapx or -mapy options). + */ + if (AxisIsHorizontal(axisPtr)) { + y = Blt_InvHMap(axisPtr, (double)sy); + } else { + y = Blt_InvVMap(axisPtr, (double)sy); + } + Tcl_SetDoubleObj(Tcl_GetObjResult(interp), y); + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * MarginOp -- + * + * This procedure returns a string representing the margin the axis + * resides. The format of the string is { left top right bottom}. + * + * Results: + * Always returns TCL_OK. The interp->result field is + * a list of the graph axis limits. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +MarginOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + const char *marginName; + + marginName = ""; + if (axisPtr->flags & AXIS_USE) { + marginName = axisNames[axisPtr->margin].name; + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), marginName, -1); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * TransformOp -- + * + * Maps the given axis-value to a window coordinate. + * + * Results: + * Returns a standard TCL result. interp->result contains + * the window coordinate. If an error occurred, TCL_ERROR + * is returned and interp->result will contain an error + * message. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +TransformOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + Graph *graphPtr = axisPtr->obj.graphPtr; + double x; + + if (graphPtr->flags & RESET_AXES) { + Blt_ResetAxes(graphPtr); + } + if (Blt_ExprDoubleFromObj(interp, objv[0], &x) != TCL_OK) { + return TCL_ERROR; + } + if (AxisIsHorizontal(axisPtr)) { + x = Blt_HMap(axisPtr, x); + } else { + x = Blt_VMap(axisPtr, x); + } + Tcl_SetIntObj(Tcl_GetObjResult(interp), (int)x); + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * TypeOp -- + * + * This procedure returns a string representing the margin the axis + * resides. The format of the string is "x", "y", or "". + * + * Results: + * Always returns TCL_OK. The interp->result field is the type of + * axis. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +TypeOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + const char *typeName; + + typeName = ""; + if (axisPtr->flags & AXIS_USE) { + if (axisNames[axisPtr->margin].classId == CID_AXIS_X) { + typeName = "x"; + } else if (axisNames[axisPtr->margin].classId == CID_AXIS_Y) { + typeName = "y"; + } + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), typeName, -1); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * UseOp -- + * + * Sets the default axis for a margin. + * + * Results: + * A standard TCL result. If the named axis doesn't exist + * an error message is put in interp->result. + * + * .g xaxis use "abc def gah" + * .g xaxis use [lappend abc [.g axis use]] + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +UseOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + Graph *graphPtr = (Graph *)axisPtr; + Blt_Chain chain; + Blt_ChainLink link; + Tcl_Obj **axisObjv; + ClassId classId; + int axisObjc; + int i; + + chain = graphPtr->margins[lastMargin].axes; + if (objc == 0) { + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (link = Blt_Chain_FirstLink(chain); link != NULL; + link = Blt_Chain_NextLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(axisPtr->obj.name, -1)); + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; + } + if ((lastMargin == MARGIN_BOTTOM) || (lastMargin == MARGIN_TOP)) { + classId = (graphPtr->inverted) ? CID_AXIS_Y : CID_AXIS_X; + } else { + classId = (graphPtr->inverted) ? CID_AXIS_X : CID_AXIS_Y; + } + if (Tcl_ListObjGetElements(interp, objv[0], &axisObjc, &axisObjv) + != TCL_OK) { + return TCL_ERROR; + } + for (link = Blt_Chain_FirstLink(chain); link!= NULL; + link = Blt_Chain_NextLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + axisPtr->link = NULL; + axisPtr->flags &= ~AXIS_USE; + /* Clear the axis type if it's not currently used.*/ + if (axisPtr->refCount == 0) { + Blt_GraphSetObjectClass(&axisPtr->obj, CID_NONE); + } + } + Blt_Chain_Reset(chain); + for (i = 0; i < axisObjc; i++) { + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, axisObjv[i], &axisPtr) != TCL_OK){ + return TCL_ERROR; + } + if (axisPtr->obj.classId == CID_NONE) { + Blt_GraphSetObjectClass(&axisPtr->obj, classId); + } else if (axisPtr->obj.classId != classId) { + Tcl_AppendResult(interp, "wrong type axis \"", + axisPtr->obj.name, "\": can't use ", + axisPtr->obj.className, " type axis.", (char *)NULL); + return TCL_ERROR; + } + if (axisPtr->link != NULL) { + /* Move the axis from the old margin's "use" list to the new. */ + Blt_Chain_UnlinkLink(axisPtr->chain, axisPtr->link); + Blt_Chain_AppendLink(chain, axisPtr->link); + } else { + axisPtr->link = Blt_Chain_Append(chain, axisPtr); + } + axisPtr->chain = chain; + axisPtr->flags |= AXIS_USE; + } + graphPtr->flags |= (GET_AXIS_GEOMETRY | LAYOUT_NEEDED | RESET_AXES); + /* When any axis changes, we need to layout the entire graph. */ + graphPtr->flags |= (MAP_WORLD | REDRAW_WORLD); + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +static int +ViewOp(Tcl_Interp *interp, Axis *axisPtr, int objc, Tcl_Obj *const *objv) +{ + Graph *graphPtr; + double axisOffset, axisScale; + double fract; + double viewMin, viewMax, worldMin, worldMax; + double viewWidth, worldWidth; + + graphPtr = axisPtr->obj.graphPtr; + worldMin = axisPtr->valueRange.min; + worldMax = axisPtr->valueRange.max; + /* Override data dimensions with user-selected limits. */ + if (DEFINED(axisPtr->scrollMin)) { + worldMin = axisPtr->scrollMin; + } + if (DEFINED(axisPtr->scrollMax)) { + worldMax = axisPtr->scrollMax; + } + viewMin = axisPtr->min; + viewMax = axisPtr->max; + /* Bound the view within scroll region. */ + if (viewMin < worldMin) { + viewMin = worldMin; + } + if (viewMax > worldMax) { + viewMax = worldMax; + } + if (axisPtr->logScale) { + worldMin = log10(worldMin); + worldMax = log10(worldMax); + viewMin = log10(viewMin); + viewMax = log10(viewMax); + } + worldWidth = worldMax - worldMin; + viewWidth = viewMax - viewMin; + + /* Unlike horizontal axes, vertical axis values run opposite of the + * scrollbar first/last values. So instead of pushing the axis minimum + * around, we move the maximum instead. */ + if (AxisIsHorizontal(axisPtr) != axisPtr->descending) { + axisOffset = viewMin - worldMin; + axisScale = graphPtr->hScale; + } else { + axisOffset = worldMax - viewMax; + axisScale = graphPtr->vScale; + } + if (objc == 4) { + Tcl_Obj *listObjPtr; + double first, last; + + first = Clamp(axisOffset / worldWidth); + last = Clamp((axisOffset + viewWidth) / worldWidth); + listObjPtr = Tcl_NewListObj(0, NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(first)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(last)); + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; + } + fract = axisOffset / worldWidth; + if (GetAxisScrollInfo(interp, objc, objv, &fract, + viewWidth / worldWidth, axisPtr->scrollUnits, axisScale) != TCL_OK) { + return TCL_ERROR; + } + if (AxisIsHorizontal(axisPtr) != axisPtr->descending) { + axisPtr->reqMin = (fract * worldWidth) + worldMin; + axisPtr->reqMax = axisPtr->reqMin + viewWidth; + } else { + axisPtr->reqMax = worldMax - (fract * worldWidth); + axisPtr->reqMin = axisPtr->reqMax - viewWidth; + } + if (axisPtr->logScale) { + axisPtr->reqMin = EXP10(axisPtr->reqMin); + axisPtr->reqMax = EXP10(axisPtr->reqMax); + } + graphPtr->flags |= (GET_AXIS_GEOMETRY | LAYOUT_NEEDED | RESET_AXES); + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * AxisCreateOp -- + * + * Creates a new axis. + * + * Results: + * Returns a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +AxisCreateOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + Axis *axisPtr; + int flags; + + axisPtr = NewAxis(graphPtr, Tcl_GetString(objv[3]), MARGIN_NONE); + if (axisPtr == NULL) { + return TCL_ERROR; + } + flags = Blt_GraphType(graphPtr); + if ((Blt_ConfigureComponentFromObj(interp, graphPtr->tkwin, + axisPtr->obj.name, "Axis", configSpecs, objc - 4, objv + 4, + (char *)axisPtr, flags) != TCL_OK) || + (ConfigureAxis(axisPtr) != TCL_OK)) { + DestroyAxis(axisPtr); + return TCL_ERROR; + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), axisPtr->obj.name, -1); + return TCL_OK; +} +/* + *--------------------------------------------------------------------------- + * + * AxisActivateOp -- + * + * Activates the axis, drawing the axis with its -activeforeground, + * -activebackgound, -activerelief attributes. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new axis attributes. + * + *--------------------------------------------------------------------------- + */ +static int +AxisActivateOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + return ActivateOp(interp, axisPtr, objc, objv); +} + + +/*------------------------------------------------------------------------------- + * + * AxisBindOp -- + * + * .g axis bind axisName sequence command + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +AxisBindOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + if (objc == 3) { + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.tagTable, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + const char *tagName; + Tcl_Obj *objPtr; + + tagName = Blt_GetHashKey(&graphPtr->axes.tagTable, hPtr); + objPtr = Tcl_NewStringObj(tagName, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; + } + return Blt_ConfigureBindingsFromObj(interp, graphPtr->bindTable, + Blt_MakeAxisTag(graphPtr, Tcl_GetString(objv[3])), objc - 4, objv + 4); +} + + +/* + *--------------------------------------------------------------------------- + * + * AxisCgetOp -- + * + * Queries axis attributes (font, line width, label, etc). + * + * Results: + * Return value is a standard TCL result. If querying configuration + * values, interp->result will contain the results. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static int +AxisCgetOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + return CgetOp(interp, axisPtr, objc - 4, objv + 4); +} + +/* + *--------------------------------------------------------------------------- + * + * AxisConfigureOp -- + * + * Queries or resets axis attributes (font, line width, label, etc). + * + * Results: + * Return value is a standard TCL result. If querying configuration + * values, interp->result will contain the results. + * + * Side Effects: + * Axis resources are possibly allocated (GC, font). Axis layout is + * deferred until the height and width of the window are known. + * + *--------------------------------------------------------------------------- + */ +static int +AxisConfigureOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + Tcl_Obj *const *options; + int i; + int nNames, nOpts; + + /* Figure out where the option value pairs begin */ + objc -= 3; + objv += 3; + for (i = 0; i < objc; i++) { + Axis *axisPtr; + const char *string; + + string = Tcl_GetString(objv[i]); + if (string[0] == '-') { + break; + } + if (GetAxisFromObj(interp, graphPtr, objv[i], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + } + nNames = i; /* Number of pen names specified */ + nOpts = objc - i; /* Number of options specified */ + options = objv + i; /* Start of options in objv */ + + for (i = 0; i < nNames; i++) { + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[i], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + if (ConfigureOp(interp, axisPtr, nOpts, options) != TCL_OK) { + break; + } + } + if (i < nNames) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * AxisDeleteOp -- + * + * Deletes one or more axes. The actual removal may be deferred until the + * axis is no longer used by any element. The axis can't be referenced by + * its name any longer and it may be recreated. + * + * Results: + * Returns a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +AxisDeleteOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + int i; + + for (i = 3; i < objc; i++) { + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[i], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + axisPtr->flags |= DELETE_PENDING; + if (axisPtr->refCount == 0) { + Tcl_EventuallyFree(axisPtr, FreeAxis); + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * AxisFocusOp -- + * + * Activates the axis, drawing the axis with its -activeforeground, + * -activebackgound, -activerelief attributes. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new axis attributes. + * + *--------------------------------------------------------------------------- + */ +static int +AxisFocusOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + if (objc > 3) { + Axis *axisPtr; + const char *string; + + axisPtr = NULL; + string = Tcl_GetString(objv[3]); + if ((string[0] != '\0') && + (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK)) { + return TCL_ERROR; + } + graphPtr->focusPtr = NULL; + if ((axisPtr != NULL) && + ((axisPtr->flags & (AXIS_USE|HIDE)) == AXIS_USE)) { + graphPtr->focusPtr = axisPtr; + } + Blt_SetFocusItem(graphPtr->bindTable, graphPtr->focusPtr, NULL); + } + /* Return the name of the axis that has focus. */ + if (graphPtr->focusPtr != NULL) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), + graphPtr->focusPtr->obj.name, -1); + } + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * AxisGetOp -- + * + * Returns the name of the picked axis (using the axis bind operation). + * Right now, the only name accepted is "current". + * + * Results: + * A standard TCL result. The interpreter result will contain the name of + * the axis. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +AxisGetOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + axisPtr = Blt_GetCurrentItem(graphPtr->bindTable); + /* Report only on axes. */ + if ((axisPtr != NULL) && + ((axisPtr->obj.classId == CID_AXIS_X) || + (axisPtr->obj.classId == CID_AXIS_Y) || + (axisPtr->obj.classId == CID_NONE))) { + char c; + char *string; + + string = Tcl_GetString(objv[3]); + c = string[0]; + if ((c == 'c') && (strcmp(string, "current") == 0)) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), axisPtr->obj.name,-1); + } else if ((c == 'd') && (strcmp(string, "detail") == 0)) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), axisPtr->detail, -1); + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * AxisInvTransformOp -- + * + * Maps the given window coordinate into an axis-value. + * + * Results: + * Returns a standard TCL result. interp->result contains + * the axis value. If an error occurred, TCL_ERROR is returned + * and interp->result will contain an error message. + * + *--------------------------------------------------------------------------- + */ +static int +AxisInvTransformOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + return InvTransformOp(interp, axisPtr, objc - 4, objv + 4); +} + +/* + *--------------------------------------------------------------------------- + * + * AxisLimitsOp -- + * + * This procedure returns a string representing the axis limits of the + * graph. The format of the string is { left top right bottom}. + * + * Results: + * Always returns TCL_OK. The interp->result field is + * a list of the graph axis limits. + * + *--------------------------------------------------------------------------- + */ +static int +AxisLimitsOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + return LimitsOp(interp, axisPtr, objc - 4, objv + 4); +} + +/* + *--------------------------------------------------------------------------- + * + * AxisMarginOp -- + * + * This procedure returns a string representing the axis limits of the + * graph. The format of the string is { left top right bottom}. + * + * Results: + * Always returns TCL_OK. The interp->result field is + * a list of the graph axis limits. + * + *--------------------------------------------------------------------------- + */ +static int +AxisMarginOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + return MarginOp(interp, axisPtr, objc - 4, objv + 4); +} + + +/* + *--------------------------------------------------------------------------- + * + * AxisNamesOp -- + * + * Return a list of the names of all the axes. + * + * Results: + * Returns a standard TCL result. + * + *--------------------------------------------------------------------------- + */ + +/*ARGSUSED*/ +static int +AxisNamesOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (objc == 3) { + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + + axisPtr = Blt_GetHashValue(hPtr); + if (axisPtr->flags & DELETE_PENDING) { + continue; + } + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(axisPtr->obj.name, -1)); + } + } else { + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + int i; + + axisPtr = Blt_GetHashValue(hPtr); + for (i = 3; i < objc; i++) { + const char *pattern; + + pattern = Tcl_GetString(objv[i]); + if (Tcl_StringMatch(axisPtr->obj.name, pattern)) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(axisPtr->obj.name, -1)); + break; + } + } + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * AxisTransformOp -- + * + * Maps the given axis-value to a window coordinate. + * + * Results: + * Returns the window coordinate via interp->result. If an error occurred, + * TCL_ERROR is returned and interp->result will contain an error message. + * + *--------------------------------------------------------------------------- + */ +static int +AxisTransformOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + return TransformOp(interp, axisPtr, objc - 4, objv + 4); +} + +/* + *--------------------------------------------------------------------------- + * + * AxisMarginOp -- + * + * This procedure returns a string representing the axis limits of the + * graph. The format of the string is { left top right bottom}. + * + * Results: + * Always returns TCL_OK. The interp->result field is + * a list of the graph axis limits. + * + *--------------------------------------------------------------------------- + */ +static int +AxisTypeOp(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + return TypeOp(interp, axisPtr, objc - 4, objv + 4); +} + + +static int +AxisViewOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Axis *axisPtr; + + if (GetAxisFromObj(interp, graphPtr, objv[3], &axisPtr) != TCL_OK) { + return TCL_ERROR; + } + return ViewOp(interp, axisPtr, objc - 4, objv + 4); +} + +static Blt_OpSpec virtAxisOps[] = { + {"activate", 1, AxisActivateOp, 4, 4, "axisName"}, + {"bind", 1, AxisBindOp, 3, 6, "axisName sequence command"}, + {"cget", 2, AxisCgetOp, 5, 5, "axisName option"}, + {"configure", 2, AxisConfigureOp, 4, 0, "axisName ?axisName?... " + "?option value?..."}, + {"create", 2, AxisCreateOp, 4, 0, "axisName ?option value?..."}, + {"deactivate", 3, AxisActivateOp, 4, 4, "axisName"}, + {"delete", 3, AxisDeleteOp, 3, 0, "?axisName?..."}, + {"focus", 1, AxisFocusOp, 3, 4, "?axisName?"}, + {"get", 1, AxisGetOp, 4, 4, "name"}, + {"invtransform", 1, AxisInvTransformOp, 5, 5, "axisName value"}, + {"limits", 1, AxisLimitsOp, 4, 4, "axisName"}, + {"margin", 1, AxisMarginOp, 4, 4, "axisName"}, + {"names", 1, AxisNamesOp, 3, 0, "?pattern?..."}, + {"transform", 2, AxisTransformOp, 5, 5, "axisName value"}, + {"type", 2, AxisTypeOp, 4, 4, "axisName"}, + {"view", 1, AxisViewOp, 4, 7, "axisName ?moveto fract? " + "?scroll number what?"}, +}; +static int nVirtAxisOps = sizeof(virtAxisOps) / sizeof(Blt_OpSpec); + +int +Blt_VirtualAxisOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + GraphVirtualAxisProc *proc; + int result; + + proc = Blt_GetOpFromObj(interp, nVirtAxisOps, virtAxisOps, BLT_OP_ARG2, + objc, objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + result = (*proc) (interp, graphPtr, objc, objv); + return result; +} + +static Blt_OpSpec axisOps[] = { + {"activate", 1, ActivateOp, 3, 3, "",}, + {"bind", 1, BindOp, 2, 5, "sequence command",}, + {"cget", 2, CgetOp, 4, 4, "option",}, + {"configure", 2, ConfigureOp, 3, 0, "?option value?...",}, + {"deactivate", 1, ActivateOp, 3, 3, "",}, + {"invtransform", 1, InvTransformOp, 4, 4, "value",}, + {"limits", 1, LimitsOp, 3, 3, "",}, + {"transform", 1, TransformOp, 4, 4, "value",}, + {"use", 1, UseOp, 3, 4, "?axisName?",}, + {"view", 1, ViewOp, 3, 6, "?moveto fract? ",}, +}; + +static int nAxisOps = sizeof(axisOps) / sizeof(Blt_OpSpec); + +int +Blt_AxisOp(Tcl_Interp *interp, Graph *graphPtr, int margin, int objc, + Tcl_Obj *const *objv) +{ + int result; + GraphAxisProc *proc; + + proc = Blt_GetOpFromObj(interp, nAxisOps, axisOps, BLT_OP_ARG2, + objc, objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + if (proc == UseOp) { + lastMargin = margin; /* Set global variable to the margin + * in the argument list. Needed only + * for UseOp. */ + result = (*proc)(interp, (Axis *)graphPtr, objc - 3, objv + 3); + } else { + Axis *axisPtr; + + axisPtr = Blt_GetFirstAxis(graphPtr->margins[margin].axes); + if (axisPtr == NULL) { + return TCL_OK; + } + result = (*proc)(interp, axisPtr, objc - 3, objv + 3); + } + return result; +} + +void +Blt_MapAxes(Graph *graphPtr) +{ + int margin; + + for (margin = 0; margin < 4; margin++) { + Blt_Chain chain; + Blt_ChainLink link; + int count, offset; + + chain = graphPtr->margins[margin].axes; + count = offset = 0; + for (link = Blt_Chain_FirstLink(chain); link != NULL; + link = Blt_Chain_NextLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + if ((axisPtr->flags & (AXIS_USE|DELETE_PENDING)) != AXIS_USE) { + continue; + } + if (graphPtr->stackAxes) { + if (axisPtr->reqNumMajorTicks <= 0) { + axisPtr->reqNumMajorTicks = 4; + } + MapStackedAxis(axisPtr, count, margin); + } else { + if (axisPtr->reqNumMajorTicks <= 0) { + axisPtr->reqNumMajorTicks = 4; + } + MapAxis(axisPtr, offset, margin); + } + if (axisPtr->flags & AXIS_GRID) { + MapGridlines(axisPtr); + } + offset += (AxisIsHorizontal(axisPtr)) + ? axisPtr->height : axisPtr->width; + count++; + } + } +} + +void +Blt_DrawAxes(Graph *graphPtr, Drawable drawable) +{ + int i; + + for (i = 0; i < 4; i++) { + Blt_ChainLink link; + + for (link = Blt_Chain_LastLink(graphPtr->margins[i].axes); + link != NULL; link = Blt_Chain_PrevLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + if ((axisPtr->flags & (DELETE_PENDING|HIDE|AXIS_USE)) == AXIS_USE) { + DrawAxis(axisPtr, drawable); + } + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DrawGrids -- + * + * Draws the grid lines associated with each axis. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DrawGrids(Graph *graphPtr, Drawable drawable) +{ + int i; + + for (i = 0; i < 4; i++) { + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(graphPtr->margins[i].axes); link != NULL; + link = Blt_Chain_NextLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + if (axisPtr->flags & (DELETE_PENDING|HIDE)) { + continue; + } + if ((axisPtr->flags & AXIS_USE) && (axisPtr->flags & AXIS_GRID)) { + Blt_Draw2DSegments(graphPtr->display, drawable, + axisPtr->major.gc, axisPtr->major.segments, + axisPtr->major.nUsed); + if (axisPtr->flags & AXIS_GRIDMINOR) { + Blt_Draw2DSegments(graphPtr->display, drawable, + axisPtr->minor.gc, axisPtr->minor.segments, + axisPtr->minor.nUsed); + } + } + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GridsToPostScript -- + * + * Draws the grid lines associated with each axis. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_GridsToPostScript(Graph *graphPtr, Blt_Ps ps) +{ + int i; + + for (i = 0; i < 4; i++) { + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(graphPtr->margins[i].axes); link != NULL; + link = Blt_Chain_NextLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + if ((axisPtr->flags & (DELETE_PENDING|HIDE|AXIS_USE|AXIS_GRID)) != + (AXIS_GRID|AXIS_USE)) { + continue; + } + Blt_Ps_Format(ps, "%% Axis %s: grid line attributes\n", + axisPtr->obj.name); + Blt_Ps_XSetLineAttributes(ps, axisPtr->major.color, + axisPtr->major.lineWidth, &axisPtr->major.dashes, CapButt, + JoinMiter); + Blt_Ps_Format(ps, "%% Axis %s: major grid line segments\n", + axisPtr->obj.name); + Blt_Ps_Draw2DSegments(ps, axisPtr->major.segments, + axisPtr->major.nUsed); + if (axisPtr->flags & AXIS_GRIDMINOR) { + Blt_Ps_XSetLineAttributes(ps, axisPtr->minor.color, + axisPtr->minor.lineWidth, &axisPtr->minor.dashes, CapButt, + JoinMiter); + Blt_Ps_Format(ps, "%% Axis %s: minor grid line segments\n", + axisPtr->obj.name); + Blt_Ps_Draw2DSegments(ps, axisPtr->minor.segments, + axisPtr->minor.nUsed); + } + } + } +} + +void +Blt_AxesToPostScript(Graph *graphPtr, Blt_Ps ps) +{ + Margin *mp, *mend; + + for (mp = graphPtr->margins, mend = mp + 4; mp < mend; mp++) { + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(mp->axes); link != NULL; + link = Blt_Chain_NextLink(link)) { + Axis *axisPtr; + + axisPtr = Blt_Chain_GetValue(link); + if ((axisPtr->flags & (DELETE_PENDING|HIDE|AXIS_USE)) == AXIS_USE) { + AxisToPostScript(ps, axisPtr); + } + } + } +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_DrawAxisLimits -- + * + * Draws the min/max values of the axis in the plotting area. The text + * strings are formatted according to the "sprintf" format descriptors in + * the limitsFormats array. + * + * Results: + * None. + * + * Side Effects: + * Draws the numeric values of the axis limits into the outer regions of + * the plotting area. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DrawAxisLimits(Graph *graphPtr, Drawable drawable) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + char minString[200], maxString[200]; + int vMin, hMin, vMax, hMax; + +#define SPACING 8 + vMin = vMax = graphPtr->left + graphPtr->padLeft + 2; + hMin = hMax = graphPtr->bottom - graphPtr->padBottom - 2; /* Offsets */ + + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + Dim2D textDim; + const char *minFmt, *maxFmt; + char *minPtr, *maxPtr; + int isHoriz; + + axisPtr = Blt_GetHashValue(hPtr); + if (axisPtr->flags & DELETE_PENDING) { + continue; + } + if (axisPtr->nFormats == 0) { + continue; + } + isHoriz = AxisIsHorizontal(axisPtr); + minPtr = maxPtr = NULL; + minFmt = maxFmt = axisPtr->limitsFormats[0]; + if (axisPtr->nFormats > 1) { + maxFmt = axisPtr->limitsFormats[1]; + } + if (minFmt[0] != '\0') { + minPtr = minString; + sprintf_s(minString, 200, minFmt, axisPtr->axisRange.min); + } + if (maxFmt[0] != '\0') { + maxPtr = maxString; + sprintf_s(maxString, 200, maxFmt, axisPtr->axisRange.max); + } + if (axisPtr->descending) { + char *tmp; + + tmp = minPtr, minPtr = maxPtr, maxPtr = tmp; + } + if (maxPtr != NULL) { + if (isHoriz) { + Blt_Ts_SetAngle(axisPtr->limitsTextStyle, 90.0); + Blt_Ts_SetAnchor(axisPtr->limitsTextStyle, TK_ANCHOR_SE); + Blt_DrawText2(graphPtr->tkwin, drawable, maxPtr, + &axisPtr->limitsTextStyle, graphPtr->right, hMax, &textDim); + hMax -= (textDim.height + SPACING); + } else { + Blt_Ts_SetAngle(axisPtr->limitsTextStyle, 0.0); + Blt_Ts_SetAnchor(axisPtr->limitsTextStyle, TK_ANCHOR_NW); + Blt_DrawText2(graphPtr->tkwin, drawable, maxPtr, + &axisPtr->limitsTextStyle, vMax, graphPtr->top, &textDim); + vMax += (textDim.width + SPACING); + } + } + if (minPtr != NULL) { + Blt_Ts_SetAnchor(axisPtr->limitsTextStyle, TK_ANCHOR_SW); + if (isHoriz) { + Blt_Ts_SetAngle(axisPtr->limitsTextStyle, 90.0); + Blt_DrawText2(graphPtr->tkwin, drawable, minPtr, + &axisPtr->limitsTextStyle, graphPtr->left, hMin, &textDim); + hMin -= (textDim.height + SPACING); + } else { + Blt_Ts_SetAngle(axisPtr->limitsTextStyle, 0.0); + Blt_DrawText2(graphPtr->tkwin, drawable, minPtr, + &axisPtr->limitsTextStyle, vMin, graphPtr->bottom, &textDim); + vMin += (textDim.width + SPACING); + } + } + } /* Loop on axes */ +} + +void +Blt_AxisLimitsToPostScript(Graph *graphPtr, Blt_Ps ps) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + double vMin, hMin, vMax, hMax; + char string[200]; + +#define SPACING 8 + vMin = vMax = graphPtr->left + graphPtr->padLeft + 2; + hMin = hMax = graphPtr->bottom - graphPtr->padBottom - 2; /* Offsets */ + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + const char *minFmt, *maxFmt; + unsigned int textWidth, textHeight; + + axisPtr = Blt_GetHashValue(hPtr); + if (axisPtr->flags & DELETE_PENDING) { + continue; + } + if (axisPtr->nFormats == 0) { + continue; + } + minFmt = maxFmt = axisPtr->limitsFormats[0]; + if (axisPtr->nFormats > 1) { + maxFmt = axisPtr->limitsFormats[1]; + } + if (*maxFmt != '\0') { + sprintf_s(string, 200, maxFmt, axisPtr->axisRange.max); + Blt_GetTextExtents(axisPtr->tickFont, 0, string, -1, &textWidth, + &textHeight); + if ((textWidth > 0) && (textHeight > 0)) { + if (axisPtr->obj.classId == CID_AXIS_X) { + Blt_Ts_SetAngle(axisPtr->limitsTextStyle, 90.0); + Blt_Ts_SetAnchor(axisPtr->limitsTextStyle, TK_ANCHOR_SE); + Blt_Ps_DrawText(ps, string, &axisPtr->limitsTextStyle, + (double)graphPtr->right, hMax); + hMax -= (textWidth + SPACING); + } else { + Blt_Ts_SetAngle(axisPtr->limitsTextStyle, 0.0); + Blt_Ts_SetAnchor(axisPtr->limitsTextStyle, TK_ANCHOR_NW); + Blt_Ps_DrawText(ps, string, &axisPtr->limitsTextStyle, + vMax, (double)graphPtr->top); + vMax += (textWidth + SPACING); + } + } + } + if (*minFmt != '\0') { + sprintf_s(string, 200, minFmt, axisPtr->axisRange.min); + Blt_GetTextExtents(axisPtr->tickFont, 0, string, -1, &textWidth, + &textHeight); + if ((textWidth > 0) && (textHeight > 0)) { + Blt_Ts_SetAnchor(axisPtr->limitsTextStyle, TK_ANCHOR_SW); + if (axisPtr->obj.classId == CID_AXIS_X) { + Blt_Ts_SetAngle(axisPtr->limitsTextStyle, 90.0); + Blt_Ps_DrawText(ps, string, &axisPtr->limitsTextStyle, + (double)graphPtr->left, hMin); + hMin -= (textWidth + SPACING); + } else { + Blt_Ts_SetAngle(axisPtr->limitsTextStyle, 0.0); + Blt_Ps_DrawText(ps, string, &axisPtr->limitsTextStyle, + vMin, (double)graphPtr->bottom); + vMin += (textWidth + SPACING); + } + } + } + } +} + +Axis * +Blt_GetFirstAxis(Blt_Chain chain) +{ + Blt_ChainLink link; + + link = Blt_Chain_FirstLink(chain); + if (link == NULL) { + return NULL; + } + return Blt_Chain_GetValue(link); +} + +Axis * +Blt_NearestAxis(Graph *graphPtr, int x, int y) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->axes.table, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Axis *axisPtr; + + axisPtr = Blt_GetHashValue(hPtr); + if ((axisPtr->flags & (DELETE_PENDING|HIDE|AXIS_USE)) != AXIS_USE) { + continue; + } + if (axisPtr->flags & AXIS_SHOWTICKS) { + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(axisPtr->tickLabels); link != NULL; + link = Blt_Chain_NextLink(link)) { + TickLabel *labelPtr; + Point2d t; + double rw, rh; + Point2d bbox[5]; + + labelPtr = Blt_Chain_GetValue(link); + Blt_GetBoundingBox(labelPtr->width, labelPtr->height, + axisPtr->tickAngle, &rw, &rh, bbox); + t = Blt_AnchorPoint(labelPtr->anchorPos.x, + labelPtr->anchorPos.y, rw, rh, axisPtr->tickAnchor); + t.x = x - t.x - (rw * 0.5); + t.y = y - t.y - (rh * 0.5); + + bbox[4] = bbox[0]; + if (Blt_PointInPolygon(&t, bbox, 5)) { + axisPtr->detail = "label"; + return axisPtr; + } + } + } + if (axisPtr->title != NULL) { /* and then the title string. */ + Point2d bbox[5]; + Point2d t; + double rw, rh; + unsigned int w, h; + + Blt_GetTextExtents(axisPtr->titleFont, 0, axisPtr->title,-1,&w,&h); + Blt_GetBoundingBox(w, h, axisPtr->titleAngle, &rw, &rh, bbox); + t = Blt_AnchorPoint(axisPtr->titlePos.x, axisPtr->titlePos.y, + rw, rh, axisPtr->titleAnchor); + /* Translate the point so that the 0,0 is the upper left + * corner of the bounding box. */ + t.x = x - t.x - (rw * 0.5); + t.y = y - t.y - (rh * 0.5); + + bbox[4] = bbox[0]; + if (Blt_PointInPolygon(&t, bbox, 5)) { + axisPtr->detail = "title"; + return axisPtr; + } + } + if (axisPtr->lineWidth > 0) { /* Check for the axis region */ + if ((x <= axisPtr->right) && (x >= axisPtr->left) && + (y <= axisPtr->bottom) && (y >= axisPtr->top)) { + axisPtr->detail = "line"; + return axisPtr; + } + } + } + return NULL; +} + +ClientData +Blt_MakeAxisTag(Graph *graphPtr, const char *tagName) +{ + Blt_HashEntry *hPtr; + int isNew; + + hPtr = Blt_CreateHashEntry(&graphPtr->axes.tagTable, tagName, &isNew); + return Blt_GetHashKey(&graphPtr->axes.tagTable, hPtr); +} + + + +/* + *--------------------------------------------------------------------------- + * + * TimeScaleAxis -- + * + * Determine the units of a linear scaled axis. + * + * The axis limits are either the range of the data values mapped + * to the axis (autoscaled), or the values specified by the -min + * and -max options (manual). + * + * If autoscaled, the smallest and largest major ticks will + * encompass the range of data values. If the -loose option is + * selected, the next outer ticks are choosen. If tight, the + * ticks are at or inside of the data limits are used. + * + * If manually set, the ticks are at or inside the data limits + * are used. This makes sense for zooming. You want the + * selected range to represent the next limit, not something a + * bit bigger. + * + * Note: I added an "always" value to the -loose option to force + * the manually selected axes to be loose. It's probably + * not a good idea. + * + * maxY + * | units = magnitude (of least significant digit) + * | high = largest unit tick < max axis value + * high _| low = smallest unit tick > min axis value + * | + * | range = high - low + * | # ticks = greatest factor of range/units + * _| + * U | + * n | + * i | + * t _| + * | + * | + * | + * low _| + * | + * |_minX________________maxX__ + * | | | | | + * minY low high + * minY + * + * numTicks = Number of ticks + * min = Minimum value of axis + * max = Maximum value of axis + * range = Range of values (max - min) + * + * Results: + * None. + * + * Side Effects: + * The axis tick information is set. The actual tick values will + * be generated later. + * + *--------------------------------------------------------------------------- + */ +static void +TimeScaleAxis(Axis *axisPtr, double min, double max) +{ +#ifdef notdef + double step; + double tickMin, tickMax; + double axisMin, axisMax; + unsigned int nTicks; + + range = max - min; + + +#define SECONDS_MIN (60) +#define SECONDS_HOUR (SECONDS_MIN * 60) +#define SECONDS_DAY (SECONDS_HOUR * 24) +#define SECONDS_MONTH (SECONDS_DAY * 30) +#define SECONDS_YEAR (SECONDS_MONTH * 12) + div = nTicks - 1; + if (range > (SECONDS_MONTH * 6 * div)) { + unit = TICK_YEAR; + } else if (range > (SECONDS_MONTH * 3 * div)) { + unit = TICKS_6MONTH; + first = timefloor(min, unit); + last = timeceil(max, unit); + } else if (range > (SECONDS_MONTH * 2 * div)) { + unit = TICKS_3MONTH; + first = timefloor(min, unit); + last = timeceil(max, unit); + } else if (range > (SECONDS_MONTH * div)) { + unit = TICKS_2MONTH; + first = timefloor(min, unit); + last = timeceil(max, unit); + } else if (range > (SECONDS_DAY * 15 * div)) { + unit = TICKS_1MONTH; + } else if (range > (SECONDS_DAY * 10 * div)) { + unit = TICKS_15DAY; + } else if (range > (SECONDS_DAY * div)) { + unit = TICKS_10DAY; + } else if (range > (SECONDS_HOUR * 12 * div)) { + unit = TICKS_1DAY; + } else if (range > (SECONDS_HOUR * 6 * div)) { + unit = TICKS_12HOUR; + } else if (range > (SECONDS_HOUR * 3 * div)) { + unit = TICKS_6HOUR; + } else if (range > (SECONDS_HOUR * div)) { + unit = TICKS_3HOUR; + } else if (range > (SECONDS_MIN * 30 * div)) { + unit = TICKS_HOUR; + } else if (range > (SECONDS_MIN * 20 * div)) { + unit = TICKS_30MIN; + } else if (range > (SECONDS_MIN * 15 * div)) { + unit = TICKS_20MIN; + } else if (range > (SECONDS_MIN * 10 * div)) { + unit = TICKS_15MIN; + } else if (range > (SECONDS_MIN * div)) { + unit = TICKS_10MIN; + } else if (range > (SECONDS_SEC * 30 * div)) { + unit = TICKS_1MIN; + } else if (range > (SECONDS_SEC * 20 * div)) { + unit = TICKS_30SEC; + } else if (range > (SECONDS_SEC * 15 * div)) { + unit = TICKS_20SEC; + } else if (range > (SECONDS_SEC * 10 * div)) { + unit = TICKS_15SEC; + } else if (range > (SECONDS_SEC * div)) { + unit = TICKS_10SEC; + } else { + unit = TICKS_1SEC; + } + + } else { + unit = TICKS_SECS; + } + nTicks = 0; + step = 1.0; + /* Suppress compiler warning. */ + axisMin = axisMax = tickMin = tickMax = Blt_NaN(); + if (min < max) { + double range; + + range = max - min; + /* Calculate the major tick stepping. */ + if (axisPtr->reqStep > 0.0) { + /* An interval was designated by the user. Keep scaling it until + * it fits comfortably within the current range of the axis. */ + step = axisPtr->reqStep; + while ((2 * step) >= range) { + step *= 0.5; + } + } else { + range = NiceNum(range, 0); + step = NiceNum(range / axisPtr->reqNumMajorTicks, 1); + } + + /* Find the outer tick values. Add 0.0 to prevent getting -0.0. */ + axisMin = tickMin = floor(min / step) * step + 0.0; + axisMax = tickMax = ceil(max / step) * step + 0.0; + + nTicks = Round((tickMax - tickMin) / step) + 1; + } + axisPtr->majorSweep.step = step; + axisPtr->majorSweep.initial = tickMin; + axisPtr->majorSweep.nSteps = nTicks; + + /* + * The limits of the axis are either the range of the data ("tight") or at + * the next outer tick interval ("loose"). The looseness or tightness has + * to do with how the axis fits the range of data values. This option is + * overridden when the user sets an axis limit (by either -min or -max + * option). The axis limit is always at the selected limit (otherwise we + * assume that user would have picked a different number). + */ + if ((axisPtr->looseMin == AXIS_TIGHT) || + ((axisPtr->looseMin == AXIS_LOOSE) && + (DEFINED(axisPtr->reqMin)))) { + axisMin = min; + } + if ((axisPtr->looseMax == AXIS_TIGHT) || + ((axisPtr->looseMax == AXIS_LOOSE) && + (DEFINED(axisPtr->reqMax)))) { + axisMax = max; + } + SetAxisRange(&axisPtr->axisRange, axisMin, axisMax); + + /* Now calculate the minor tick step and number. */ + + if ((axisPtr->reqNumMinorTicks > 0) && (axisPtr->flags & AXIS_AUTO_MAJOR)) { + nTicks = axisPtr->reqNumMinorTicks - 1; + step = 1.0 / (nTicks + 1); + } else { + nTicks = 0; /* No minor ticks. */ + step = 0.5; /* Don't set the minor tick interval to + * 0.0. It makes the GenerateTicks + * routine * create minor log-scale tick + * marks. */ + } + axisPtr->minorSweep.initial = axisPtr->minorSweep.step = step; + axisPtr->minorSweep.nSteps = nTicks; +#endif +} + +#ifdef notdef +static Ticks * +TimeGenerateTicks(TickSweep *sweepPtr) +{ + Ticks *ticksPtr; + + ticksPtr = Blt_AssertMalloc(sizeof(Ticks) + + (sweepPtr->nSteps * sizeof(double))); + ticksPtr->nTicks = 0; + + if (sweepPtr->step == 0.0) { + /* Hack: A zero step indicates to use log values. */ + int i; + /* Precomputed log10 values [1..10] */ + static double logTable[] = { + 0.0, + 0.301029995663981, + 0.477121254719662, + 0.602059991327962, + 0.698970004336019, + 0.778151250383644, + 0.845098040014257, + 0.903089986991944, + 0.954242509439325, + 1.0 + }; + for (i = 0; i < sweepPtr->nSteps; i++) { + ticksPtr->values[i] = logTable[i]; + } + } else { + double value; + int i; + + value = sweepPtr->initial; /* Start from smallest axis tick */ + for (i = 0; i < sweepPtr->nSteps; i++) { + value = UROUND(value, sweepPtr->step); + ticksPtr->values[i] = value; + value += sweepPtr->step; + } + } + ticksPtr->nTicks = sweepPtr->nSteps; + return ticksPtr; +} + +static double +TimeFloor(double min, int unit) +{ + unsigned long ticks; + + ticks = (long)floor(min); + localtime_r(&ticks, &tm); + switch(unit) { + case TICK_6MONTHS: + tm.sec = 0; + tm.min = 0; + tm.day = 0; + tm. + } +} +static double +TimeCeil(double max, int unit) +{ + +} + +#endif + diff --git a/src/bltGrAxis.h b/src/bltGrAxis.h new file mode 100644 index 0000000..a009aec --- /dev/null +++ b/src/bltGrAxis.h @@ -0,0 +1,332 @@ + +/* + * bltGrAxis.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_GR_AXIS_H +#define _BLT_GR_AXIS_H + +#include "bltList.h" + +/* + *--------------------------------------------------------------------------- + * + * Grid -- + * + * Contains attributes of describing how to draw grids (at major ticks) + * in the graph. Grids may be mapped to either/both X and Y axis. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + Blt_Dashes dashes; /* Dash style of the grid. This represents an + * array of alternatingly drawn pixel + * values. */ + int lineWidth; /* Width of the grid lines */ + XColor *color; /* Color of the grid lines */ + GC gc; /* Graphics context for the grid. */ + + Segment2d *segments; /* Array of line segments representing the + * grid lines */ + int nUsed; /* # of axis segments in use. */ + int nAllocated; /* # of axis segments allocated. */ +} Grid; + +/* + *--------------------------------------------------------------------------- + * + * AxisRange -- + * + * Designates a range of values by a minimum and maximum limit. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + double min, max, range, scale; +} AxisRange; + +/* + *--------------------------------------------------------------------------- + * + * TickLabel -- + * + * Structure containing the X-Y screen coordinates of the tick + * label (anchored at its center). + * + *--------------------------------------------------------------------------- + */ +typedef struct { + Point2d anchorPos; + unsigned int width, height; + char string[1]; +} TickLabel; + +/* + *--------------------------------------------------------------------------- + * + * Ticks -- + * + * Structure containing information where the ticks (major or + * minor) will be displayed on the graph. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + unsigned int nTicks; /* # of ticks on axis */ + double values[1]; /* Array of tick values (malloc-ed). */ +} Ticks; + +/* + *--------------------------------------------------------------------------- + * + * TickSweep -- + * + * Structure containing information where the ticks (major or + * minor) will be displayed on the graph. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + double initial; /* Initial value */ + double step; /* Size of interval */ + unsigned int nSteps; /* Number of intervals. */ +} TickSweep; + +/* + *--------------------------------------------------------------------------- + * + * Axis -- + * + * Structure contains options controlling how the axis will be + * displayed. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + GraphObj obj; /* Must be first field in axis. */ + + unsigned int flags; + + Blt_HashEntry *hashPtr; + + /* Fields specific to axes. */ + + const char *detail; + + int refCount; /* Number of elements referencing this + * axis. */ + int logScale; /* If non-zero, generate log scale + * ticks for the axis. */ + int timeScale; /* If non-zero, generate time scale + * ticks for the axis. This option is + * overridden by -logscale. */ + int descending; /* If non-zero, display the range of + * values on the axis in descending + * order, from high to low. */ + + int looseMin, looseMax; /* If non-zero, axis range extends to + * the outer major ticks, otherwise at + * the limits of the data values. This + * is overriddened by setting the -min + * and -max options. */ + + const char *title; /* Title of the axis. */ + + int titleAlternate; /* Indicates whether to position the + * title above/left of the axis. */ + + Point2d titlePos; /* Position of the title */ + + unsigned short int titleWidth, titleHeight; + + + int lineWidth; /* Width of lines representing axis + * (including ticks). If zero, then + * no axis lines or ticks are + * drawn. */ + + const char **limitsFormats; /* One or two strings of sprintf-like + * formats describing how to display + * virtual axis limits. If NULL, + * display no limits. */ + int nFormats; + + TextStyle limitsTextStyle; /* Text attributes (color, font, + * rotation, etc.) of the limits. */ + + double windowSize; /* Size of a sliding window of values + * used to scale the axis + * automatically as new data values + * are added. The axis will always + * display the latest values in this + * range. */ + + double shiftBy; /* Shift maximum by this interval. */ + + int tickLength; /* Length of major ticks in pixels */ + + const char *formatCmd; /* Specifies a TCL command, to be + * invoked by the axis whenever it has + * to generate tick labels. */ + + Tcl_Obj *scrollCmdObjPtr; + int scrollUnits; + + double min, max; /* The actual axis range. */ + + double reqMin, reqMax; /* Requested axis bounds. Consult the + * axisPtr->flags field for + * AXIS_CONFIG_MIN and AXIS_CONFIG_MAX + * to see if the requested bound have + * been set. They override the + * computed range of the axis + * (determined by auto-scaling). */ + + double reqScrollMin, reqScrollMax; + + double scrollMin, scrollMax; /* Defines the scrolling reqion of the + * axis. Normally the region is + * determined from the data limits. If + * specified, these values override + * the data-range. */ + + AxisRange valueRange; /* Range of data values of elements + * mapped to this axis. This is used + * to auto-scale the axis in "tight" + * mode. */ + AxisRange axisRange; /* Smallest and largest major tick + * values for the axis. The tick + * values lie outside the range of + * data values. This is used to + * auto-scale the axis in "loose" + * mode. */ + + double prevMin, prevMax; + + double reqStep; /* If > 0.0, overrides the computed major + * tick interval. Otherwise a stepsize + * is automatically calculated, based + * upon the range of elements mapped to the + * axis. The default value is 0.0. */ + + Ticks *t1Ptr; /* Array of major tick positions. May be + * set by the user or generated from the + * major sweep below. */ + + Ticks *t2Ptr; /* Array of minor tick positions. May be + * set by the user or generated from the + * minor sweep below. */ + + TickSweep minorSweep, majorSweep; + + int reqNumMajorTicks; /* Default number of ticks to be displayed. */ + int reqNumMinorTicks; /* If non-zero, represents the + * requested the number of minor ticks + * to be uniformally displayed along + * each major tick. */ + + + int labelOffset; /* If non-zero, indicates that the tick + * label should be offset to sit in the + * middle of the next interval. */ + + /* The following fields are specific to logical axes */ + + int margin; /* Margin that contains this axis. */ + Blt_ChainLink link; /* Axis link in margin list. */ + Blt_Chain chain; + Segment2d *segments; /* Array of line segments representing + * the major and minor ticks, but also + * the * axis line itself. The segment + * coordinates * are relative to the + * axis. */ + int nSegments; /* Number of segments in the above + * array. */ + Blt_Chain tickLabels; /* Contains major tick label strings + * and their offsets along the + * axis. */ + short int left, right, top, bottom; /* Region occupied by the of axis. */ + short int width, height; /* Extents of axis */ + short int maxTickWidth, maxTickHeight; + Blt_Background normalBg; + Blt_Background activeBg; + XColor *activeFgColor; + + int relief; + int borderWidth; + int activeRelief; + + float tickAngle; + Blt_Font tickFont; + Tk_Anchor tickAnchor; + Tk_Anchor reqTickAnchor; + XColor *tickColor; + GC tickGC; /* Graphics context for axis and tick + * labels */ + GC activeTickGC; + + double titleAngle; + Blt_Font titleFont; + Tk_Anchor titleAnchor; + Tk_Justify titleJustify; + XColor *titleColor; + + Grid major, minor; /* Axis grid information. */ + + double screenScale; + int screenMin, screenRange; + +} Axis; + +/* + *--------------------------------------------------------------------------- + * + * Axis2d -- + * + * The pair of axes mapping a point onto the graph. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + Axis *x, *y; +} Axis2d; + +/* Axis flags: */ + +#define AXIS_AUTO_MAJOR (1<<16) /* Auto-generate major ticks. */ +#define AXIS_AUTO_MINOR (1<<17) /* Auto-generate minor ticks. */ +#define AXIS_ONSCREEN (1<<18) /* Axis is displayed on the screen via + * the "use" operation */ +#define AXIS_GRID (1<<19) +#define AXIS_GRID_MINOR (1<<20) +#define AXIS_TICKS (1<<21) +#define AXIS_TICKS_INTERIOR (1<<22) +#define AXIS_CHECK_LIMITS (1<<23) +#define AXIS_LOGSCALE (1<<24) +#define AXIS_DECREASING (1<<25) + +#endif /* _BLT_GR_AXIS_H */ diff --git a/src/bltGrBind.C b/src/bltGrBind.C new file mode 100644 index 0000000..7b288f7 --- /dev/null +++ b/src/bltGrBind.C @@ -0,0 +1,1825 @@ + +/* + * bltBind.c -- + * + * This module implements object binding procedures for the BLT toolkit. + * + * Copyright 1998 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltInt.h" +#include "bltBind.h" +#include <bltList.h> + +static Tk_EventProc BindProc; + +typedef struct _Blt_BindTable BindTable; + +/* Make button presses on objects have implicit grab. */ +#define FULLY_SIMULATE_GRAB 1 + +/* + * Binding table procedures. + */ +#define REPICK_IN_PROGRESS (1<<0) +#define LEFT_GRABBED_ITEM (1<<1) + +#define ALL_BUTTONS_MASK \ + (Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask) + +#ifndef VirtualEventMask +#define VirtualEventMask (1L << 30) +#endif + +#define ALL_VALID_EVENTS_MASK \ + (ButtonMotionMask | Button1MotionMask | Button2MotionMask | \ + Button3MotionMask | Button4MotionMask | Button5MotionMask | \ + ButtonPressMask | ButtonReleaseMask | EnterWindowMask | \ + LeaveWindowMask | KeyPressMask | KeyReleaseMask | \ + PointerMotionMask | VirtualEventMask) + +static int buttonMasks[] = +{ + 0, /* No buttons pressed */ + Button1Mask, Button2Mask, Button3Mask, Button4Mask, Button5Mask, +}; + + +/* + * How to make drag&drop work? + * + * Right now we generate pseudo <Enter> <Leave> events within button grab + * on an object. They're marked NotifyVirtual instead of NotifyAncestor. + * A better solution: generate new-style virtual <<DragEnter>> + * <<DragMotion>> <<DragLeave>> events. These virtual events don't have + * to exist as "real" event sequences, like virtual events do now. + */ + +/* + *--------------------------------------------------------------------------- + * + * DoEvent -- + * + * This procedure is called to invoke binding processing for a new event + * that is associated with the current item for a legend. + * + * Results: + * None. + * + * Side effects: + * Depends on the bindings for the legend. A binding script could delete + * an entry, so callers should protect themselves with Tcl_Preserve and + * Tcl_Release. + * + *--------------------------------------------------------------------------- + */ +static void +DoEvent( + BindTable *bindPtr, /* Binding information for widget in which + * event occurred. */ + XEvent *eventPtr, /* Real or simulated X event that is to be + * processed. */ + ClientData item, /* Item picked. */ + ClientData context) /* Context of item. */ +{ + Blt_List tagList; + + if ((bindPtr->tkwin == NULL) || (bindPtr->bindingTable == NULL)) { + return; + } + if ((eventPtr->type == KeyPress) || (eventPtr->type == KeyRelease)) { + item = bindPtr->focusItem; + context = bindPtr->focusContext; + } + if (item == NULL) { + return; + } + /* + * Invoke the binding system. + */ + tagList = Blt_List_Create(BLT_ONE_WORD_KEYS); + if (bindPtr->tagProc == NULL) { + Blt_List_Append(tagList, Tk_GetUid("all"), 0); + Blt_List_Append(tagList, (char *)item, 0); + } else { + (*bindPtr->tagProc) (bindPtr, item, context, tagList); + } + if (Blt_List_GetLength(tagList) > 0) { + int nTags; + ClientData *tagArray; +#define MAX_STATIC_TAGS 64 + ClientData staticTags[MAX_STATIC_TAGS]; + Blt_ListNode node; + + tagArray = staticTags; + nTags = Blt_List_GetLength(tagList); + if (nTags >= MAX_STATIC_TAGS) { + tagArray = Blt_AssertMalloc(sizeof(ClientData) * nTags); + + } + nTags = 0; + for (node = Blt_List_FirstNode(tagList); node != NULL; + node = Blt_List_NextNode(node)) { + tagArray[nTags++] = (ClientData)Blt_List_GetKey(node); + } + Tk_BindEvent(bindPtr->bindingTable, eventPtr, bindPtr->tkwin, nTags, + tagArray); + if (tagArray != staticTags) { + Blt_Free(tagArray); + } + } + Blt_List_Destroy(tagList); +} + +/* + *--------------------------------------------------------------------------- + * + * PickCurrentItem -- + * + * Find the topmost item in a legend that contains a given location and + * mark the the current item. If the current item has changed, generate + * a fake exit event on the old current item and a fake enter event on + * the new current item. + * + * Results: + * None. + * + * Side effects: + * The current item may change. If it does, then the commands associated + * with item entry and exit could do just about anything. A binding + * script could delete the legend, so callers should protect themselves + * with Tcl_Preserve and Tcl_Release. + * + *--------------------------------------------------------------------------- + */ +static void +PickCurrentItem( + BindTable *bindPtr, /* Binding table information. */ + XEvent *eventPtr) /* Event describing location of mouse cursor. + * Must be EnterWindow, LeaveWindow, + * ButtonRelease, or MotionNotify. */ +{ + int buttonDown; + ClientData newItem, oldItem; + ClientData newContext; + + /* + * Check whether or not a button is down. If so, we'll log entry and exit + * into and out of the current item, but not entry into any other item. + * This implements a form of grabbing equivalent to what the X server does + * for windows. + */ + buttonDown = (bindPtr->state & ALL_BUTTONS_MASK); + if (!buttonDown) { + bindPtr->flags &= ~LEFT_GRABBED_ITEM; + } + + /* + * Save information about this event in the widget. The event in the + * widget is used for two purposes: + * + * 1. Event bindings: if the current item changes, fake events are + * generated to allow item-enter and item-leave bindings to trigger. + * 2. Reselection: if the current item gets deleted, can use the + * saved event to find a new current item. + * Translate MotionNotify events into EnterNotify events, since that's + * what gets reported to item handlers. + */ + + if (eventPtr != &bindPtr->pickEvent) { + if ((eventPtr->type == MotionNotify) || + (eventPtr->type == ButtonRelease)) { + bindPtr->pickEvent.xcrossing.type = EnterNotify; + bindPtr->pickEvent.xcrossing.serial = eventPtr->xmotion.serial; + bindPtr->pickEvent.xcrossing.send_event = + eventPtr->xmotion.send_event; + bindPtr->pickEvent.xcrossing.display = eventPtr->xmotion.display; + bindPtr->pickEvent.xcrossing.window = eventPtr->xmotion.window; + bindPtr->pickEvent.xcrossing.root = eventPtr->xmotion.root; + bindPtr->pickEvent.xcrossing.subwindow = None; + bindPtr->pickEvent.xcrossing.time = eventPtr->xmotion.time; + bindPtr->pickEvent.xcrossing.x = eventPtr->xmotion.x; + bindPtr->pickEvent.xcrossing.y = eventPtr->xmotion.y; + bindPtr->pickEvent.xcrossing.x_root = eventPtr->xmotion.x_root; + bindPtr->pickEvent.xcrossing.y_root = eventPtr->xmotion.y_root; + bindPtr->pickEvent.xcrossing.mode = NotifyNormal; + bindPtr->pickEvent.xcrossing.detail = NotifyNonlinear; + bindPtr->pickEvent.xcrossing.same_screen + = eventPtr->xmotion.same_screen; + bindPtr->pickEvent.xcrossing.focus = False; + bindPtr->pickEvent.xcrossing.state = eventPtr->xmotion.state; + } else { + bindPtr->pickEvent = *eventPtr; + } + } + bindPtr->activePick = TRUE; + + /* + * If this is a recursive call (there's already a partially completed call + * pending on the stack; it's in the middle of processing a Leave event + * handler for the old current item) then just return; the pending call + * will do everything that's needed. + */ + if (bindPtr->flags & REPICK_IN_PROGRESS) { + return; + } + /* + * A LeaveNotify event automatically means that there's no current item, + * so the check for closest item can be skipped. + */ + newContext = NULL; + if (bindPtr->pickEvent.type != LeaveNotify) { + int x, y; + + x = bindPtr->pickEvent.xcrossing.x; + y = bindPtr->pickEvent.xcrossing.y; + newItem = (*bindPtr->pickProc) (bindPtr->clientData, x, y, &newContext); + } else { + newItem = NULL; + } + if (((newItem == bindPtr->currentItem) && + (newContext == bindPtr->currentContext)) && + ((bindPtr->flags & LEFT_GRABBED_ITEM) == 0)) { + /* + * Nothing to do: the current item hasn't changed. + */ + return; + } +#if FULLY_SIMULATE_GRAB + if (((newItem != bindPtr->currentItem) || + (newContext != bindPtr->currentContext)) && + (buttonDown)) { + bindPtr->flags |= LEFT_GRABBED_ITEM; +#ifdef notdef + fprintf(stderr, "pickcurrentitem: simulate grab.\n"); +#endif + return; + } +#endif + /* + * Simulate a LeaveNotify event on the previous current item and an + * EnterNotify event on the new current item. Remove the "current" tag + * from the previous current item and place it on the new current item. + */ + oldItem = bindPtr->currentItem; + Tcl_Preserve(oldItem); + Tcl_Preserve(newItem); + + if ((bindPtr->currentItem != NULL) && + ((newItem != bindPtr->currentItem) || + (newContext != bindPtr->currentContext)) && + ((bindPtr->flags & LEFT_GRABBED_ITEM) == 0)) { + XEvent event; + + event = bindPtr->pickEvent; + event.type = LeaveNotify; + /* + * If the event's detail happens to be NotifyInferior the binding + * mechanism will discard the event. To be consistent, always use + * NotifyAncestor. + */ + event.xcrossing.detail = NotifyAncestor; + + bindPtr->flags |= REPICK_IN_PROGRESS; + DoEvent(bindPtr, &event, bindPtr->currentItem, bindPtr->currentContext); + bindPtr->flags &= ~REPICK_IN_PROGRESS; + + /* + * Note: during DoEvent above, it's possible that bindPtr->newItem got + * reset to NULL because the item was deleted. + */ + } + if (((newItem != bindPtr->currentItem) || + (newContext != bindPtr->currentContext)) && + (buttonDown)) { + XEvent event; + + bindPtr->flags |= LEFT_GRABBED_ITEM; + event = bindPtr->pickEvent; + if ((newItem != bindPtr->newItem) || + (newContext != bindPtr->newContext)) { + ClientData savedItem; + ClientData savedContext; + + /* + * Generate <Enter> and <Leave> events for objects during button + * grabs. This isn't standard. But for example, it allows one to + * provide balloon help on the individual entries of the Hierbox + * widget. + */ + savedItem = bindPtr->currentItem; + savedContext = bindPtr->currentContext; + if (bindPtr->newItem != NULL) { + event.type = LeaveNotify; + event.xcrossing.detail = NotifyVirtual /* Ancestor */ ; + bindPtr->currentItem = bindPtr->newItem; + DoEvent(bindPtr, &event, bindPtr->newItem, bindPtr->newContext); + } + bindPtr->newItem = newItem; + bindPtr->newContext = newContext; + if (newItem != NULL) { + event.type = EnterNotify; + event.xcrossing.detail = NotifyVirtual /* Ancestor */ ; + bindPtr->currentItem = newItem; + DoEvent(bindPtr, &event, newItem, newContext); + } + bindPtr->currentItem = savedItem; + bindPtr->currentContext = savedContext; + } + goto done; + } + /* + * Special note: it's possible that + * bindPtr->newItem == bindPtr->currentItem + * here. This can happen, for example, if LEFT_GRABBED_ITEM was set. + */ + + bindPtr->flags &= ~LEFT_GRABBED_ITEM; + bindPtr->currentItem = bindPtr->newItem = newItem; + bindPtr->currentContext = bindPtr->newContext = newContext; + if (bindPtr->currentItem != NULL) { + XEvent event; + + event = bindPtr->pickEvent; + event.type = EnterNotify; + event.xcrossing.detail = NotifyAncestor; + DoEvent(bindPtr, &event, newItem, newContext); +#ifdef notdef + if ((eventPtr->type == MotionNotify) || + (eventPtr->type == ButtonRelease)) { + fprintf(stderr, "pickcurrentitem: DoEvent Button buttondown=%d.\n", + buttonDown); + event.type = eventPtr->type; + event.xbutton.button = eventPtr->xbutton.button; + DoEvent(bindPtr, &event, newItem, newContext); + fprintf(stderr, "pickcurrentitem: done.\n"); + } +#endif + } + done: + Tcl_Release(newItem); + Tcl_Release(oldItem); +} + +/* + *--------------------------------------------------------------------------- + * + * BindProc -- + * + * This procedure is invoked by the Tk dispatcher to handle events + * associated with bindings on items. + * + * Results: + * None. + * + * Side effects: + * Depends on the command invoked as part of the binding + * (if there was any). + * + *--------------------------------------------------------------------------- + */ +static void +BindProc( + ClientData clientData, /* Pointer to widget structure. */ + XEvent *eventPtr) /* Pointer to X event that just happened. */ +{ + BindTable *bindPtr = clientData; + int mask; + + Tcl_Preserve(bindPtr->clientData); + /* + * This code below keeps track of the current modifier state in + * bindPtr->state. This information is used to defer repicks of the + * current item while buttons are down. + */ + switch (eventPtr->type) { + case ButtonPress: + case ButtonRelease: + mask = 0; + if ((eventPtr->xbutton.button >= Button1) && + (eventPtr->xbutton.button <= Button5)) { + mask = buttonMasks[eventPtr->xbutton.button]; + } + /* + * For button press events, repick the current item using the button + * state before the event, then process the event. For button release + * events, first process the event, then repick the current item using + * the button state *after* the event (the button has logically gone + * up before we change the current item). + */ + if (eventPtr->type == ButtonPress) { + + /* + * On a button press, first repick the current item using the + * button state before the event, the process the event. + */ + + bindPtr->state = eventPtr->xbutton.state; + PickCurrentItem(bindPtr, eventPtr); + bindPtr->state ^= mask; + DoEvent(bindPtr, eventPtr, bindPtr->currentItem, + bindPtr->currentContext); + + } else { + + /* + * Button release: first process the event, with the button still + * considered to be down. Then repick the current item under the + * assumption that the button is no longer down. + */ + bindPtr->state = eventPtr->xbutton.state; + DoEvent(bindPtr, eventPtr, bindPtr->currentItem, + bindPtr->currentContext); + eventPtr->xbutton.state ^= mask; + bindPtr->state = eventPtr->xbutton.state; + PickCurrentItem(bindPtr, eventPtr); + eventPtr->xbutton.state ^= mask; + } + break; + + case EnterNotify: + case LeaveNotify: + bindPtr->state = eventPtr->xcrossing.state; + PickCurrentItem(bindPtr, eventPtr); + break; + + case MotionNotify: + bindPtr->state = eventPtr->xmotion.state; + PickCurrentItem(bindPtr, eventPtr); + DoEvent(bindPtr, eventPtr, bindPtr->currentItem, + bindPtr->currentContext); + break; + + case KeyPress: + case KeyRelease: + bindPtr->state = eventPtr->xkey.state; + PickCurrentItem(bindPtr, eventPtr); + DoEvent(bindPtr, eventPtr, bindPtr->currentItem, + bindPtr->currentContext); + break; + } + Tcl_Release(bindPtr->clientData); +} + +int +Blt_ConfigureBindings( + Tcl_Interp *interp, + BindTable *bindPtr, + ClientData item, + int argc, + const char **argv) +{ + const char *command; + unsigned long mask; + const char *seq; + + if (argc == 0) { + Tk_GetAllBindings(interp, bindPtr->bindingTable, item); + return TCL_OK; + } + if (argc == 1) { + command = Tk_GetBinding(interp, bindPtr->bindingTable, item, argv[0]); + if (command == NULL) { + Tcl_AppendResult(interp, "can't find event \"", argv[0], "\"", + (char *)NULL); + return TCL_ERROR; + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), command, -1); + return TCL_OK; + } + + seq = argv[0]; + command = argv[1]; + + if (command[0] == '\0') { + return Tk_DeleteBinding(interp, bindPtr->bindingTable, item, seq); + } + + if (command[0] == '+') { + mask = Tk_CreateBinding(interp, bindPtr->bindingTable, item, seq, + command + 1, TRUE); + } else { + mask = Tk_CreateBinding(interp, bindPtr->bindingTable, item, seq, + command, FALSE); + } + if (mask == 0) { + Tcl_AppendResult(interp, "event mask can't be zero for \"", item, "\"", + (char *)NULL); + return TCL_ERROR; + } + if (mask & (unsigned)~ALL_VALID_EVENTS_MASK) { + Tk_DeleteBinding(interp, bindPtr->bindingTable, item, seq); + Tcl_ResetResult(interp); + Tcl_AppendResult(interp, "requested illegal events; ", + "only key, button, motion, enter, leave, and virtual ", + "events may be used", (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + + +int +Blt_ConfigureBindingsFromObj( + Tcl_Interp *interp, + BindTable *bindPtr, + ClientData item, + int objc, + Tcl_Obj *const *objv) +{ + const char *command; + unsigned long mask; + const char *seq; + const char *string; + + if (objc == 0) { + Tk_GetAllBindings(interp, bindPtr->bindingTable, item); + return TCL_OK; + } + string = Tcl_GetString(objv[0]); + if (objc == 1) { + command = Tk_GetBinding(interp, bindPtr->bindingTable, item, string); + if (command == NULL) { + Tcl_ResetResult(interp); + Tcl_AppendResult(interp, "invalid binding event \"", string, "\"", + (char *)NULL); + return TCL_ERROR; + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), command, -1); + return TCL_OK; + } + + seq = string; + command = Tcl_GetString(objv[1]); + + if (command[0] == '\0') { + return Tk_DeleteBinding(interp, bindPtr->bindingTable, item, seq); + } + + if (command[0] == '+') { + mask = Tk_CreateBinding(interp, bindPtr->bindingTable, item, seq, + command + 1, TRUE); + } else { + mask = Tk_CreateBinding(interp, bindPtr->bindingTable, item, seq, + command, FALSE); + } + if (mask == 0) { + return TCL_ERROR; + } + if (mask & (unsigned)~ALL_VALID_EVENTS_MASK) { + Tk_DeleteBinding(interp, bindPtr->bindingTable, item, seq); + Tcl_ResetResult(interp); + Tcl_AppendResult(interp, "requested illegal events; ", + "only key, button, motion, enter, leave, and virtual ", + "events may be used", (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +Blt_BindTable +Blt_CreateBindingTable( + Tcl_Interp *interp, + Tk_Window tkwin, + ClientData clientData, + Blt_BindPickProc *pickProc, + Blt_BindTagProc *tagProc) +{ + unsigned int mask; + BindTable *bindPtr; + + bindPtr = Blt_AssertCalloc(1, sizeof(BindTable)); + bindPtr->bindingTable = Tk_CreateBindingTable(interp); + bindPtr->clientData = clientData; + bindPtr->tkwin = tkwin; + bindPtr->pickProc = pickProc; + bindPtr->tagProc = tagProc; + mask = (KeyPressMask | KeyReleaseMask | ButtonPressMask | + ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | + PointerMotionMask); + Tk_CreateEventHandler(tkwin, mask, BindProc, bindPtr); + return bindPtr; +} + +void +Blt_DestroyBindingTable(BindTable *bindPtr) +{ + unsigned int mask; + + Tk_DeleteBindingTable(bindPtr->bindingTable); + mask = (KeyPressMask | KeyReleaseMask | ButtonPressMask | + ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | + PointerMotionMask); + Tk_DeleteEventHandler(bindPtr->tkwin, mask, BindProc, bindPtr); + Blt_Free(bindPtr); +} + +void +Blt_PickCurrentItem(BindTable *bindPtr) +{ + if (bindPtr->activePick) { + PickCurrentItem(bindPtr, &bindPtr->pickEvent); + } +} + +void +Blt_DeleteBindings( + BindTable *bindPtr, + ClientData object) +{ + Tk_DeleteAllBindings(bindPtr->bindingTable, object); + + /* + * If this is the object currently picked, we need to repick one. + */ + if (bindPtr->currentItem == object) { + bindPtr->currentItem = NULL; + bindPtr->currentContext = NULL; + } + if (bindPtr->newItem == object) { + bindPtr->newItem = NULL; + bindPtr->newContext = NULL; + } + if (bindPtr->focusItem == object) { + bindPtr->focusItem = NULL; + bindPtr->focusContext = NULL; + } +} + +void +Blt_MoveBindingTable( + BindTable *bindPtr, + Tk_Window tkwin) +{ + unsigned int mask; + + mask = (KeyPressMask | KeyReleaseMask | ButtonPressMask | + ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | + PointerMotionMask); + if (bindPtr->tkwin != NULL) { + Tk_DeleteEventHandler(bindPtr->tkwin, mask, BindProc, bindPtr); + } + Tk_CreateEventHandler(tkwin, mask, BindProc, bindPtr); + bindPtr->tkwin = tkwin; +} + +/* + * The following union is used to hold the detail information from an + * XEvent (including Tk's XVirtualEvent extension). + */ +typedef union { + KeySym keySym; /* KeySym that corresponds to xkey.keycode. */ + int button; /* Button that was pressed (xbutton.button). */ + Tk_Uid name; /* Tk_Uid of virtual event. */ + ClientData clientData; /* Used when type of Detail is unknown, and to + * ensure that all bytes of Detail are initialized + * when this structure is used in a hash key. */ +} Detail; + + +/* + * The following structure defines a pattern, which is matched against X + * events as part of the process of converting X events into TCL commands. + */ +typedef struct { + int eventType; /* Type of X event, e.g. ButtonPress. */ + int needMods; /* Mask of modifiers that must be + * present (0 means no modifiers are + * required). */ + Detail detail; /* Additional information that must + * match event. Normally this is 0, + * meaning no additional information + * must match. For KeyPress and + * KeyRelease events, a keySym may + * be specified to select a + * particular keystroke (0 means any + * keystrokes). For button events, + * specifies a particular button (0 + * means any buttons are OK). For virtual + * events, specifies the Tk_Uid of the + * virtual event name (never 0). */ +} Pattern; + +typedef struct { + const char *name; /* Name of modifier. */ + int mask; /* Button/modifier mask value, such as + * Button1Mask. */ + int flags; /* Various flags; see below for + * definitions. */ +} EventModifier; + +/* + * Flags for EventModifier structures: + * + * DOUBLE - Non-zero means duplicate this event, + * e.g. for double-clicks. + * TRIPLE - Non-zero means triplicate this event, + * e.g. for triple-clicks. + * QUADRUPLE - Non-zero means quadruple this event, + * e.g. for 4-fold-clicks. + * MULT_CLICKS - Combination of all of above. + */ + +#define DOUBLE (1<<0) +#define TRIPLE (1<<1) +#define QUADRUPLE (1<<2) +#define MULT_CLICKS (DOUBLE|TRIPLE|QUADRUPLE) + +#define META_MASK (AnyModifier<<1) +#define ALT_MASK (AnyModifier<<2) + +static EventModifier eventModifiers[] = { + {"Alt", ALT_MASK, 0}, + {"Any", 0, 0}, /* Ignored: historical relic. */ + {"B1", Button1Mask, 0}, + {"B2", Button2Mask, 0}, + {"B3", Button3Mask, 0}, + {"B4", Button4Mask, 0}, + {"B5", Button5Mask, 0}, + {"Button1", Button1Mask, 0}, + {"Button2", Button2Mask, 0}, + {"Button3", Button3Mask, 0}, + {"Button4", Button4Mask, 0}, + {"Button5", Button5Mask, 0}, + {"Command", Mod1Mask, 0}, + {"Control", ControlMask, 0}, + {"Double", 0, DOUBLE}, + {"Lock", LockMask, 0}, + {"M", META_MASK, 0}, + {"M1", Mod1Mask, 0}, + {"M2", Mod2Mask, 0}, + {"M3", Mod3Mask, 0}, + {"M4", Mod4Mask, 0}, + {"M5", Mod5Mask, 0}, + {"Meta", META_MASK, 0}, + {"Mod1", Mod1Mask, 0}, + {"Mod2", Mod2Mask, 0}, + {"Mod3", Mod3Mask, 0}, + {"Mod4", Mod4Mask, 0}, + {"Mod5", Mod5Mask, 0}, + {"Option", Mod2Mask, 0}, + {"Quadruple", 0, QUADRUPLE}, + {"Shift", ShiftMask, 0}, + {"Triple", 0, TRIPLE}, +}; + +typedef struct { + const char *name; /* Name of event. */ + int type; /* Event type for X, such as + * ButtonPress. */ + int eventMask; /* Mask bits (for XSelectInput) + * for this event type. */ +} EventInfo; + +/* + * Note: some of the masks below are an OR-ed combination of + * several masks. This is necessary because X doesn't report + * up events unless you also ask for down events. Also, X + * doesn't report button state in motion events unless you've + * asked about button events. + */ + +static EventInfo events[] = { + {"Activate", ActivateNotify, ActivateMask}, + {"Button", ButtonPress, ButtonPressMask}, + {"ButtonPress", ButtonPress, ButtonPressMask}, + {"ButtonRelease", ButtonRelease, ButtonPressMask|ButtonReleaseMask}, + {"Circulate", CirculateNotify, StructureNotifyMask}, + {"CirculateRequest", CirculateRequest, SubstructureRedirectMask}, + {"Colormap", ColormapNotify, ColormapChangeMask}, + {"Configure", ConfigureNotify, StructureNotifyMask}, + {"ConfigureRequest", ConfigureRequest, SubstructureRedirectMask}, + {"Create", CreateNotify, SubstructureNotifyMask}, + {"Deactivate", DeactivateNotify, ActivateMask}, + {"Destroy", DestroyNotify, StructureNotifyMask}, + {"Enter", EnterNotify, EnterWindowMask}, + {"Expose", Expose, ExposureMask}, + {"FocusIn", FocusIn, FocusChangeMask}, + {"FocusOut", FocusOut, FocusChangeMask}, + {"Gravity", GravityNotify, StructureNotifyMask}, + {"Key", KeyPress, KeyPressMask}, + {"KeyPress", KeyPress, KeyPressMask}, + {"KeyRelease", KeyRelease, KeyPressMask|KeyReleaseMask}, + {"Leave", LeaveNotify, LeaveWindowMask}, + {"Map", MapNotify, StructureNotifyMask}, + {"MapRequest", MapRequest, SubstructureRedirectMask}, + {"Motion", MotionNotify, ButtonPressMask|PointerMotionMask}, + {"MouseWheel", MouseWheelEvent, MouseWheelMask}, + {"Property", PropertyNotify, PropertyChangeMask}, + {"Reparent", ReparentNotify, StructureNotifyMask}, + {"ResizeRequest", ResizeRequest, ResizeRedirectMask}, + {"Unmap", UnmapNotify, StructureNotifyMask}, + {"Visibility", VisibilityNotify, VisibilityChangeMask}, +}; + +/* + * The defines and table below are used to classify events into + * various groups. The reason for this is that logically identical + * fields (e.g. "state") appear at different places in different + * types of events. The classification masks can be used to figure + * out quickly where to extract information from events. + */ + +#define KEY 0x1 +#define BUTTON 0x2 +#define MOTION 0x4 +#define CROSSING 0x8 +#define FOCUS 0x10 +#define EXPOSE 0x20 +#define VISIBILITY 0x40 +#define CREATE 0x80 +#define DESTROY 0x100 +#define UNMAP 0x200 +#define MAP 0x400 +#define REPARENT 0x800 +#define CONFIG 0x1000 +#define GRAVITY 0x2000 +#define CIRC 0x4000 +#define PROP 0x8000 +#define COLORMAP 0x10000 +#define VIRTUAL 0x20000 +#define ACTIVATE 0x40000 +#define MAPREQ 0x80000 +#define CONFIGREQ 0x100000 +#define RESIZEREQ 0x200000 +#define CIRCREQ 0x400000 + +#define KEY_BUTTON_MOTION_VIRTUAL (KEY|BUTTON|MOTION|VIRTUAL) +#define KEY_BUTTON_MOTION_CROSSING (KEY|BUTTON|MOTION|CROSSING|VIRTUAL) + +static int flagArray[TK_LASTEVENT+1] = { + /* Not used */ 0, + /* Not used */ 0, + /* KeyPress */ KEY, + /* KeyRelease */ KEY, + /* ButtonPress */ BUTTON, + /* ButtonRelease */ BUTTON, + /* MotionNotify */ MOTION, + /* EnterNotify */ CROSSING, + /* LeaveNotify */ CROSSING, + /* FocusIn */ FOCUS, + /* FocusOut */ FOCUS, + /* KeymapNotify */ 0, + /* Expose */ EXPOSE, + /* GraphicsExpose */ EXPOSE, + /* NoExpose */ 0, + /* VisibilityNotify */ VISIBILITY, + /* CreateNotify */ CREATE, + /* DestroyNotify */ DESTROY, + /* UnmapNotify */ UNMAP, + /* MapNotify */ MAP, + /* MapRequest */ MAPREQ, + /* ReparentNotify */ REPARENT, + /* ConfigureNotify */ CONFIG, + /* ConfigureRequest */ CONFIGREQ, + /* GravityNotify */ GRAVITY, + /* ResizeRequest */ RESIZEREQ, + /* CirculateNotify */ CIRC, + /* CirculateRequest */ 0, + /* PropertyNotify */ PROP, + /* SelectionClear */ 0, + /* SelectionRequest */ 0, + /* SelectionNotify */ 0, + /* ColormapNotify */ COLORMAP, + /* ClientMessage */ 0, + /* MappingNotify */ 0, +#ifdef GenericEvent + /* GenericEvent */ 0, +#endif + /* VirtualEvent */ VIRTUAL, + /* Activate */ ACTIVATE, + /* Deactivate */ ACTIVATE, + /* MouseWheel */ KEY +}; + + +static EventModifier * +FindModifier(const char *string) +{ + int high, low; + char c; + + low = 0; + high = (sizeof(eventModifiers) / sizeof(EventModifier)) - 1; + c = string[0]; + while (low <= high) { + EventModifier *modPtr; + int compare; + int median; + + median = (low + high) >> 1; + modPtr = eventModifiers + median; + + /* Test the first character */ + compare = c - modPtr->name[0]; + if (compare == 0) { + compare = strcmp(string, modPtr->name); + } + if (compare < 0) { + high = median - 1; + } else if (compare > 0) { + low = median + 1; + } else { + return modPtr; /* Modifier found. */ + } + } + return NULL; /* Can't find modifier */ +} + +static EventInfo * +FindEvent(const char *string) +{ + int high, low; + char c; + + low = 0; + high = (sizeof(events) / sizeof(EventInfo)) - 1; + c = string[0]; + while (low <= high) { + EventInfo *infoPtr; + int compare; + int median; + + median = (low + high) >> 1; + infoPtr = events + median; + + /* Test the first character */ + compare = c - infoPtr->name[0]; + if (compare == 0) { + compare = strcmp(string, infoPtr->name); + } + if (compare < 0) { + high = median - 1; + } else if (compare > 0) { + low = median + 1; + } else { + return infoPtr; /* Event found. */ + } + } + return NULL; /* Can't find event. */ +} + + +/* + *---------------------------------------------------------------------- + * + * GetField -- + * + * Used to parse pattern descriptions. Copies up to + * size characters from p to copy, stopping at end of + * string, space, "-", ">", or whenever size is + * exceeded. + * + * Results: + * The return value is a pointer to the character just + * after the last one copied (usually "-" or space or + * ">", but could be anything if size was exceeded). + * Also places NULL-terminated string (up to size + * character, including NULL), at copy. + * + * Side effects: + * None. + * + *---------------------------------------------------------------------- + */ + +static char * +GetField(p, copy, size) + char *p; /* Pointer to part of pattern. */ + char *copy; /* Place to copy field. */ + int size; /* Maximum number of characters to + * copy. */ +{ + while ((*p != '\0') && !isspace(UCHAR(*p)) && (*p != '>') + && (*p != '-') && (size > 1)) { + *copy = *p; + p++; + copy++; + size--; + } + *copy = '\0'; + return p; +} + +static int +ParseEventDescription(Tcl_Interp *interp, const char **eventStringPtr, + Pattern *patPtr, unsigned long *eventMaskPtr) +{ + char *p; + unsigned long eventMask; + int count, eventFlags; +#define FIELD_SIZE 48 + char field[FIELD_SIZE]; + EventInfo *infoPtr; + + Tcl_DString copy; + Tcl_DStringInit(©); + p = Tcl_DStringAppend(©, *eventStringPtr, -1); + + patPtr->eventType = -1; + patPtr->needMods = 0; + patPtr->detail.clientData = 0; + + eventMask = 0; + count = 1; + + /* + * Handle simple ASCII characters. + */ + + if (*p != '<') { + char string[2]; + + patPtr->eventType = KeyPress; + eventMask = KeyPressMask; + string[0] = *p; + string[1] = 0; + patPtr->detail.keySym = XStringToKeysym(string); + if (patPtr->detail.keySym == NoSymbol) { + if (isprint(UCHAR(*p))) { + patPtr->detail.keySym = *p; + } else { + char buf[64]; + + sprintf(buf, "bad ASCII character 0x%x", (unsigned char) *p); + Tcl_SetResult(interp, buf, TCL_VOLATILE); + count = 0; + goto done; + } + } + p++; + goto end; + } + + /* + * A physical event description consists of: + * + * 1. open angle bracket. + * 2. any number of modifiers, each followed by spaces + * or dashes. + * 3. an optional event name. + * 4. an option button or keysym name. Either this or + * item 3 *must* be present; if both are present + * then they are separated by spaces or dashes. + * 5. a close angle bracket. + */ + + p++; + + while (1) { + EventModifier *modPtr; + p = GetField(p, field, FIELD_SIZE); + if (*p == '>') { + /* + * This solves the problem of, e.g., <Control-M> being + * misinterpreted as Control + Meta + missing keysym + * instead of Control + KeyPress + M. + */ + break; + } + modPtr = FindModifier(field); + if (modPtr == NULL) { + break; + } + patPtr->needMods |= modPtr->mask; + if (modPtr->flags & (MULT_CLICKS)) { + int i = modPtr->flags & MULT_CLICKS; + count = 2; + while (i >>= 1) count++; + } + while ((*p == '-') || isspace(UCHAR(*p))) { + p++; + } + } + + eventFlags = 0; + infoPtr = FindEvent(field); + if (infoPtr != NULL) { + patPtr->eventType = infoPtr->type; + eventFlags = flagArray[infoPtr->type]; + eventMask = infoPtr->eventMask; + while ((*p == '-') || isspace(UCHAR(*p))) { + p++; + } + p = GetField(p, field, FIELD_SIZE); + } + if (*field != '\0') { + if ((*field >= '1') && (*field <= '5') && (field[1] == '\0')) { + if (eventFlags == 0) { + patPtr->eventType = ButtonPress; + eventMask = ButtonPressMask; + } else if (eventFlags & KEY) { + goto getKeysym; + } else if ((eventFlags & BUTTON) == 0) { + Tcl_AppendResult(interp, "specified button \"", field, + "\" for non-button event", (char *) NULL); + count = 0; + goto done; + } + patPtr->detail.button = (*field - '0'); + } else { + getKeysym: + patPtr->detail.keySym = XStringToKeysym(field); + if (patPtr->detail.keySym == NoSymbol) { + Tcl_AppendResult(interp, "bad event type or keysym \"", + field, "\"", (char *)NULL); + count = 0; + goto done; + } + if (eventFlags == 0) { + patPtr->eventType = KeyPress; + eventMask = KeyPressMask; + } else if ((eventFlags & KEY) == 0) { + Tcl_AppendResult(interp, "specified keysym \"", field, + "\" for non-key event", (char *)NULL); + count = 0; + goto done; + } + } + } else if (eventFlags == 0) { + Tcl_AppendResult(interp, "no event type or button # or keysym", + (char *)NULL); + count = 0; + goto done; + } + + while ((*p == '-') || isspace(UCHAR(*p))) { + p++; + } + if (*p != '>') { + while (*p != '\0') { + p++; + if (*p == '>') { + Tcl_AppendResult(interp, + "extra characters after detail in binding", + (char *)NULL); + count = 0; + goto done; + } + } + Tcl_AppendResult(interp, "missing \">\" in binding", (char *)NULL); + count = 0; + goto done; + } + p++; + +end: + *eventStringPtr += (p - Tcl_DStringValue(©)); + *eventMaskPtr |= eventMask; +done: + Tcl_DStringFree(©); + return count; +} + +typedef struct { + int numKey; /* Integer representation of a value. */ + const char *strKey; /* String representation of a value. */ +} TkStateMap; + +static TkStateMap notifyMode[] = { + {NotifyNormal, "NotifyNormal"}, + {NotifyGrab, "NotifyGrab"}, + {NotifyUngrab, "NotifyUngrab"}, + {NotifyWhileGrabbed, "NotifyWhileGrabbed"}, + {-1, NULL} +}; + +static TkStateMap notifyDetail[] = { + {NotifyAncestor, "NotifyAncestor"}, + {NotifyVirtual, "NotifyVirtual"}, + {NotifyInferior, "NotifyInferior"}, + {NotifyNonlinear, "NotifyNonlinear"}, + {NotifyNonlinearVirtual, "NotifyNonlinearVirtual"}, + {NotifyPointer, "NotifyPointer"}, + {NotifyPointerRoot, "NotifyPointerRoot"}, + {NotifyDetailNone, "NotifyDetailNone"}, + {-1, NULL} +}; + +static TkStateMap circPlace[] = { + {PlaceOnTop, "PlaceOnTop"}, + {PlaceOnBottom, "PlaceOnBottom"}, + {-1, NULL} +}; + +static TkStateMap visNotify[] = { + {VisibilityUnobscured, "VisibilityUnobscured"}, + {VisibilityPartiallyObscured, "VisibilityPartiallyObscured"}, + {VisibilityFullyObscured, "VisibilityFullyObscured"}, + {-1, NULL} +}; + +static TkStateMap configureRequestDetail[] = { + {None, "None"}, + {Above, "Above"}, + {Below, "Below"}, + {BottomIf, "BottomIf"}, + {TopIf, "TopIf"}, + {Opposite, "Opposite"}, + {-1, NULL} +}; + +static TkStateMap propNotify[] = { + {PropertyNewValue, "NewValue"}, + {PropertyDelete, "Delete"}, + {-1, NULL} +}; + +/* + *--------------------------------------------------------------------------- + * + * HandleEventGenerate -- + * + * Helper function for the "event generate" command. Generate and + * process an XEvent, constructed from information parsed from the + * event description string and its optional arguments. + * + * argv[0] contains name of the target window. + * argv[1] contains pattern string for one event (e.g, <Control-v>). + * argv[2..argc-1] contains -field/option pairs for specifying + * additional detail in the generated event. + * + * Either virtual or physical events can be generated this way. + * The event description string must contain the specification + * for only one event. + * + * Results: + * None. + * + * Side effects: + * When constructing the event, + * event.xany.serial is filled with the current X serial number. + * event.xany.window is filled with the target window. + * event.xany.display is filled with the target window's display. + * Any other fields in eventPtr which are not specified by the pattern + * string or the optional arguments, are set to 0. + * + * The event may be handled sychronously or asynchronously, depending + * on the value specified by the optional "-when" option. The + * default setting is synchronous. + * + *--------------------------------------------------------------------------- + */ +static int +SendEventCmd(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + XEvent event; + CONST char *p; + char *name; + Window window; + Display *display; + Tk_Window tkwin; + int count, flags, synch, i, number, warp; + Tcl_QueuePosition pos; + Pattern pat; + unsigned long eventMask; + static CONST char *fieldStrings[] = { + "-when", "-above", "-borderwidth", "-button", + "-count", "-delta", "-detail", "-focus", + "-height", + "-keycode", "-keysym", "-mode", "-override", + "-place", "-root", "-rootx", "-rooty", + "-sendevent", "-serial", "-state", "-subwindow", + "-time", "-warp", "-width", "-window", + "-x", "-y", NULL + }; + enum field { + EVENT_WHEN, EVENT_ABOVE, EVENT_BORDER, EVENT_BUTTON, + EVENT_COUNT, EVENT_DELTA, EVENT_DETAIL, EVENT_FOCUS, + EVENT_HEIGHT, + EVENT_KEYCODE, EVENT_KEYSYM, EVENT_MODE, EVENT_OVERRIDE, + EVENT_PLACE, EVENT_ROOT, EVENT_ROOTX, EVENT_ROOTY, + EVENT_SEND, EVENT_SERIAL, EVENT_STATE, EVENT_SUBWINDOW, + EVENT_TIME, EVENT_WARP, EVENT_WIDTH, EVENT_WINDOW, + EVENT_X, EVENT_Y + }; + tkwin = Tk_MainWindow(interp); + if (Blt_GetWindowFromObj(interp, objv[1], &window) != TCL_OK) { + return TCL_ERROR; + } + name = Tcl_GetStringFromObj(objv[2], NULL); + + display = Tk_Display(tkwin); + p = name; + eventMask = 0; + count = ParseEventDescription(interp, &p, &pat, &eventMask); + if (count == 0) { + return TCL_ERROR; + } + if (count != 1) { + Tcl_AppendResult(interp, "Double or Triple modifier not allowed", + (char *)NULL); + return TCL_ERROR; + } + if (*p != '\0') { + Tcl_AppendResult(interp, "only one event specification allowed", + (char *)NULL); + return TCL_ERROR; + } + + memset((VOID *) &event, 0, sizeof(event)); + event.xany.type = pat.eventType; + event.xany.serial = NextRequest(display); + event.xany.send_event = False; + event.xany.window = window; + event.xany.display = display; + + flags = flagArray[event.xany.type]; + if (flags & DESTROY) { + /* + * Event DestroyNotify should be generated by destroying + * the window. + */ + XDestroyWindow(display, window); + return TCL_OK; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL)) { + event.xkey.state = pat.needMods; + if ((flags & KEY) && (event.xany.type != MouseWheelEvent)) { + TkpSetKeycodeAndState(tkwin, pat.detail.keySym, &event); + } else if (flags & BUTTON) { + event.xbutton.button = pat.detail.button; + } else if (flags & VIRTUAL) { + ((XVirtualEvent *) &event)->name = pat.detail.name; + } + } + if (flags & (CREATE|UNMAP|MAP|REPARENT|CONFIG|GRAVITY|CIRC)) { + event.xcreatewindow.window = event.xany.window; + } + + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + event.xkey.x_root = -1; + event.xkey.y_root = -1; + } + + /* + * Process the remaining arguments to fill in additional fields + * of the event. + */ + + synch = 1; + warp = 0; + pos = TCL_QUEUE_TAIL; + for (i = 3; i < objc; i += 2) { + Tcl_Obj *optionPtr, *valuePtr; + int index; + + optionPtr = objv[i]; + valuePtr = objv[i + 1]; + + if (Tcl_GetIndexFromObj(interp, optionPtr, fieldStrings, "option", + TCL_EXACT, &index) != TCL_OK) { + return TCL_ERROR; + } + if ((objc & 1) == 0) { + /* + * This test occurs after Tcl_GetIndexFromObj() so that + * "event generate <Button> -xyz" will return the error message + * that "-xyz" is a bad option, rather than that the value + * for "-xyz" is missing. + */ + + Tcl_AppendResult(interp, "value for \"", + Tcl_GetStringFromObj(optionPtr, NULL), "\" missing", + (char *)NULL); + return TCL_ERROR; + } + + switch ((enum field) index) { + case EVENT_WARP: { + if (Tcl_GetBooleanFromObj(interp, valuePtr, &warp) != TCL_OK) { + return TCL_ERROR; + } + if (!(flags & (KEY_BUTTON_MOTION_VIRTUAL))) { + goto badopt; + } + break; + } + case EVENT_WHEN: { +#ifdef notdef + pos = (Tcl_QueuePosition) TkFindStateNumObj(interp, optionPtr, + queuePosition, valuePtr); + if ((int) pos < -1) { + return TCL_ERROR; + } + synch = 0; + if ((int) pos == -1) { + synch = 1; + } +#endif + break; + } + case EVENT_ABOVE: { + Window window2; + + if (Blt_GetWindowFromObj(interp, valuePtr, &window2) != TCL_OK) { + return TCL_ERROR; + } + if (flags & CONFIG) { + event.xconfigure.above = window2; + } else { + goto badopt; + } + break; + } + case EVENT_BORDER: { + if (Tk_GetPixelsFromObj(interp, tkwin, valuePtr, &number)!=TCL_OK) { + return TCL_ERROR; + } + if (flags & (CREATE|CONFIG)) { + event.xcreatewindow.border_width = number; + } else { + goto badopt; + } + break; + } + case EVENT_BUTTON: { + if (Tcl_GetIntFromObj(interp, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if (flags & BUTTON) { + event.xbutton.button = number; + } else { + goto badopt; + } + break; + } + case EVENT_COUNT: { + if (Tcl_GetIntFromObj(interp, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if (flags & EXPOSE) { + event.xexpose.count = number; + } else { + goto badopt; + } + break; + } + case EVENT_DELTA: { + if (Tcl_GetIntFromObj(interp, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if ((flags & KEY) && (event.xkey.type == MouseWheelEvent)) { + event.xkey.keycode = number; + } else { + goto badopt; + } + break; + } + case EVENT_DETAIL: { + number = TkFindStateNumObj(interp, optionPtr, notifyDetail, + valuePtr); + if (number < 0) { + return TCL_ERROR; + } + if (flags & FOCUS) { + event.xfocus.detail = number; + } else if (flags & CROSSING) { + event.xcrossing.detail = number; + } else { + goto badopt; + } + break; + } + case EVENT_FOCUS: { + if (Tcl_GetBooleanFromObj(interp, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if (flags & CROSSING) { + event.xcrossing.focus = number; + } else { + goto badopt; + } + break; + } + case EVENT_HEIGHT: { + if (Tk_GetPixelsFromObj(interp, tkwin, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if (flags & EXPOSE) { + event.xexpose.height = number; + } else if (flags & CONFIG) { + event.xconfigure.height = number; + } else { + goto badopt; + } + break; + } + case EVENT_KEYCODE: { + if (Tcl_GetIntFromObj(interp, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if ((flags & KEY) && (event.xkey.type != MouseWheelEvent)) { + event.xkey.keycode = number; + } else { + goto badopt; + } + break; + } + case EVENT_KEYSYM: { + KeySym keysym; + char *value; + + value = Tcl_GetStringFromObj(valuePtr, NULL); + keysym = TkStringToKeysym(value); + if (keysym == NoSymbol) { + Tcl_AppendResult(interp, "unknown keysym \"", value, "\"", + (char *)NULL); + return TCL_ERROR; + } + + TkpSetKeycodeAndState(tkwin, keysym, &event); + if (event.xkey.keycode == 0) { + Tcl_AppendResult(interp, "no keycode for keysym \"", value, + "\"", (char *)NULL); + return TCL_ERROR; + } + if (!(flags & KEY) || (event.xkey.type == MouseWheelEvent)) { + goto badopt; + } + break; + } + case EVENT_MODE: { + number = TkFindStateNumObj(interp, optionPtr, notifyMode, + valuePtr); + if (number < 0) { + return TCL_ERROR; + } + if (flags & CROSSING) { + event.xcrossing.mode = number; + } else if (flags & FOCUS) { + event.xfocus.mode = number; + } else { + goto badopt; + } + break; + } + case EVENT_OVERRIDE: { + if (Tcl_GetBooleanFromObj(interp, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if (flags & CREATE) { + event.xcreatewindow.override_redirect = number; + } else if (flags & MAP) { + event.xmap.override_redirect = number; + } else if (flags & REPARENT) { + event.xreparent.override_redirect = number; + } else if (flags & CONFIG) { + event.xconfigure.override_redirect = number; + } else { + goto badopt; + } + break; + } + case EVENT_PLACE: { + number = TkFindStateNumObj(interp, optionPtr, circPlace, + valuePtr); + if (number < 0) { + return TCL_ERROR; + } + if (flags & CIRC) { + event.xcirculate.place = number; + } else { + goto badopt; + } + break; + } + case EVENT_ROOT: { + Window window2; + + if (Blt_GetWindowFromObj(interp, valuePtr, &window2) != TCL_OK) { + return TCL_ERROR; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + event.xkey.root = window2; + } else { + goto badopt; + } + break; + } + case EVENT_ROOTX: { + if (Tk_GetPixelsFromObj(interp, tkwin, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + event.xkey.x_root = number; + } else { + goto badopt; + } + break; + } + case EVENT_ROOTY: { + if (Tk_GetPixelsFromObj(interp, tkwin, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + event.xkey.y_root = number; + } else { + goto badopt; + } + break; + } + case EVENT_SEND: { + CONST char *value; + + value = Tcl_GetStringFromObj(valuePtr, NULL); + if (isdigit(UCHAR(value[0]))) { + /* + * Allow arbitrary integer values for the field; they + * are needed by a few of the tests in the Tk test suite. + */ + + if (Tcl_GetIntFromObj(interp, valuePtr, &number) + != TCL_OK) { + return TCL_ERROR; + } + } else { + if (Tcl_GetBooleanFromObj(interp, valuePtr, &number) + != TCL_OK) { + return TCL_ERROR; + } + } + event.xany.send_event = number; + break; + } + case EVENT_SERIAL: { + if (Tcl_GetIntFromObj(interp, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + event.xany.serial = number; + break; + } + case EVENT_STATE: { + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + if (Tcl_GetIntFromObj(interp, valuePtr, &number) + != TCL_OK) { + return TCL_ERROR; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL)) { + event.xkey.state = number; + } else { + event.xcrossing.state = number; + } + } else if (flags & VISIBILITY) { + number = TkFindStateNumObj(interp, optionPtr, visNotify, + valuePtr); + if (number < 0) { + return TCL_ERROR; + } + event.xvisibility.state = number; + } else { + goto badopt; + } + break; + } + case EVENT_SUBWINDOW: { + Window window2; + + if (Blt_GetWindowFromObj(interp, valuePtr, &window2) != TCL_OK) { + return TCL_ERROR; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + event.xkey.subwindow = window2; + } else { + goto badopt; + } + break; + } + case EVENT_TIME: { + if (Tcl_GetIntFromObj(interp, valuePtr, &number) != TCL_OK) { + return TCL_ERROR; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + event.xkey.time = (Time) number; + } else if (flags & PROP) { + event.xproperty.time = (Time) number; + } else { + goto badopt; + } + break; + } + case EVENT_WIDTH: { + if (Tk_GetPixelsFromObj(interp, tkwin, valuePtr, &number) + != TCL_OK) { + return TCL_ERROR; + } + if (flags & EXPOSE) { + event.xexpose.width = number; + } else if (flags & (CREATE|CONFIG)) { + event.xcreatewindow.width = number; + } else { + goto badopt; + } + break; + } + case EVENT_WINDOW: { + Window window2; + + if (Blt_GetWindowFromObj(interp, valuePtr, &window2) != TCL_OK) { + return TCL_ERROR; + } + if (flags & (CREATE|UNMAP|MAP|REPARENT|CONFIG + |GRAVITY|CIRC)) { + event.xcreatewindow.window = window2; + } else { + goto badopt; + } + break; + } + case EVENT_X: { + if (Tk_GetPixelsFromObj(interp, tkwin, valuePtr, &number) + != TCL_OK) { + return TCL_ERROR; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + event.xkey.x = number; + /* + * Only modify rootx as well if it hasn't been changed. + */ + if (event.xkey.x_root == -1) { + int rootX, rootY; + + Tk_GetRootCoords(tkwin, &rootX, &rootY); + event.xkey.x_root = rootX + number; + } + } else if (flags & EXPOSE) { + event.xexpose.x = number; + } else if (flags & (CREATE|CONFIG|GRAVITY)) { + event.xcreatewindow.x = number; + } else if (flags & REPARENT) { + event.xreparent.x = number; + } else { + goto badopt; + } + break; + } + case EVENT_Y: { + if (Tk_GetPixelsFromObj(interp, tkwin, valuePtr, &number) + != TCL_OK) { + return TCL_ERROR; + } + if (flags & (KEY_BUTTON_MOTION_VIRTUAL|CROSSING)) { + event.xkey.y = number; + /* + * Only modify rooty as well if it hasn't been changed. + */ + if (event.xkey.y_root == -1) { + int rootX, rootY; + + Tk_GetRootCoords(tkwin, &rootX, &rootY); + event.xkey.y_root = rootY + number; + } + } else if (flags & EXPOSE) { + event.xexpose.y = number; + } else if (flags & (CREATE|CONFIG|GRAVITY)) { + event.xcreatewindow.y = number; + } else if (flags & REPARENT) { + event.xreparent.y = number; + } else { + goto badopt; + } + break; + } + } + continue; + + badopt: + Tcl_AppendResult(interp, name, " event doesn't accept \"", + Tcl_GetStringFromObj(optionPtr, NULL), "\" option", + (char *)NULL); + return TCL_ERROR; + } + if (!XSendEvent(display, window, False, pat.eventType, &event)) { + fprintf(stderr, "synthethic event failed\n"); + } + return TCL_OK; +} + +int +Blt_SendEventCmdInitProc(Tcl_Interp *interp) +{ + static Blt_InitCmdSpec cmdSpec = { + "sendevent", SendEventCmd, + }; + return Blt_InitCmd(interp, "::blt", &cmdSpec); +} diff --git a/src/bltGrBind.h b/src/bltGrBind.h new file mode 100644 index 0000000..2e2c5cb --- /dev/null +++ b/src/bltGrBind.h @@ -0,0 +1,120 @@ +/* + * bltBind.h -- + * + * Copyright 1998-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_BIND_H +#define _BLT_BIND_H + +#include <bltList.h> + +typedef struct _Blt_BindTable *Blt_BindTable; + +typedef ClientData (Blt_BindPickProc)(ClientData clientData, int x, int y, + ClientData *contextPtr); + +typedef void (Blt_BindTagProc)(Blt_BindTable bindTable, ClientData object, + ClientData context, Blt_List list); + + +/* + * Binding structure information: + */ + +struct _Blt_BindTable { + unsigned int flags; + Tk_BindingTable bindingTable; + /* Table of all bindings currently defined. + * NULL means that no bindings exist, so the + * table hasn't been created. Each "object" + * used for this table is either a Tk_Uid for + * a tag or the address of an item named by + * id. */ + + ClientData currentItem; /* The item currently containing the mouse + * pointer, or NULL if none. */ + ClientData currentContext; /* One word indicating what kind of object was + * picked. */ + + ClientData newItem; /* The item that is about to become the + * current one, or NULL. This field is used + * to detect deletions of the new current item + * pointer that occur during Leave processing + * of the previous current tab. */ + ClientData newContext; /* One-word indicating what kind of object was + * just picked. */ + + ClientData focusItem; + ClientData focusContext; + + XEvent pickEvent; /* The event upon which the current choice of + * the current tab is based. Must be saved so + * that if the current item is deleted, we can + * pick another. */ + int activePick; /* The pick event has been initialized so that + * we can repick it */ + + int state; /* Last known modifier state. Used to defer + * picking a new current object while buttons + * are down. */ + + ClientData clientData; + Tk_Window tkwin; + Blt_BindPickProc *pickProc; /* Routine to report the item the mouse is + * currently over. */ + Blt_BindTagProc *tagProc; /* Routine to report tags picked items. */ +}; + +BLT_EXTERN void Blt_DestroyBindingTable(Blt_BindTable table); + +BLT_EXTERN Blt_BindTable Blt_CreateBindingTable(Tcl_Interp *interp, + Tk_Window tkwin, ClientData clientData, Blt_BindPickProc *pickProc, + Blt_BindTagProc *tagProc); + +BLT_EXTERN int Blt_ConfigureBindings(Tcl_Interp *interp, Blt_BindTable table, + ClientData item, int argc, const char **argv); + +BLT_EXTERN int Blt_ConfigureBindingsFromObj(Tcl_Interp *interp, + Blt_BindTable table, ClientData item, int objc, Tcl_Obj *const *objv); + +BLT_EXTERN void Blt_PickCurrentItem(Blt_BindTable table); + +BLT_EXTERN void Blt_DeleteBindings(Blt_BindTable table, ClientData object); + +BLT_EXTERN void Blt_MoveBindingTable(Blt_BindTable table, Tk_Window tkwin); + +#define Blt_SetFocusItem(bindPtr, object, context) \ + ((bindPtr)->focusItem = (ClientData)(object),\ + (bindPtr)->focusContext = (ClientData)(context)) + +#define Blt_SetCurrentItem(bindPtr, object, context) \ + ((bindPtr)->currentItem = (ClientData)(object),\ + (bindPtr)->currentContext = (ClientData)(context)) + +#define Blt_GetCurrentItem(bindPtr) ((bindPtr)->currentItem) +#define Blt_GetCurrentContext(bindPtr) ((bindPtr)->currentContext) +#define Blt_GetLatestItem(bindPtr) ((bindPtr)->newItem) + +#define Blt_GetBindingData(bindPtr) ((bindPtr)->clientData) + +#endif /*_BLT_BIND_H*/ diff --git a/src/bltGrElemBar.C b/src/bltGrElemBar.C new file mode 100644 index 0000000..328275a --- /dev/null +++ b/src/bltGrElemBar.C @@ -0,0 +1,2543 @@ + +/* + * bltGrBar.c -- + * + * This module implements barchart elements for the BLT graph widget. + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include <X11/Xutil.h> + +#include "bltGrElem.h" + +#define CLAMP(x,l,h) ((x) = (((x)<(l))? (l) : ((x)>(h)) ? (h) : (x))) + +typedef struct { + float x1, y1, x2, y2; +} BarRegion; + +typedef struct { + Point2f ul, lr; + Segment2d segments[4]; + int nSegments; +} Bar; + +typedef struct { + const char *name; /* Pen style identifier. If NULL, pen + * was statically allocated. */ + ClassId classId; /* Type of pen */ + const char *typeId; /* String token identifying the type of + * pen */ + unsigned int flags; /* Indicates if the pen element is + * active or normal */ + int refCount; /* Reference count for elements using + * this pen. */ + Blt_HashEntry *hashPtr; + Blt_ConfigSpec *configSpecs; /* Configuration specifications */ + PenConfigureProc *configProc; + PenDestroyProc *destroyProc; + Graph *graphPtr; /* Graph that the pen is associated + * with. */ + /* Barchart specific pen fields start here. */ + XColor *outlineColor; /* Outline (foreground) color of bar */ + Blt_Background fill; /* 3D border and fill (background) + * color */ + int borderWidth; /* 3D border width of bar */ + int relief; /* Relief of the bar */ + Pixmap stipple; /* Stipple */ + GC fillGC; /* Graphics context */ + GC outlineGC; /* GC for outline of bar. */ + + /* Error bar attributes. */ + int errorBarShow; /* Describes which error bars to + * display: none, x, y, or * both. */ + + int errorBarLineWidth; /* Width of the error bar segments. */ + + int errorBarCapWidth; + XColor *errorBarColor; /* Color of the error bar. */ + + GC errorBarGC; /* Error bar graphics context. */ + + /* Show value attributes. */ + int valueShow; /* Indicates whether to display data + * value. Values are x, y, or none. */ + + const char *valueFormat; /* A printf format string. */ + TextStyle valueStyle; /* Text attributes (color, font, + * rotation, etc.) of the value. */ + +} BarPen; + +typedef struct { + Weight weight; /* Weight range where this pen is + * valid. */ + BarPen *penPtr; /* Pen to use. */ + + XRectangle *bars; /* Indicates starting location in bar + * array for this pen. */ + int nBars; /* # of bar segments for this pen. */ + + GraphSegments xeb, yeb; /* X and Y error bars. */ + + int symbolSize; /* Size of the pen's symbol scaled to + * the current graph size. */ + int errorBarCapWidth; /* Length of the cap ends on each error + * bar. */ + +} BarStyle; + +typedef struct { + GraphObj obj; /* Must be first field in element. */ + unsigned int flags; + Blt_HashEntry *hashPtr; + + /* Fields specific to elements. */ + const char *label; /* Label displayed in legend */ + unsigned short row, col; /* Position of the entry in the + * legend. */ + int legendRelief; /* Relief of label in legend. */ + Axis2d axes; /* X-axis and Y-axis mapping the + * element */ + ElemValues x, y, w; /* Contains array of floating point + * graph coordinate values. Also holds + * min/max and the number of + * coordinates */ + int *activeIndices; /* Array of indices (malloc-ed) which + * indicate which data points are active + * (drawn * with "active" colors). */ + int nActiveIndices; /* Number of active data points. + * Special case: if nActiveIndices < 0 + * and the active bit is set in "flags", + * then all data * points are drawn + * active. */ + ElementProcs *procsPtr; + Blt_ConfigSpec *configSpecs; /* Configuration specifications. */ + BarPen *activePenPtr; /* Standard Pens */ + BarPen *normalPenPtr; + BarPen *builtinPenPtr; + Blt_Chain stylePalette; /* Palette of pens. */ + + /* Symbol scaling */ + int scaleSymbols; /* If non-zero, the symbols will scale + * in size as the graph is zoomed + * in/out. */ + double xRange, yRange; /* Initial X-axis and Y-axis ranges: + * used to scale the size of element's + * symbol. */ + int state; + Blt_ChainLink link; + + /* Fields specific to the barchart element */ + + float barWidth; + const char *groupName; + + int *barToData; + XRectangle *bars; /* Array of rectangles comprising the bar + * segments of the element. */ + int *activeToData; + XRectangle *activeRects; + + int nBars; /* # of visible bar segments for + * element */ + int nActive; + + int xPad; /* Spacing on either side of bar */ + + ElemValues xError; /* Relative/symmetric X error values. */ + ElemValues yError; /* Relative/symmetric Y error values. */ + ElemValues xHigh, xLow; /* Absolute/asymmetric X-coordinate + * high/low error values. */ + ElemValues yHigh, yLow; /* Absolute/asymmetric Y-coordinate + * high/low error values. */ + BarPen builtinPen; + + GraphSegments xeb, yeb; + + int errorBarCapWidth; /* Length of cap on error bars */ +} BarElement; + +BLT_EXTERN Blt_CustomOption bltBarPenOption; +BLT_EXTERN Blt_CustomOption bltValuesOption; +BLT_EXTERN Blt_CustomOption bltValuePairsOption; +BLT_EXTERN Blt_CustomOption bltXAxisOption; +BLT_EXTERN Blt_CustomOption bltYAxisOption; +BLT_EXTERN Blt_CustomOption bltColorOption; +BLT_EXTERN Blt_CustomOption bltBarStylesOption; + +static Blt_OptionParseProc ObjToBarMode; +static Blt_OptionPrintProc BarModeToObj; +Blt_CustomOption bltBarModeOption = +{ + ObjToBarMode, BarModeToObj, NULL, (ClientData)0 +}; + +#define DEF_BAR_ACTIVE_PEN "activeBar" +#define DEF_BAR_AXIS_X "x" +#define DEF_BAR_AXIS_Y "y" +#define DEF_BAR_BACKGROUND "navyblue" +#define DEF_BAR_BORDERWIDTH "2" +#define DEF_BAR_ERRORBAR_COLOR "defcolor" +#define DEF_BAR_ERRORBAR_LINE_WIDTH "1" +#define DEF_BAR_ERRORBAR_CAP_WIDTH "1" +#define DEF_BAR_FOREGROUND "blue" +#define DEF_BAR_HIDE "no" +#define DEF_BAR_LABEL_RELIEF "flat" +#define DEF_BAR_NORMAL_STIPPLE "" +#define DEF_BAR_RELIEF "raised" +#define DEF_BAR_SHOW_ERRORBARS "both" +#define DEF_BAR_STATE "normal" +#define DEF_BAR_STACK (char *)NULL +#define DEF_BAR_STYLES "" +#define DEF_BAR_TAGS "all" +#define DEF_BAR_WIDTH "0.0" + +#define DEF_PEN_ACTIVE_BACKGROUND "red" +#define DEF_PEN_ACTIVE_FOREGROUND "pink" +#define DEF_PEN_BORDERWIDTH "2" +#define DEF_PEN_NORMAL_BACKGROUND "navyblue" +#define DEF_PEN_NORMAL_FOREGROUND "blue" +#define DEF_PEN_RELIEF "raised" +#define DEF_PEN_STIPPLE "" +#define DEF_PEN_TYPE "bar" +#define DEF_PEN_VALUE_ANCHOR "s" +#define DEF_PEN_VALUE_COLOR RGB_BLACK +#define DEF_PEN_VALUE_FONT STD_FONT_SMALL +#define DEF_PEN_VALUE_FORMAT "%g" +#define DEF_PEN_SHOW_VALUES "no" + +static Blt_ConfigSpec barPenConfigSpecs[] = +{ + {BLT_CONFIG_BACKGROUND, "-background", "background", "Background", + DEF_PEN_ACTIVE_BACKGROUND, Blt_Offset(BarPen, fill), + BLT_CONFIG_NULL_OK | ACTIVE_PEN}, + {BLT_CONFIG_BACKGROUND, "-background", "background", "Background", + DEF_PEN_NORMAL_BACKGROUND, Blt_Offset(BarPen, fill), + BLT_CONFIG_NULL_OK | NORMAL_PEN}, + {BLT_CONFIG_SYNONYM, "-bd", "borderWidth", (char *)NULL, + (char *)NULL, 0, ALL_PENS}, + {BLT_CONFIG_SYNONYM, "-bg", "background", (char *)NULL, + (char *)NULL, 0, ALL_PENS}, + {BLT_CONFIG_PIXELS_NNEG, "-borderwidth", "borderWidth", "BorderWidth", + DEF_PEN_BORDERWIDTH, Blt_Offset(BarPen, borderWidth), ALL_PENS}, + {BLT_CONFIG_CUSTOM, "-errorbarcolor", "errorBarColor", "ErrorBarColor", + DEF_BAR_ERRORBAR_COLOR, Blt_Offset(BarPen, errorBarColor), ALL_PENS, + &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG, "-errorbarwidth", "errorBarWidth","ErrorBarWidth", + DEF_BAR_ERRORBAR_LINE_WIDTH, Blt_Offset(BarPen, errorBarLineWidth), + ALL_PENS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-errorbarcap", "errorBarCap", "ErrorBarCap", + DEF_BAR_ERRORBAR_CAP_WIDTH, Blt_Offset(BarPen, errorBarCapWidth), + ALL_PENS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_SYNONYM, "-fg", "foreground", (char *)NULL, + (char *)NULL, 0, ALL_PENS}, + {BLT_CONFIG_SYNONYM, "-fill", "background", (char *)NULL, + (char *)NULL, 0, ALL_PENS}, + {BLT_CONFIG_COLOR, "-foreground", "foreground", "Foreground", + DEF_PEN_ACTIVE_FOREGROUND, Blt_Offset(BarPen, outlineColor), + ACTIVE_PEN | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-foreground", "foreground", "Foreground", + DEF_PEN_NORMAL_FOREGROUND, Blt_Offset(BarPen, outlineColor), + NORMAL_PEN | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-outline", "foreground", (char *)NULL, + (char *)NULL, 0, ALL_PENS}, + {BLT_CONFIG_RELIEF, "-relief", "relief", "Relief", + DEF_PEN_RELIEF, Blt_Offset(BarPen, relief), ALL_PENS}, + {BLT_CONFIG_FILL, "-showerrorbars", "showErrorBars", "ShowErrorBars", + DEF_BAR_SHOW_ERRORBARS, Blt_Offset(BarPen, errorBarShow), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FILL, "-showvalues", "showValues", "ShowValues", + DEF_PEN_SHOW_VALUES, Blt_Offset(BarPen, valueShow), + ALL_PENS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMAP, "-stipple", "stipple", "Stipple", DEF_PEN_STIPPLE, + Blt_Offset(BarPen, stipple), ALL_PENS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STRING, "-type", (char *)NULL, (char *)NULL, DEF_PEN_TYPE, + Blt_Offset(BarPen, typeId), ALL_PENS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_ANCHOR, "-valueanchor", "valueAnchor", "ValueAnchor", + DEF_PEN_VALUE_ANCHOR, Blt_Offset(BarPen, valueStyle.anchor), + ALL_PENS}, + {BLT_CONFIG_COLOR, "-valuecolor", "valueColor", "ValueColor", + DEF_PEN_VALUE_COLOR, Blt_Offset(BarPen, valueStyle.color), + ALL_PENS}, + {BLT_CONFIG_FONT, "-valuefont", "valueFont", "ValueFont", + DEF_PEN_VALUE_FONT, Blt_Offset(BarPen, valueStyle.font), + ALL_PENS}, + {BLT_CONFIG_STRING, "-valueformat", "valueFormat", "ValueFormat", + DEF_PEN_VALUE_FORMAT, Blt_Offset(BarPen, valueFormat), + ALL_PENS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_FLOAT, "-valuerotate", "valueRotate", "ValueRotate", + (char *)NULL, Blt_Offset(BarPen, valueStyle.angle), ALL_PENS}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + + +static Blt_ConfigSpec barElemConfigSpecs[] = { + {BLT_CONFIG_CUSTOM, "-activepen", "activePen", "ActivePen", + DEF_BAR_ACTIVE_PEN, Blt_Offset(BarElement, activePenPtr), + BLT_CONFIG_NULL_OK, &bltBarPenOption}, + {BLT_CONFIG_BACKGROUND, "-background", "background", "Background", + DEF_BAR_BACKGROUND, Blt_Offset(BarElement, builtinPen.fill), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_FLOAT, "-barwidth", "barWidth", "BarWidth", + DEF_BAR_WIDTH, Blt_Offset(BarElement, barWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_SYNONYM, "-bd", "borderWidth", (char *)NULL, + (char *)NULL, 0, 0}, + {BLT_CONFIG_SYNONYM, "-bg", "background", (char *)NULL, + (char *)NULL, 0, 0}, + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_BAR_TAGS, + Blt_Offset(BarElement, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_PIXELS_NNEG, "-borderwidth", "borderWidth", "BorderWidth", + DEF_BAR_BORDERWIDTH, Blt_Offset(BarElement, builtinPen.borderWidth), 0}, + {BLT_CONFIG_SYNONYM, "-color", "background", (char *)NULL, + (char *)NULL, 0, 0}, + {BLT_CONFIG_CUSTOM, "-errorbarcolor", "errorBarColor", "ErrorBarColor", + DEF_BAR_ERRORBAR_COLOR, + Blt_Offset(BarElement, builtinPen.errorBarColor), 0, &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG,"-errorbarwidth", "errorBarWidth", "ErrorBarWidth", + DEF_BAR_ERRORBAR_LINE_WIDTH, + Blt_Offset(BarElement, builtinPen.errorBarLineWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-errorbarcap", "errorBarCap", "ErrorBarCap", + DEF_BAR_ERRORBAR_CAP_WIDTH, + Blt_Offset(BarElement, builtinPen.errorBarCapWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_SYNONYM, "-fg", "foreground", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_CUSTOM, "-data", "data", "Data", (char *)NULL, 0, 0, + &bltValuePairsOption}, + {BLT_CONFIG_SYNONYM, "-fill", "background", (char *)NULL, + (char *)NULL, 0, 0}, + {BLT_CONFIG_COLOR, "-foreground", "foreground", "Foreground", + DEF_BAR_FOREGROUND, Blt_Offset(BarElement, builtinPen.outlineColor), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STRING, "-label", "label", "Label", (char *)NULL, + Blt_Offset(BarElement, label), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_RELIEF, "-legendrelief", "legendRelief", "LegendRelief", + DEF_BAR_LABEL_RELIEF, Blt_Offset(BarElement, legendRelief), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_BAR_HIDE, + Blt_Offset(BarElement, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", DEF_BAR_AXIS_X, + Blt_Offset(BarElement, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", DEF_BAR_AXIS_Y, + Blt_Offset(BarElement, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_SYNONYM, "-outline", "foreground", (char *)NULL, + (char *)NULL, 0, 0}, + {BLT_CONFIG_CUSTOM, "-pen", "pen", "Pen", (char *)NULL, + Blt_Offset(BarElement, normalPenPtr), BLT_CONFIG_NULL_OK, + &bltBarPenOption}, + {BLT_CONFIG_RELIEF, "-relief", "relief", "Relief", + DEF_BAR_RELIEF, Blt_Offset(BarElement, builtinPen.relief), 0}, + {BLT_CONFIG_FILL, "-showerrorbars", "showErrorBars", "ShowErrorBars", + DEF_BAR_SHOW_ERRORBARS, Blt_Offset(BarElement, builtinPen.errorBarShow), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FILL, "-showvalues", "showValues", "ShowValues", + DEF_PEN_SHOW_VALUES, Blt_Offset(BarElement, builtinPen.valueShow), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-stack", "stack", "Stack", DEF_BAR_STACK, + Blt_Offset(BarElement, groupName), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STATE, "-state", "state", "State", DEF_BAR_STATE, + Blt_Offset(BarElement, state), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMAP, "-stipple", "stipple", "Stipple", + DEF_BAR_NORMAL_STIPPLE, Blt_Offset(BarElement, builtinPen.stipple), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-styles", "styles", "Styles", DEF_BAR_STYLES, + Blt_Offset(BarElement, stylePalette), 0, &bltBarStylesOption}, + {BLT_CONFIG_ANCHOR, "-valueanchor", "valueAnchor", "ValueAnchor", + DEF_PEN_VALUE_ANCHOR, + Blt_Offset(BarElement, builtinPen.valueStyle.anchor), 0}, + {BLT_CONFIG_COLOR, "-valuecolor", "valueColor", "ValueColor", + DEF_PEN_VALUE_COLOR, + Blt_Offset(BarElement, builtinPen.valueStyle.color), 0}, + {BLT_CONFIG_FONT, "-valuefont", "valueFont", "ValueFont", + DEF_PEN_VALUE_FONT, + Blt_Offset(BarElement, builtinPen.valueStyle.font), 0}, + {BLT_CONFIG_STRING, "-valueformat", "valueFormat", "ValueFormat", + DEF_PEN_VALUE_FORMAT, Blt_Offset(BarElement, builtinPen.valueFormat), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_FLOAT, "-valuerotate", "valueRotate", "ValueRotate", + (char *)NULL, Blt_Offset(BarElement, builtinPen.valueStyle.angle), 0}, + {BLT_CONFIG_CUSTOM, "-weights", "weights", "Weights", (char *)NULL, + Blt_Offset(BarElement, w), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-x", "xdata", "Xdata", (char *)NULL, + Blt_Offset(BarElement, x), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-y", "ydata", "Ydata", (char *)NULL, + Blt_Offset(BarElement, y), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xdata", "xdata", "Xdata", (char *)NULL, + Blt_Offset(BarElement, x), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-ydata", "ydata", "Ydata", (char *)NULL, + Blt_Offset(BarElement, y), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xerror", "xError", "XError", (char *)NULL, + Blt_Offset(BarElement, xError), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xhigh", "xHigh", "XHigh", (char *)NULL, + Blt_Offset(BarElement, xHigh), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xlow", "xLow", "XLow", (char *)NULL, + Blt_Offset(BarElement, xLow), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-yerror", "yError", "YError", (char *)NULL, + Blt_Offset(BarElement, yError), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-yhigh", "yHigh", "YHigh", (char *)NULL, + Blt_Offset(BarElement, yHigh), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-ylow", "yLow", "YLow", (char *)NULL, + Blt_Offset(BarElement, yLow), 0, &bltValuesOption}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +/* Forward declarations */ +static PenConfigureProc ConfigureBarPenProc; +static PenDestroyProc DestroyBarPenProc; +static ElementClosestProc ClosestBarProc; +static ElementConfigProc ConfigureBarProc; +static ElementDestroyProc DestroyBarProc; +static ElementDrawProc DrawActiveBarProc; +static ElementDrawProc DrawNormalBarProc; +static ElementDrawSymbolProc DrawSymbolProc; +static ElementExtentsProc GetBarExtentsProc; +static ElementToPostScriptProc ActiveBarToPostScriptProc; +static ElementToPostScriptProc NormalBarToPostScriptProc; +static ElementSymbolToPostScriptProc SymbolToPostScriptProc; +static ElementMapProc MapBarProc; + +INLINE static int +Round(double x) +{ + return (int) (x + ((x < 0.0) ? -0.5 : 0.5)); +} + +/* + *--------------------------------------------------------------------------- + * Custom option parse and print procedures + *--------------------------------------------------------------------------- + */ + +/* + *--------------------------------------------------------------------------- + * + * NameOfBarMode -- + * + * Converts the integer representing the mode style into a string. + * + *--------------------------------------------------------------------------- + */ +static const char * +NameOfBarMode(BarMode mode) +{ + switch (mode) { + case BARS_INFRONT: + return "infront"; + case BARS_OVERLAP: + return "overlap"; + case BARS_STACKED: + return "stacked"; + case BARS_ALIGNED: + return "aligned"; + default: + return "unknown mode value"; + } +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToMode -- + * + * Converts the mode string into its numeric representation. + * + * Valid mode strings are: + * + * "infront" Draw a full bar at each point in the element. + * + * "stacked" Stack bar segments vertically. Each stack is defined + * by each ordinate at a particular abscissa. The height + * of each segment is represented by the sum the previous + * ordinates. + * + * "aligned" Align bar segments as smaller slices one next to + * the other. Like "stacks", aligned segments are + * defined by each ordinate at a particular abscissa. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToBarMode( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back + * to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* Mode style string */ + char *widgRec, /* Cubicle structure record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + BarMode *modePtr = (BarMode *)(widgRec + offset); + int length; + char c; + char *string; + + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[0]; + if ((c == 'n') && (strncmp(string, "normal", length) == 0)) { + *modePtr = BARS_INFRONT; + } else if ((c == 'i') && (strncmp(string, "infront", length) == 0)) { + *modePtr = BARS_INFRONT; + } else if ((c == 's') && (strncmp(string, "stacked", length) == 0)) { + *modePtr = BARS_STACKED; + } else if ((c == 'a') && (strncmp(string, "aligned", length) == 0)) { + *modePtr = BARS_ALIGNED; + } else if ((c == 'o') && (strncmp(string, "overlap", length) == 0)) { + *modePtr = BARS_OVERLAP; + } else { + Tcl_AppendResult(interp, "bad mode argument \"", string, "\": should" + "be \"infront\", \"stacked\", \"overlap\", or \"aligned\"", + (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * BarModeToObj -- + * + * Returns the mode style string based upon the mode flags. + * + * Results: + * The mode style string is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +BarModeToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Row/column structure record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + BarMode mode = *(BarMode *)(widgRec + offset); + + return Tcl_NewStringObj(NameOfBarMode(mode), -1); +} + + +/* + * Zero out the style's number of bars and errorbars. + */ +static void +ResetStylePalette(Blt_Chain stylePalette) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(stylePalette); link != NULL; + link = Blt_Chain_NextLink(link)) { + BarStyle *stylePtr; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->xeb.length = stylePtr->yeb.length = 0; + stylePtr->nBars = 0; + } +} + +static int +ConfigureBarPen(Graph *graphPtr, BarPen *penPtr) +{ + XGCValues gcValues; + unsigned long gcMask; + GC newGC; + long defColor; + int screenNum; + + screenNum = Tk_ScreenNumber(graphPtr->tkwin); + gcMask = GCForeground | GCLineWidth; + gcValues.line_width = LineWidth(penPtr->errorBarLineWidth); + + if (penPtr->outlineColor != NULL) { + defColor = penPtr->outlineColor->pixel; + gcValues.foreground = penPtr->outlineColor->pixel; + } else if (penPtr->fill != NULL) { + defColor = Blt_BackgroundBorderColor(penPtr->fill)->pixel; + gcValues.foreground = defColor; + } else { + defColor = BlackPixel(graphPtr->display, screenNum); + } + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (penPtr->outlineGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->outlineGC); + } + penPtr->outlineGC = newGC; + + newGC = NULL; + if (penPtr->stipple != None) { + /* Handle old-style -stipple specially. */ + gcMask = GCForeground | GCBackground | GCFillStyle | GCStipple; + gcValues.foreground = BlackPixel(graphPtr->display, screenNum); + gcValues.background = WhitePixel(graphPtr->display, screenNum); + if (penPtr->fill != NULL) { + gcValues.foreground = + Blt_BackgroundBorderColor(penPtr->fill)->pixel; + } else if (penPtr->outlineColor != NULL) { + gcValues.foreground = penPtr->outlineColor->pixel; + } + gcValues.stipple = penPtr->stipple; + gcValues.fill_style = FillStippled; + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + } + if (penPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->fillGC); + } + penPtr->fillGC = newGC; + + gcMask = GCForeground | GCLineWidth; + if (penPtr->errorBarColor == COLOR_DEFAULT) { + gcValues.foreground = defColor; + } else { + gcValues.foreground = penPtr->errorBarColor->pixel; + } + gcValues.line_width = LineWidth(penPtr->errorBarLineWidth); + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (penPtr->errorBarGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->errorBarGC); + } + penPtr->errorBarGC = newGC; + return TCL_OK; +} + +static void +DestroyBarPen(Graph *graphPtr, BarPen *penPtr) +{ + Blt_Ts_FreeStyle(graphPtr->display, &penPtr->valueStyle); + if (penPtr->outlineGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->outlineGC); + } + if (penPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->fillGC); + } + if (penPtr->errorBarGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->errorBarGC); + } +} + +static int +ConfigureBarPenProc(Graph *graphPtr, Pen *basePtr) +{ + return ConfigureBarPen(graphPtr, (BarPen *)basePtr); +} + +static void +DestroyBarPenProc(Graph *graphPtr, Pen *basePtr) +{ + DestroyBarPen(graphPtr, (BarPen *)basePtr); +} + + +static void +InitializeBarPen(BarPen *penPtr) +{ + /* Generic fields common to all pen types. */ + penPtr->configProc = ConfigureBarPenProc; + penPtr->destroyProc = DestroyBarPenProc; + penPtr->flags = NORMAL_PEN; + penPtr->configSpecs = barPenConfigSpecs; + + /* Initialize fields specific to bar pens. */ + Blt_Ts_InitStyle(penPtr->valueStyle); + penPtr->relief = TK_RELIEF_RAISED; + penPtr->valueShow = SHOW_NONE; + penPtr->borderWidth = 2; + penPtr->errorBarShow = SHOW_BOTH; +} + +Pen * +Blt_BarPen(const char *penName) +{ + BarPen *penPtr; + + penPtr = Blt_AssertCalloc(1, sizeof(BarPen)); + InitializeBarPen(penPtr); + penPtr->name = Blt_AssertStrdup(penName); + if (strcmp(penName, "activeBar") == 0) { + penPtr->flags = ACTIVE_PEN; + } + return (Pen *)penPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * CheckBarStacks -- + * + * Check that the data limits are not superseded by the heights of + * stacked bar segments. The heights are calculated by + * Blt_ComputeStacks. + * + * Results: + * If the y-axis limits need to be adjusted for stacked segments, + * *minPtr* or *maxPtr* are updated. + * + * Side effects: + * Autoscaling of the y-axis is affected. + * + *--------------------------------------------------------------------------- + */ +static void +CheckBarStacks(Graph *graphPtr, Axis2d *pairPtr, double *minPtr, double *maxPtr) +{ + BarGroup *gp, *gend; + + if ((graphPtr->mode != BARS_STACKED) || (graphPtr->nBarGroups == 0)) { + return; + } + for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; gp < gend; + gp++) { + if ((gp->axes.x == pairPtr->x) && (gp->axes.y == pairPtr->y)) { + /* + * Check if any of the y-values (because of stacking) are greater + * than the current limits of the graph. + */ + if (gp->sum < 0.0f) { + if (*minPtr > gp->sum) { + *minPtr = gp->sum; + } + } else { + if (*maxPtr < gp->sum) { + *maxPtr = gp->sum; + } + } + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureBarProc -- + * + * Sets up the appropriate configuration parameters in the GC. It is + * assumed the parameters have been previously set by a call to + * Blt_ConfigureWidget. + * + * Results: + * The return value is a standard TCL result. If TCL_ERROR is returned, + * then interp->result contains an error message. + * + * Side effects: + * Configuration information such as bar foreground/background color and + * stipple etc. get set in a new GC. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ConfigureBarProc(Graph *graphPtr, Element *basePtr) +{ + BarElement *elemPtr = (BarElement *)basePtr; + Blt_ChainLink link; + BarStyle *stylePtr; + + if (ConfigureBarPen(graphPtr, elemPtr->builtinPenPtr)!= TCL_OK) { + return TCL_ERROR; + } + /* + * Point to the static normal pen if no external pens have been selected. + */ + link = Blt_Chain_FirstLink(elemPtr->stylePalette); + if (link == NULL) { + link = Blt_Chain_AllocLink(sizeof(BarStyle)); + Blt_Chain_LinkAfter(elemPtr->stylePalette, link, NULL); + } + stylePtr = Blt_Chain_GetValue(link); + stylePtr->penPtr = NORMALPEN(elemPtr); + + if (Blt_ConfigModified(elemPtr->configSpecs, "-barwidth", "-*data", + "-map*", "-label", "-hide", "-x", "-y", (char *)NULL)) { + elemPtr->flags |= MAP_ITEM; + } + return TCL_OK; +} + +static void +GetBarExtentsProc(Element *basePtr, Region2d *regPtr) +{ + BarElement *elemPtr = (BarElement *)basePtr; + Graph *graphPtr; + double middle, barWidth; + int nPoints; + + graphPtr = elemPtr->obj.graphPtr; + regPtr->top = regPtr->left = DBL_MAX; + regPtr->bottom = regPtr->right = -DBL_MAX; + + nPoints = NUMBEROFPOINTS(elemPtr); + if (nPoints < 1) { + return; /* No data points */ + } + barWidth = graphPtr->barWidth; + if (elemPtr->barWidth > 0.0f) { + barWidth = elemPtr->barWidth; + } + middle = 0.5; + regPtr->left = elemPtr->x.min - middle; + regPtr->right = elemPtr->x.max + middle; + + regPtr->top = elemPtr->y.min; + regPtr->bottom = elemPtr->y.max; + if (regPtr->bottom < graphPtr->baseline) { + regPtr->bottom = graphPtr->baseline; + } + /* + * Handle stacked bar elements specially. + * + * If element is stacked, the sum of its ordinates may be outside the + * minimum/maximum limits of the element's data points. + */ + if ((graphPtr->mode == BARS_STACKED) && (graphPtr->nBarGroups > 0)) { + CheckBarStacks(graphPtr, &elemPtr->axes, ®Ptr->top, ®Ptr->bottom); + } + /* Warning: You get what you deserve if the x-axis is logScale */ + if (elemPtr->axes.x->logScale) { + regPtr->left = Blt_FindElemValuesMinimum(&elemPtr->x, DBL_MIN) + + middle; + } + /* Fix y-min limits for barchart */ + if (elemPtr->axes.y->logScale) { + if ((regPtr->top <= 0.0) || (regPtr->top > 1.0)) { + regPtr->top = 1.0; + } + } else { + if (regPtr->top > 0.0) { + regPtr->top = 0.0; + } + } + /* Correct the extents for error bars if they exist. */ + if (elemPtr->xError.nValues > 0) { + int i; + + /* Correct the data limits for error bars */ + nPoints = MIN(elemPtr->xError.nValues, nPoints); + for (i = 0; i < nPoints; i++) { + double x; + + x = elemPtr->x.values[i] + elemPtr->xError.values[i]; + if (x > regPtr->right) { + regPtr->right = x; + } + x = elemPtr->x.values[i] - elemPtr->xError.values[i]; + if (elemPtr->axes.x->logScale) { + if (x < 0.0) { + x = -x; /* Mirror negative values, instead of + * ignoring them. */ + } + if ((x > DBL_MIN) && (x < regPtr->left)) { + regPtr->left = x; + } + } else if (x < regPtr->left) { + regPtr->left = x; + } + } + } else { + if ((elemPtr->xHigh.nValues > 0) && + (elemPtr->xHigh.max > regPtr->right)) { + regPtr->right = elemPtr->xHigh.max; + } + if (elemPtr->xLow.nValues > 0) { + double left; + + if ((elemPtr->xLow.min <= 0.0) && + (elemPtr->axes.x->logScale)) { + left = Blt_FindElemValuesMinimum(&elemPtr->xLow, DBL_MIN); + } else { + left = elemPtr->xLow.min; + } + if (left < regPtr->left) { + regPtr->left = left; + } + } + } + if (elemPtr->yError.nValues > 0) { + int i; + + nPoints = MIN(elemPtr->yError.nValues, nPoints); + for (i = 0; i < nPoints; i++) { + double y; + + y = elemPtr->y.values[i] + elemPtr->yError.values[i]; + if (y > regPtr->bottom) { + regPtr->bottom = y; + } + y = elemPtr->y.values[i] - elemPtr->yError.values[i]; + if (elemPtr->axes.y->logScale) { + if (y < 0.0) { + y = -y; /* Mirror negative values, instead of + * ignoring them. */ + } + if ((y > DBL_MIN) && (y < regPtr->left)) { + regPtr->top = y; + } + } else if (y < regPtr->top) { + regPtr->top = y; + } + } + } else { + if ((elemPtr->yHigh.nValues > 0) && + (elemPtr->yHigh.max > regPtr->bottom)) { + regPtr->bottom = elemPtr->yHigh.max; + } + if (elemPtr->yLow.nValues > 0) { + double top; + + if ((elemPtr->yLow.min <= 0.0) && + (elemPtr->axes.y->logScale)) { + top = Blt_FindElemValuesMinimum(&elemPtr->yLow, DBL_MIN); + } else { + top = elemPtr->yLow.min; + } + if (top < regPtr->top) { + regPtr->top = top; + } + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * ClosestBar -- + * + * Find the bar segment closest to the window coordinates point + * specified. + * + * Note: This does not return the height of the stacked segment + * (in graph coordinates) properly. + * + * Results: + * Returns 1 if the point is width any bar segment, otherwise 0. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static void +ClosestBarProc( + Graph *graphPtr, /* Not used. */ + Element *basePtr, /* Bar element */ + ClosestSearch *searchPtr) /* Information about closest point in + * element */ +{ + BarElement *elemPtr = (BarElement *)basePtr; + XRectangle *bp; + double minDist; + int imin; + int i; + + minDist = searchPtr->dist; + imin = 0; + + for (bp = elemPtr->bars, i = 0; i < elemPtr->nBars; i++, bp++) { + Point2d *pp, *pend; + Point2d outline[5]; + double left, right, top, bottom; + + if (PointInRectangle(bp, searchPtr->x, searchPtr->y)) { + imin = elemPtr->barToData[i]; + minDist = 0.0; + break; + } + left = bp->x, top = bp->y; + right = (double)(bp->x + bp->width); + bottom = (double)(bp->y + bp->height); + outline[4].x = outline[3].x = outline[0].x = left; + outline[4].y = outline[1].y = outline[0].y = top; + outline[2].x = outline[1].x = right; + outline[3].y = outline[2].y = bottom; + + for (pp = outline, pend = outline + 4; pp < pend; pp++) { + Point2d t; + double dist; + + t = Blt_GetProjection(searchPtr->x, searchPtr->y, pp, pp + 1); + if (t.x > right) { + t.x = right; + } else if (t.x < left) { + t.x = left; + } + if (t.y > bottom) { + t.y = bottom; + } else if (t.y < top) { + t.y = top; + } + dist = hypot((t.x - searchPtr->x), (t.y - searchPtr->y)); + if (dist < minDist) { + minDist = dist; + imin = elemPtr->barToData[i]; + } + } + } + if (minDist < searchPtr->dist) { + searchPtr->elemPtr = (Element *)elemPtr; + searchPtr->dist = minDist; + searchPtr->index = imin; + searchPtr->point.x = (double)elemPtr->x.values[imin]; + searchPtr->point.y = (double)elemPtr->y.values[imin]; + } +} + +/* + *--------------------------------------------------------------------------- + * + * MergePens -- + * + * Reorders the both arrays of points and errorbars to merge pens. + * + * Results: + * None. + * + * Side effects: + * The old arrays are freed and new ones allocated containing + * the reordered points and errorbars. + * + *--------------------------------------------------------------------------- + */ +static void +MergePens(BarElement *elemPtr, BarStyle **dataToStyle) +{ + if (Blt_Chain_GetLength(elemPtr->stylePalette) < 2) { + Blt_ChainLink link; + BarStyle *stylePtr; + + link = Blt_Chain_FirstLink(elemPtr->stylePalette); + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->nBars = elemPtr->nBars; + stylePtr->bars = elemPtr->bars; + stylePtr->symbolSize = elemPtr->bars->width / 2; + stylePtr->xeb.length = elemPtr->xeb.length; + stylePtr->xeb.segments = elemPtr->xeb.segments; + stylePtr->yeb.length = elemPtr->yeb.length; + stylePtr->yeb.segments = elemPtr->yeb.segments; + return; + } + /* We have more than one style. Group bar segments of like pen styles + * together. */ + + if (elemPtr->nBars > 0) { + Blt_ChainLink link; + XRectangle *bars, *bp; + int *ip, *barToData; + + bars = Blt_AssertMalloc(elemPtr->nBars * sizeof(XRectangle)); + barToData = Blt_AssertMalloc(elemPtr->nBars * sizeof(int)); + bp = bars, ip = barToData; + for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; + link = Blt_Chain_NextLink(link)) { + BarStyle *stylePtr; + int i; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->symbolSize = bp->width / 2; + stylePtr->bars = bp; + for (i = 0; i < elemPtr->nBars; i++) { + int iData; + + iData = elemPtr->barToData[i]; + if (dataToStyle[iData] == stylePtr) { + *bp++ = elemPtr->bars[i]; + *ip++ = iData; + } + } + stylePtr->nBars = bp - stylePtr->bars; + } + Blt_Free(elemPtr->bars); + Blt_Free(elemPtr->barToData); + elemPtr->bars = bars; + elemPtr->barToData = barToData; + } + + if (elemPtr->xeb.length > 0) { + Blt_ChainLink link; + Segment2d *bars, *sp; + int *map, *ip; + + bars = Blt_AssertMalloc(elemPtr->xeb.length * sizeof(Segment2d)); + map = Blt_AssertMalloc(elemPtr->xeb.length * sizeof(int)); + sp = bars, ip = map; + for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); + link != NULL; link = Blt_Chain_NextLink(link)) { + BarStyle *stylePtr; + int i; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->xeb.segments = sp; + for (i = 0; i < elemPtr->xeb.length; i++) { + int iData; + + iData = elemPtr->xeb.map[i]; + if (dataToStyle[iData] == stylePtr) { + *sp++ = elemPtr->xeb.segments[i]; + *ip++ = iData; + } + } + stylePtr->xeb.length = sp - stylePtr->xeb.segments; + } + Blt_Free(elemPtr->xeb.segments); + elemPtr->xeb.segments = bars; + Blt_Free(elemPtr->xeb.map); + elemPtr->xeb.map = map; + } + if (elemPtr->yeb.length > 0) { + Blt_ChainLink link; + Segment2d *bars, *sp; + int *map, *ip; + + bars = Blt_AssertMalloc(elemPtr->yeb.length * sizeof(Segment2d)); + map = Blt_AssertMalloc(elemPtr->yeb.length * sizeof(int)); + sp = bars, ip = map; + for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; + link = Blt_Chain_NextLink(link)) { + BarStyle *stylePtr; + int i; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->yeb.segments = sp; + for (i = 0; i < elemPtr->yeb.length; i++) { + int iData; + + iData = elemPtr->yeb.map[i]; + if (dataToStyle[iData] == stylePtr) { + *sp++ = elemPtr->yeb.segments[i]; + *ip++ = iData; + } + } + stylePtr->yeb.length = sp - stylePtr->yeb.segments; + } + Blt_Free(elemPtr->yeb.segments); + elemPtr->yeb.segments = bars; + Blt_Free(elemPtr->yeb.map); + elemPtr->yeb.map = map; + } +} + +/* + *--------------------------------------------------------------------------- + * + * MapActiveBars -- + * + * Creates an array of points of the active graph coordinates. + * + * Results: + * None. + * + * Side effects: + * Memory is freed and allocated for the active point array. + * + *--------------------------------------------------------------------------- + */ +static void +MapActiveBars(BarElement *elemPtr) +{ + if (elemPtr->activeRects != NULL) { + Blt_Free(elemPtr->activeRects); + elemPtr->activeRects = NULL; + } + if (elemPtr->activeToData != NULL) { + Blt_Free(elemPtr->activeToData); + elemPtr->activeToData = NULL; + } + elemPtr->nActive = 0; + + if (elemPtr->nActiveIndices > 0) { + XRectangle *activeRects; + int *activeToData; + int i; + int count; + + activeRects = Blt_AssertMalloc(sizeof(XRectangle) * + elemPtr->nActiveIndices); + activeToData = Blt_AssertMalloc(sizeof(int) * + elemPtr->nActiveIndices); + count = 0; + for (i = 0; i < elemPtr->nBars; i++) { + int *ip, *iend; + + for (ip = elemPtr->activeIndices, + iend = ip + elemPtr->nActiveIndices; ip < iend; ip++) { + if (elemPtr->barToData[i] == *ip) { + activeRects[count] = elemPtr->bars[i]; + activeToData[count] = i; + count++; + } + } + } + elemPtr->nActive = count; + elemPtr->activeRects = activeRects; + elemPtr->activeToData = activeToData; + } + elemPtr->flags &= ~ACTIVE_PENDING; +} + +static void +ResetBar(BarElement *elemPtr) +{ + /* Release any storage associated with the display of the bar */ + ResetStylePalette(elemPtr->stylePalette); + if (elemPtr->activeRects != NULL) { + Blt_Free(elemPtr->activeRects); + } + if (elemPtr->activeToData != NULL) { + Blt_Free(elemPtr->activeToData); + } + if (elemPtr->xeb.segments != NULL) { + Blt_Free(elemPtr->xeb.segments); + } + if (elemPtr->xeb.map != NULL) { + Blt_Free(elemPtr->xeb.map); + } + if (elemPtr->yeb.segments != NULL) { + Blt_Free(elemPtr->yeb.segments); + } + if (elemPtr->yeb.map != NULL) { + Blt_Free(elemPtr->yeb.map); + } + if (elemPtr->bars != NULL) { + Blt_Free(elemPtr->bars); + } + if (elemPtr->barToData != NULL) { + Blt_Free(elemPtr->barToData); + } + elemPtr->activeToData = elemPtr->xeb.map = elemPtr->yeb.map = + elemPtr->barToData = NULL; + elemPtr->activeRects = elemPtr->bars = NULL; + elemPtr->xeb.segments = elemPtr->yeb.segments = NULL; + elemPtr->nActive = elemPtr->xeb.length = elemPtr->yeb.length = + elemPtr->nBars = 0; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_MapErrorBars -- + * + * Creates two arrays of points and pen indices, filled with the screen + * coordinates of the visible + * + * Results: + * None. + * + * Side effects: + * Memory is freed and allocated for the index array. + * + *--------------------------------------------------------------------------- + */ +static void +MapErrorBars(Graph *graphPtr, BarElement *elemPtr, BarStyle **dataToStyle) +{ + int n, nPoints; + Region2d reg; + + Blt_GraphExtents(graphPtr, ®); + nPoints = NUMBEROFPOINTS(elemPtr); + if (elemPtr->xError.nValues > 0) { + n = MIN(elemPtr->xError.nValues, nPoints); + } else { + n = MIN3(elemPtr->xHigh.nValues, elemPtr->xLow.nValues, nPoints); + } + if (n > 0) { + Segment2d *bars; + Segment2d *segPtr; + int *map; + int *indexPtr; + int i; + + segPtr = bars = Blt_AssertMalloc(n * 3 * sizeof(Segment2d)); + indexPtr = map = Blt_AssertMalloc(n * 3 * sizeof(int)); + for (i = 0; i < n; i++) { + double x, y; + double high, low; + BarStyle *stylePtr; + + x = elemPtr->x.values[i]; + y = elemPtr->y.values[i]; + stylePtr = dataToStyle[i]; + if ((FINITE(x)) && (FINITE(y))) { + if (elemPtr->xError.nValues > 0) { + high = x + elemPtr->xError.values[i]; + low = x - elemPtr->xError.values[i]; + } else { + high = elemPtr->xHigh.values[i]; + low = elemPtr->xLow.values[i]; + } + if ((FINITE(high)) && (FINITE(low))) { + Point2d p, q; + + p = Blt_Map2D(graphPtr, high, y, &elemPtr->axes); + q = Blt_Map2D(graphPtr, low, y, &elemPtr->axes); + segPtr->p = p; + segPtr->q = q; + if (Blt_LineRectClip(®, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + /* Left cap */ + segPtr->p.x = segPtr->q.x = p.x; + segPtr->p.y = p.y - stylePtr->errorBarCapWidth; + segPtr->q.y = p.y + stylePtr->errorBarCapWidth; + if (Blt_LineRectClip(®, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + /* Right cap */ + segPtr->p.x = segPtr->q.x = q.x; + segPtr->p.y = q.y - stylePtr->errorBarCapWidth; + segPtr->q.y = q.y + stylePtr->errorBarCapWidth; + if (Blt_LineRectClip(®, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + } + } + } + elemPtr->xeb.segments = bars; + elemPtr->xeb.length = segPtr - bars; + elemPtr->xeb.map = map; + } + if (elemPtr->yError.nValues > 0) { + n = MIN(elemPtr->yError.nValues, nPoints); + } else { + n = MIN3(elemPtr->yHigh.nValues, elemPtr->yLow.nValues, nPoints); + } + if (n > 0) { + Segment2d *bars; + Segment2d *segPtr; + int *map; + int *indexPtr; + int i; + + segPtr = bars = Blt_AssertMalloc(n * 3 * sizeof(Segment2d)); + indexPtr = map = Blt_AssertMalloc(n * 3 * sizeof(int)); + for (i = 0; i < n; i++) { + double x, y; + double high, low; + BarStyle *stylePtr; + + x = elemPtr->x.values[i]; + y = elemPtr->y.values[i]; + stylePtr = dataToStyle[i]; + if ((FINITE(x)) && (FINITE(y))) { + if (elemPtr->yError.nValues > 0) { + high = y + elemPtr->yError.values[i]; + low = y - elemPtr->yError.values[i]; + } else { + high = elemPtr->yHigh.values[i]; + low = elemPtr->yLow.values[i]; + } + if ((FINITE(high)) && (FINITE(low))) { + Point2d p, q; + + p = Blt_Map2D(graphPtr, x, high, &elemPtr->axes); + q = Blt_Map2D(graphPtr, x, low, &elemPtr->axes); + segPtr->p = p; + segPtr->q = q; + if (Blt_LineRectClip(®, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + /* Top cap. */ + segPtr->p.y = segPtr->q.y = p.y; + segPtr->p.x = p.x - stylePtr->errorBarCapWidth; + segPtr->q.x = p.x + stylePtr->errorBarCapWidth; + if (Blt_LineRectClip(®, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + /* Bottom cap. */ + segPtr->p.y = segPtr->q.y = q.y; + segPtr->p.x = q.x - stylePtr->errorBarCapWidth; + segPtr->q.x = q.x + stylePtr->errorBarCapWidth; + if (Blt_LineRectClip(®, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + } + } + } + elemPtr->yeb.segments = bars; + elemPtr->yeb.length = segPtr - bars; + elemPtr->yeb.map = map; + } +} + + +/* + *--------------------------------------------------------------------------- + * + * MapBarProc -- + * + * Calculates the actual window coordinates of the bar element. The + * window coordinates are saved in the bar element structure. + * + * Results: + * None. + * + * Notes: + * A bar can have multiple segments (more than one x,y pairs). In this + * case, the bar can be represented as either a set of non-contiguous + * bars or a single multi-segmented (stacked) bar. + * + * The x-axis layout for a barchart may be presented in one of two ways. + * If abscissas are used, the bars are placed at those coordinates. + * Otherwise, the range will represent the number of values. + * + *--------------------------------------------------------------------------- + */ +static void +MapBarProc(Graph *graphPtr, Element *basePtr) +{ + BarElement *elemPtr = (BarElement *)basePtr; + BarStyle **dataToStyle; + double *x, *y; + double barWidth, barOffset; + double baseline, ybot; + int *barToData; /* Maps bars to data point indices */ + int invertBar; + int nPoints, count; + XRectangle *rp, *bars; + int i; + int size; + + ResetBar(elemPtr); + nPoints = NUMBEROFPOINTS(elemPtr); + if (nPoints < 1) { + return; /* No data points */ + } + barWidth = graphPtr->barWidth; + barWidth = (elemPtr->barWidth > 0.0f) + ? elemPtr->barWidth : graphPtr->barWidth; + baseline = (elemPtr->axes.y->logScale) ? 0.0 : graphPtr->baseline; + barOffset = barWidth * 0.5; + + /* + * Create an array of bars representing the screen coordinates of all the + * segments in the bar. + */ + bars = Blt_AssertCalloc(nPoints, sizeof(XRectangle)); + barToData = Blt_AssertCalloc(nPoints, sizeof(int)); + + x = elemPtr->x.values, y = elemPtr->y.values; + count = 0; + for (rp = bars, i = 0; i < nPoints; i++) { + Point2d c1, c2; /* Two opposite corners of the rectangle + * in graph coordinates. */ + double dx, dy; + int height; + double right, left, top, bottom; + + if (((x[i] - barWidth) > elemPtr->axes.x->axisRange.max) || + ((x[i] + barWidth) < elemPtr->axes.x->axisRange.min)) { + continue; /* Abscissa is out of range of the + * x-axis */ + } + c1.x = x[i] - barOffset; + c1.y = y[i]; + c2.x = c1.x + barWidth; + c2.y = baseline; + + /* + * If the mode is "aligned" or "stacked" we need to adjust the x or y + * coordinates of the two corners. + */ + + if ((graphPtr->nBarGroups > 0) && (graphPtr->mode != BARS_INFRONT) && + (!graphPtr->stackAxes)) { + Blt_HashEntry *hPtr; + BarSetKey key; + + key.value = (float)x[i]; + key.axes = elemPtr->axes; + key.axes.y = NULL; + hPtr = Blt_FindHashEntry(&graphPtr->setTable, (char *)&key); + if (hPtr != NULL) { + Blt_HashTable *tablePtr; + const char *name; + + tablePtr = Blt_GetHashValue(hPtr); + name = (elemPtr->groupName != NULL) ? elemPtr->groupName : + elemPtr->axes.y->obj.name; + hPtr = Blt_FindHashEntry(tablePtr, name); + if (hPtr != NULL) { + BarGroup *groupPtr; + double slice, width, offset; + + groupPtr = Blt_GetHashValue(hPtr); + slice = barWidth / (double)graphPtr->maxBarSetSize; + offset = (slice * groupPtr->index); + if (graphPtr->maxBarSetSize > 1) { + offset += slice * 0.05; + slice *= 0.90; + } + switch (graphPtr->mode) { + case BARS_STACKED: + groupPtr->count++; + c2.y = groupPtr->lastY; + c1.y += c2.y; + groupPtr->lastY = c1.y; + c1.x += offset; + c2.x = c1.x + slice; + break; + + case BARS_ALIGNED: + slice /= groupPtr->nSegments; + c1.x += offset + (slice * groupPtr->count); + c2.x = c1.x + slice; + groupPtr->count++; + break; + + case BARS_OVERLAP: + slice /= (groupPtr->nSegments + 1); + width = slice + slice; + groupPtr->count++; + c1.x += offset + + (slice * (groupPtr->nSegments - groupPtr->count)); + c2.x = c1.x + width; + break; + + case BARS_INFRONT: + break; + } + } + } + } + invertBar = FALSE; + if (c1.y < c2.y) { + double temp; + + /* Handle negative bar values by swapping ordinates */ + temp = c1.y, c1.y = c2.y, c2.y = temp; + invertBar = TRUE; + } + /* + * Get the two corners of the bar segment and compute the rectangle + */ + ybot = c2.y; + c1 = Blt_Map2D(graphPtr, c1.x, c1.y, &elemPtr->axes); + c2 = Blt_Map2D(graphPtr, c2.x, c2.y, &elemPtr->axes); + if ((ybot == 0.0) && (elemPtr->axes.y->logScale)) { + c2.y = graphPtr->bottom; + } + + if (c2.y < c1.y) { + double t; + t = c1.y, c1.y = c2.y, c2.y = t; + } + if (c2.x < c1.x) { + double t; + t = c1.x, c1.x = c2.x, c2.x = t; + } + if ((c1.x > graphPtr->right) || (c2.x < graphPtr->left) || + (c1.y > graphPtr->bottom) || (c2.y < graphPtr->top)) { + continue; + } + /* Bound the bars horizontally by the width of the graph window */ + /* Bound the bars vertically by the position of the axis. */ + if (graphPtr->stackAxes) { + top = elemPtr->axes.y->screenMin; + bottom = elemPtr->axes.y->screenMin + elemPtr->axes.y->screenRange; + left = graphPtr->left; + right = graphPtr->right; + } else { + left = top = 0; + bottom = right = 10000; + /* Shouldn't really have a call to Tk_Width or Tk_Height in + * mapping routine. We only want to clamp the bar segment to the + * size of the window if we're actually mapped onscreen. */ + if (Tk_Height(graphPtr->tkwin) > 1) { + bottom = Tk_Height(graphPtr->tkwin); + } + if (Tk_Width(graphPtr->tkwin) > 1) { + right = Tk_Width(graphPtr->tkwin); + } + } + CLAMP(c1.y, top, bottom); + CLAMP(c2.y, top, bottom); + CLAMP(c1.x, left, right); + CLAMP(c2.x, left, right); + dx = FABS(c1.x - c2.x); + dy = FABS(c1.y - c2.y); + if ((dx == 0) || (dy == 0)) { + continue; + } + height = (int)dy; + if (invertBar) { + rp->y = (short int)MIN(c1.y, c2.y); + } else { + rp->y = (short int)(MAX(c1.y, c2.y)) - height; + } + rp->x = (short int)MIN(c1.x, c2.x); + rp->width = (short int)dx + 1; + rp->width |= 0x1; + if (rp->width < 1) { + rp->width = 1; + } + rp->height = height + 1; + if (rp->height < 1) { + rp->height = 1; + } + barToData[count] = i; /* Save the data index corresponding to + * the rectangle */ + count++; + rp++; + } + elemPtr->nBars = count; + elemPtr->bars = bars; + elemPtr->barToData = barToData; + if (elemPtr->nActiveIndices > 0) { + MapActiveBars(elemPtr); + } + + size = 20; + if (count > 0) { + size = bars->width; + } + { + Blt_ChainLink link; + + /* Set the symbol size of all the pen styles. */ + for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; + link = Blt_Chain_NextLink(link)) { + BarStyle *stylePtr; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->symbolSize = size; + stylePtr->errorBarCapWidth = + (stylePtr->penPtr->errorBarCapWidth > 0) + ? stylePtr->penPtr->errorBarCapWidth : (size * 66666) / 100000; + stylePtr->errorBarCapWidth /= 2; + } + } + dataToStyle = (BarStyle **)Blt_StyleMap((Element *)elemPtr); + if (((elemPtr->yHigh.nValues > 0) && (elemPtr->yLow.nValues > 0)) || + ((elemPtr->xHigh.nValues > 0) && (elemPtr->xLow.nValues > 0)) || + (elemPtr->xError.nValues > 0) || (elemPtr->yError.nValues > 0)) { + MapErrorBars(graphPtr, elemPtr, dataToStyle); + } + MergePens(elemPtr, dataToStyle); + Blt_Free(dataToStyle); +} + +/* + *--------------------------------------------------------------------------- + * + * DrawSymbolProc -- + * + * Draw a symbol centered at the given x,y window coordinate based upon + * the element symbol type and size. + * + * Results: + * None. + * + * Problems: + * Most notable is the round-off errors generated when calculating the + * centered position of the symbol. + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static void +DrawSymbolProc(Graph *graphPtr, Drawable drawable, Element *basePtr, + int x, int y, int size) +{ + BarElement *elemPtr = (BarElement *)basePtr; + BarPen *penPtr; + int radius; + + penPtr = NORMALPEN(elemPtr); + if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) { + return; + } + radius = (size / 2); + size--; + + x -= radius; + y -= radius; + if (penPtr->fillGC != NULL) { + XSetTSOrigin(graphPtr->display, penPtr->fillGC, x, y); + } + if (penPtr->stipple != None) { + XFillRectangle(graphPtr->display, drawable, penPtr->fillGC, x, y, + size, size); + } else { + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, penPtr->fill, + x, y, size, size, penPtr->borderWidth, penPtr->relief); + } + XDrawRectangle(graphPtr->display, drawable, penPtr->outlineGC, x, y, + size, size); + if (penPtr->fillGC != NULL) { + XSetTSOrigin(graphPtr->display, penPtr->fillGC, 0, 0); + } +} + +/* + *--------------------------------------------------------------------------- + * + * DrawBarSegments -- + * + * Draws each of the rectangular segments for the element. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +DrawBarSegments(Graph *graphPtr, Drawable drawable, BarPen *penPtr, + XRectangle *bars, int nBars) +{ + TkRegion rgn; + + { + XRectangle clip; + clip.x = graphPtr->left; + clip.y = graphPtr->top; + clip.width = graphPtr->right - graphPtr->left + 1; + clip.height = graphPtr->bottom - graphPtr->top + 1; + rgn = TkCreateRegion(); + TkUnionRectWithRegion(&clip, rgn, rgn); + } + if (penPtr->fill != NULL) { + XRectangle *rp, *rend; + int hasOutline; + int relief; + + relief = (penPtr->relief == TK_RELIEF_SOLID) + ? TK_RELIEF_FLAT: penPtr->relief; + hasOutline = ((relief == TK_RELIEF_FLAT) && + (penPtr->outlineColor != NULL)); + if (penPtr->stipple != None) { + TkSetRegion(graphPtr->display, penPtr->fillGC, rgn); + } + Blt_SetBackgroundClipRegion(graphPtr->tkwin, penPtr->fill, rgn); + if (hasOutline) { + TkSetRegion(graphPtr->display, penPtr->outlineGC, rgn); + } + for (rp = bars, rend = rp + nBars; rp < rend; rp++) { + if (penPtr->stipple != None) { + XFillRectangle(graphPtr->display, drawable, penPtr->fillGC, + rp->x, rp->y, rp->width, rp->height); + } else { + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, + penPtr->fill, rp->x, rp->y, rp->width, rp->height, + penPtr->borderWidth, relief); + } + if (hasOutline) { + XDrawRectangle(graphPtr->display, drawable, penPtr->outlineGC, + rp->x, rp->y, rp->width, rp->height); + } + } + Blt_UnsetBackgroundClipRegion(graphPtr->tkwin, penPtr->fill); + if (hasOutline) { + XSetClipMask(graphPtr->display, penPtr->outlineGC, None); + } + if (penPtr->stipple != None) { + XSetClipMask(graphPtr->display, penPtr->fillGC, None); + } + } else if (penPtr->outlineColor != NULL) { + TkSetRegion(graphPtr->display, penPtr->outlineGC, rgn); + XDrawRectangles(graphPtr->display, drawable, penPtr->outlineGC, bars, + nBars); + XSetClipMask(graphPtr->display, penPtr->outlineGC, None); + } + TkDestroyRegion(rgn); +} + +/* + *--------------------------------------------------------------------------- + * + * DrawBarValues -- + * + * Draws the numeric value of the bar. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +DrawBarValues(Graph *graphPtr, Drawable drawable, BarElement *elemPtr, + BarPen *penPtr, XRectangle *bars, int nBars, int *barToData) +{ + XRectangle *rp, *rend; + int count; + const char *fmt; + + fmt = penPtr->valueFormat; + if (fmt == NULL) { + fmt = "%g"; + } + count = 0; + for (rp = bars, rend = rp + nBars; rp < rend; rp++) { + Point2d anchorPos; + double x, y; + char string[TCL_DOUBLE_SPACE * 2 + 2]; + + x = elemPtr->x.values[barToData[count]]; + y = elemPtr->y.values[barToData[count]]; + + count++; + if (penPtr->valueShow == SHOW_X) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); + } else if (penPtr->valueShow == SHOW_Y) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); + } else if (penPtr->valueShow == SHOW_BOTH) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); + strcat(string, ","); + sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y); + } + if (graphPtr->inverted) { + anchorPos.y = rp->y + rp->height * 0.5; + anchorPos.x = rp->x + rp->width; + if (x < graphPtr->baseline) { + anchorPos.x -= rp->width; + } + } else { + anchorPos.x = rp->x + rp->width * 0.5; + anchorPos.y = rp->y; + if (y < graphPtr->baseline) { + anchorPos.y += rp->height; + } + } + Blt_DrawText(graphPtr->tkwin, drawable, string, &penPtr->valueStyle, + (int)anchorPos.x, (int)anchorPos.y); + } +} + + +/* + *--------------------------------------------------------------------------- + * + * DrawNormalBar -- + * + * Draws the rectangle representing the bar element. If the relief + * option is set to "raised" or "sunken" and the bar borderwidth is set + * (borderwidth > 0), a 3D border is drawn around the bar. + * + * Don't draw bars that aren't visible (i.e. within the limits of the + * axis). + * + * Results: + * None. + * + * Side effects: + * X drawing commands are output. + * + *--------------------------------------------------------------------------- + */ +static void +DrawNormalBarProc(Graph *graphPtr, Drawable drawable, Element *basePtr) +{ + BarElement *elemPtr = (BarElement *)basePtr; + int count; + Blt_ChainLink link; + + count = 0; + for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; + link = Blt_Chain_NextLink(link)) { + BarStyle *stylePtr; + BarPen *penPtr; + + stylePtr = Blt_Chain_GetValue(link); + penPtr = stylePtr->penPtr; + if (stylePtr->nBars > 0) { + DrawBarSegments(graphPtr, drawable, penPtr, stylePtr->bars, + stylePtr->nBars); + } + if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) { + Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, + stylePtr->xeb.segments, stylePtr->xeb.length); + } + if ((stylePtr->yeb.length > 0) && (penPtr->errorBarShow & SHOW_Y)) { + Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, + stylePtr->yeb.segments, stylePtr->yeb.length); + } + if (penPtr->valueShow != SHOW_NONE) { + DrawBarValues(graphPtr, drawable, elemPtr, penPtr, + stylePtr->bars, stylePtr->nBars, + elemPtr->barToData + count); + } + count += stylePtr->nBars; + } +} + +/* + *--------------------------------------------------------------------------- + * + * DrawActiveBar -- + * + * Draws bars representing the active segments of the bar element. If + * the -relief option is set (other than "flat") and the borderwidth is + * greater than 0, a 3D border is drawn around the each bar segment. + * + * Results: + * None. + * + * Side effects: + * X drawing commands are output. + * + *--------------------------------------------------------------------------- + */ +static void +DrawActiveBarProc(Graph *graphPtr, Drawable drawable, Element *basePtr) +{ + BarElement *elemPtr = (BarElement *)basePtr; + + if (elemPtr->activePenPtr != NULL) { + BarPen *penPtr = elemPtr->activePenPtr; + + if (elemPtr->nActiveIndices > 0) { + if (elemPtr->flags & ACTIVE_PENDING) { + MapActiveBars(elemPtr); + } + DrawBarSegments(graphPtr, drawable, penPtr, elemPtr->activeRects, + elemPtr->nActive); + if (penPtr->valueShow != SHOW_NONE) { + DrawBarValues(graphPtr, drawable, elemPtr, penPtr, + elemPtr->activeRects, elemPtr->nActive, + elemPtr->activeToData); + } + } else if (elemPtr->nActiveIndices < 0) { + DrawBarSegments(graphPtr, drawable, penPtr, elemPtr->bars, + elemPtr->nBars); + if (penPtr->valueShow != SHOW_NONE) { + DrawBarValues(graphPtr, drawable, elemPtr, penPtr, + elemPtr->bars, elemPtr->nBars, elemPtr->barToData); + } + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * SymbolToPostScript -- + * + * Draw a symbol centered at the given x,y window coordinate based upon + * the element symbol type and size. + * + * Results: + * None. + * + * Problems: + * Most notable is the round-off errors generated when calculating the + * centered position of the symbol. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static void +SymbolToPostScriptProc( + Graph *graphPtr, + Blt_Ps ps, + Element *basePtr, + double x, double y, + int size) +{ + BarElement *elemPtr = (BarElement *)basePtr; + BarPen *penPtr; + + penPtr = NORMALPEN(elemPtr); + if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) { + return; + } + /* + * Build a PostScript procedure to draw the fill and outline of the symbol + * after the path of the symbol shape has been formed + */ + Blt_Ps_Append(ps, "\n" + "/DrawSymbolProc {\n" + "gsave\n "); + if (penPtr->stipple != None) { + if (penPtr->fill != NULL) { + Blt_Ps_XSetBackground(ps, Blt_BackgroundBorderColor(penPtr->fill)); + Blt_Ps_Append(ps, " gsave fill grestore\n "); + } + if (penPtr->outlineColor != NULL) { + Blt_Ps_XSetForeground(ps, penPtr->outlineColor); + } else { + Blt_Ps_XSetForeground(ps, Blt_BackgroundBorderColor(penPtr->fill)); + } + Blt_Ps_XSetStipple(ps, graphPtr->display, penPtr->stipple); + } else if (penPtr->outlineColor != NULL) { + Blt_Ps_XSetForeground(ps, penPtr->outlineColor); + Blt_Ps_Append(ps, " fill\n"); + } + Blt_Ps_Append(ps, " grestore\n"); + Blt_Ps_Append(ps, "} def\n\n"); + Blt_Ps_Format(ps, "%g %g %d Sq\n", x, y, size); +} + +static void +SegmentsToPostScript(Graph *graphPtr, Blt_Ps ps, BarPen *penPtr, + XRectangle *bars, int nBars) +{ + XRectangle *rp, *rend; + + if ((penPtr->fill == NULL) && (penPtr->outlineColor == NULL)) { + return; + } + for (rp = bars, rend = rp + nBars; rp < rend; rp++) { + if ((rp->width < 1) || (rp->height < 1)) { + continue; + } + if (penPtr->stipple != None) { + Blt_Ps_Rectangle(ps, rp->x, rp->y, rp->width - 1, rp->height - 1); + if (penPtr->fill != NULL) { + Blt_Ps_XSetBackground(ps,Blt_BackgroundBorderColor(penPtr->fill)); + Blt_Ps_Append(ps, "gsave fill grestore\n"); + } + if (penPtr->outlineColor != NULL) { + Blt_Ps_XSetForeground(ps, penPtr->outlineColor); + } else { + Blt_Ps_XSetForeground(ps,Blt_BackgroundBorderColor(penPtr->fill)); + } + Blt_Ps_XSetStipple(ps, graphPtr->display, penPtr->stipple); + } else if (penPtr->outlineColor != NULL) { + Blt_Ps_XSetForeground(ps, penPtr->outlineColor); + Blt_Ps_XFillRectangle(ps, (double)rp->x, (double)rp->y, + (int)rp->width - 1, (int)rp->height - 1); + } + if ((penPtr->fill != NULL) && (penPtr->borderWidth > 0) && + (penPtr->relief != TK_RELIEF_FLAT)) { + Blt_Ps_Draw3DRectangle(ps, Blt_BackgroundBorder(penPtr->fill), + (double)rp->x, (double)rp->y, (int)rp->width, (int)rp->height, + penPtr->borderWidth, penPtr->relief); + } + } +} + +static void +BarValuesToPostScript(Graph *graphPtr, Blt_Ps ps, BarElement *elemPtr, + BarPen *penPtr, XRectangle *bars, int nBars, + int *barToData) +{ + XRectangle *rp, *rend; + int count; + const char *fmt; + char string[TCL_DOUBLE_SPACE * 2 + 2]; + double x, y; + Point2d anchorPos; + + count = 0; + fmt = penPtr->valueFormat; + if (fmt == NULL) { + fmt = "%g"; + } + for (rp = bars, rend = rp + nBars; rp < rend; rp++) { + x = elemPtr->x.values[barToData[count]]; + y = elemPtr->y.values[barToData[count]]; + count++; + if (penPtr->valueShow == SHOW_X) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); + } else if (penPtr->valueShow == SHOW_Y) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); + } else if (penPtr->valueShow == SHOW_BOTH) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); + strcat(string, ","); + sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y); + } + if (graphPtr->inverted) { + anchorPos.y = rp->y + rp->height * 0.5; + anchorPos.x = rp->x + rp->width; + if (x < graphPtr->baseline) { + anchorPos.x -= rp->width; + } + } else { + anchorPos.x = rp->x + rp->width * 0.5; + anchorPos.y = rp->y; + if (y < graphPtr->baseline) { + anchorPos.y += rp->height; + } + } + Blt_Ps_DrawText(ps, string, &penPtr->valueStyle, anchorPos.x, + anchorPos.y); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ActiveBarToPostScript -- + * + * Similar to the NormalBarToPostScript procedure, generates PostScript + * commands to display the bars representing the active bar segments of + * the element. + * + * Results: + * None. + * + * Side effects: + * PostScript pen width, dashes, and color settings are changed. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static void +ActiveBarToPostScriptProc(Graph *graphPtr, Blt_Ps ps, Element *basePtr) +{ + BarElement *elemPtr = (BarElement *)basePtr; + + if (elemPtr->activePenPtr != NULL) { + BarPen *penPtr = elemPtr->activePenPtr; + + if (elemPtr->nActiveIndices > 0) { + if (elemPtr->flags & ACTIVE_PENDING) { + MapActiveBars(elemPtr); + } + SegmentsToPostScript(graphPtr, ps, penPtr, elemPtr->activeRects, + elemPtr->nActive); + if (penPtr->valueShow != SHOW_NONE) { + BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, + elemPtr->activeRects, elemPtr->nActive, elemPtr->activeToData); + } + } else if (elemPtr->nActiveIndices < 0) { + SegmentsToPostScript(graphPtr, ps, penPtr, elemPtr->bars, + elemPtr->nBars); + if (penPtr->valueShow != SHOW_NONE) { + BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, + elemPtr->bars, elemPtr->nBars, elemPtr->barToData); + } + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * NormalBarToPostScript -- + * + * Generates PostScript commands to form the bars representing the + * segments of the bar element. + * + * Results: + * None. + * + * Side effects: + * PostScript pen width, dashes, and color settings are changed. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static void +NormalBarToPostScriptProc(Graph *graphPtr, Blt_Ps ps, Element *basePtr) +{ + BarElement *elemPtr = (BarElement *)basePtr; + Blt_ChainLink link; + int count; + + count = 0; + for (link = Blt_Chain_FirstLink(elemPtr->stylePalette); link != NULL; + link = Blt_Chain_NextLink(link)) { + BarStyle *stylePtr; + BarPen *penPtr; + XColor *colorPtr; + + stylePtr = Blt_Chain_GetValue(link); + penPtr = stylePtr->penPtr; + if (stylePtr->nBars > 0) { + SegmentsToPostScript(graphPtr, ps, penPtr, stylePtr->bars, + stylePtr->nBars); + } + colorPtr = penPtr->errorBarColor; + if (colorPtr == COLOR_DEFAULT) { + colorPtr = penPtr->outlineColor; + } + if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) { + Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, + NULL, CapButt, JoinMiter); + Blt_Ps_Draw2DSegments(ps, stylePtr->xeb.segments, + stylePtr->xeb.length); + } + if ((stylePtr->yeb.length > 0) && (penPtr->errorBarShow & SHOW_Y)) { + Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, + NULL, CapButt, JoinMiter); + Blt_Ps_Draw2DSegments(ps, stylePtr->yeb.segments, + stylePtr->yeb.length); + } + if (penPtr->valueShow != SHOW_NONE) { + BarValuesToPostScript(graphPtr, ps, elemPtr, penPtr, + stylePtr->bars, stylePtr->nBars, elemPtr->barToData + count); + } + count += stylePtr->nBars; + } +} + +/* + *--------------------------------------------------------------------------- + * + * DestroyBar -- + * + * Release memory and resources allocated for the bar element. + * + * Results: + * None. + * + * Side effects: + * Everything associated with the bar element is freed up. + * + *--------------------------------------------------------------------------- + */ + +static void +DestroyBarProc(Graph *graphPtr, Element *basePtr) +{ + BarElement *elemPtr = (BarElement *)basePtr; + + DestroyBarPen(graphPtr, elemPtr->builtinPenPtr); + if (elemPtr->activePenPtr != NULL) { + Blt_FreePen((Pen *)elemPtr->activePenPtr); + } + ResetBar(elemPtr); + if (elemPtr->stylePalette != NULL) { + Blt_FreeStylePalette(elemPtr->stylePalette); + Blt_Chain_Destroy(elemPtr->stylePalette); + } + if (elemPtr->activeIndices != NULL) { + Blt_Free(elemPtr->activeIndices); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_BarElement -- + * + * Allocate memory and initialize methods for the new bar element. + * + * Results: + * The pointer to the newly allocated element structure is returned. + * + * Side effects: + * Memory is allocated for the bar element structure. + * + *--------------------------------------------------------------------------- + */ + +static ElementProcs barProcs = { + ClosestBarProc, + ConfigureBarProc, + DestroyBarProc, + DrawActiveBarProc, + DrawNormalBarProc, + DrawSymbolProc, + GetBarExtentsProc, + ActiveBarToPostScriptProc, + NormalBarToPostScriptProc, + SymbolToPostScriptProc, + MapBarProc, +}; + + +Element * +Blt_BarElement(Graph *graphPtr, const char *name, ClassId classId) +{ + BarElement *elemPtr; + + elemPtr = Blt_AssertCalloc(1, sizeof(BarElement)); + elemPtr->procsPtr = &barProcs; + elemPtr->configSpecs = barElemConfigSpecs; + elemPtr->legendRelief = TK_RELIEF_FLAT; + Blt_GraphSetObjectClass(&elemPtr->obj, classId); + elemPtr->obj.name = Blt_AssertStrdup(name); + elemPtr->obj.graphPtr = graphPtr; + /* By default, an element's name and label are the same. */ + elemPtr->label = Blt_AssertStrdup(name); + elemPtr->builtinPenPtr = &elemPtr->builtinPen; + InitializeBarPen(elemPtr->builtinPenPtr); + elemPtr->stylePalette = Blt_Chain_Create(); + bltBarStylesOption.clientData = (ClientData)sizeof(BarStyle); + return (Element *)elemPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_InitBarSetTable -- + * + * Generate a table of abscissa frequencies. Duplicate x-coordinates + * (depending upon the bar drawing mode) indicate that something special + * should be done with each bar segment mapped to the same abscissa + * (i.e. it should be stacked, aligned, or overlay-ed with other segments) + * + * Results: + * None. + * + * Side effects: + * Memory is allocated for the bar element structure. + * + *--------------------------------------------------------------------------- + */ +void +Blt_InitBarSetTable(Graph *graphPtr) +{ + Blt_ChainLink link; + int nStacks, nSegs; + Blt_HashTable setTable; + int sum, max; + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + /* + * Free resources associated with a previous frequency table. This includes + * the array of frequency information and the table itself + */ + Blt_DestroyBarSets(graphPtr); + if (graphPtr->mode == BARS_INFRONT) { + return; /* No set table is needed for + * "infront" mode */ + } + Blt_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int)); + + /* + * Initialize a hash table and fill it with unique abscissas. Keep track + * of the frequency of each x-coordinate and how many abscissas have + * duplicate mappings. + */ + Blt_InitHashTable(&setTable, sizeof(BarSetKey) / sizeof(int)); + nSegs = nStacks = 0; + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + BarElement *elemPtr; + double *x, *xend; + int nPoints; + + elemPtr = Blt_Chain_GetValue(link); + if ((elemPtr->flags & HIDE) || (elemPtr->obj.classId != CID_ELEM_BAR)) { + continue; + } + nSegs++; + nPoints = NUMBEROFPOINTS(elemPtr); + for (x = elemPtr->x.values, xend = x + nPoints; x < xend; x++) { + Blt_HashEntry *hPtr; + Blt_HashTable *tablePtr; + BarSetKey key; + int isNew; + size_t count; + const char *name; + + key.value = *x; + key.axes = elemPtr->axes; + key.axes.y = NULL; + hPtr = Blt_CreateHashEntry(&setTable, (char *)&key, &isNew); + if (isNew) { + tablePtr = Blt_AssertMalloc(sizeof(Blt_HashTable)); + Blt_InitHashTable(tablePtr, BLT_STRING_KEYS); + Blt_SetHashValue(hPtr, tablePtr); + } else { + tablePtr = Blt_GetHashValue(hPtr); + } + name = (elemPtr->groupName != NULL) ? elemPtr->groupName : + elemPtr->axes.y->obj.name; + hPtr = Blt_CreateHashEntry(tablePtr, name, &isNew); + if (isNew) { + count = 1; + } else { + count = (size_t)Blt_GetHashValue(hPtr); + count++; + } + Blt_SetHashValue(hPtr, (ClientData)count); + } + } + if (setTable.numEntries == 0) { + return; /* No bar elements to be displayed */ + } + sum = max = 0; + for (hPtr = Blt_FirstHashEntry(&setTable, &iter); hPtr != NULL; + hPtr = Blt_NextHashEntry(&iter)) { + Blt_HashTable *tablePtr; + Blt_HashEntry *hPtr2; + BarSetKey *keyPtr; + int isNew; + + keyPtr = (BarSetKey *)Blt_GetHashKey(&setTable, hPtr); + hPtr2 = Blt_CreateHashEntry(&graphPtr->setTable, (char *)keyPtr,&isNew); + tablePtr = Blt_GetHashValue(hPtr); + Blt_SetHashValue(hPtr2, tablePtr); + if (max < tablePtr->numEntries) { + max = tablePtr->numEntries; /* # of stacks in group. */ + } + sum += tablePtr->numEntries; + } + Blt_DeleteHashTable(&setTable); + if (sum > 0) { + BarGroup *groupPtr; + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + graphPtr->barGroups = Blt_AssertCalloc(sum, sizeof(BarGroup)); + groupPtr = graphPtr->barGroups; + for (hPtr = Blt_FirstHashEntry(&graphPtr->setTable, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + BarSetKey *keyPtr; + Blt_HashTable *tablePtr; + Blt_HashEntry *hPtr2; + Blt_HashSearch iter2; + size_t xcount; + + tablePtr = Blt_GetHashValue(hPtr); + keyPtr = (BarSetKey *)Blt_GetHashKey(&setTable, hPtr); + xcount = 0; + for (hPtr2 = Blt_FirstHashEntry(tablePtr, &iter2); hPtr2!=NULL; + hPtr2 = Blt_NextHashEntry(&iter2)) { + size_t count; + + count = (size_t)Blt_GetHashValue(hPtr2); + groupPtr->nSegments = count; + groupPtr->axes = keyPtr->axes; + Blt_SetHashValue(hPtr2, groupPtr); + groupPtr->index = xcount++; + groupPtr++; + } + } + } + graphPtr->maxBarSetSize = max; + graphPtr->nBarGroups = sum; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ComputeStacks -- + * + * Determine the height of each stack of bar segments. A stack is created + * by designating two or more points with the same abscissa. Each ordinate + * defines the height of a segment in the stack. This procedure simply + * looks at all the data points summing the heights of each stacked + * segment. The sum is saved in the frequency information table. This + * value will be used to calculate the y-axis limits (data limits aren't + * sufficient). + * + * Results: + * None. + * + * Side effects: + * The heights of each stack is computed. CheckBarGroups will use this + * information to adjust the y-axis limits if necessary. + * + *--------------------------------------------------------------------------- + */ +void +Blt_ComputeBarStacks(Graph *graphPtr) +{ + Blt_ChainLink link; + + if ((graphPtr->mode != BARS_STACKED) || (graphPtr->nBarGroups == 0)) { + return; + } + + /* Initialize the stack sums to zero. */ + { + BarGroup *gp, *gend; + + for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; + gp < gend; gp++) { + gp->sum = 0.0; + } + } + + /* Consider each bar x-y coordinate. Add the ordinates of duplicate + * abscissas. */ + + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + BarElement *elemPtr; + double *x, *y, *xend; + + elemPtr = Blt_Chain_GetValue(link); + if ((elemPtr->flags & HIDE) || (elemPtr->obj.classId != CID_ELEM_BAR)) { + continue; + } + for (x = elemPtr->x.values, y = elemPtr->y.values, + xend = x + NUMBEROFPOINTS(elemPtr); x < xend; x++, y++) { + BarSetKey key; + BarGroup *groupPtr; + Blt_HashEntry *hPtr; + Blt_HashTable *tablePtr; + const char *name; + + key.value = *x; + key.axes = elemPtr->axes; + key.axes.y = NULL; + hPtr = Blt_FindHashEntry(&graphPtr->setTable, (char *)&key); + if (hPtr == NULL) { + continue; + } + tablePtr = Blt_GetHashValue(hPtr); + name = (elemPtr->groupName != NULL) ? elemPtr->groupName : + elemPtr->axes.y->obj.name; + hPtr = Blt_FindHashEntry(tablePtr, name); + if (hPtr == NULL) { + continue; + } + groupPtr = Blt_GetHashValue(hPtr); + groupPtr->sum += *y; + } + } +} + +void +Blt_ResetBarGroups(Graph *graphPtr) +{ + BarGroup *gp, *gend; + + for (gp = graphPtr->barGroups, gend = gp + graphPtr->nBarGroups; gp < gend; + gp++) { + gp->lastY = 0.0; + gp->count = 0; + } +} + +void +Blt_DestroyBarSets(Graph *graphPtr) +{ + Blt_HashSearch iter; + Blt_HashEntry *hPtr; + + if (graphPtr->barGroups != NULL) { + Blt_Free(graphPtr->barGroups); + graphPtr->barGroups = NULL; + } + graphPtr->nBarGroups = 0; + for (hPtr = Blt_FirstHashEntry(&graphPtr->setTable, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + Blt_HashTable *tablePtr; + + tablePtr = Blt_GetHashValue(hPtr); + Blt_DeleteHashTable(tablePtr); + Blt_Free(tablePtr); + } + Blt_DeleteHashTable(&graphPtr->setTable); + Blt_InitHashTable(&graphPtr->setTable, sizeof(BarSetKey) / sizeof(int)); +} diff --git a/src/bltGrElemLine.C b/src/bltGrElemLine.C new file mode 100644 index 0000000..82234da --- /dev/null +++ b/src/bltGrElemLine.C @@ -0,0 +1,5347 @@ + +/* + * bltGrLine.c -- + * + * This module implements line graph and stripchart elements for the BLT graph + * widget. + * + * Copyright (c) 1993 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include "bltChain.h" +#include <X11/Xutil.h> +#include "bltGrElem.h" +#include "tkDisplay.h" +#include "bltBgStyle.h" +#include "bltImage.h" +#include "bltBitmap.h" + +#define COLOR_DEFAULT (XColor *)1 +#define PATTERN_SOLID ((Pixmap)1) + +#define PEN_INCREASING 1 /* Draw line segments for only those + * data points whose abscissas are + * monotonically increasing in + * order. */ +#define PEN_DECREASING 2 /* Lines will be drawn between only + * those points whose abscissas are + * decreasing in order. */ + +#define PEN_BOTH_DIRECTIONS (PEN_INCREASING | PEN_DECREASING) + +/* Lines will be drawn between points regardless of the ordering of the + * abscissas */ + +#define BROKEN_TRACE(dir,last,next) \ + (((((dir) & PEN_DECREASING) == 0) && ((next) < (last))) || \ + ((((dir) & PEN_INCREASING) == 0) && ((next) > (last)))) + +#define DRAW_SYMBOL(linePtr) \ + (((linePtr)->symbolCounter % (linePtr)->symbolInterval) == 0) + +typedef enum { + PEN_SMOOTH_LINEAR, /* Line segments */ + PEN_SMOOTH_STEP, /* Step-and-hold */ + PEN_SMOOTH_NATURAL, /* Natural cubic spline */ + PEN_SMOOTH_QUADRATIC, /* Quadratic spline */ + PEN_SMOOTH_CATROM, /* Catrom parametric spline */ + PEN_SMOOTH_LAST /* Sentinel */ +} Smoothing; + +typedef struct { + const char *name; + Smoothing value; +} SmoothingInfo; + +static SmoothingInfo smoothingInfo[] = { + { "none", PEN_SMOOTH_LINEAR }, + { "linear", PEN_SMOOTH_LINEAR }, + { "step", PEN_SMOOTH_STEP }, + { "natural", PEN_SMOOTH_NATURAL }, + { "cubic", PEN_SMOOTH_NATURAL }, + { "quadratic", PEN_SMOOTH_QUADRATIC }, + { "catrom", PEN_SMOOTH_CATROM }, + { (char *)NULL, PEN_SMOOTH_LAST } +}; + + +typedef struct { + Point2d *screenPts; /* Array of transformed coordinates */ + int nScreenPts; /* Number of coordinates */ + int *styleMap; /* Index of pen styles */ + int *map; /* Maps segments/traces to data + * points */ +} MapInfo; + +/* Symbol types for line elements */ +typedef enum { + SYMBOL_NONE, + SYMBOL_SQUARE, + SYMBOL_CIRCLE, + SYMBOL_DIAMOND, + SYMBOL_PLUS, + SYMBOL_CROSS, + SYMBOL_SPLUS, + SYMBOL_SCROSS, + SYMBOL_TRIANGLE, + SYMBOL_ARROW, + SYMBOL_BITMAP, + SYMBOL_IMAGE +} SymbolType; + +typedef struct { + const char *name; + unsigned int minChars; + SymbolType type; +} GraphSymbolType; + +static GraphSymbolType graphSymbols[] = { + { "arrow", 1, SYMBOL_ARROW, }, + { "circle", 2, SYMBOL_CIRCLE, }, + { "cross", 2, SYMBOL_CROSS, }, + { "diamond", 1, SYMBOL_DIAMOND, }, + { "none", 1, SYMBOL_NONE, }, + { "plus", 1, SYMBOL_PLUS, }, + { "scross", 2, SYMBOL_SCROSS, }, + { "splus", 2, SYMBOL_SPLUS, }, + { "square", 2, SYMBOL_SQUARE, }, + { "triangle", 1, SYMBOL_TRIANGLE, }, + { NULL, 0, 0 }, +}; + +typedef struct { + SymbolType type; /* Type of symbol to be drawn/printed */ + + int size; /* Requested size of symbol in pixels */ + + XColor *outlineColor; /* Outline color */ + + int outlineWidth; /* Width of the outline */ + + GC outlineGC; /* Outline graphics context */ + + XColor *fillColor; /* Normal fill color */ + + GC fillGC; /* Fill graphics context */ + + Tk_Image image; /* This is used of image symbols. */ + + /* The last two fields are used only for bitmap symbols. */ + + Pixmap bitmap; /* Bitmap to determine + * foreground/background pixels of the + * symbol */ + Pixmap mask; /* Bitmap representing the transparent + * pixels of the symbol */ +} Symbol; + +typedef struct { + int start; /* Index into the X-Y coordinate arrays + * indicating where trace starts. */ + GraphPoints screenPts; /* Array of screen coordinates + * (malloc-ed) representing the + * trace. */ +} Trace; + +typedef struct { + const char *name; /* Pen style identifier. If NULL pen + * was statically allocated. */ + ClassId classId; /* Type of pen */ + const char *typeId; /* String token identifying the type of + * pen */ + unsigned int flags; /* Indicates if the pen element is + * active or normal */ + int refCount; /* Reference count for elements using + * this pen. */ + Blt_HashEntry *hashPtr; + + Blt_ConfigSpec *configSpecs; /* Configuration specifications */ + + PenConfigureProc *configProc; + PenDestroyProc *destroyProc; + Graph *graphPtr; /* Graph that the pen is associated + * with. */ + + /* Symbol attributes. */ + Symbol symbol; /* Element symbol type */ + + /* Trace attributes. */ + int traceWidth; /* Width of the line segments. If + * lineWidth is 0, no line will be + * drawn, only symbols. */ + + Blt_Dashes traceDashes; /* Dash on-off list value */ + + XColor *traceColor; /* Line segment color */ + + XColor *traceOffColor; /* Line segment dash gap color */ + + GC traceGC; /* Line segment graphics context */ + + /* Error bar attributes. */ + int errorBarShow; /* Describes which error bars to display: + * none, x, y, or * both. */ + + int errorBarLineWidth; /* Width of the error bar segments. */ + + int errorBarCapWidth; /* Width of the cap on error bars. */ + + XColor *errorBarColor; /* Color of the error bar. */ + + GC errorBarGC; /* Error bar graphics context. */ + + /* Show value attributes. */ + int valueShow; /* Indicates whether to display data + * value. Values are x, y, both, or + * none. */ + const char *valueFormat; /* A printf format string. */ + + TextStyle valueStyle; /* Text attributes (color, font, + * rotation, etc.) of the value. */ +} LinePen; + +typedef struct { + Weight weight; /* Weight range where this pen is + * valid. */ + LinePen *penPtr; /* Pen to use. */ + GraphPoints symbolPts; + + GraphSegments lines; /* Points to start of the line segments + * for this pen. */ + GraphSegments xeb, yeb; /* X and Y axis error bars. */ + + int symbolSize; /* Size of the pen's symbol scaled to + * the current graph size. */ + int errorBarCapWidth; /* Length of the cap ends on each error + * bar. */ +} LineStyle; + +typedef struct { + GraphObj obj; /* Must be first field in element. */ + unsigned int flags; + Blt_HashEntry *hashPtr; + + /* Fields specific to elements. */ + const char *label; /* Label displayed in legend */ + unsigned short row, col; /* Position of the entry in the + * legend. */ + int legendRelief; /* Relief of label in legend. */ + Axis2d axes; /* X-axis and Y-axis mapping the + * element */ + ElemValues x, y, w; /* Contains array of floating point + * graph coordinate values. Also holds + * min/max * and the number of + * coordinates */ + int *activeIndices; /* Array of indices (malloc-ed) which + * indicate which data points are active + * (drawn * with "active" colors). */ + int nActiveIndices; /* Number of active data points. + * Special case: if nActiveIndices < 0 + * and the * active bit is set in + * "flags", then all data points are + * drawn active. */ + ElementProcs *procsPtr; + Blt_ConfigSpec *configSpecs; /* Configuration specifications. */ + LinePen *activePenPtr; /* Standard Pens */ + LinePen *normalPenPtr; + LinePen *builtinPenPtr; + Blt_Chain styles; /* Palette of pens. */ + + /* Symbol scaling */ + int scaleSymbols; /* If non-zero, the symbols will scale + * in size as the graph is zoomed + * in/out. */ + + double xRange, yRange; /* Initial X-axis and Y-axis ranges: + * used to scale the size of element's + * symbol. */ + int state; + Blt_ChainLink link; /* Element's link in display list. */ + + /* The line element specific fields start here. */ + + ElemValues xError; /* Relative/symmetric X error values. */ + ElemValues yError; /* Relative/symmetric Y error values. */ + ElemValues xHigh, xLow; /* Absolute/asymmetric X-coordinate + * high/low error values. */ + ElemValues yHigh, yLow; /* Absolute/asymmetric Y-coordinate + * high/low error values. */ + LinePen builtinPen; + int errorBarCapWidth; /* Length of cap on error bars */ + + /* Line smoothing */ + Smoothing reqSmooth; /* Requested smoothing function to use + * for connecting the data points */ + Smoothing smooth; /* Smoothing function used. */ + float rTolerance; /* Tolerance to reduce the number of + * points displayed. */ + + /* Drawing-related data structures. */ + + /* Area-under-curve fill attributes. */ + XColor *fillFgColor; + XColor *fillBgColor; + GC fillGC; + + Blt_Background fillBg; /* Background for fill area. */ + + Point2d *fillPts; /* Array of points used to draw polygon + * to fill area under the curve */ + int nFillPts; + + /* Symbol points */ + GraphPoints symbolPts; + + /* Active symbol points */ + GraphPoints activePts; + GraphSegments xeb, yeb; /* Point to start of this pen's X-error + * bar segments in the element's + * array. */ + int reqMaxSymbols; + int symbolInterval; + int symbolCounter; + + /* X-Y graph-specific fields */ + + int penDir; /* Indicates if a change in the pen + * direction should be considered a + * retrace (line segment is not + * drawn). */ + Blt_Chain traces; /* List of traces (a trace is a series + * of contiguous line segments). New + * traces are generated when either + * the next segment changes the pen + * direction, or the end point is + * clipped by the plotting area. */ + + /* Stripchart-specific fields */ + + GraphSegments lines; /* Holds the the line segments of the + * element trace. The segments are + * grouped by pen style. */ +} LineElement; + +static Blt_OptionParseProc ObjToSmoothProc; +static Blt_OptionPrintProc SmoothToObjProc; +static Blt_CustomOption smoothOption = +{ + ObjToSmoothProc, SmoothToObjProc, NULL, (ClientData)0 +}; + +static Blt_OptionParseProc ObjToPenDirProc; +static Blt_OptionPrintProc PenDirToObjProc; +static Blt_CustomOption penDirOption = +{ + ObjToPenDirProc, PenDirToObjProc, NULL, (ClientData)0 +}; + +static Blt_OptionFreeProc FreeSymbolProc; +static Blt_OptionParseProc ObjToSymbolProc; +static Blt_OptionPrintProc SymbolToObjProc; +static Blt_CustomOption symbolOption = +{ + ObjToSymbolProc, SymbolToObjProc, FreeSymbolProc, (ClientData)0 +}; + +BLT_EXTERN Blt_CustomOption bltLineStylesOption; +BLT_EXTERN Blt_CustomOption bltColorOption; +BLT_EXTERN Blt_CustomOption bltValuesOption; +BLT_EXTERN Blt_CustomOption bltValuePairsOption; +BLT_EXTERN Blt_CustomOption bltLinePenOption; +BLT_EXTERN Blt_CustomOption bltXAxisOption; +BLT_EXTERN Blt_CustomOption bltYAxisOption; + +#define DEF_LINE_ACTIVE_PEN "activeLine" +#define DEF_LINE_AXIS_X "x" +#define DEF_LINE_AXIS_Y "y" +#define DEF_LINE_DASHES (char *)NULL +#define DEF_LINE_DATA (char *)NULL +#define DEF_LINE_FILL_COLOR "defcolor" +#define DEF_LINE_HIDE "no" +#define DEF_LINE_LABEL (char *)NULL +#define DEF_LINE_LABEL_RELIEF "flat" +#define DEF_LINE_MAX_SYMBOLS "0" +#define DEF_LINE_OFFDASH_COLOR (char *)NULL +#define DEF_LINE_OUTLINE_COLOR "defcolor" +#define DEF_LINE_OUTLINE_WIDTH "1" +#define DEF_LINE_PATTERN_BG (char *)NULL +#define DEF_LINE_PATTERN_FG "black" +#define DEF_LINE_PEN_COLOR RGB_NAVYBLUE +#define DEF_LINE_PEN_DIRECTION "both" +#define DEF_LINE_PEN_WIDTH "1" +#define DEF_LINE_PIXELS "0.1i" +#define DEF_LINE_REDUCE "0.0" +#define DEF_LINE_SCALE_SYMBOLS "yes" +#define DEF_LINE_SMOOTH "linear" +#define DEF_LINE_STATE "normal" +#define DEF_LINE_STIPPLE (char *)NULL +#define DEF_LINE_STYLES "" +#define DEF_LINE_SYMBOL "circle" +#define DEF_LINE_TAGS "all" +#define DEF_LINE_X_DATA (char *)NULL +#define DEF_LINE_Y_DATA (char *)NULL + +#define DEF_LINE_ERRORBAR_COLOR "defcolor" +#define DEF_LINE_ERRORBAR_LINE_WIDTH "2" +#define DEF_LINE_ERRORBAR_CAP_WIDTH "2" +#define DEF_LINE_SHOW_ERRORBARS "both" + +#define DEF_PEN_ACTIVE_COLOR RGB_BLUE +#define DEF_PEN_DASHES (char *)NULL +#define DEF_PEN_FILL_COLOR "defcolor" +#define DEF_PEN_LINE_WIDTH "1" +#define DEF_PEN_NORMAL_COLOR RGB_NAVYBLUE +#define DEF_PEN_OFFDASH_COLOR (char *)NULL +#define DEF_PEN_OUTLINE_COLOR "defcolor" +#define DEF_PEN_OUTLINE_WIDTH "1" +#define DEF_PEN_PIXELS "0.1i" +#define DEF_PEN_SYMBOL "circle" +#define DEF_PEN_TYPE "line" +#define DEF_PEN_VALUE_ANCHOR "s" +#define DEF_PEN_VALUE_COLOR RGB_BLACK +#define DEF_PEN_VALUE_FONT STD_FONT_NUMBERS +#define DEF_PEN_VALUE_FORMAT "%g" +#define DEF_PEN_VALUE_ANGLE (char *)NULL +#define DEF_PEN_SHOW_VALUES "no" + +static Blt_ConfigSpec lineElemConfigSpecs[] = +{ + {BLT_CONFIG_CUSTOM, "-activepen", "activePen", "ActivePen", + DEF_LINE_ACTIVE_PEN, Blt_Offset(LineElement, activePenPtr), + BLT_CONFIG_NULL_OK, &bltLinePenOption}, + {BLT_CONFIG_COLOR, "-areaforeground", "areaForeground", "AreaForeground", + DEF_LINE_PATTERN_FG, Blt_Offset(LineElement, fillFgColor), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BACKGROUND, "-areabackground", "areaBackground", + "AreaBackground", DEF_LINE_PATTERN_BG, Blt_Offset(LineElement, fillBg), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_LINE_TAGS, + Blt_Offset(LineElement, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-color", "color", "Color", DEF_LINE_PEN_COLOR, + Blt_Offset(LineElement, builtinPen.traceColor), 0}, + {BLT_CONFIG_DASHES, "-dashes", "dashes", "Dashes", DEF_LINE_DASHES, + Blt_Offset(LineElement, builtinPen.traceDashes), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-data", "data", "Data", DEF_LINE_DATA, 0, 0, + &bltValuePairsOption}, + {BLT_CONFIG_CUSTOM, "-errorbarcolor", "errorBarColor", "ErrorBarColor", + DEF_LINE_ERRORBAR_COLOR, + Blt_Offset(LineElement, builtinPen.errorBarColor), 0, &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG,"-errorbarwidth", "errorBarWidth", "ErrorBarWidth", + DEF_LINE_ERRORBAR_LINE_WIDTH, + Blt_Offset(LineElement, builtinPen.errorBarLineWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-errorbarcap", "errorBarCap", "ErrorBarCap", + DEF_LINE_ERRORBAR_CAP_WIDTH, + Blt_Offset(LineElement, builtinPen.errorBarCapWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-fill", "fill", "Fill", DEF_LINE_FILL_COLOR, + Blt_Offset(LineElement, builtinPen.symbol.fillColor), + BLT_CONFIG_NULL_OK, &bltColorOption}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_LINE_HIDE, + Blt_Offset(LineElement, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_STRING, "-label", "label", "Label", (char *)NULL, + Blt_Offset(LineElement, label), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_RELIEF, "-legendrelief", "legendRelief", "LegendRelief", + DEF_LINE_LABEL_RELIEF, Blt_Offset(LineElement, legendRelief), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-linewidth", "lineWidth", "LineWidth", + DEF_LINE_PEN_WIDTH, Blt_Offset(LineElement, builtinPen.traceWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", + DEF_LINE_AXIS_X, Blt_Offset(LineElement, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", + DEF_LINE_AXIS_Y, Blt_Offset(LineElement, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_INT_NNEG, "-maxsymbols", "maxSymbols", "MaxSymbols", + DEF_LINE_MAX_SYMBOLS, Blt_Offset(LineElement, reqMaxSymbols), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-offdash", "offDash", "OffDash", + DEF_LINE_OFFDASH_COLOR, + Blt_Offset(LineElement, builtinPen.traceOffColor), + BLT_CONFIG_NULL_OK, &bltColorOption}, + {BLT_CONFIG_CUSTOM, "-outline", "outline", "Outline", + DEF_LINE_OUTLINE_COLOR, + Blt_Offset(LineElement, builtinPen.symbol.outlineColor), + 0, &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG, "-outlinewidth", "outlineWidth", "OutlineWidth", + DEF_LINE_OUTLINE_WIDTH, + Blt_Offset(LineElement, builtinPen.symbol.outlineWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-pen", "pen", "Pen", (char *)NULL, + Blt_Offset(LineElement, normalPenPtr), BLT_CONFIG_NULL_OK, + &bltLinePenOption}, + {BLT_CONFIG_PIXELS_NNEG, "-pixels", "pixels", "Pixels", DEF_LINE_PIXELS, + Blt_Offset(LineElement, builtinPen.symbol.size), GRAPH | STRIPCHART}, + {BLT_CONFIG_FLOAT, "-reduce", "reduce", "Reduce", + DEF_LINE_REDUCE, Blt_Offset(LineElement, rTolerance), + GRAPH | STRIPCHART | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-scalesymbols", "scaleSymbols", "ScaleSymbols", + DEF_LINE_SCALE_SYMBOLS, Blt_Offset(LineElement, scaleSymbols), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FILL, "-showerrorbars", "showErrorBars", "ShowErrorBars", + DEF_LINE_SHOW_ERRORBARS, + Blt_Offset(LineElement, builtinPen.errorBarShow), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FILL, "-showvalues", "showValues", "ShowValues", + DEF_PEN_SHOW_VALUES, Blt_Offset(LineElement, builtinPen.valueShow), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-smooth", "smooth", "Smooth", DEF_LINE_SMOOTH, + Blt_Offset(LineElement, reqSmooth), BLT_CONFIG_DONT_SET_DEFAULT, + &smoothOption}, + {BLT_CONFIG_STATE, "-state", "state", "State", DEF_LINE_STATE, + Blt_Offset(LineElement, state), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-styles", "styles", "Styles", DEF_LINE_STYLES, + Blt_Offset(LineElement, styles), 0, &bltLineStylesOption}, + {BLT_CONFIG_CUSTOM, "-symbol", "symbol", "Symbol", DEF_LINE_SYMBOL, + Blt_Offset(LineElement, builtinPen.symbol), + BLT_CONFIG_DONT_SET_DEFAULT, &symbolOption}, + {BLT_CONFIG_CUSTOM, "-trace", "trace", "Trace", DEF_LINE_PEN_DIRECTION, + Blt_Offset(LineElement, penDir), + BLT_CONFIG_DONT_SET_DEFAULT, &penDirOption}, + {BLT_CONFIG_ANCHOR, "-valueanchor", "valueAnchor", "ValueAnchor", + DEF_PEN_VALUE_ANCHOR, + Blt_Offset(LineElement, builtinPen.valueStyle.anchor), 0}, + {BLT_CONFIG_COLOR, "-valuecolor", "valueColor", "ValueColor", + DEF_PEN_VALUE_COLOR, + Blt_Offset(LineElement, builtinPen.valueStyle.color), 0}, + {BLT_CONFIG_FONT, "-valuefont", "valueFont", "ValueFont", + DEF_PEN_VALUE_FONT, + Blt_Offset(LineElement, builtinPen.valueStyle.font), 0}, + {BLT_CONFIG_STRING, "-valueformat", "valueFormat", "ValueFormat", + DEF_PEN_VALUE_FORMAT, Blt_Offset(LineElement, builtinPen.valueFormat), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_FLOAT, "-valuerotate", "valueRotate", "ValueRotate", + DEF_PEN_VALUE_ANGLE, + Blt_Offset(LineElement, builtinPen.valueStyle.angle), 0}, + {BLT_CONFIG_CUSTOM, "-weights", "weights", "Weights", (char *)NULL, + Blt_Offset(LineElement, w), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-x", "xData", "XData", (char *)NULL, + Blt_Offset(LineElement, x), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xdata", "xData", "XData", (char *)NULL, + Blt_Offset(LineElement, x), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xerror", "xError", "XError", (char *)NULL, + Blt_Offset(LineElement, xError), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xhigh", "xHigh", "XHigh", (char *)NULL, + Blt_Offset(LineElement, xHigh), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xlow", "xLow", "XLow", (char *)NULL, + Blt_Offset(LineElement, xLow), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-y", "yData", "YData", (char *)NULL, + Blt_Offset(LineElement, y), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-ydata", "yData", "YData", (char *)NULL, + Blt_Offset(LineElement, y), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-yerror", "yError", "YError", (char *)NULL, + Blt_Offset(LineElement, yError), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-yhigh", "yHigh", "YHigh", (char *)NULL, + Blt_Offset(LineElement, yHigh), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-ylow", "yLow", "YLow", (char *)NULL, + Blt_Offset(LineElement, yLow), 0, &bltValuesOption}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + + +static Blt_ConfigSpec stripElemConfigSpecs[] = +{ + {BLT_CONFIG_CUSTOM, "-activepen", "activePen", "ActivePen", + DEF_LINE_ACTIVE_PEN, Blt_Offset(LineElement, activePenPtr), + BLT_CONFIG_NULL_OK, &bltLinePenOption}, + {BLT_CONFIG_COLOR, "-areaforeground", "areaForeground", "areaForeground", + DEF_LINE_PATTERN_FG, Blt_Offset(LineElement, fillFgColor), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BACKGROUND, "-areabackground", "areaBackground", + "areaBackground", DEF_LINE_PATTERN_BG, Blt_Offset(LineElement, fillBg), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_LINE_TAGS, + Blt_Offset(LineElement, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-color", "color", "Color", + DEF_LINE_PEN_COLOR, Blt_Offset(LineElement, builtinPen.traceColor), 0}, + {BLT_CONFIG_DASHES, "-dashes", "dashes", "Dashes", + DEF_LINE_DASHES, Blt_Offset(LineElement, builtinPen.traceDashes), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-data", "data", "Data", DEF_LINE_DATA, 0, 0, + &bltValuePairsOption}, + {BLT_CONFIG_CUSTOM, "-errorbarcolor", "errorBarColor", "ErrorBarColor", + DEF_LINE_ERRORBAR_COLOR, + Blt_Offset(LineElement, builtinPen.errorBarColor), 0, &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG, "-errorbarwidth", "errorBarWidth", "ErrorBarWidth", + DEF_LINE_ERRORBAR_LINE_WIDTH, + Blt_Offset(LineElement, builtinPen.errorBarLineWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-errorbarcap", "errorBarCap", "ErrorBarCap", + DEF_LINE_ERRORBAR_CAP_WIDTH, + Blt_Offset(LineElement, builtinPen.errorBarCapWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-fill", "fill", "Fill", DEF_LINE_FILL_COLOR, + Blt_Offset(LineElement, builtinPen.symbol.fillColor), + BLT_CONFIG_NULL_OK, &bltColorOption}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_LINE_HIDE, + Blt_Offset(LineElement, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_STRING, "-label", "label", "Label", (char *)NULL, + Blt_Offset(LineElement, label), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_RELIEF, "-legendrelief", "legendRelief", "LegendRelief", + DEF_LINE_LABEL_RELIEF, Blt_Offset(LineElement, legendRelief), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-linewidth", "lineWidth", "LineWidth", + DEF_LINE_PEN_WIDTH, Blt_Offset(LineElement, builtinPen.traceWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", DEF_LINE_AXIS_X, + Blt_Offset(LineElement, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", DEF_LINE_AXIS_Y, + Blt_Offset(LineElement, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_INT_NNEG, "-maxsymbols", "maxSymbols", "MaxSymbols", + DEF_LINE_MAX_SYMBOLS, Blt_Offset(LineElement, reqMaxSymbols), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-offdash", "offDash", "OffDash", + DEF_LINE_OFFDASH_COLOR, Blt_Offset(LineElement, builtinPen.traceOffColor), + BLT_CONFIG_NULL_OK, &bltColorOption}, + {BLT_CONFIG_CUSTOM, "-outline", "outline", "Outline", + DEF_LINE_OUTLINE_COLOR, + Blt_Offset(LineElement, builtinPen.symbol.outlineColor), 0, + &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG, "-outlinewidth", "outlineWidth", "OutlineWidth", + DEF_LINE_OUTLINE_WIDTH, + Blt_Offset(LineElement, builtinPen.symbol.outlineWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-pen", "pen", "Pen", (char *)NULL, + Blt_Offset(LineElement, normalPenPtr), BLT_CONFIG_NULL_OK, + &bltLinePenOption}, + {BLT_CONFIG_PIXELS_NNEG, "-pixels", "pixels", "Pixels", DEF_LINE_PIXELS, + Blt_Offset(LineElement, builtinPen.symbol.size), 0}, + {BLT_CONFIG_BOOLEAN, "-scalesymbols", "scaleSymbols", "ScaleSymbols", + DEF_LINE_SCALE_SYMBOLS, Blt_Offset(LineElement, scaleSymbols), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FILL, "-showerrorbars", "showErrorBars", "ShowErrorBars", + DEF_LINE_SHOW_ERRORBARS, + Blt_Offset(LineElement, builtinPen.errorBarShow), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FILL, "-showvalues", "showValues", "ShowValues", + DEF_PEN_SHOW_VALUES, Blt_Offset(LineElement, builtinPen.valueShow), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-smooth", "smooth", "Smooth", DEF_LINE_SMOOTH, + Blt_Offset(LineElement, reqSmooth), BLT_CONFIG_DONT_SET_DEFAULT, + &smoothOption}, + {BLT_CONFIG_CUSTOM, "-styles", "styles", "Styles", DEF_LINE_STYLES, + Blt_Offset(LineElement, styles), 0, &bltLineStylesOption}, + {BLT_CONFIG_CUSTOM, "-symbol", "symbol", "Symbol", DEF_LINE_SYMBOL, + Blt_Offset(LineElement, builtinPen.symbol), + BLT_CONFIG_DONT_SET_DEFAULT, &symbolOption}, + {BLT_CONFIG_ANCHOR, "-valueanchor", "valueAnchor", "ValueAnchor", + DEF_PEN_VALUE_ANCHOR, + Blt_Offset(LineElement, builtinPen.valueStyle.anchor), 0}, + {BLT_CONFIG_COLOR, "-valuecolor", "valueColor", "ValueColor", + DEF_PEN_VALUE_COLOR, + Blt_Offset(LineElement, builtinPen.valueStyle.color), 0}, + {BLT_CONFIG_FONT, "-valuefont", "valueFont", "ValueFont", + DEF_PEN_VALUE_FONT, + Blt_Offset(LineElement, builtinPen.valueStyle.font), 0}, + {BLT_CONFIG_STRING, "-valueformat", "valueFormat", "ValueFormat", + DEF_PEN_VALUE_FORMAT, Blt_Offset(LineElement, builtinPen.valueFormat), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_FLOAT, "-valuerotate", "valueRotate", "ValueRotate", + DEF_PEN_VALUE_ANGLE, + Blt_Offset(LineElement, builtinPen.valueStyle.angle),0}, + {BLT_CONFIG_CUSTOM, "-weights", "weights", "Weights", (char *)NULL, + Blt_Offset(LineElement, w), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-x", "xData", "XData", (char *)NULL, + Blt_Offset(LineElement, x), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xdata", "xData", "XData", (char *)NULL, + Blt_Offset(LineElement, x), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-y", "yData", "YData", (char *)NULL, + Blt_Offset(LineElement, y), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xerror", "xError", "XError", (char *)NULL, + Blt_Offset(LineElement, xError), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-ydata", "yData", "YData", (char *)NULL, + Blt_Offset(LineElement, y), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-yerror", "yError", "YError", (char *)NULL, + Blt_Offset(LineElement, yError), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xhigh", "xHigh", "XHigh", (char *)NULL, + Blt_Offset(LineElement, xHigh), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-xlow", "xLow", "XLow", (char *)NULL, + Blt_Offset(LineElement, xLow), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-yhigh", "yHigh", "YHigh", (char *)NULL, + Blt_Offset(LineElement, xHigh), 0, &bltValuesOption}, + {BLT_CONFIG_CUSTOM, "-ylow", "yLow", "YLow", (char *)NULL, + Blt_Offset(LineElement, yLow), 0, &bltValuesOption}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static Blt_ConfigSpec linePenConfigSpecs[] = +{ + {BLT_CONFIG_COLOR, "-color", "color", "Color", DEF_PEN_ACTIVE_COLOR, + Blt_Offset(LinePen, traceColor), ACTIVE_PEN}, + {BLT_CONFIG_COLOR, "-color", "color", "Color", DEF_PEN_NORMAL_COLOR, + Blt_Offset(LinePen, traceColor), NORMAL_PEN}, + {BLT_CONFIG_DASHES, "-dashes", "dashes", "Dashes", DEF_PEN_DASHES, + Blt_Offset(LinePen, traceDashes), BLT_CONFIG_NULL_OK | ALL_PENS}, + {BLT_CONFIG_CUSTOM, "-errorbarcolor", "errorBarColor", "ErrorBarColor", + DEF_LINE_ERRORBAR_COLOR, Blt_Offset(LinePen, errorBarColor), + ALL_PENS, &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG, "-errorbarwidth", "errorBarWidth", "ErrorBarWidth", + DEF_LINE_ERRORBAR_LINE_WIDTH, Blt_Offset(LinePen, errorBarLineWidth), + ALL_PENS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-errorbarcap", "errorBarCap", "ErrorBarCap", + DEF_LINE_ERRORBAR_CAP_WIDTH, Blt_Offset(LinePen, errorBarCapWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-fill", "fill", "Fill", DEF_PEN_FILL_COLOR, + Blt_Offset(LinePen, symbol.fillColor), BLT_CONFIG_NULL_OK | ALL_PENS, + &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG, "-linewidth", "lineWidth", "LineWidth", + (char *)NULL, Blt_Offset(LinePen, traceWidth), + ALL_PENS| BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-offdash", "offDash", "OffDash", DEF_PEN_OFFDASH_COLOR, + Blt_Offset(LinePen, traceOffColor), BLT_CONFIG_NULL_OK | ALL_PENS, + &bltColorOption}, + {BLT_CONFIG_CUSTOM, "-outline", "outline", "Outline", DEF_PEN_OUTLINE_COLOR, + Blt_Offset(LinePen, symbol.outlineColor), ALL_PENS, &bltColorOption}, + {BLT_CONFIG_PIXELS_NNEG, "-outlinewidth", "outlineWidth", "OutlineWidth", + DEF_PEN_OUTLINE_WIDTH, Blt_Offset(LinePen, symbol.outlineWidth), + BLT_CONFIG_DONT_SET_DEFAULT | ALL_PENS}, + {BLT_CONFIG_PIXELS_NNEG, "-pixels", "pixels", "Pixels", DEF_PEN_PIXELS, + Blt_Offset(LinePen, symbol.size), ALL_PENS}, + {BLT_CONFIG_FILL, "-showerrorbars", "showErrorBars", "ShowErrorBars", + DEF_LINE_SHOW_ERRORBARS, Blt_Offset(LinePen, errorBarShow), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FILL, "-showvalues", "showValues", "ShowValues", + DEF_PEN_SHOW_VALUES, Blt_Offset(LinePen, valueShow), + ALL_PENS | BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-symbol", "symbol", "Symbol", DEF_PEN_SYMBOL, + Blt_Offset(LinePen, symbol), BLT_CONFIG_DONT_SET_DEFAULT | ALL_PENS, + &symbolOption}, + {BLT_CONFIG_STRING, "-type", (char *)NULL, (char *)NULL, DEF_PEN_TYPE, + Blt_Offset(Pen, typeId), ALL_PENS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_ANCHOR, "-valueanchor", "valueAnchor", "ValueAnchor", + DEF_PEN_VALUE_ANCHOR, Blt_Offset(LinePen, valueStyle.anchor), ALL_PENS}, + {BLT_CONFIG_COLOR, "-valuecolor", "valueColor", "ValueColor", + DEF_PEN_VALUE_COLOR, Blt_Offset(LinePen, valueStyle.color), ALL_PENS}, + {BLT_CONFIG_FONT, "-valuefont", "valueFont", "ValueFont", + DEF_PEN_VALUE_FONT, Blt_Offset(LinePen, valueStyle.font), ALL_PENS}, + {BLT_CONFIG_STRING, "-valueformat", "valueFormat", "ValueFormat", + DEF_PEN_VALUE_FORMAT, Blt_Offset(LinePen, valueFormat), + ALL_PENS | BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_FLOAT, "-valuerotate", "valueRotate", "ValueRotate", + DEF_PEN_VALUE_ANGLE, Blt_Offset(LinePen, valueStyle.angle), ALL_PENS}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +typedef double (DistanceProc)(int x, int y, Point2d *p, Point2d *q, Point2d *t); + +/* Forward declarations */ +static PenConfigureProc ConfigurePenProc; +static PenDestroyProc DestroyPenProc; +static ElementClosestProc ClosestLineProc; +static ElementConfigProc ConfigureLineProc; +static ElementDestroyProc DestroyLineProc; +static ElementDrawProc DrawActiveLineProc; +static ElementDrawProc DrawNormalLineProc; +static ElementDrawSymbolProc DrawSymbolProc; +static ElementExtentsProc GetLineExtentsProc; +static ElementToPostScriptProc ActiveLineToPostScriptProc; +static ElementToPostScriptProc NormalLineToPostScriptProc; +static ElementSymbolToPostScriptProc SymbolToPostScriptProc; +static ElementMapProc MapLineProc; +static DistanceProc DistanceToYProc; +static DistanceProc DistanceToXProc; +static DistanceProc DistanceToLineProc; +static Blt_BackgroundChangedProc BackgroundChangedProc; + +#ifdef WIN32 + +static int tkpWinRopModes[] = +{ + R2_BLACK, /* GXclear */ + R2_MASKPEN, /* GXand */ + R2_MASKPENNOT, /* GXandReverse */ + R2_COPYPEN, /* GXcopy */ + R2_MASKNOTPEN, /* GXandInverted */ + R2_NOT, /* GXnoop */ + R2_XORPEN, /* GXxor */ + R2_MERGEPEN, /* GXor */ + R2_NOTMERGEPEN, /* GXnor */ + R2_NOTXORPEN, /* GXequiv */ + R2_NOT, /* GXinvert */ + R2_MERGEPENNOT, /* GXorReverse */ + R2_NOTCOPYPEN, /* GXcopyInverted */ + R2_MERGENOTPEN, /* GXorInverted */ + R2_NOTMASKPEN, /* GXnand */ + R2_WHITE /* GXset */ +}; + +#endif + +#ifndef notdef +INLINE static int +Round(double x) +{ + return (int) (x + ((x < 0.0) ? -0.5 : 0.5)); +} +#else +#define Round Round +#endif +/* + *--------------------------------------------------------------------------- + * Custom configuration option (parse and print) routines + *--------------------------------------------------------------------------- + */ + +static void +DestroySymbol(Display *display, Symbol *symbolPtr) +{ + if (symbolPtr->image != NULL) { + Tk_FreeImage(symbolPtr->image); + symbolPtr->image = NULL; + } + if (symbolPtr->bitmap != None) { + Tk_FreeBitmap(display, symbolPtr->bitmap); + symbolPtr->bitmap = None; + } + if (symbolPtr->mask != None) { + Tk_FreeBitmap(display, symbolPtr->mask); + symbolPtr->mask = None; + } + symbolPtr->type = SYMBOL_NONE; +} + +/* + *--------------------------------------------------------------------------- + * + * ImageChangedProc + * + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static void +ImageChangedProc( + ClientData clientData, + int x, int y, int w, int h, /* Not used. */ + int imageWidth, int imageHeight) /* Not used. */ +{ + Element *elemPtr; + Graph *graphPtr; + + elemPtr = clientData; + elemPtr->flags |= MAP_ITEM; + graphPtr = elemPtr->obj.graphPtr; + graphPtr->flags |= CACHE_DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); +} + +/*ARGSUSED*/ +static void +FreeSymbolProc( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + Symbol *symbolPtr = (Symbol *)(widgRec + offset); + + DestroySymbol(display, symbolPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToSymbol -- + * + * Convert the string representation of a line style or symbol name into + * its numeric form. + * + * Results: + * The return value is a standard TCL result. The symbol type is written + * into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToSymbolProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back + * to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing symbol type */ + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Symbol *symbolPtr = (Symbol *)(widgRec + offset); + const char *string; + + { + int length; + GraphSymbolType *p; + char c; + + string = Tcl_GetStringFromObj(objPtr, &length); + if (length == 0) { + DestroySymbol(Tk_Display(tkwin), symbolPtr); + symbolPtr->type = SYMBOL_NONE; + return TCL_OK; + } + c = string[0]; + for (p = graphSymbols; p->name != NULL; p++) { + if (length < p->minChars) { + continue; + } + if ((c == p->name[0]) && (strncmp(string, p->name, length) == 0)) { + DestroySymbol(Tk_Display(tkwin), symbolPtr); + symbolPtr->type = p->type; + return TCL_OK; + } + } + } + { + Tk_Image tkImage; + Element *elemPtr = (Element *)widgRec; + + tkImage = Tk_GetImage(interp, tkwin, string, ImageChangedProc, elemPtr); + if (tkImage != NULL) { + DestroySymbol(Tk_Display(tkwin), symbolPtr); + symbolPtr->image = tkImage; + symbolPtr->type = SYMBOL_IMAGE; + return TCL_OK; + } + } + { + Pixmap bitmap, mask; + Tcl_Obj **objv; + int objc; + + if ((Tcl_ListObjGetElements(NULL, objPtr, &objc, &objv) != TCL_OK) || + (objc > 2)) { + goto error; + } + bitmap = mask = None; + if (objc > 0) { + bitmap = Tk_AllocBitmapFromObj((Tcl_Interp *)NULL, tkwin, objv[0]); + if (bitmap == None) { + goto error; + } + } + if (objc > 1) { + mask = Tk_AllocBitmapFromObj((Tcl_Interp *)NULL, tkwin, objv[1]); + if (mask == None) { + goto error; + } + } + DestroySymbol(Tk_Display(tkwin), symbolPtr); + symbolPtr->bitmap = bitmap; + symbolPtr->mask = mask; + symbolPtr->type = SYMBOL_BITMAP; + return TCL_OK; + } + error: + Tcl_AppendResult(interp, "bad symbol \"", string, + "\": should be \"none\", \"circle\", \"square\", \"diamond\", " + "\"plus\", \"cross\", \"splus\", \"scross\", \"triangle\", " + "\"arrow\" or the name of a bitmap", (char *)NULL); + return TCL_ERROR; +} + +/* + *--------------------------------------------------------------------------- + * + * SymbolToObj -- + * + * Convert the symbol value into a string. + * + * Results: + * The string representing the symbol type or line style is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +SymbolToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Symbol *symbolPtr = (Symbol *)(widgRec + offset); + + if (symbolPtr->type == SYMBOL_BITMAP) { + Tcl_Obj *listObjPtr, *objPtr; + const char *name; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + name = Tk_NameOfBitmap(Tk_Display(tkwin), symbolPtr->bitmap); + objPtr = Tcl_NewStringObj(name, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + if (symbolPtr->mask == None) { + objPtr = Tcl_NewStringObj("", -1); + } else { + name = Tk_NameOfBitmap(Tk_Display(tkwin), symbolPtr->mask); + objPtr = Tcl_NewStringObj(name, -1); + } + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + return listObjPtr; + } else { + GraphSymbolType *p; + + for (p = graphSymbols; p->name != NULL; p++) { + if (p->type == symbolPtr->type) { + return Tcl_NewStringObj(p->name, -1); + } + } + return Tcl_NewStringObj("?unknown symbol type?", -1); + } +} + +/* + *--------------------------------------------------------------------------- + * + * NameOfSmooth -- + * + * Converts the smooth value into its string representation. + * + * Results: + * The static string representing the smooth type is returned. + * + *--------------------------------------------------------------------------- + */ +static const char * +NameOfSmooth(Smoothing value) +{ + SmoothingInfo *siPtr; + + for (siPtr = smoothingInfo; siPtr->name != NULL; siPtr++) { + if (siPtr->value == value) { + return siPtr->name; + } + } + return "unknown smooth value"; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToSmooth -- + * + * Convert the string representation of a line style or smooth name + * into its numeric form. + * + * Results: + * The return value is a standard TCL result. The smooth type is + * written into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToSmoothProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back + * to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing smooth type */ + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Smoothing *valuePtr = (Smoothing *)(widgRec + offset); + SmoothingInfo *siPtr; + const char *string; + char c; + + string = Tcl_GetString(objPtr); + c = string[0]; + for (siPtr = smoothingInfo; siPtr->name != NULL; siPtr++) { + if ((c == siPtr->name[0]) && (strcmp(string, siPtr->name) == 0)) { + *valuePtr = siPtr->value; + return TCL_OK; + } + } + Tcl_AppendResult(interp, "bad smooth value \"", string, "\": should be \ +linear, step, natural, or quadratic", (char *)NULL); + return TCL_ERROR; +} + +/* + *--------------------------------------------------------------------------- + * + * SmoothToObj -- + * + * Convert the smooth value into a string. + * + * Results: + * The string representing the smooth type or line style is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +SmoothToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + int smooth = *(int *)(widgRec + offset); + + return Tcl_NewStringObj(NameOfSmooth(smooth), -1); +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToPenDir -- + * + * Convert the string representation of a line style or symbol name + * into its numeric form. + * + * Results: + * The return value is a standard TCL result. The symbol type is + * written into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToPenDirProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back + * to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing pen direction */ + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + int *penDirPtr = (int *)(widgRec + offset); + int length; + char c; + char *string; + + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[0]; + if ((c == 'i') && (strncmp(string, "increasing", length) == 0)) { + *penDirPtr = PEN_INCREASING; + } else if ((c == 'd') && (strncmp(string, "decreasing", length) == 0)) { + *penDirPtr = PEN_DECREASING; + } else if ((c == 'b') && (strncmp(string, "both", length) == 0)) { + *penDirPtr = PEN_BOTH_DIRECTIONS; + } else { + Tcl_AppendResult(interp, "bad trace value \"", string, + "\" : should be \"increasing\", \"decreasing\", or \"both\"", + (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NameOfPenDir -- + * + * Convert the pen direction into a string. + * + * Results: + * The static string representing the pen direction is returned. + * + *--------------------------------------------------------------------------- + */ +static const char * +NameOfPenDir(int penDir) +{ + switch (penDir) { + case PEN_INCREASING: + return "increasing"; + case PEN_DECREASING: + return "decreasing"; + case PEN_BOTH_DIRECTIONS: + return "both"; + default: + return "unknown trace direction"; + } +} + +/* + *--------------------------------------------------------------------------- + * + * PenDirToObj -- + * + * Convert the pen direction into a string. + * + * Results: + * The string representing the pen drawing direction is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +PenDirToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + int penDir = *(int *)(widgRec + offset); + + return Tcl_NewStringObj(NameOfPenDir(penDir), -1); +} + + +/* + * Reset the number of points and segments, in case there are no segments or + * points + */ +static void +ResetStylePalette(Blt_Chain styles) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(styles); link != NULL; + link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->lines.length = stylePtr->symbolPts.length = 0; + stylePtr->xeb.length = stylePtr->yeb.length = 0; + } +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigurePenProc -- + * + * Sets up the appropriate configuration parameters in the GC. It is + * assumed the parameters have been previously set by a call to + * Blt_ConfigureWidget. + * + * Results: + * The return value is a standard TCL result. If TCL_ERROR is returned, + * then interp->result contains an error message. + * + * Side effects: + * Configuration information such as line width, line style, color + * etc. get set in a new GC. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ConfigurePenProc(Graph *graphPtr, Pen *penPtr) +{ + LinePen *lpPtr = (LinePen *)penPtr; + unsigned long gcMask; + GC newGC; + XGCValues gcValues; + XColor *colorPtr; + + /* + * Set the outline GC for this pen: GCForeground is outline color. + * GCBackground is the fill color (only used for bitmap symbols). + */ + gcMask = (GCLineWidth | GCForeground); + colorPtr = lpPtr->symbol.outlineColor; + if (colorPtr == COLOR_DEFAULT) { + colorPtr = lpPtr->traceColor; + } + gcValues.foreground = colorPtr->pixel; + if (lpPtr->symbol.type == SYMBOL_BITMAP) { + colorPtr = lpPtr->symbol.fillColor; + if (colorPtr == COLOR_DEFAULT) { + colorPtr = lpPtr->traceColor; + } + /* + * Set a clip mask if either + * 1) no background color was designated or + * 2) a masking bitmap was specified. + * + * These aren't necessarily the bitmaps we'll be using for clipping. But + * this makes it unlikely that anyone else will be sharing this GC when + * we set the clip origin (at the time the bitmap is drawn). + */ + if (colorPtr != NULL) { + gcValues.background = colorPtr->pixel; + gcMask |= GCBackground; + if (lpPtr->symbol.mask != None) { + gcValues.clip_mask = lpPtr->symbol.mask; + gcMask |= GCClipMask; + } + } else { + gcValues.clip_mask = lpPtr->symbol.bitmap; + gcMask |= GCClipMask; + } + } + gcValues.line_width = LineWidth(lpPtr->symbol.outlineWidth); + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (lpPtr->symbol.outlineGC != NULL) { + Tk_FreeGC(graphPtr->display, lpPtr->symbol.outlineGC); + } + lpPtr->symbol.outlineGC = newGC; + + /* Fill GC for symbols: GCForeground is fill color */ + + gcMask = (GCLineWidth | GCForeground); + colorPtr = lpPtr->symbol.fillColor; + if (colorPtr == COLOR_DEFAULT) { + colorPtr = lpPtr->traceColor; + } + newGC = NULL; + if (colorPtr != NULL) { + gcValues.foreground = colorPtr->pixel; + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + } + if (lpPtr->symbol.fillGC != NULL) { + Tk_FreeGC(graphPtr->display, lpPtr->symbol.fillGC); + } + lpPtr->symbol.fillGC = newGC; + + /* Line segments */ + + gcMask = (GCLineWidth | GCForeground | GCLineStyle | GCCapStyle | + GCJoinStyle); + gcValues.cap_style = CapButt; + gcValues.join_style = JoinRound; + gcValues.line_style = LineSolid; + gcValues.line_width = LineWidth(lpPtr->traceWidth); + + colorPtr = lpPtr->traceOffColor; + if (colorPtr == COLOR_DEFAULT) { + colorPtr = lpPtr->traceColor; + } + if (colorPtr != NULL) { + gcMask |= GCBackground; + gcValues.background = colorPtr->pixel; + } + gcValues.foreground = lpPtr->traceColor->pixel; + if (LineIsDashed(lpPtr->traceDashes)) { + gcValues.line_width = lpPtr->traceWidth; + gcValues.line_style = + (colorPtr == NULL) ? LineOnOffDash : LineDoubleDash; + } + newGC = Blt_GetPrivateGC(graphPtr->tkwin, gcMask, &gcValues); + if (lpPtr->traceGC != NULL) { + Blt_FreePrivateGC(graphPtr->display, lpPtr->traceGC); + } + if (LineIsDashed(lpPtr->traceDashes)) { + lpPtr->traceDashes.offset = lpPtr->traceDashes.values[0] / 2; + Blt_SetDashes(graphPtr->display, newGC, &lpPtr->traceDashes); + } + lpPtr->traceGC = newGC; + + gcMask = (GCLineWidth | GCForeground); + colorPtr = lpPtr->errorBarColor; + if (colorPtr == COLOR_DEFAULT) { + colorPtr = lpPtr->traceColor; + } + gcValues.line_width = LineWidth(lpPtr->errorBarLineWidth); + gcValues.foreground = colorPtr->pixel; + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (lpPtr->errorBarGC != NULL) { + Tk_FreeGC(graphPtr->display, lpPtr->errorBarGC); + } + lpPtr->errorBarGC = newGC; + + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DestroyPenProc -- + * + * Release memory and resources allocated for the style. + * + * Results: + * None. + * + * Side effects: + * Everything associated with the pen style is freed up. + * + *--------------------------------------------------------------------------- + */ +static void +DestroyPenProc(Graph *graphPtr, Pen *basePtr) +{ + LinePen *penPtr = (LinePen *)basePtr; + + Blt_Ts_FreeStyle(graphPtr->display, &penPtr->valueStyle); + if (penPtr->symbol.outlineGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->symbol.outlineGC); + } + if (penPtr->symbol.fillGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->symbol.fillGC); + } + if (penPtr->errorBarGC != NULL) { + Tk_FreeGC(graphPtr->display, penPtr->errorBarGC); + } + if (penPtr->traceGC != NULL) { + Blt_FreePrivateGC(graphPtr->display, penPtr->traceGC); + } + if (penPtr->symbol.bitmap != None) { + Tk_FreeBitmap(graphPtr->display, penPtr->symbol.bitmap); + penPtr->symbol.bitmap = None; + } + if (penPtr->symbol.mask != None) { + Tk_FreeBitmap(graphPtr->display, penPtr->symbol.mask); + penPtr->symbol.mask = None; + } +} + + +static void +InitLinePen(LinePen *penPtr) +{ + Blt_Ts_InitStyle(penPtr->valueStyle); + penPtr->errorBarLineWidth = 2; + penPtr->errorBarShow = SHOW_BOTH; + penPtr->configProc = ConfigurePenProc; + penPtr->configSpecs = linePenConfigSpecs; + penPtr->destroyProc = DestroyPenProc; + penPtr->flags = NORMAL_PEN; + penPtr->name = ""; + penPtr->symbol.bitmap = penPtr->symbol.mask = None; + penPtr->symbol.outlineColor = penPtr->symbol.fillColor = COLOR_DEFAULT; + penPtr->symbol.outlineWidth = penPtr->traceWidth = 1; + penPtr->symbol.type = SYMBOL_CIRCLE; + penPtr->valueShow = SHOW_NONE; +} + +Pen * +Blt_LinePen(const char *penName) +{ + LinePen *penPtr; + + penPtr = Blt_AssertCalloc(1, sizeof(LinePen)); + InitLinePen(penPtr); + penPtr->name = Blt_AssertStrdup(penName); + penPtr->classId = CID_ELEM_LINE; + if (strcmp(penName, "activeLine") == 0) { + penPtr->flags = ACTIVE_PEN; + } + return (Pen *)penPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * In this section, the routines deal with building and filling the + * element's data structures with transformed screen coordinates. They are + * triggered from TranformLine which is called whenever the data or + * coordinates axes have changed and new screen coordinates need to be + * calculated. + * + *--------------------------------------------------------------------------- + */ + +/* + *--------------------------------------------------------------------------- + * + * ScaleSymbol -- + * + * Returns the scaled size for the line element. Scaling depends upon when + * the base line ranges for the element were set and the current range of + * the graph. + * + * Results: + * The new size of the symbol, after considering how much the graph has + * been scaled, is returned. + * + *--------------------------------------------------------------------------- + */ +static int +ScaleSymbol(LineElement *elemPtr, int normalSize) +{ + int maxSize; + double scale; + int newSize; + + scale = 1.0; + if (elemPtr->scaleSymbols) { + double xRange, yRange; + + xRange = (elemPtr->axes.x->max - elemPtr->axes.x->min); + yRange = (elemPtr->axes.y->max - elemPtr->axes.y->min); + if (elemPtr->flags & SCALE_SYMBOL) { + /* Save the ranges as a baseline for future scaling. */ + elemPtr->xRange = xRange; + elemPtr->yRange = yRange; + elemPtr->flags &= ~SCALE_SYMBOL; + } else { + double xScale, yScale; + + /* Scale the symbol by the smallest change in the X or Y axes */ + xScale = elemPtr->xRange / xRange; + yScale = elemPtr->yRange / yRange; + scale = MIN(xScale, yScale); + } + } + newSize = Round(normalSize * scale); + + /* + * Don't let the size of symbols go unbounded. Both X and Win32 drawing + * routines assume coordinates to be a signed short int. + */ + maxSize = (int)MIN(elemPtr->obj.graphPtr->hRange, + elemPtr->obj.graphPtr->vRange); + if (newSize > maxSize) { + newSize = maxSize; + } + + /* Make the symbol size odd so that its center is a single pixel. */ + newSize |= 0x01; + return newSize; +} + +/* + *--------------------------------------------------------------------------- + * + * GetScreenPoints -- + * + * Generates a coordinate array of transformed screen coordinates from + * the data points. Coordinates with Inf, -Inf, or NaN values are + * removed. + * + * Results: + * The transformed screen coordinates are returned. + * + * Side effects: + * Memory is allocated for the coordinate array. + * + * + * Future ideas: + * Allow bad values to be removed (as done currently) or break + * into separate traces. Smoothing would be affected. + * + *--------------------------------------------------------------------------- + */ +static void +GetScreenPoints(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr) +{ + double *x, *y; + int i, np; + int count; + Point2d *points; + int *map; + + np = NUMBEROFPOINTS(elemPtr); + x = elemPtr->x.values; + y = elemPtr->y.values; + points = Blt_AssertMalloc(sizeof(Point2d) * np); + map = Blt_AssertMalloc(sizeof(int) * np); + + count = 0; /* Count the valid screen coordinates */ + if (graphPtr->inverted) { + for (i = 0; i < np; i++) { + if ((FINITE(x[i])) && (FINITE(y[i]))) { + points[count].x = Blt_HMap(elemPtr->axes.y, y[i]); + points[count].y = Blt_VMap(elemPtr->axes.x, x[i]); + map[count] = i; + count++; + } + } + } else { + for (i = 0; i < np; i++) { + if ((FINITE(x[i])) && (FINITE(y[i]))) { + points[count].x = Blt_HMap(elemPtr->axes.x, x[i]); + points[count].y = Blt_VMap(elemPtr->axes.y, y[i]); + map[count] = i; + count++; + } + } + } + mapPtr->screenPts = points; + mapPtr->nScreenPts = count; + mapPtr->map = map; +} + +/* + *--------------------------------------------------------------------------- + * + * ReducePoints -- + * + * Generates a coordinate array of transformed screen coordinates from + * the data points. + * + * Results: + * The transformed screen coordinates are returned. + * + * Side effects: + * Memory is allocated for the coordinate array. + * + *--------------------------------------------------------------------------- + */ +static void +ReducePoints(MapInfo *mapPtr, double tolerance) +{ + int i, np; + Point2d *screenPts; + int *map, *simple; + + simple = Blt_AssertMalloc(mapPtr->nScreenPts * sizeof(int)); + map = Blt_AssertMalloc(mapPtr->nScreenPts * sizeof(int)); + screenPts = Blt_AssertMalloc(mapPtr->nScreenPts * sizeof(Point2d)); + np = Blt_SimplifyLine(mapPtr->screenPts, 0, mapPtr->nScreenPts - 1, + tolerance, simple); + for (i = 0; i < np; i++) { + int k; + + k = simple[i]; + screenPts[i] = mapPtr->screenPts[k]; + map[i] = mapPtr->map[k]; + } +#ifdef notdef + if (np < mapPtr->nScreenPts) { + fprintf(stderr, "reduced from %d to %d\n", mapPtr->nScreenPts, np); + } +#endif + Blt_Free(mapPtr->screenPts); + Blt_Free(mapPtr->map); + Blt_Free(simple); + mapPtr->screenPts = screenPts; + mapPtr->map = map; + mapPtr->nScreenPts = np; +} + +/* + *--------------------------------------------------------------------------- + * + * GenerateSteps -- + * + * Resets the coordinate and pen index arrays adding new points for + * step-and-hold type smoothing. + * + * Results: + * None. + * + * Side Effects: + * The temporary arrays for screen coordinates and pen indices + * are updated. + * + *--------------------------------------------------------------------------- + */ +static void +GenerateSteps(MapInfo *mapPtr) +{ + int newSize; + int i, count; + Point2d *screenPts; + int *map; + + newSize = ((mapPtr->nScreenPts - 1) * 2) + 1; + screenPts = Blt_AssertMalloc(newSize * sizeof(Point2d)); + map = Blt_AssertMalloc(sizeof(int) * newSize); + screenPts[0] = mapPtr->screenPts[0]; + map[0] = 0; + + count = 1; + for (i = 1; i < mapPtr->nScreenPts; i++) { + screenPts[count + 1] = mapPtr->screenPts[i]; + + /* Hold last y-coordinate, use new x-coordinate */ + screenPts[count].x = screenPts[count + 1].x; + screenPts[count].y = screenPts[count - 1].y; + + /* Use the same style for both the hold and the step points */ + map[count] = map[count + 1] = mapPtr->map[i]; + count += 2; + } + Blt_Free(mapPtr->screenPts); + Blt_Free(mapPtr->map); + mapPtr->map = map; + mapPtr->screenPts = screenPts; + mapPtr->nScreenPts = newSize; +} + +/* + *--------------------------------------------------------------------------- + * + * GenerateSpline -- + * + * Computes a spline based upon the data points, returning a new (larger) + * coordinate array or points. + * + * Results: + * None. + * + * Side Effects: + * The temporary arrays for screen coordinates and data map are updated + * based upon spline. + * + * FIXME: Can't interpolate knots along the Y-axis. Need to break + * up point array into interchangable X and Y vectors earlier. + * Pass extents (left/right or top/bottom) as parameters. + * + *--------------------------------------------------------------------------- + */ +static void +GenerateSpline(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr) +{ + Point2d *origPts, *iPts; + int *map; + int extra; + int niPts, nOrigPts; + int result; + int i, j, count; + + nOrigPts = mapPtr->nScreenPts; + origPts = mapPtr->screenPts; + assert(mapPtr->nScreenPts > 0); + for (i = 0, j = 1; j < nOrigPts; i++, j++) { + if (origPts[j].x <= origPts[i].x) { + return; /* Points are not monotonically + * increasing */ + } + } + if (((origPts[0].x > (double)graphPtr->right)) || + ((origPts[mapPtr->nScreenPts - 1].x < (double)graphPtr->left))) { + return; /* All points are clipped */ + } + + /* + * The spline is computed in screen coordinates instead of data points so + * that we can select the abscissas of the interpolated points from each + * pixel horizontally across the plotting area. + */ + extra = (graphPtr->right - graphPtr->left) + 1; + if (extra < 1) { + return; + } + niPts = nOrigPts + extra + 1; + iPts = Blt_AssertMalloc(niPts * sizeof(Point2d)); + map = Blt_AssertMalloc(sizeof(int) * niPts); + /* Populate the x2 array with both the original X-coordinates and extra + * X-coordinates for each horizontal pixel that the line segment + * contains. */ + count = 0; + for (i = 0, j = 1; j < nOrigPts; i++, j++) { + + /* Add the original x-coordinate */ + iPts[count].x = origPts[i].x; + + /* Include the starting offset of the point in the offset array */ + map[count] = mapPtr->map[i]; + count++; + + /* Is any part of the interval (line segment) in the plotting area? */ + if ((origPts[j].x >= (double)graphPtr->left) || + (origPts[i].x <= (double)graphPtr->right)) { + double x, last; + + x = origPts[i].x + 1.0; + + /* + * Since the line segment may be partially clipped on the left or + * right side, the points to interpolate are always interior to + * the plotting area. + * + * left right + * x1----|---------------------------|---x2 + * + * Pick the max of the starting X-coordinate and the left edge and + * the min of the last X-coordinate and the right edge. + */ + x = MAX(x, (double)graphPtr->left); + last = MIN(origPts[j].x, (double)graphPtr->right); + + /* Add the extra x-coordinates to the interval. */ + while (x < last) { + map[count] = mapPtr->map[i]; + iPts[count++].x = x; + x++; + } + } + } + niPts = count; + result = FALSE; + if (elemPtr->smooth == PEN_SMOOTH_NATURAL) { + result = Blt_NaturalSpline(origPts, nOrigPts, iPts, niPts); + } else if (elemPtr->smooth == PEN_SMOOTH_QUADRATIC) { + result = Blt_QuadraticSpline(origPts, nOrigPts, iPts, niPts); + } + if (!result) { + /* The spline interpolation failed. We'll fallback to the current + * coordinates and do no smoothing (standard line segments). */ + elemPtr->smooth = PEN_SMOOTH_LINEAR; + Blt_Free(iPts); + Blt_Free(map); + } else { + Blt_Free(mapPtr->screenPts); + Blt_Free(mapPtr->map); + mapPtr->map = map; + mapPtr->screenPts = iPts; + mapPtr->nScreenPts = niPts; + } +} + + +/* + *--------------------------------------------------------------------------- + * + * GenerateParametricSpline -- + * + * Computes a spline based upon the data points, returning a new (larger) + * coordinate array or points. + * + * Results: + * None. + * + * Side Effects: + * The temporary arrays for screen coordinates and data map are updated + * based upon spline. + * + * FIXME: Can't interpolate knots along the Y-axis. Need to break + * up point array into interchangable X and Y vectors earlier. + * Pass extents (left/right or top/bottom) as parameters. + * + *--------------------------------------------------------------------------- + */ +static void +GenerateParametricSpline(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr) +{ + Region2d exts; + Point2d *origPts, *iPts; + int *map; + int niPts, nOrigPts; + int result; + int i, j, count; + + nOrigPts = mapPtr->nScreenPts; + origPts = mapPtr->screenPts; + assert(mapPtr->nScreenPts > 0); + + Blt_GraphExtents(graphPtr, &exts); + + /* + * Populate the x2 array with both the original X-coordinates and extra + * X-coordinates for each horizontal pixel that the line segment contains. + */ + count = 1; + for (i = 0, j = 1; j < nOrigPts; i++, j++) { + Point2d p, q; + + p = origPts[i]; + q = origPts[j]; + count++; + if (Blt_LineRectClip(&exts, &p, &q)) { + count += (int)(hypot(q.x - p.x, q.y - p.y) * 0.5); + } + } + niPts = count; + iPts = Blt_AssertMalloc(niPts * sizeof(Point2d)); + map = Blt_AssertMalloc(sizeof(int) * niPts); + + /* + * FIXME: This is just plain wrong. The spline should be computed + * and evaluated in separate steps. This will mean breaking + * up this routine since the catrom coefficients can be + * independently computed for original data point. This + * also handles the problem of allocating enough points + * since evaluation is independent of the number of points + * to be evalualted. The interpolated + * line segments should be clipped, not the original segments. + */ + count = 0; + for (i = 0, j = 1; j < nOrigPts; i++, j++) { + Point2d p, q; + double d; + + p = origPts[i]; + q = origPts[j]; + + d = hypot(q.x - p.x, q.y - p.y); + /* Add the original x-coordinate */ + iPts[count].x = (double)i; + iPts[count].y = 0.0; + + /* Include the starting offset of the point in the offset array */ + map[count] = mapPtr->map[i]; + count++; + + /* Is any part of the interval (line segment) in the plotting + * area? */ + + if (Blt_LineRectClip(&exts, &p, &q)) { + double dp, dq; + + /* Distance of original point to p. */ + dp = hypot(p.x - origPts[i].x, p.y - origPts[i].y); + /* Distance of original point to q. */ + dq = hypot(q.x - origPts[i].x, q.y - origPts[i].y); + dp += 2.0; + while(dp <= dq) { + /* Point is indicated by its interval and parameter t. */ + iPts[count].x = (double)i; + iPts[count].y = dp / d; + map[count] = mapPtr->map[i]; + count++; + dp += 2.0; + } + } + } + iPts[count].x = (double)i; + iPts[count].y = 0.0; + map[count] = mapPtr->map[i]; + count++; + niPts = count; + result = FALSE; + if (elemPtr->smooth == PEN_SMOOTH_NATURAL) { + result = Blt_NaturalParametricSpline(origPts, nOrigPts, &exts, FALSE, + iPts, niPts); + } else if (elemPtr->smooth == PEN_SMOOTH_CATROM) { + result = Blt_CatromParametricSpline(origPts, nOrigPts, iPts, niPts); + } + if (!result) { + /* The spline interpolation failed. We will fall back to the current + * coordinates and do no smoothing (standard line segments). */ + elemPtr->smooth = PEN_SMOOTH_LINEAR; + Blt_Free(iPts); + Blt_Free(map); + } else { + Blt_Free(mapPtr->screenPts); + Blt_Free(mapPtr->map); + mapPtr->map = map; + mapPtr->screenPts = iPts; + mapPtr->nScreenPts = niPts; + } +} + + +/* + *--------------------------------------------------------------------------- + * + * MapSymbols -- + * + * Creates two arrays of points and pen map, filled with the screen + * coordinates of the visible + * + * Results: + * None. + * + * Side effects: + * Memory is freed and allocated for the index array. + * + *--------------------------------------------------------------------------- + */ +static void +MapSymbols(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr) +{ + Region2d exts; + Point2d *pp, *points; + int *map; + int i, count; + + points = Blt_AssertMalloc(sizeof(Point2d) * mapPtr->nScreenPts); + map = Blt_AssertMalloc(sizeof(int) * mapPtr->nScreenPts); + + Blt_GraphExtents(graphPtr, &exts); + count = 0; /* Count the number of visible points */ + + for (pp = mapPtr->screenPts, i = 0; i < mapPtr->nScreenPts; i++, pp++) { + if (PointInRegion(&exts, pp->x, pp->y)) { + points[count].x = pp->x; + points[count].y = pp->y; + map[count] = mapPtr->map[i]; + count++; + } + } + elemPtr->symbolPts.points = points; + elemPtr->symbolPts.length = count; + elemPtr->symbolPts.map = map; +} + +/* + *--------------------------------------------------------------------------- + * + * MapActiveSymbols -- + * + * Creates an array of points of the active graph coordinates. + * + * Results: + * None. + * + * Side effects: + * Memory is freed and allocated for the active point array. + * + *--------------------------------------------------------------------------- + */ +static void +MapActiveSymbols(Graph *graphPtr, LineElement *elemPtr) +{ + Point2d *points; + Region2d exts; + int *map; + int count, i, np; + + if (elemPtr->activePts.points != NULL) { + Blt_Free(elemPtr->activePts.points); + elemPtr->activePts.points = NULL; + } + if (elemPtr->activePts.map != NULL) { + Blt_Free(elemPtr->activePts.map); + elemPtr->activePts.map = NULL; + } + Blt_GraphExtents(graphPtr, &exts); + points = Blt_AssertMalloc(sizeof(Point2d) * elemPtr->nActiveIndices); + map = Blt_AssertMalloc(sizeof(int) * elemPtr->nActiveIndices); + np = NUMBEROFPOINTS(elemPtr); + count = 0; /* Count the visible active points */ + for (i = 0; i < elemPtr->nActiveIndices; i++) { + double x, y; + int iPoint; + + iPoint = elemPtr->activeIndices[i]; + if (iPoint >= np) { + continue; /* Index not available */ + } + x = elemPtr->x.values[iPoint]; + y = elemPtr->y.values[iPoint]; + points[count] = Blt_Map2D(graphPtr, x, y, &elemPtr->axes); + map[count] = iPoint; + if (PointInRegion(&exts, points[count].x, points[count].y)) { + count++; + } + } + if (count > 0) { + elemPtr->activePts.points = points; + elemPtr->activePts.map = map; + } else { + /* No active points were visible. */ + Blt_Free(points); + Blt_Free(map); + } + elemPtr->activePts.length = count; + elemPtr->flags &= ~ACTIVE_PENDING; +} + +/* + *--------------------------------------------------------------------------- + * + * MapStrip -- + * + * Creates an array of line segments of the graph coordinates. + * + * Results: + * None. + * + * Side effects: + * Memory is allocated for the line segment array. + * + *--------------------------------------------------------------------------- + */ +static void +MapStrip(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr) +{ + Region2d exts; + Segment2d *lines; + int *indices, *indexPtr; + Point2d *pend, *pp; + Segment2d *sp; + int count; + + indices = Blt_AssertMalloc(sizeof(int) * mapPtr->nScreenPts); + + /* + * Create array to hold points for line segments (not polyline + * coordinates). So allocate twice the number of points. + */ + sp = lines = Blt_AssertMalloc(mapPtr->nScreenPts * sizeof(Segment2d)); + Blt_GraphExtents(graphPtr, &exts); + count = 0; /* Count the number of segments. */ + indexPtr = mapPtr->map; + for (pp = mapPtr->screenPts, pend = pp + (mapPtr->nScreenPts - 1); + pp < pend; pp++, indexPtr++) { + sp->p = pp[0], sp->q = pp[1]; + if (Blt_LineRectClip(&exts, &sp->p, &sp->q)) { + sp++; + indices[count] = *indexPtr; + count++; + } + } + elemPtr->lines.map = indices; + elemPtr->lines.length = count; + elemPtr->lines.segments = lines; +} + +/* + *--------------------------------------------------------------------------- + * + * MergePens -- + * + * Reorders the both arrays of points and segments to merge pens. + * + * Results: + * None. + * + * Side effects: + * The old arrays are freed and new ones allocated containing + * the reordered points and segments. + * + *--------------------------------------------------------------------------- + */ +static void +MergePens(LineElement *elemPtr, LineStyle **styleMap) +{ + if (Blt_Chain_GetLength(elemPtr->styles) < 2) { + Blt_ChainLink link; + LineStyle *stylePtr; + + link = Blt_Chain_FirstLink(elemPtr->styles); + stylePtr = Blt_Chain_GetValue(link); + stylePtr->errorBarCapWidth = elemPtr->errorBarCapWidth; + stylePtr->lines.length = elemPtr->lines.length; + stylePtr->lines.segments = elemPtr->lines.segments; + stylePtr->symbolPts.length = elemPtr->symbolPts.length; + stylePtr->symbolPts.points = elemPtr->symbolPts.points; + stylePtr->xeb.length = elemPtr->xeb.length; + stylePtr->xeb.segments = elemPtr->xeb.segments; + stylePtr->yeb.length = elemPtr->yeb.length; + stylePtr->yeb.segments = elemPtr->yeb.segments; + return; + } + + /* We have more than one style. Group line segments and points of like pen + * styles. */ + if (elemPtr->lines.length > 0) { + Blt_ChainLink link; + Segment2d *sp, *segments; + int *ip; + int *map; + + segments = Blt_AssertMalloc(elemPtr->lines.length * sizeof(Segment2d)); + map = Blt_AssertMalloc(elemPtr->lines.length * sizeof(int)); + sp = segments, ip = map; + for (link = Blt_Chain_FirstLink(elemPtr->styles); + link != NULL; link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + int i; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->lines.segments = sp; + for (i = 0; i < elemPtr->lines.length; i++) { + int iData; + + iData = elemPtr->lines.map[i]; + if (styleMap[iData] == stylePtr) { + *sp++ = elemPtr->lines.segments[i]; + *ip++ = iData; + } + } + stylePtr->lines.length = sp - stylePtr->lines.segments; + } + Blt_Free(elemPtr->lines.segments); + elemPtr->lines.segments = segments; + Blt_Free(elemPtr->lines.map); + elemPtr->lines.map = map; + } + if (elemPtr->symbolPts.length > 0) { + Blt_ChainLink link; + int *ip; + Point2d *points, *pp; + int *map; + + points = Blt_AssertMalloc(elemPtr->symbolPts.length * sizeof(Point2d)); + map = Blt_AssertMalloc(elemPtr->symbolPts.length * sizeof(int)); + pp = points, ip = map; + for (link = Blt_Chain_FirstLink(elemPtr->styles); + link != NULL; link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + int i; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->symbolPts.points = pp; + for (i = 0; i < elemPtr->symbolPts.length; i++) { + int iData; + + iData = elemPtr->symbolPts.map[i]; + if (styleMap[iData] == stylePtr) { + *pp++ = elemPtr->symbolPts.points[i]; + *ip++ = iData; + } + } + stylePtr->symbolPts.length = pp - stylePtr->symbolPts.points; + } + Blt_Free(elemPtr->symbolPts.points); + Blt_Free(elemPtr->symbolPts.map); + elemPtr->symbolPts.points = points; + elemPtr->symbolPts.map = map; + } + if (elemPtr->xeb.length > 0) { + Segment2d *segments, *sp; + int *map, *ip; + Blt_ChainLink link; + + segments = Blt_AssertMalloc(elemPtr->xeb.length * sizeof(Segment2d)); + map = Blt_AssertMalloc(elemPtr->xeb.length * sizeof(int)); + sp = segments, ip = map; + for (link = Blt_Chain_FirstLink(elemPtr->styles); + link != NULL; link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + int i; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->xeb.segments = sp; + for (i = 0; i < elemPtr->xeb.length; i++) { + int iData; + + iData = elemPtr->xeb.map[i]; + if (styleMap[iData] == stylePtr) { + *sp++ = elemPtr->xeb.segments[i]; + *ip++ = iData; + } + } + stylePtr->xeb.length = sp - stylePtr->xeb.segments; + } + Blt_Free(elemPtr->xeb.segments); + Blt_Free(elemPtr->xeb.map); + elemPtr->xeb.segments = segments; + elemPtr->xeb.map = map; + } + if (elemPtr->yeb.length > 0) { + Segment2d *segments, *sp; + int *map, *ip; + Blt_ChainLink link; + + segments = Blt_AssertMalloc(elemPtr->yeb.length * sizeof(Segment2d)); + map = Blt_AssertMalloc(elemPtr->yeb.length * sizeof(int)); + sp = segments, ip = map; + for (link = Blt_Chain_FirstLink(elemPtr->styles); + link != NULL; link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + int i; + + stylePtr = Blt_Chain_GetValue(link); + stylePtr->yeb.segments = sp; + for (i = 0; i < elemPtr->yeb.length; i++) { + int iData; + + iData = elemPtr->yeb.map[i]; + if (styleMap[iData] == stylePtr) { + *sp++ = elemPtr->yeb.segments[i]; + *ip++ = iData; + } + } + stylePtr->yeb.length = sp - stylePtr->yeb.segments; + } + Blt_Free(elemPtr->yeb.segments); + elemPtr->yeb.segments = segments; + Blt_Free(elemPtr->yeb.map); + elemPtr->yeb.map = map; + } +} + +#define CLIP_TOP (1<<0) +#define CLIP_BOTTOM (1<<1) +#define CLIP_RIGHT (1<<2) +#define CLIP_LEFT (1<<3) + +INLINE static int +OutCode(Region2d *extsPtr, Point2d *p) +{ + int code; + + code = 0; + if (p->x > extsPtr->right) { + code |= CLIP_RIGHT; + } else if (p->x < extsPtr->left) { + code |= CLIP_LEFT; + } + if (p->y > extsPtr->bottom) { + code |= CLIP_BOTTOM; + } else if (p->y < extsPtr->top) { + code |= CLIP_TOP; + } + return code; +} + +static int +ClipSegment( + Region2d *extsPtr, + int code1, int code2, + Point2d *p, Point2d *q) +{ + int inside, outside; + + inside = ((code1 | code2) == 0); + outside = ((code1 & code2) != 0); + + /* + * In the worst case, we'll clip the line segment against each of the four + * sides of the bounding rectangle. + */ + while ((!outside) && (!inside)) { + if (code1 == 0) { + Point2d *tmp; + int code; + + /* Swap pointers and out codes */ + tmp = p, p = q, q = tmp; + code = code1, code1 = code2, code2 = code; + } + if (code1 & CLIP_LEFT) { + p->y += (q->y - p->y) * + (extsPtr->left - p->x) / (q->x - p->x); + p->x = extsPtr->left; + } else if (code1 & CLIP_RIGHT) { + p->y += (q->y - p->y) * + (extsPtr->right - p->x) / (q->x - p->x); + p->x = extsPtr->right; + } else if (code1 & CLIP_BOTTOM) { + p->x += (q->x - p->x) * + (extsPtr->bottom - p->y) / (q->y - p->y); + p->y = extsPtr->bottom; + } else if (code1 & CLIP_TOP) { + p->x += (q->x - p->x) * + (extsPtr->top - p->y) / (q->y - p->y); + p->y = extsPtr->top; + } + code1 = OutCode(extsPtr, p); + + inside = ((code1 | code2) == 0); + outside = ((code1 & code2) != 0); + } + return (!inside); +} + +/* + *--------------------------------------------------------------------------- + * + * SaveTrace -- + * + * Creates a new trace and inserts it into the line's list of traces. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +SaveTrace( + LineElement *elemPtr, + int start, /* Starting index of the trace in data point + * array. Used to figure out closest point */ + int length, /* Number of points forming the trace */ + MapInfo *mapPtr) +{ + Trace *tracePtr; + Point2d *screenPts; + int *map; + int i, j; + + tracePtr = Blt_AssertMalloc(sizeof(Trace)); + screenPts = Blt_AssertMalloc(sizeof(Point2d) * length); + map = Blt_AssertMalloc(sizeof(int) * length); + + /* Copy the screen coordinates of the trace into the point array */ + + if (mapPtr->map != NULL) { + for (i = 0, j = start; i < length; i++, j++) { + screenPts[i].x = mapPtr->screenPts[j].x; + screenPts[i].y = mapPtr->screenPts[j].y; + map[i] = mapPtr->map[j]; + } + } else { + for (i = 0, j = start; i < length; i++, j++) { + screenPts[i].x = mapPtr->screenPts[j].x; + screenPts[i].y = mapPtr->screenPts[j].y; + map[i] = j; + } + } + tracePtr->screenPts.length = length; + tracePtr->screenPts.points = screenPts; + tracePtr->screenPts.map = map; + tracePtr->start = start; + if (elemPtr->traces == NULL) { + elemPtr->traces = Blt_Chain_Create(); + } + Blt_Chain_Append(elemPtr->traces, tracePtr); +} + +/* + *--------------------------------------------------------------------------- + * + * FreeTraces -- + * + * Deletes all the traces for the line. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +FreeTraces(LineElement *elemPtr) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(elemPtr->traces); link != NULL; + link = Blt_Chain_NextLink(link)) { + Trace *tracePtr; + + tracePtr = Blt_Chain_GetValue(link); + Blt_Free(tracePtr->screenPts.map); + Blt_Free(tracePtr->screenPts.points); + Blt_Free(tracePtr); + } + Blt_Chain_Destroy(elemPtr->traces); + elemPtr->traces = NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * MapTraces -- + * + * Creates an array of line segments of the graph coordinates. + * + * Results: + * None. + * + * Side effects: + * Memory is allocated for the line segment array. + * + *--------------------------------------------------------------------------- + */ +static void +MapTraces(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr) +{ + Point2d *p, *q; + Region2d exts; + int code1; + int i; + int start, count; + + Blt_GraphExtents(graphPtr, &exts); + count = 1; + code1 = OutCode(&exts, mapPtr->screenPts); + p = mapPtr->screenPts; + q = p + 1; + for (i = 1; i < mapPtr->nScreenPts; i++, p++, q++) { + Point2d s; + int code2; + int broken, offscreen; + + s.x = s.y = 0; + code2 = OutCode(&exts, q); + if (code2 != 0) { + /* Save the coordinates of the last point, before clipping */ + s = *q; + } + broken = BROKEN_TRACE(elemPtr->penDir, p->x, q->x); + offscreen = ClipSegment(&exts, code1, code2, p, q); + if (broken || offscreen) { + + /* + * The last line segment is either totally clipped by the plotting + * area or the x-direction is wrong, breaking the trace. Either + * way, save information about the last trace (if one exists), + * discarding the current line segment + */ + + if (count > 1) { + start = i - count; + SaveTrace(elemPtr, start, count, mapPtr); + count = 1; + } + } else { + count++; /* Add the point to the trace. */ + if (code2 != 0) { + + /* + * If the last point is clipped, this means that the trace is + * broken after this point. Restore the original coordinate + * (before clipping) after saving the trace. + */ + + start = i - (count - 1); + SaveTrace(elemPtr, start, count, mapPtr); + mapPtr->screenPts[i] = s; + count = 1; + } + } + code1 = code2; + } + if (count > 1) { + start = i - count; + SaveTrace(elemPtr, start, count, mapPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * MapFillArea -- + * + * Creates an array of points that represent a polygon that fills + * the area under the element. + * + * Results: + * None. + * + * Side effects: + * Memory is allocated for the polygon point array. + * + *--------------------------------------------------------------------------- + */ +static void +MapFillArea(Graph *graphPtr, LineElement *elemPtr, MapInfo *mapPtr) +{ + Point2d *origPts, *clipPts; + Region2d exts; + int np; + + if (elemPtr->fillPts != NULL) { + Blt_Free(elemPtr->fillPts); + elemPtr->fillPts = NULL; + elemPtr->nFillPts = 0; + } + if (mapPtr->nScreenPts < 3) { + return; + } + np = mapPtr->nScreenPts + 3; + Blt_GraphExtents(graphPtr, &exts); + + origPts = Blt_AssertMalloc(sizeof(Point2d) * np); + if (graphPtr->inverted) { + double minX; + int i; + + minX = (double)elemPtr->axes.y->screenMin; + for (i = 0; i < mapPtr->nScreenPts; i++) { + origPts[i].x = mapPtr->screenPts[i].x + 1; + origPts[i].y = mapPtr->screenPts[i].y; + if (origPts[i].x < minX) { + minX = origPts[i].x; + } + } + /* Add edges to make (if necessary) the polygon fill to the bottom of + * plotting window */ + origPts[i].x = minX; + origPts[i].y = origPts[i - 1].y; + i++; + origPts[i].x = minX; + origPts[i].y = origPts[0].y; + i++; + origPts[i] = origPts[0]; + } else { + double maxY; + int i; + + maxY = (double)elemPtr->axes.y->bottom; + for (i = 0; i < mapPtr->nScreenPts; i++) { + origPts[i].x = mapPtr->screenPts[i].x + 1; + origPts[i].y = mapPtr->screenPts[i].y; + if (origPts[i].y > maxY) { + maxY = origPts[i].y; + } + } + /* Add edges to extend the fill polygon to the bottom of plotting + * window */ + origPts[i].x = origPts[i - 1].x; + origPts[i].y = maxY; + i++; + origPts[i].x = origPts[0].x; + origPts[i].y = maxY; + i++; + origPts[i] = origPts[0]; + } + + clipPts = Blt_AssertMalloc(sizeof(Point2d) * np * 3); + np = Blt_PolyRectClip(&exts, origPts, np - 1, clipPts); + + Blt_Free(origPts); + if (np < 3) { + Blt_Free(clipPts); + } else { + elemPtr->fillPts = clipPts; + elemPtr->nFillPts = np; + } +} + +static void +ResetLine(LineElement *elemPtr) +{ + FreeTraces(elemPtr); + ResetStylePalette(elemPtr->styles); + if (elemPtr->symbolPts.points != NULL) { + Blt_Free(elemPtr->symbolPts.points); + } + if (elemPtr->symbolPts.map != NULL) { + Blt_Free(elemPtr->symbolPts.map); + } + if (elemPtr->lines.segments != NULL) { + Blt_Free(elemPtr->lines.segments); + } + if (elemPtr->lines.map != NULL) { + Blt_Free(elemPtr->lines.map); + } + if (elemPtr->activePts.points != NULL) { + Blt_Free(elemPtr->activePts.points); + } + if (elemPtr->activePts.map != NULL) { + Blt_Free(elemPtr->activePts.map); + } + if (elemPtr->xeb.segments != NULL) { + Blt_Free(elemPtr->xeb.segments); + } + if (elemPtr->xeb.map != NULL) { + Blt_Free(elemPtr->xeb.map); + } + if (elemPtr->yeb.segments != NULL) { + Blt_Free(elemPtr->yeb.segments); + } + if (elemPtr->yeb.map != NULL) { + Blt_Free(elemPtr->yeb.map); + } + elemPtr->xeb.segments = elemPtr->yeb.segments = elemPtr->lines.segments = NULL; + elemPtr->symbolPts.points = elemPtr->activePts.points = NULL; + elemPtr->lines.map = elemPtr->symbolPts.map = elemPtr->xeb.map = + elemPtr->yeb.map = elemPtr->activePts.map = NULL; + elemPtr->activePts.length = elemPtr->symbolPts.length = + elemPtr->lines.length = elemPtr->xeb.length = elemPtr->yeb.length = 0; +} + +/* + *--------------------------------------------------------------------------- + * + * MapErrorBars -- + * + * Creates two arrays of points and pen indices, filled with the screen + * coordinates of the visible + * + * Results: + * None. + * + * Side effects: + * Memory is freed and allocated for the index array. + * + *--------------------------------------------------------------------------- + */ +static void +MapErrorBars(Graph *graphPtr, LineElement *elemPtr, LineStyle **styleMap) +{ + int n, np; + Region2d exts; + + Blt_GraphExtents(graphPtr, &exts); + np = NUMBEROFPOINTS(elemPtr); + if (elemPtr->xError.nValues > 0) { + n = MIN(elemPtr->xError.nValues, np); + } else { + n = MIN3(elemPtr->xHigh.nValues, elemPtr->xLow.nValues, np); + } + if (n > 0) { + Segment2d *errorBars; + Segment2d *segPtr; + int *errorToData; + int *indexPtr; + int i; + + segPtr = errorBars = Blt_AssertMalloc(n * 3 * sizeof(Segment2d)); + indexPtr = errorToData = Blt_AssertMalloc(n * 3 * sizeof(int)); + for (i = 0; i < n; i++) { + double x, y; + double high, low; + LineStyle *stylePtr; + + x = elemPtr->x.values[i]; + y = elemPtr->y.values[i]; + stylePtr = styleMap[i]; + if ((FINITE(x)) && (FINITE(y))) { + if (elemPtr->xError.nValues > 0) { + high = x + elemPtr->xError.values[i]; + low = x - elemPtr->xError.values[i]; + } else { + high = elemPtr->xHigh.values[i]; + low = elemPtr->xLow.values[i]; + } + if ((FINITE(high)) && (FINITE(low))) { + Point2d p, q; + + p = Blt_Map2D(graphPtr, high, y, &elemPtr->axes); + q = Blt_Map2D(graphPtr, low, y, &elemPtr->axes); + segPtr->p = p; + segPtr->q = q; + if (Blt_LineRectClip(&exts, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + /* Left cap */ + segPtr->p.x = segPtr->q.x = p.x; + segPtr->p.y = p.y - stylePtr->errorBarCapWidth; + segPtr->q.y = p.y + stylePtr->errorBarCapWidth; + if (Blt_LineRectClip(&exts, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + /* Right cap */ + segPtr->p.x = segPtr->q.x = q.x; + segPtr->p.y = q.y - stylePtr->errorBarCapWidth; + segPtr->q.y = q.y + stylePtr->errorBarCapWidth; + if (Blt_LineRectClip(&exts, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + } + } + } + elemPtr->xeb.segments = errorBars; + elemPtr->xeb.length = segPtr - errorBars; + elemPtr->xeb.map = errorToData; + } + if (elemPtr->yError.nValues > 0) { + n = MIN(elemPtr->yError.nValues, np); + } else { + n = MIN3(elemPtr->yHigh.nValues, elemPtr->yLow.nValues, np); + } + if (n > 0) { + Segment2d *errorBars; + Segment2d *segPtr; + int *errorToData; + int *indexPtr; + int i; + + segPtr = errorBars = Blt_AssertMalloc(n * 3 * sizeof(Segment2d)); + indexPtr = errorToData = Blt_AssertMalloc(n * 3 * sizeof(int)); + for (i = 0; i < n; i++) { + double x, y; + double high, low; + LineStyle *stylePtr; + + x = elemPtr->x.values[i]; + y = elemPtr->y.values[i]; + stylePtr = styleMap[i]; + if ((FINITE(x)) && (FINITE(y))) { + if (elemPtr->yError.nValues > 0) { + high = y + elemPtr->yError.values[i]; + low = y - elemPtr->yError.values[i]; + } else { + high = elemPtr->yHigh.values[i]; + low = elemPtr->yLow.values[i]; + } + if ((FINITE(high)) && (FINITE(low))) { + Point2d p, q; + + p = Blt_Map2D(graphPtr, x, high, &elemPtr->axes); + q = Blt_Map2D(graphPtr, x, low, &elemPtr->axes); + segPtr->p = p; + segPtr->q = q; + if (Blt_LineRectClip(&exts, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + /* Top cap. */ + segPtr->p.y = segPtr->q.y = p.y; + segPtr->p.x = p.x - stylePtr->errorBarCapWidth; + segPtr->q.x = p.x + stylePtr->errorBarCapWidth; + if (Blt_LineRectClip(&exts, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + /* Bottom cap. */ + segPtr->p.y = segPtr->q.y = q.y; + segPtr->p.x = q.x - stylePtr->errorBarCapWidth; + segPtr->q.x = q.x + stylePtr->errorBarCapWidth; + if (Blt_LineRectClip(&exts, &segPtr->p, &segPtr->q)) { + segPtr++; + *indexPtr++ = i; + } + } + } + } + elemPtr->yeb.segments = errorBars; + elemPtr->yeb.length = segPtr - errorBars; + elemPtr->yeb.map = errorToData; + } +} + +/* + *--------------------------------------------------------------------------- + * + * MapLineProc -- + * + * Calculates the actual window coordinates of the line element. The + * window coordinates are saved in an allocated point array. + * + * Results: + * None. + * + * Side effects: + * Memory is (re)allocated for the point array. + * + *--------------------------------------------------------------------------- + */ +static void +MapLineProc(Graph *graphPtr, Element *basePtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + MapInfo mi; + int size, np; + LineStyle **styleMap; + Blt_ChainLink link; + + ResetLine(elemPtr); + np = NUMBEROFPOINTS(elemPtr); + if (np < 1) { + return; /* No data points */ + } + GetScreenPoints(graphPtr, elemPtr, &mi); + MapSymbols(graphPtr, elemPtr, &mi); + + if ((elemPtr->flags & ACTIVE_PENDING) && (elemPtr->nActiveIndices > 0)) { + MapActiveSymbols(graphPtr, elemPtr); + } + /* + * Map connecting line segments if they are to be displayed. + */ + elemPtr->smooth = elemPtr->reqSmooth; + if ((np > 1) && ((graphPtr->classId == CID_ELEM_STRIP) || + (elemPtr->builtinPen.traceWidth > 0))) { + /* + * Do smoothing if necessary. This can extend the coordinate array, + * so both mi.points and mi.nPoints may change. + */ + switch (elemPtr->smooth) { + case PEN_SMOOTH_STEP: + GenerateSteps(&mi); + break; + + case PEN_SMOOTH_NATURAL: + case PEN_SMOOTH_QUADRATIC: + if (mi.nScreenPts < 3) { + /* Can't interpolate with less than three points. */ + elemPtr->smooth = PEN_SMOOTH_LINEAR; + } else { + GenerateSpline(graphPtr, elemPtr, &mi); + } + break; + + case PEN_SMOOTH_CATROM: + if (mi.nScreenPts < 3) { + /* Can't interpolate with less than three points. */ + elemPtr->smooth = PEN_SMOOTH_LINEAR; + } else { + GenerateParametricSpline(graphPtr, elemPtr, &mi); + } + break; + + default: + break; + } + if (elemPtr->rTolerance > 0.0) { + ReducePoints(&mi, elemPtr->rTolerance); + } + if (elemPtr->fillBg != NULL) { + MapFillArea(graphPtr, elemPtr, &mi); + } + if (graphPtr->classId == CID_ELEM_STRIP) { + MapStrip(graphPtr, elemPtr, &mi); + } else { + MapTraces(graphPtr, elemPtr, &mi); + } + } + Blt_Free(mi.screenPts); + Blt_Free(mi.map); + + /* Set the symbol size of all the pen styles. */ + for (link = Blt_Chain_FirstLink(elemPtr->styles); link != NULL; + link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + LinePen *penPtr; + + stylePtr = Blt_Chain_GetValue(link); + penPtr = (LinePen *)stylePtr->penPtr; + size = ScaleSymbol(elemPtr, penPtr->symbol.size); + stylePtr->symbolSize = size; + stylePtr->errorBarCapWidth = (penPtr->errorBarCapWidth > 0) + ? penPtr->errorBarCapWidth : Round(size * 0.6666666); + stylePtr->errorBarCapWidth /= 2; + } + styleMap = (LineStyle **)Blt_StyleMap((Element *)elemPtr); + if (((elemPtr->yHigh.nValues > 0) && (elemPtr->yLow.nValues > 0)) || + ((elemPtr->xHigh.nValues > 0) && (elemPtr->xLow.nValues > 0)) || + (elemPtr->xError.nValues > 0) || (elemPtr->yError.nValues > 0)) { + MapErrorBars(graphPtr, elemPtr, styleMap); + } + MergePens(elemPtr, styleMap); + Blt_Free(styleMap); +} + +static double +DistanceToLineProc( + int x, int y, /* Sample X-Y coordinate. */ + Point2d *p, Point2d *q, /* End points of the line segment. */ + Point2d *t) /* (out) Point on line segment. */ +{ + double right, left, top, bottom; + + *t = Blt_GetProjection(x, y, p, q); + if (p->x > q->x) { + right = p->x, left = q->x; + } else { + left = p->x, right = q->x; + } + if (p->y > q->y) { + bottom = p->y, top = q->y; + } else { + top = p->y, bottom = q->y; + } + if (t->x > right) { + t->x = right; + } else if (t->x < left) { + t->x = left; + } + if (t->y > bottom) { + t->y = bottom; + } else if (t->y < top) { + t->y = top; + } + return hypot((t->x - x), (t->y - y)); +} + +static double +DistanceToXProc( + int x, int y, /* Search X-Y coordinate. */ + Point2d *p, + Point2d *q, /* End points of the line segment. */ + Point2d *t) /* (out) Point on line segment. */ +{ + double dx, dy; + double d; + + if (p->x > q->x) { + if ((x > p->x) || (x < q->x)) { + return DBL_MAX; /* X-coordinate outside line segment. */ + } + } else { + if ((x > q->x) || (x < p->x)) { + return DBL_MAX; /* X-coordinate outside line segment. */ + } + } + dx = p->x - q->x; + dy = p->y - q->y; + t->x = (double)x; + if (FABS(dx) < DBL_EPSILON) { + double d1, d2; + /* + * Same X-coordinate indicates a vertical line. Pick the closest end + * point. + */ + d1 = p->y - y; + d2 = q->y - y; + if (FABS(d1) < FABS(d2)) { + t->y = p->y, d = d1; + } else { + t->y = q->y, d = d2; + } + } else if (FABS(dy) < DBL_EPSILON) { + /* Horizontal line. */ + t->y = p->y, d = p->y - y; + } else { + double m, b; + + m = dy / dx; + b = p->y - (m * p->x); + t->y = (x * m) + b; + d = y - t->y; + } + return FABS(d); +} + +static double +DistanceToYProc( + int x, int y, /* Search X-Y coordinate. */ + Point2d *p, Point2d *q, /* End points of the line segment. */ + Point2d *t) /* (out) Point on line segment. */ +{ + double dx, dy; + double d; + + if (p->y > q->y) { + if ((y > p->y) || (y < q->y)) { + return DBL_MAX; + } + } else { + if ((y > q->y) || (y < p->y)) { + return DBL_MAX; + } + } + dx = p->x - q->x; + dy = p->y - q->y; + t->y = y; + if (FABS(dy) < DBL_EPSILON) { + double d1, d2; + + /* Save Y-coordinate indicates an horizontal line. Pick the closest end + * point. */ + d1 = p->x - x; + d2 = q->x - x; + if (FABS(d1) < FABS(d2)) { + t->x = p->x, d = d1; + } else { + t->x = q->x, d = d2; + } + } else if (FABS(dx) < DBL_EPSILON) { + /* Vertical line. */ + t->x = p->x, d = p->x - x; + } else { + double m, b; + + m = dy / dx; + b = p->y - (m * p->x); + t->x = (y - b) / m; + d = x - t->x; + } + return FABS(d); +} + +/* + *--------------------------------------------------------------------------- + * + * ClosestTrace -- + * + * Find the line segment closest to the given window coordinate in the + * element. + * + * Results: + * If a new minimum distance is found, the information regarding it is + * returned via searchPtr. + * + *--------------------------------------------------------------------------- + */ +static int +ClosestTrace( + Graph *graphPtr, /* Graph widget record */ + LineElement *elemPtr, + ClosestSearch *searchPtr, /* Info about closest point in + * element */ + DistanceProc *distProc) +{ + Blt_ChainLink link; + Point2d closest; + double dMin; + int iClose; + + iClose = -1; /* Suppress compiler warning. */ + dMin = searchPtr->dist; + closest.x = closest.y = 0; /* Suppress compiler warning. */ + for (link = Blt_Chain_FirstLink(elemPtr->traces); link != NULL; + link = Blt_Chain_NextLink(link)) { + Trace *tracePtr; + Point2d *p, *pend; + + tracePtr = Blt_Chain_GetValue(link); + for (p = tracePtr->screenPts.points, + pend = p + (tracePtr->screenPts.length - 1); p < pend; p++) { + Point2d b; + double d; + + d = (*distProc)(searchPtr->x, searchPtr->y, p, p + 1, &b); + if (d < dMin) { + closest = b; + iClose = tracePtr->screenPts.map[p-tracePtr->screenPts.points]; + dMin = d; + } + } + } + if (dMin < searchPtr->dist) { + searchPtr->dist = dMin; + searchPtr->elemPtr = (Element *)elemPtr; + searchPtr->index = iClose; + searchPtr->point = Blt_InvMap2D(graphPtr, closest.x, closest.y, + &elemPtr->axes); + return TRUE; + } + return FALSE; +} + +/* + *--------------------------------------------------------------------------- + * + * ClosestStrip -- + * + * Find the line segment closest to the given window coordinate in the + * element. + * + * Results: + * If a new minimum distance is found, the information regarding it is + * returned via searchPtr. + * + *--------------------------------------------------------------------------- + */ +static int +ClosestStrip( + Graph *graphPtr, /* Graph widget record */ + LineElement *elemPtr, /* Line element record */ + ClosestSearch *searchPtr, /* Info about closest point in + * element */ + DistanceProc *distProc) +{ + Point2d closest; + double dMin; + int count; + int iClose; + Segment2d *sp; + + iClose = 0; + dMin = searchPtr->dist; + closest.x = closest.y = 0; + for (sp = elemPtr->lines.segments, count = 0; + count < elemPtr->lines.length; count++, sp++) { + double d; + Point2d b; + + d = (*distProc)(searchPtr->x, searchPtr->y, &sp->p, &sp->q, &b); + if (d < dMin) { + closest = b; + iClose = elemPtr->lines.map[count]; + dMin = d; + } + } + if (dMin < searchPtr->dist) { + searchPtr->dist = dMin; + searchPtr->elemPtr = (Element *)elemPtr; + searchPtr->index = iClose; + searchPtr->point = Blt_InvMap2D(graphPtr, closest.x, closest.y, + &elemPtr->axes); + return TRUE; + } + return FALSE; +} + +/* + *--------------------------------------------------------------------------- + * + * ClosestPoint -- + * + * Find the element whose data point is closest to the given screen + * coordinate. + * + * Results: + * If a new minimum distance is found, the information regarding + * it is returned via searchPtr. + * + *--------------------------------------------------------------------------- + */ +static void +ClosestPoint( + LineElement *elemPtr, /* Line element to be searched. */ + ClosestSearch *searchPtr) /* Assorted information related to + * searching for the closest point */ +{ + double dMin; + int count, iClose; + Point2d *pp; + + dMin = searchPtr->dist; + iClose = 0; + + /* + * Instead of testing each data point in graph coordinates, look at the + * array of mapped screen coordinates. The advantages are + * 1) only examine points that are visible (unclipped), and + * 2) the computed distance is already in screen coordinates. + */ + for (pp = elemPtr->symbolPts.points, count = 0; + count < elemPtr->symbolPts.length; count++, pp++) { + double dx, dy; + double d; + + dx = (double)(searchPtr->x - pp->x); + dy = (double)(searchPtr->y - pp->y); + if (searchPtr->along == SEARCH_BOTH) { + d = hypot(dx, dy); + } else if (searchPtr->along == SEARCH_X) { + d = dx; + } else if (searchPtr->along == SEARCH_Y) { + d = dy; + } else { + /* This can't happen */ + continue; + } + if (d < dMin) { + iClose = elemPtr->symbolPts.map[count]; + dMin = d; + } + } + if (dMin < searchPtr->dist) { + searchPtr->elemPtr = (Element *)elemPtr; + searchPtr->dist = dMin; + searchPtr->index = iClose; + searchPtr->point.x = elemPtr->x.values[iClose]; + searchPtr->point.y = elemPtr->y.values[iClose]; + } +} + +/* + *--------------------------------------------------------------------------- + * + * GetLineExtentsProc -- + * + * Retrieves the range of the line element + * + * Results: + * Returns the number of data points in the element. + * + *--------------------------------------------------------------------------- + */ +static void +GetLineExtentsProc(Element *basePtr, Region2d *extsPtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + int np; + + extsPtr->top = extsPtr->left = DBL_MAX; + extsPtr->bottom = extsPtr->right = -DBL_MAX; + + np = NUMBEROFPOINTS(elemPtr); + if (np < 1) { + return; + } + extsPtr->right = elemPtr->x.max; + if ((elemPtr->x.min <= 0.0) && (elemPtr->axes.x->logScale)) { + extsPtr->left = Blt_FindElemValuesMinimum(&elemPtr->x, DBL_MIN); + } else { + extsPtr->left = elemPtr->x.min; + } + extsPtr->bottom = elemPtr->y.max; + if ((elemPtr->y.min <= 0.0) && (elemPtr->axes.y->logScale)) { + extsPtr->top = Blt_FindElemValuesMinimum(&elemPtr->y, DBL_MIN); + } else { + extsPtr->top = elemPtr->y.min; + } + + /* Correct the data limits for error bars */ + + if (elemPtr->xError.nValues > 0) { + int i; + + np = MIN(elemPtr->xError.nValues, np); + for (i = 0; i < np; i++) { + double x; + + x = elemPtr->x.values[i] + elemPtr->xError.values[i]; + if (x > extsPtr->right) { + extsPtr->right = x; + } + x = elemPtr->x.values[i] - elemPtr->xError.values[i]; + if (elemPtr->axes.x->logScale) { + if (x < 0.0) { + x = -x; /* Mirror negative values, instead of + * ignoring them. */ + } + if ((x > DBL_MIN) && (x < extsPtr->left)) { + extsPtr->left = x; + } + } else if (x < extsPtr->left) { + extsPtr->left = x; + } + } + } else { + if ((elemPtr->xHigh.nValues > 0) && + (elemPtr->xHigh.max > extsPtr->right)) { + extsPtr->right = elemPtr->xHigh.max; + } + if (elemPtr->xLow.nValues > 0) { + double left; + + if ((elemPtr->xLow.min <= 0.0) && + (elemPtr->axes.x->logScale)) { + left = Blt_FindElemValuesMinimum(&elemPtr->xLow, DBL_MIN); + } else { + left = elemPtr->xLow.min; + } + if (left < extsPtr->left) { + extsPtr->left = left; + } + } + } + + if (elemPtr->yError.nValues > 0) { + int i; + + np = MIN(elemPtr->yError.nValues, np); + for (i = 0; i < np; i++) { + double y; + + y = elemPtr->y.values[i] + elemPtr->yError.values[i]; + if (y > extsPtr->bottom) { + extsPtr->bottom = y; + } + y = elemPtr->y.values[i] - elemPtr->yError.values[i]; + if (elemPtr->axes.y->logScale) { + if (y < 0.0) { + y = -y; /* Mirror negative values, instead of + * ignoring them. */ + } + if ((y > DBL_MIN) && (y < extsPtr->left)) { + extsPtr->top = y; + } + } else if (y < extsPtr->top) { + extsPtr->top = y; + } + } + } else { + if ((elemPtr->yHigh.nValues > 0) && + (elemPtr->yHigh.max > extsPtr->bottom)) { + extsPtr->bottom = elemPtr->yHigh.max; + } + if (elemPtr->yLow.nValues > 0) { + double top; + + if ((elemPtr->yLow.min <= 0.0) && + (elemPtr->axes.y->logScale)) { + top = Blt_FindElemValuesMinimum(&elemPtr->yLow, DBL_MIN); + } else { + top = elemPtr->yLow.min; + } + if (top < extsPtr->top) { + extsPtr->top = top; + } + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * BackgroundChangedProc + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static void +BackgroundChangedProc(ClientData clientData) +{ + Element *elemPtr = clientData; + Graph *graphPtr; + + graphPtr = elemPtr->obj.graphPtr; + if (graphPtr->tkwin != NULL) { + graphPtr->flags |= REDRAW_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureLineProc -- + * + * Sets up the appropriate configuration parameters in the GC. It is + * assumed the parameters have been previously set by a call to + * Blt_ConfigureWidget. + * + * Results: + * The return value is a standard TCL result. If TCL_ERROR is returned, + * then interp->result contains an error message. + * + * Side effects: + * Configuration information such as line width, line style, color + * etc. get set in a new GC. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ConfigureLineProc(Graph *graphPtr, Element *basePtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + unsigned long gcMask; + XGCValues gcValues; + GC newGC; + Blt_ChainLink link; + LineStyle *stylePtr; + + if (ConfigurePenProc(graphPtr, (Pen *)&elemPtr->builtinPen) != TCL_OK) { + return TCL_ERROR; + } + /* + * Point to the static normal/active pens if no external pens have been + * selected. + */ + link = Blt_Chain_FirstLink(elemPtr->styles); + if (link == NULL) { + link = Blt_Chain_AllocLink(sizeof(LineStyle)); + Blt_Chain_LinkAfter(elemPtr->styles, link, NULL); + } + stylePtr = Blt_Chain_GetValue(link); + stylePtr->penPtr = NORMALPEN(elemPtr); + + if (elemPtr->fillBg != NULL) { + Blt_SetBackgroundChangedProc(elemPtr->fillBg, BackgroundChangedProc, + elemPtr); + } + /* + * Set the outline GC for this pen: GCForeground is outline color. + * GCBackground is the fill color (only used for bitmap symbols). + */ + gcMask = 0; + if (elemPtr->fillFgColor != NULL) { + gcMask |= GCForeground; + gcValues.foreground = elemPtr->fillFgColor->pixel; + } + if (elemPtr->fillBgColor != NULL) { + gcMask |= GCBackground; + gcValues.background = elemPtr->fillBgColor->pixel; + } + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (elemPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, elemPtr->fillGC); + } + elemPtr->fillGC = newGC; + + if (Blt_ConfigModified(elemPtr->configSpecs, "-scalesymbols", + (char *)NULL)) { + elemPtr->flags |= (MAP_ITEM | SCALE_SYMBOL); + } + if (Blt_ConfigModified(elemPtr->configSpecs, "-pixels", "-trace", + "-*data", "-smooth", "-map*", "-label", "-hide", "-x", "-y", + "-areabackground", (char *)NULL)) { + elemPtr->flags |= MAP_ITEM; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ClosestLineProc -- + * + * Find the closest point or line segment (if interpolated) to the given + * window coordinate in the line element. + * + * Results: + * Returns the distance of the closest point among other information. + * + *--------------------------------------------------------------------------- + */ +static void +ClosestLineProc(Graph *graphPtr, Element *basePtr, ClosestSearch *searchPtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + int mode; + + mode = searchPtr->mode; + if (mode == SEARCH_AUTO) { + LinePen *penPtr; + + penPtr = NORMALPEN(elemPtr); + mode = SEARCH_POINTS; + if ((NUMBEROFPOINTS(elemPtr) > 1) && (penPtr->traceWidth > 0)) { + mode = SEARCH_TRACES; + } + } + if (mode == SEARCH_POINTS) { + ClosestPoint(elemPtr, searchPtr); + } else { + DistanceProc *distProc; + int found; + + if (searchPtr->along == SEARCH_X) { + distProc = DistanceToXProc; + } else if (searchPtr->along == SEARCH_Y) { + distProc = DistanceToYProc; + } else { + distProc = DistanceToLineProc; + } + if (elemPtr->obj.classId == CID_ELEM_STRIP) { + found = ClosestStrip(graphPtr, elemPtr, searchPtr, distProc); + } else { + found = ClosestTrace(graphPtr, elemPtr, searchPtr, distProc); + } + if ((!found) && (searchPtr->along != SEARCH_BOTH)) { + ClosestPoint(elemPtr, searchPtr); + } + } +} + +/* + * XDrawLines() points: XMaxRequestSize(dpy) - 3 + * XFillPolygon() points: XMaxRequestSize(dpy) - 4 + * XDrawSegments() segments: (XMaxRequestSize(dpy) - 3) / 2 + * XDrawRectangles() rectangles: (XMaxRequestSize(dpy) - 3) / 2 + * XFillRectangles() rectangles: (XMaxRequestSize(dpy) - 3) / 2 + * XDrawArcs() or XFillArcs() arcs: (XMaxRequestSize(dpy) - 3) / 3 + */ + +#define MAX_DRAWLINES(d) Blt_MaxRequestSize(d, sizeof(XPoint)) +#define MAX_DRAWPOLYGON(d) Blt_MaxRequestSize(d, sizeof(XPoint)) +#define MAX_DRAWSEGMENTS(d) Blt_MaxRequestSize(d, sizeof(XSegment)) +#define MAX_DRAWRECTANGLES(d) Blt_MaxRequestSize(d, sizeof(XRectangle)) +#define MAX_DRAWARCS(d) Blt_MaxRequestSize(d, sizeof(XArc)) + +#ifdef WIN32 + +static void +DrawCircles( + Display *display, + Drawable drawable, + LineElement *elemPtr, + LinePen *penPtr, + int nSymbolPts, + Point2d *symbolPts, + int radius) +{ + HBRUSH brush, oldBrush; + HPEN pen, oldPen; + HDC dc; + TkWinDCState state; + + if (drawable == None) { + return; /* Huh? */ + } + if ((penPtr->symbol.fillGC == NULL) && + (penPtr->symbol.outlineWidth == 0)) { + return; + } + dc = TkWinGetDrawableDC(display, drawable, &state); + /* SetROP2(dc, tkpWinRopModes[penPtr->symbol.fillGC->function]); */ + if (penPtr->symbol.fillGC != NULL) { + brush = CreateSolidBrush(penPtr->symbol.fillGC->foreground); + } else { + brush = GetStockBrush(NULL_BRUSH); + } + if (penPtr->symbol.outlineWidth > 0) { + pen = Blt_GCToPen(dc, penPtr->symbol.outlineGC); + } else { + pen = GetStockPen(NULL_PEN); + } + oldPen = SelectPen(dc, pen); + oldBrush = SelectBrush(dc, brush); + { + Point2d *pp, *pend; + + for (pp = symbolPts, pend = pp + nSymbolPts; pp < pend; pp++) { + int rndx, rndy; + rndx = Round(pp->x), rndy = Round(pp->y); + Ellipse(dc, rndx - radius, rndy - radius, rndx + radius + 1, + rndy + radius + 1); + } + } + DeleteBrush(SelectBrush(dc, oldBrush)); + DeletePen(SelectPen(dc, oldPen)); + TkWinReleaseDrawableDC(drawable, dc, &state); +} + +#else + +static void +DrawCircles(Display *display, Drawable drawable, LineElement *elemPtr, + LinePen *penPtr, int nSymbolPts, Point2d *symbolPts, int radius) +{ + int i; + XArc *arcs; /* Array of arcs (circle) */ + int reqSize; + int s; + int count; + + s = radius + radius; + arcs = Blt_AssertMalloc(nSymbolPts * sizeof(XArc)); + + if (elemPtr->symbolInterval > 0) { + Point2d *pp, *pend; + XArc *ap; + + ap = arcs; + count = 0; + for (pp = symbolPts, pend = pp + nSymbolPts; pp < pend; pp++) { + if (DRAW_SYMBOL(elemPtr)) { + ap->x = Round(pp->x) - radius; + ap->y = Round(pp->y) - radius; + ap->width = ap->height = (unsigned short)s; + ap->angle1 = 0; + ap->angle2 = 23040; + ap++, count++; + } + elemPtr->symbolCounter++; + } + } else { + Point2d *pp, *pend; + XArc *ap; + + ap = arcs; + for (pp = symbolPts, pend = pp + nSymbolPts; pp < pend; pp++) { + ap->x = Round(pp->x) - radius; + ap->y = Round(pp->y) - radius; + ap->width = ap->height = (unsigned short)s; + ap->angle1 = 0; + ap->angle2 = 23040; + ap++; + } + count = nSymbolPts; + } + reqSize = MAX_DRAWARCS(display); + for (i = 0; i < count; i += reqSize) { + int n; + + n = ((i + reqSize) > count) ? (count - i) : reqSize; + if (penPtr->symbol.fillGC != NULL) { + XFillArcs(display, drawable, penPtr->symbol.fillGC, arcs + i, n); + } + if (penPtr->symbol.outlineWidth > 0) { + XDrawArcs(display, drawable, penPtr->symbol.outlineGC, arcs + i, n); + } + } + Blt_Free(arcs); +} + +#endif + +static void +DrawSquares(Display *display, Drawable drawable, LineElement *elemPtr, + LinePen *penPtr, int nSymbolPts, Point2d *symbolPts, int r) +{ + XRectangle *rectangles; + XRectangle *rp, *rend; + int reqSize; + int s, count; + + s = r + r; + rectangles = Blt_AssertMalloc(nSymbolPts * sizeof(XRectangle)); + if (elemPtr->symbolInterval > 0) { + Point2d *pp, *pend; + XRectangle *rp; + + count = 0; + rp = rectangles; + for (pp = symbolPts, pend = pp + nSymbolPts; pp < pend; pp++) { + if (DRAW_SYMBOL(elemPtr)) { + rp->x = Round(pp->x) - r; + rp->y = Round(pp->y) - r; + rp->width = rp->height = (unsigned short)s; + rp++, count++; + } + elemPtr->symbolCounter++; + } + } else { + Point2d *pp, *pend; + XRectangle *rp; + + rp = rectangles; + for (pp = symbolPts, pend = pp + nSymbolPts; pp < pend; pp++) { + rp->x = Round(pp->x) - r; + rp->y = Round(pp->y) - r; + rp->width = rp->height = (unsigned short)s; + rp++; + } + count = nSymbolPts; + } + reqSize = MAX_DRAWRECTANGLES(display) - 3; + for (rp = rectangles, rend = rp + count; rp < rend; rp += reqSize) { + int n; + + n = rend - rp; + if (n > reqSize) { + n = reqSize; + } + if (penPtr->symbol.fillGC != NULL) { + XFillRectangles(display, drawable, penPtr->symbol.fillGC, rp, n); + } + if (penPtr->symbol.outlineWidth > 0) { + XDrawRectangles(display, drawable, penPtr->symbol.outlineGC, rp, n); + } + } + Blt_Free(rectangles); +} + +/* + *--------------------------------------------------------------------------- + * + * DrawSymbols -- + * + * Draw the symbols centered at the each given x,y coordinate in the array + * of points. + * + * Results: + * None. + * + * Side Effects: + * Draws a symbol at each coordinate given. If active, only those + * coordinates which are currently active are drawn. + * + *--------------------------------------------------------------------------- + */ +static void +DrawSymbols( + Graph *graphPtr, /* Graph widget record */ + Drawable drawable, /* Pixmap or window to draw into */ + LineElement *elemPtr, + LinePen *penPtr, + int size, /* Size of element */ + int nSymbolPts, /* Number of coordinates in array */ + Point2d *symbolPts) /* Array of x,y coordinates for line */ +{ + XPoint pattern[13]; /* Template for polygon symbols */ + int r1, r2; + int count; +#define SQRT_PI 1.77245385090552 +#define S_RATIO 0.886226925452758 + + if (size < 3) { + if (penPtr->symbol.fillGC != NULL) { + Point2d *pp, *endp; + XPoint *points, *xpp; + + xpp = points = Blt_AssertMalloc(nSymbolPts * sizeof(XPoint)); + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + xpp->x = Round(pp->x); + xpp->y = Round(pp->y); + xpp++; + } + XDrawPoints(graphPtr->display, drawable, penPtr->symbol.fillGC, + points, nSymbolPts, CoordModeOrigin); + Blt_Free(points); + } + return; + } + r1 = (int)ceil(size * 0.5); + r2 = (int)ceil(size * S_RATIO * 0.5); + + switch (penPtr->symbol.type) { + case SYMBOL_NONE: + break; + + case SYMBOL_SQUARE: + DrawSquares(graphPtr->display, drawable, elemPtr, penPtr, nSymbolPts, + symbolPts, r2); + break; + + case SYMBOL_CIRCLE: + DrawCircles(graphPtr->display, drawable, elemPtr, penPtr, nSymbolPts, + symbolPts, r1); + break; + + case SYMBOL_SPLUS: + case SYMBOL_SCROSS: + { + XSegment *segments; /* Array of line segments (splus, + * scross) */ + int i; + int reqSize, nSegs; + + if (penPtr->symbol.type == SYMBOL_SCROSS) { + r2 = Round((double)r2 * M_SQRT1_2); + pattern[3].y = pattern[2].x = pattern[0].x = pattern[0].y = -r2; + pattern[3].x = pattern[2].y = pattern[1].y = pattern[1].x = r2; + } else { + pattern[0].y = pattern[1].y = pattern[2].x = pattern[3].x = 0; + pattern[0].x = pattern[2].y = -r2; + pattern[1].x = pattern[3].y = r2; + } + segments = Blt_AssertMalloc(nSymbolPts * 2 * sizeof(XSegment)); + if (elemPtr->symbolInterval > 0) { + Point2d *pp, *endp; + XSegment *sp; + + sp = segments; + count = 0; + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + if (DRAW_SYMBOL(elemPtr)) { + int rndx, rndy; + rndx = Round(pp->x), rndy = Round(pp->y); + sp->x1 = pattern[0].x + rndx; + sp->y1 = pattern[0].y + rndy; + sp->x2 = pattern[1].x + rndx; + sp->y2 = pattern[1].y + rndy; + sp++; + sp->x1 = pattern[2].x + rndx; + sp->y1 = pattern[2].y + rndy; + sp->x2 = pattern[3].x + rndx; + sp->y2 = pattern[3].y + rndy; + sp++; + count++; + } + elemPtr->symbolCounter++; + } + } else { + Point2d *pp, *endp; + XSegment *sp; + + sp = segments; + count = nSymbolPts; + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + int rndx, rndy; + rndx = Round(pp->x), rndy = Round(pp->y); + sp->x1 = pattern[0].x + rndx; + sp->y1 = pattern[0].y + rndy; + sp->x2 = pattern[1].x + rndx; + sp->y2 = pattern[1].y + rndy; + sp++; + sp->x1 = pattern[2].x + rndx; + sp->y1 = pattern[2].y + rndy; + sp->x2 = pattern[3].x + rndx; + sp->y2 = pattern[3].y + rndy; + sp++; + } + } + nSegs = count * 2; + /* Always draw skinny symbols regardless of the outline width */ + reqSize = MAX_DRAWSEGMENTS(graphPtr->display); + for (i = 0; i < nSegs; i += reqSize) { + int chunk; + + chunk = ((i + reqSize) > nSegs) ? (nSegs - i) : reqSize; + XDrawSegments(graphPtr->display, drawable, + penPtr->symbol.outlineGC, segments + i, chunk); + } + Blt_Free(segments); + } + break; + + case SYMBOL_PLUS: + case SYMBOL_CROSS: + { + XPoint *polygon; + int d; /* Small delta for cross/plus + * thickness */ + + d = (r2 / 3); + + /* + * + * 2 3 The plus/cross symbol is a closed polygon + * of 12 points. The diagram to the left + * 0,12 1 4 5 represents the positions of the points + * x,y which are computed below. The extra + * 11 10 7 6 (thirteenth) point connects the first and + * last points. + * 9 8 + */ + + pattern[0].x = pattern[11].x = pattern[12].x = -r2; + pattern[2].x = pattern[1].x = pattern[10].x = pattern[9].x = -d; + pattern[3].x = pattern[4].x = pattern[7].x = pattern[8].x = d; + pattern[5].x = pattern[6].x = r2; + pattern[2].y = pattern[3].y = -r2; + pattern[0].y = pattern[1].y = pattern[4].y = pattern[5].y = + pattern[12].y = -d; + pattern[11].y = pattern[10].y = pattern[7].y = pattern[6].y = d; + pattern[9].y = pattern[8].y = r2; + + if (penPtr->symbol.type == SYMBOL_CROSS) { + int i; + + /* For the cross symbol, rotate the points by 45 degrees. */ + for (i = 0; i < 12; i++) { + double dx, dy; + + dx = (double)pattern[i].x * M_SQRT1_2; + dy = (double)pattern[i].y * M_SQRT1_2; + pattern[i].x = Round(dx - dy); + pattern[i].y = Round(dx + dy); + } + pattern[12] = pattern[0]; + } + polygon = Blt_AssertMalloc(nSymbolPts * 13 * sizeof(XPoint)); + if (elemPtr->symbolInterval > 0) { + Point2d *pp, *endp; + XPoint *xpp; + + count = 0; + xpp = polygon; + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + if (DRAW_SYMBOL(elemPtr)) { + int i; + int rndx, rndy; + + rndx = Round(pp->x), rndy = Round(pp->y); + for (i = 0; i < 13; i++) { + xpp->x = pattern[i].x + rndx; + xpp->y = pattern[i].y + rndy; + xpp++; + } + count++; + } + elemPtr->symbolCounter++; + } + } else { + Point2d *pp, *endp; + XPoint *xpp; + + xpp = polygon; + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + int i; + int rndx, rndy; + + rndx = Round(pp->x), rndy = Round(pp->y); + for (i = 0; i < 13; i++) { + xpp->x = pattern[i].x + rndx; + xpp->y = pattern[i].y + rndy; + xpp++; + } + } + count = nSymbolPts; + } + if (penPtr->symbol.fillGC != NULL) { + int i; + XPoint *xpp; + + for (xpp = polygon, i = 0; i < count; i++, xpp += 13) { + XFillPolygon(graphPtr->display, drawable, + penPtr->symbol.fillGC, xpp, 13, Complex, + CoordModeOrigin); + } + } + if (penPtr->symbol.outlineWidth > 0) { + int i; + XPoint *xpp; + + for (xpp = polygon, i = 0; i < count; i++, xpp += 13) { + XDrawLines(graphPtr->display, drawable, + penPtr->symbol.outlineGC, xpp, 13, CoordModeOrigin); + } + } + Blt_Free(polygon); + } + break; + + case SYMBOL_DIAMOND: + { + XPoint *polygon; + + /* + * + * The plus symbol is a closed polygon + * 1 of 4 points. The diagram to the left + * represents the positions of the points + * 0,4 x,y 2 which are computed below. The extra + * (fifth) point connects the first and + * 3 last points. + * + */ + pattern[1].y = pattern[0].x = -r1; + pattern[2].y = pattern[3].x = pattern[0].y = pattern[1].x = 0; + pattern[3].y = pattern[2].x = r1; + pattern[4] = pattern[0]; + + polygon = Blt_AssertMalloc(nSymbolPts * 5 * sizeof(XPoint)); + if (elemPtr->symbolInterval > 0) { + Point2d *pp, *endp; + XPoint *xpp; + + xpp = polygon; + count = 0; + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + int i; + + if (DRAW_SYMBOL(elemPtr)) { + int rndx, rndy; + + rndx = Round(pp->x), rndy = Round(pp->y); + for (i = 0; i < 5; i++) { + xpp->x = pattern[i].x + rndx; + xpp->y = pattern[i].y + rndy; + xpp++; + } + count++; + } + elemPtr->symbolCounter++; + } + } else { + Point2d *pp, *endp; + XPoint *xpp; + + xpp = polygon; + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + int i; + int rndx, rndy; + + rndx = Round(pp->x), rndy = Round(pp->y); + for (i = 0; i < 5; i++) { + xpp->x = pattern[i].x + rndx; + xpp->y = pattern[i].y + rndy; + xpp++; + } + } + count = nSymbolPts; + } + if (penPtr->symbol.fillGC != NULL) { + XPoint *xpp; + int i; + + for (xpp = polygon, i = 0; i < count; i++, xpp += 5) { + XFillPolygon(graphPtr->display, drawable, + penPtr->symbol.fillGC, xpp, 5, Convex, CoordModeOrigin); + + } + } + if (penPtr->symbol.outlineWidth > 0) { + XPoint *xpp; + int i; + + for (xpp = polygon, i = 0; i < count; i++, xpp += 5) { + XDrawLines(graphPtr->display, drawable, + penPtr->symbol.outlineGC, xpp, 5, CoordModeOrigin); + } + } + Blt_Free(polygon); + } + break; + + case SYMBOL_TRIANGLE: + case SYMBOL_ARROW: + { + XPoint *polygon; + double b; + int b2, h1, h2; +#define H_RATIO 1.1663402261671607 +#define B_RATIO 1.3467736870885982 +#define TAN30 0.57735026918962573 +#define COS30 0.86602540378443871 + + b = Round(size * B_RATIO * 0.7); + b2 = Round(b * 0.5); + h2 = Round(TAN30 * b2); + h1 = Round(b2 / COS30); + /* + * + * The triangle symbol is a closed polygon + * 0,3 of 3 points. The diagram to the left + * represents the positions of the points + * x,y which are computed below. The extra + * (fourth) point connects the first and + * 2 1 last points. + * + */ + + if (penPtr->symbol.type == SYMBOL_ARROW) { + pattern[3].x = pattern[0].x = 0; + pattern[3].y = pattern[0].y = h1; + pattern[1].x = b2; + pattern[2].y = pattern[1].y = -h2; + pattern[2].x = -b2; + } else { + pattern[3].x = pattern[0].x = 0; + pattern[3].y = pattern[0].y = -h1; + pattern[1].x = b2; + pattern[2].y = pattern[1].y = h2; + pattern[2].x = -b2; + } + polygon = Blt_AssertMalloc(nSymbolPts * 4 * sizeof(XPoint)); + if (elemPtr->symbolInterval > 0) { + Point2d *pp, *endp; + XPoint *xpp; + + xpp = polygon; + count = 0; + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + int i; + + if (DRAW_SYMBOL(elemPtr)) { + int rndx, rndy; + + rndx = Round(pp->x), rndy = Round(pp->y); + for (i = 0; i < 4; i++) { + xpp->x = pattern[i].x + rndx; + xpp->y = pattern[i].y + rndy; + xpp++; + } + count++; + } + elemPtr->symbolCounter++; + } + } else { + Point2d *pp, *endp; + XPoint *xpp; + + xpp = polygon; + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + int i; + int rndx, rndy; + + rndx = Round(pp->x), rndy = Round(pp->y); + for (i = 0; i < 4; i++) { + xpp->x = pattern[i].x + rndx; + xpp->y = pattern[i].y + rndy; + xpp++; + } + } + count = nSymbolPts; + } + if (penPtr->symbol.fillGC != NULL) { + XPoint *xpp; + int i; + + xpp = polygon; + for (xpp = polygon, i = 0; i < count; i++, xpp += 4) { + XFillPolygon(graphPtr->display, drawable, + penPtr->symbol.fillGC, xpp, 4, Convex, CoordModeOrigin); + } + } + if (penPtr->symbol.outlineWidth > 0) { + XPoint *xpp; + int i; + + xpp = polygon; + for (xpp = polygon, i = 0; i < count; i++, xpp += 4) { + XDrawLines(graphPtr->display, drawable, + penPtr->symbol.outlineGC, xpp, 4, CoordModeOrigin); + } + } + Blt_Free(polygon); + } + break; + + case SYMBOL_IMAGE: + { + int w, h; + int dx, dy; + + Tk_SizeOfImage(penPtr->symbol.image, &w, &h); + + dx = w / 2; + dy = h / 2; + if (elemPtr->symbolInterval > 0) { + Point2d *pp, *endp; + + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + if (DRAW_SYMBOL(elemPtr)) { + int x, y; + + x = Round(pp->x) - dx; + y = Round(pp->y) - dy; + Tk_RedrawImage(penPtr->symbol.image, 0, 0, w, h, + drawable, x, y); + } + elemPtr->symbolCounter++; + } + } else { + Point2d *pp, *endp; + + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + int x, y; + + x = Round(pp->x) - dx; + y = Round(pp->y) - dy; + Tk_RedrawImage(penPtr->symbol.image, 0, 0, w, h, + drawable, x, y); + } + } + } + break; + + case SYMBOL_BITMAP: + { + Pixmap bitmap, mask; + int w, h, bw, bh; + double scale, sx, sy; + int dx, dy; + + Tk_SizeOfBitmap(graphPtr->display, penPtr->symbol.bitmap, &w, &h); + mask = None; + + /* + * Compute the size of the scaled bitmap. Stretch the bitmap to fit + * a nxn bounding box. + */ + sx = (double)size / (double)w; + sy = (double)size / (double)h; + scale = MIN(sx, sy); + bw = (int)(w * scale); + bh = (int)(h * scale); + + XSetClipMask(graphPtr->display, penPtr->symbol.outlineGC, None); + if (penPtr->symbol.mask != None) { + mask = Blt_ScaleBitmap(graphPtr->tkwin, penPtr->symbol.mask, + w, h, bw, bh); + XSetClipMask(graphPtr->display, penPtr->symbol.outlineGC, mask); + } + bitmap = Blt_ScaleBitmap(graphPtr->tkwin, penPtr->symbol.bitmap, + w, h, bw, bh); + if (penPtr->symbol.fillGC == NULL) { + XSetClipMask(graphPtr->display, penPtr->symbol.outlineGC, + bitmap); + } + dx = bw / 2; + dy = bh / 2; + if (elemPtr->symbolInterval > 0) { + Point2d *pp, *endp; + + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + if (DRAW_SYMBOL(elemPtr)) { + int x, y; + + x = Round(pp->x) - dx; + y = Round(pp->y) - dy; + if ((penPtr->symbol.fillGC == NULL) || (mask !=None)) { + XSetClipOrigin(graphPtr->display, + penPtr->symbol.outlineGC, x, y); + } + XCopyPlane(graphPtr->display, bitmap, drawable, + penPtr->symbol.outlineGC, 0, 0, bw, bh, x, y, 1); + } + elemPtr->symbolCounter++; + } + } else { + Point2d *pp, *endp; + + for (pp = symbolPts, endp = pp + nSymbolPts; pp < endp; pp++) { + int x, y; + + x = Round(pp->x) - dx; + y = Round(pp->y) - dy; + if ((penPtr->symbol.fillGC == NULL) || (mask != None)) { + XSetClipOrigin(graphPtr->display, + penPtr->symbol.outlineGC, x, y); + } + XCopyPlane(graphPtr->display, bitmap, drawable, + penPtr->symbol.outlineGC, 0, 0, bw, bh, x, y, 1); + } + } + Tk_FreePixmap(graphPtr->display, bitmap); + if (mask != None) { + Tk_FreePixmap(graphPtr->display, mask); + } + } + break; + } +} + +/* + *--------------------------------------------------------------------------- + * + * DrawSymbolProc -- + * + * Draw the symbol centered at the each given x,y coordinate. + * + * Results: + * None. + * + * Side Effects: + * Draws a symbol at the coordinate given. + * + *--------------------------------------------------------------------------- + */ +static void +DrawSymbolProc( + Graph *graphPtr, /* Graph widget record */ + Drawable drawable, /* Pixmap or window to draw into */ + Element *basePtr, /* Line element information */ + int x, int y, /* Center position of symbol */ + int size) /* Size of symbol. */ +{ + LineElement *elemPtr = (LineElement *)basePtr; + LinePen *penPtr; + + penPtr = NORMALPEN(elemPtr); + if (penPtr->traceWidth > 0) { + /* + * Draw an extra line offset by one pixel from the previous to give a + * thicker appearance. This is only for the legend entry. This routine + * is never called for drawing the actual line segments. + */ + XDrawLine(graphPtr->display, drawable, penPtr->traceGC, x - size, y, + x + size, y); + XDrawLine(graphPtr->display, drawable, penPtr->traceGC, x - size, y + 1, + x + size, y + 1); + } + if (penPtr->symbol.type != SYMBOL_NONE) { + Point2d point; + + point.x = x, point.y = y; + DrawSymbols(graphPtr, drawable, elemPtr, penPtr, size, 1, &point); + } +} + +#ifdef WIN32 + +static void +DrawTraces( + Graph *graphPtr, + Drawable drawable, /* Pixmap or window to draw into */ + LineElement *elemPtr, + LinePen *penPtr) +{ + Blt_ChainLink link; + HBRUSH brush, oldBrush; + HDC dc; + HPEN pen, oldPen; + POINT *points; + TkWinDCState state; + int np; + + /* + * Depending if the line is wide (> 1 pixel), arbitrarily break the line in + * sections of 100 points. This bit of weirdness has to do with wide + * geometric pens. The longer the polyline, the slower it draws. The trade + * off is that we lose dash and cap uniformity for unbearably slow polyline + * draws. + */ + if (penPtr->traceGC->line_width > 1) { + np = 100; + } else { + np = Blt_MaxRequestSize(graphPtr->display, sizeof(POINT)) - 1; + } + points = Blt_AssertMalloc((np + 1) * sizeof(POINT)); + + dc = TkWinGetDrawableDC(graphPtr->display, drawable, &state); + + pen = Blt_GCToPen(dc, penPtr->traceGC); + oldPen = SelectPen(dc, pen); + brush = CreateSolidBrush(penPtr->traceGC->foreground); + oldBrush = SelectBrush(dc, brush); + SetROP2(dc, tkpWinRopModes[penPtr->traceGC->function]); + + for (link = Blt_Chain_FirstLink(elemPtr->traces); link != NULL; + link = Blt_Chain_NextLink(link)) { + POINT *p; + Trace *tracePtr; + int count, remaining; + + tracePtr = Blt_Chain_GetValue(link); + + /* + * If the trace has to be split into separate XDrawLines calls, then the + * end point of the current trace is also the starting point of the new + * split. + */ + + /* Step 1. Convert and draw the first section of the trace. + * It may contain the entire trace. */ + + for (p = points, count = 0; + count < MIN(np, tracePtr->screenPts.length); + count++, p++) { + p->x = Round(tracePtr->screenPts.points[count].x); + p->y = Round(tracePtr->screenPts.points[count].y); + } + Polyline(dc, points, count); + + /* Step 2. Next handle any full-size chunks left. */ + + while ((count + np) < tracePtr->screenPts.length) { + int j; + + /* Start with the last point of the previous trace. */ + points[0].x = points[np - 1].x; + points[0].y = points[np - 1].y; + + for (p = points + 1, j = 0; j < np; j++, count++, p++) { + p->x = Round(tracePtr->screenPts.points[count].x); + p->y = Round(tracePtr->screenPts.points[count].y); + } + Polyline(dc, points, np + 1); + } + + /* Step 3. Convert and draw the remaining points. */ + + remaining = tracePtr->screenPts.length - count; + if (remaining > 0) { + /* Start with the last point of the previous trace. */ + points[0].x = points[np - 1].x; + points[0].y = points[np - 1].y; + + for (p = points + 1; count < tracePtr->screenPts.length; + count++, p++) { + p->x = Round(tracePtr->screenPts.points[count].x); + p->y = Round(tracePtr->screenPts.points[count].y); + } + Polyline(dc, points, remaining + 1); + } + } + Blt_Free(points); + DeletePen(SelectPen(dc, oldPen)); + DeleteBrush(SelectBrush(dc, oldBrush)); + TkWinReleaseDrawableDC(drawable, dc, &state); +} + +#else + +static void +DrawTraces(Graph *graphPtr, Drawable drawable, LineElement *elemPtr, + LinePen *penPtr) +{ + Blt_ChainLink link; + XPoint *points; + int np; + + np = Blt_MaxRequestSize(graphPtr->display, sizeof(XPoint)) - 1; + points = Blt_AssertMalloc((np + 1) * sizeof(XPoint)); + + for (link = Blt_Chain_FirstLink(elemPtr->traces); link != NULL; + link = Blt_Chain_NextLink(link)) { + XPoint *xpp; + Trace *tracePtr; + int remaining, count; + int n; + + tracePtr = Blt_Chain_GetValue(link); + + /* + * If the trace has to be split into separate XDrawLines calls, then the + * end point of the current trace is also the starting point of the new + * split. + */ + /* Step 1. Convert and draw the first section of the trace. + * It may contain the entire trace. */ + + n = MIN(np, tracePtr->screenPts.length); + for (xpp = points, count = 0; count < n; count++, xpp++) { + xpp->x = Round(tracePtr->screenPts.points[count].x); + xpp->y = Round(tracePtr->screenPts.points[count].y); + } + XDrawLines(graphPtr->display, drawable, penPtr->traceGC, points, + count, CoordModeOrigin); + + /* Step 2. Next handle any full-size chunks left. */ + + while ((count + np) < tracePtr->screenPts.length) { + int j; + + /* Start with the last point of the previous trace. */ + points[0].x = points[np - 1].x; + points[0].y = points[np - 1].y; + + for (xpp = points + 1, j = 0; j < np; j++, count++, xpp++) { + xpp->x = Round(tracePtr->screenPts.points[count].x); + xpp->y = Round(tracePtr->screenPts.points[count].y); + } + XDrawLines(graphPtr->display, drawable, penPtr->traceGC, points, + np + 1, CoordModeOrigin); + } + + /* Step 3. Convert and draw the remaining points. */ + + remaining = tracePtr->screenPts.length - count; + if (remaining > 0) { + /* Start with the last point of the previous trace. */ + points[0].x = points[np - 1].x; + points[0].y = points[np - 1].y; + for (xpp = points + 1; count < tracePtr->screenPts.length; count++, + xpp++) { + xpp->x = Round(tracePtr->screenPts.points[count].x); + xpp->y = Round(tracePtr->screenPts.points[count].y); + } + XDrawLines(graphPtr->display, drawable, penPtr->traceGC, points, + remaining + 1, CoordModeOrigin); + } + } + Blt_Free(points); +} +#endif /* WIN32 */ + +static void +DrawValues(Graph *graphPtr, Drawable drawable, LineElement *elemPtr, + LinePen *penPtr, int length, Point2d *points, int *map) +{ + Point2d *pp, *endp; + double *xval, *yval; + const char *fmt; + char string[TCL_DOUBLE_SPACE * 2 + 2]; + int count; + + fmt = penPtr->valueFormat; + if (fmt == NULL) { + fmt = "%g"; + } + count = 0; + xval = elemPtr->x.values, yval = elemPtr->y.values; + for (pp = points, endp = points + length; pp < endp; pp++) { + double x, y; + + x = xval[map[count]]; + y = yval[map[count]]; + count++; + if (penPtr->valueShow == SHOW_X) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); + } else if (penPtr->valueShow == SHOW_Y) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); + } else if (penPtr->valueShow == SHOW_BOTH) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); + strcat(string, ","); + sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y); + } + Blt_DrawText(graphPtr->tkwin, drawable, string, &penPtr->valueStyle, + Round(pp->x), Round(pp->y)); + } +} + +/* + *--------------------------------------------------------------------------- + * + * DrawActiveLineProc -- + * + * Draws the connected line(s) representing the element. If the line is + * made up of non-line symbols and the line width parameter has been set + * (linewidth > 0), the element will also be drawn as a line (with the + * linewidth requested). The line may consist of separate line segments. + * + * Results: + * None. + * + * Side effects: + * X drawing commands are output. + * + *--------------------------------------------------------------------------- + */ +static void +DrawActiveLineProc(Graph *graphPtr, Drawable drawable, Element *basePtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + LinePen *penPtr = (LinePen *)elemPtr->activePenPtr; + int symbolSize; + + if (penPtr == NULL) { + return; + } + symbolSize = ScaleSymbol(elemPtr, penPtr->symbol.size); + + /* + * nActiveIndices + * > 0 Some points are active. Uses activeArr. + * < 0 All points are active. + * == 0 No points are active. + */ + if (elemPtr->nActiveIndices > 0) { + if (elemPtr->flags & ACTIVE_PENDING) { + MapActiveSymbols(graphPtr, elemPtr); + } + if (penPtr->symbol.type != SYMBOL_NONE) { + DrawSymbols(graphPtr, drawable, elemPtr, penPtr, symbolSize, + elemPtr->activePts.length, elemPtr->activePts.points); + } + if (penPtr->valueShow != SHOW_NONE) { + DrawValues(graphPtr, drawable, elemPtr, penPtr, + elemPtr->activePts.length, + elemPtr->activePts.points, + elemPtr->activePts.map); + } + } else if (elemPtr->nActiveIndices < 0) { + if (penPtr->traceWidth > 0) { + if (elemPtr->lines.length > 0) { + Blt_Draw2DSegments(graphPtr->display, drawable, + penPtr->traceGC, elemPtr->lines.segments, + elemPtr->lines.length); + } else if (Blt_Chain_GetLength(elemPtr->traces) > 0) { + DrawTraces(graphPtr, drawable, elemPtr, penPtr); + } + } + if (penPtr->symbol.type != SYMBOL_NONE) { + DrawSymbols(graphPtr, drawable, elemPtr, penPtr, symbolSize, + elemPtr->symbolPts.length, elemPtr->symbolPts.points); + } + if (penPtr->valueShow != SHOW_NONE) { + DrawValues(graphPtr, drawable, elemPtr, penPtr, + elemPtr->symbolPts.length, elemPtr->symbolPts.points, + elemPtr->symbolPts.map); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * DrawNormalLine -- + * + * Draws the connected line(s) representing the element. If the line is + * made up of non-line symbols and the line width parameter has been set + * (linewidth > 0), the element will also be drawn as a line (with the + * linewidth requested). The line may consist of separate line segments. + * + * Results: + * None. + * + * Side effects: + * X drawing commands are output. + * + *--------------------------------------------------------------------------- + */ +static void +DrawNormalLineProc(Graph *graphPtr, Drawable drawable, Element *basePtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + Blt_ChainLink link; + unsigned int count; + + /* Fill area under the curve */ + if (elemPtr->fillPts != NULL) { + XPoint *points; + Point2d *endp, *pp; + + points = Blt_AssertMalloc(sizeof(XPoint) * elemPtr->nFillPts); + count = 0; + for (pp = elemPtr->fillPts, endp = pp + elemPtr->nFillPts; + pp < endp; pp++) { + points[count].x = Round(pp->x); + points[count].y = Round(pp->y); + count++; + } + if (elemPtr->fillBg != NULL) { + Blt_SetBackgroundOrigin(graphPtr->tkwin, elemPtr->fillBg, 0, 0); + Blt_FillBackgroundPolygon(graphPtr->tkwin, drawable, + elemPtr->fillBg, points, elemPtr->nFillPts, 0, TK_RELIEF_FLAT); + } + Blt_Free(points); + } + + /* Lines: stripchart segments or graph traces. */ + if (elemPtr->lines.length > 0) { + for (link = Blt_Chain_FirstLink(elemPtr->styles); + link != NULL; link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + LinePen *penPtr; + + stylePtr = Blt_Chain_GetValue(link); + penPtr = (LinePen *)stylePtr->penPtr; + if ((stylePtr->lines.length > 0) && + (penPtr->errorBarLineWidth > 0)) { + Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->traceGC, + stylePtr->lines.segments, stylePtr->lines.length); + } + } + } else { + LinePen *penPtr; + + penPtr = NORMALPEN(elemPtr); + if ((Blt_Chain_GetLength(elemPtr->traces) > 0) && + (penPtr->traceWidth > 0)) { + DrawTraces(graphPtr, drawable, elemPtr, penPtr); + } + } + + if (elemPtr->reqMaxSymbols > 0) { + int total; + + total = 0; + for (link = Blt_Chain_FirstLink(elemPtr->styles); + link != NULL; link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + + stylePtr = Blt_Chain_GetValue(link); + total += stylePtr->symbolPts.length; + } + elemPtr->symbolInterval = total / elemPtr->reqMaxSymbols; + elemPtr->symbolCounter = 0; + } + + /* Symbols, error bars, values. */ + + count = 0; + for (link = Blt_Chain_FirstLink(elemPtr->styles); link != NULL; + link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + LinePen *penPtr; + + stylePtr = Blt_Chain_GetValue(link); + penPtr = (LinePen *)stylePtr->penPtr; + if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) { + Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, + stylePtr->xeb.segments, stylePtr->xeb.length); + } + if ((stylePtr->yeb.length > 0) && (penPtr->errorBarShow & SHOW_Y)) { + Blt_Draw2DSegments(graphPtr->display, drawable, penPtr->errorBarGC, + stylePtr->yeb.segments, stylePtr->yeb.length); + } + if ((stylePtr->symbolPts.length > 0) && + (penPtr->symbol.type != SYMBOL_NONE)) { + DrawSymbols(graphPtr, drawable, elemPtr, penPtr, + stylePtr->symbolSize, stylePtr->symbolPts.length, + stylePtr->symbolPts.points); + } + if (penPtr->valueShow != SHOW_NONE) { + DrawValues(graphPtr, drawable, elemPtr, penPtr, + stylePtr->symbolPts.length, stylePtr->symbolPts.points, + elemPtr->symbolPts.map + count); + } + count += stylePtr->symbolPts.length; + } + elemPtr->symbolInterval = 0; +} + +/* + *--------------------------------------------------------------------------- + * + * GetSymbolPostScriptInfo -- + * + * Set up the PostScript environment with the macros and attributes needed + * to draw the symbols of the element. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +GetSymbolPostScriptInfo( + Graph *graphPtr, + Blt_Ps ps, + LinePen *penPtr, + int size) +{ + XColor *outlineColor, *fillColor, *defaultColor; + + /* Set line and foreground attributes */ + outlineColor = penPtr->symbol.outlineColor; + fillColor = penPtr->symbol.fillColor; + defaultColor = penPtr->traceColor; + + if (fillColor == COLOR_DEFAULT) { + fillColor = defaultColor; + } + if (outlineColor == COLOR_DEFAULT) { + outlineColor = defaultColor; + } + if (penPtr->symbol.type == SYMBOL_NONE) { + Blt_Ps_XSetLineAttributes(ps, defaultColor, penPtr->traceWidth + 2, + &penPtr->traceDashes, CapButt, JoinMiter); + } else { + Blt_Ps_XSetLineWidth(ps, penPtr->symbol.outlineWidth); + Blt_Ps_XSetDashes(ps, (Blt_Dashes *)NULL); + } + + /* + * Build a PostScript procedure to draw the symbols. For bitmaps, paint + * both the bitmap and its mask. Otherwise fill and stroke the path formed + * already. + */ + Blt_Ps_Append(ps, "\n/DrawSymbolProc {\n"); + switch (penPtr->symbol.type) { + case SYMBOL_NONE: + break; /* Do nothing */ + case SYMBOL_BITMAP: + { + int w, h; + double sx, sy, scale; + + /* + * Compute how much to scale the bitmap. Don't let the scaled + * bitmap exceed the bounding square for the symbol. + */ + Tk_SizeOfBitmap(graphPtr->display, penPtr->symbol.bitmap, &w, &h); + sx = (double)size / (double)w; + sy = (double)size / (double)h; + scale = MIN(sx, sy); + + if ((penPtr->symbol.mask != None) && (fillColor != NULL)) { + Blt_Ps_VarAppend(ps, "\n % Bitmap mask is \"", + Tk_NameOfBitmap(graphPtr->display, penPtr->symbol.mask), + "\"\n\n ", (char *)NULL); + Blt_Ps_XSetBackground(ps, fillColor); + Blt_Ps_DrawBitmap(ps, graphPtr->display, penPtr->symbol.mask, + scale, scale); + } + Blt_Ps_VarAppend(ps, "\n % Bitmap symbol is \"", + Tk_NameOfBitmap(graphPtr->display, penPtr->symbol.bitmap), + "\"\n\n ", (char *)NULL); + Blt_Ps_XSetForeground(ps, outlineColor); + Blt_Ps_DrawBitmap(ps, graphPtr->display, penPtr->symbol.bitmap, + scale, scale); + } + break; + default: + if (fillColor != NULL) { + Blt_Ps_Append(ps, " "); + Blt_Ps_XSetBackground(ps, fillColor); + Blt_Ps_Append(ps, " gsave fill grestore\n"); + } + if ((outlineColor != NULL) && (penPtr->symbol.outlineWidth > 0)) { + Blt_Ps_Append(ps, " "); + Blt_Ps_XSetForeground(ps, outlineColor); + Blt_Ps_Append(ps, " stroke\n"); + } + break; + } + Blt_Ps_Append(ps, "} def\n\n"); +} + +/* + *--------------------------------------------------------------------------- + * + * SymbolsToPostScript -- + * + * Draw a symbol centered at the given x,y window coordinate based upon the + * element symbol type and size. + * + * Results: + * None. + * + * Problems: + * Most notable is the round-off errors generated when calculating the + * centered position of the symbol. + * + *--------------------------------------------------------------------------- + */ +static void +SymbolsToPostScript( + Graph *graphPtr, + Blt_Ps ps, + LinePen *penPtr, + int size, + int nSymbolPts, + Point2d *symbolPts) +{ + double symbolSize; + static const char *symbolMacros[] = + { + "Li", "Sq", "Ci", "Di", "Pl", "Cr", "Sp", "Sc", "Tr", "Ar", "Bm", + (char *)NULL, + }; + GetSymbolPostScriptInfo(graphPtr, ps, penPtr, size); + + symbolSize = (double)size; + switch (penPtr->symbol.type) { + case SYMBOL_SQUARE: + case SYMBOL_CROSS: + case SYMBOL_PLUS: + case SYMBOL_SCROSS: + case SYMBOL_SPLUS: + symbolSize = (double)Round(size * S_RATIO); + break; + case SYMBOL_TRIANGLE: + case SYMBOL_ARROW: + symbolSize = (double)Round(size * 0.7); + break; + case SYMBOL_DIAMOND: + symbolSize = (double)Round(size * M_SQRT1_2); + break; + + default: + break; + } + { + Point2d *pp, *endp; + + for (pp = symbolPts, endp = symbolPts + nSymbolPts; pp < endp; pp++) { + Blt_Ps_Format(ps, "%g %g %g %s\n", pp->x, pp->y, + symbolSize, symbolMacros[penPtr->symbol.type]); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * SymbolToPostScriptProc -- + * + * Draw the symbol centered at the each given x,y coordinate. + * + * Results: + * None. + * + * Side Effects: + * Draws a symbol at the coordinate given. + * + *--------------------------------------------------------------------------- + */ +static void +SymbolToPostScriptProc( + Graph *graphPtr, /* Graph widget record */ + Blt_Ps ps, + Element *basePtr, /* Line element information */ + double x, double y, /* Center position of symbol */ + int size) /* Size of element */ +{ + LineElement *elemPtr = (LineElement *)basePtr; + LinePen *penPtr; + + penPtr = NORMALPEN(elemPtr); + if (penPtr->traceWidth > 0) { + /* + * Draw an extra line offset by one pixel from the previous to give a + * thicker appearance. This is only for the legend entry. This routine + * is never called for drawing the actual line segments. + */ + Blt_Ps_XSetLineAttributes(ps, penPtr->traceColor, + penPtr->traceWidth, &penPtr->traceDashes, CapButt, JoinMiter); + Blt_Ps_Format(ps, "%g %g %d Li\n", x, y, size + size); + } + if (penPtr->symbol.type != SYMBOL_NONE) { + Point2d point; + + point.x = x, point.y = y; + SymbolsToPostScript(graphPtr, ps, penPtr, size, 1, &point); + } +} + +static void +SetLineAttributes(Blt_Ps ps, LinePen *penPtr) +{ + /* Set the attributes of the line (color, dashes, linewidth) */ + Blt_Ps_XSetLineAttributes(ps, penPtr->traceColor, + penPtr->traceWidth, &penPtr->traceDashes, CapButt, JoinMiter); + if ((LineIsDashed(penPtr->traceDashes)) && + (penPtr->traceOffColor != NULL)) { + Blt_Ps_Append(ps, "/DashesProc {\n gsave\n "); + Blt_Ps_XSetBackground(ps, penPtr->traceOffColor); + Blt_Ps_Append(ps, " "); + Blt_Ps_XSetDashes(ps, (Blt_Dashes *)NULL); + Blt_Ps_Append(ps, "stroke\n grestore\n} def\n"); + } else { + Blt_Ps_Append(ps, "/DashesProc {} def\n"); + } +} + +static void +TracesToPostScript(Blt_Ps ps, LineElement *elemPtr, LinePen *penPtr) +{ + Blt_ChainLink link; + + SetLineAttributes(ps, penPtr); + for (link = Blt_Chain_FirstLink(elemPtr->traces); link != NULL; + link = Blt_Chain_NextLink(link)) { + Trace *tracePtr; + + tracePtr = Blt_Chain_GetValue(link); + if (tracePtr->screenPts.length > 0) { + Blt_Ps_Append(ps, "% start trace\n"); + Blt_Ps_DrawPolyline(ps, tracePtr->screenPts.points, + tracePtr->screenPts.length); + Blt_Ps_Append(ps, "% end trace\n"); + } + } +} + + +static void +ValuesToPostScript(Blt_Ps ps, LineElement *elemPtr, LinePen *penPtr, + int nSymbolPts, Point2d *symbolPts, int *pointToData) +{ + Point2d *pp, *endp; + int count; + char string[TCL_DOUBLE_SPACE * 2 + 2]; + const char *fmt; + + fmt = penPtr->valueFormat; + if (fmt == NULL) { + fmt = "%g"; + } + count = 0; + for (pp = symbolPts, endp = symbolPts + nSymbolPts; pp < endp; pp++) { + double x, y; + + x = elemPtr->x.values[pointToData[count]]; + y = elemPtr->y.values[pointToData[count]]; + count++; + if (penPtr->valueShow == SHOW_X) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); + } else if (penPtr->valueShow == SHOW_Y) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, y); + } else if (penPtr->valueShow == SHOW_BOTH) { + sprintf_s(string, TCL_DOUBLE_SPACE, fmt, x); + strcat(string, ","); + sprintf_s(string + strlen(string), TCL_DOUBLE_SPACE, fmt, y); + } + Blt_Ps_DrawText(ps, string, &penPtr->valueStyle, pp->x, pp->y); + } +} + + +/* + *--------------------------------------------------------------------------- + * + * ActiveLineToPostScript -- + * + * Generates PostScript commands to draw as "active" the points (symbols) + * and or line segments (trace) representing the element. + * + * Results: + * None. + * + * Side effects: + * PostScript pen width, dashes, and color settings are changed. + * + *--------------------------------------------------------------------------- + */ +static void +ActiveLineToPostScriptProc(Graph *graphPtr, Blt_Ps ps, Element *basePtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + LinePen *penPtr = (LinePen *)elemPtr->activePenPtr; + int symbolSize; + + if (penPtr == NULL) { + return; + } + symbolSize = ScaleSymbol(elemPtr, penPtr->symbol.size); + if (elemPtr->nActiveIndices > 0) { + if (elemPtr->flags & ACTIVE_PENDING) { + MapActiveSymbols(graphPtr, elemPtr); + } + if (penPtr->symbol.type != SYMBOL_NONE) { + SymbolsToPostScript(graphPtr, ps, penPtr, symbolSize, + elemPtr->activePts.length, elemPtr->activePts.points); + } + if (penPtr->valueShow != SHOW_NONE) { + ValuesToPostScript(ps, elemPtr, penPtr, elemPtr->activePts.length, + elemPtr->activePts.points, elemPtr->activePts.map); + } + } else if (elemPtr->nActiveIndices < 0) { + if (penPtr->traceWidth > 0) { + if (elemPtr->lines.length > 0) { + SetLineAttributes(ps, penPtr); + Blt_Ps_Draw2DSegments(ps, elemPtr->lines.segments, + elemPtr->lines.length); + } + if (Blt_Chain_GetLength(elemPtr->traces) > 0) { + TracesToPostScript(ps, elemPtr, (LinePen *)penPtr); + } + } + if (penPtr->symbol.type != SYMBOL_NONE) { + SymbolsToPostScript(graphPtr, ps, penPtr, symbolSize, + elemPtr->symbolPts.length, elemPtr->symbolPts.points); + } + if (penPtr->valueShow != SHOW_NONE) { + ValuesToPostScript(ps, elemPtr, penPtr, elemPtr->symbolPts.length, + elemPtr->symbolPts.points, elemPtr->symbolPts.map); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * NormalLineToPostScriptProc -- + * + * Similar to the DrawLine procedure, prints PostScript related commands to + * form the connected line(s) representing the element. + * + * Results: + * None. + * + * Side effects: + * PostScript pen width, dashes, and color settings are changed. + * + *--------------------------------------------------------------------------- + */ +static void +NormalLineToPostScriptProc(Graph *graphPtr, Blt_Ps ps, Element *basePtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + Blt_ChainLink link; + unsigned int count; + + /* Draw fill area */ + if (elemPtr->fillPts != NULL) { + /* Create a path to use for both the polygon and its outline. */ + Blt_Ps_Append(ps, "% start fill area\n"); + Blt_Ps_Polyline(ps, elemPtr->fillPts, elemPtr->nFillPts); + + /* If the background fill color was specified, draw the polygon in a + * solid fashion with that color. */ + if (elemPtr->fillBgColor != NULL) { + Blt_Ps_XSetBackground(ps, elemPtr->fillBgColor); + Blt_Ps_Append(ps, "gsave fill grestore\n"); + } + Blt_Ps_XSetForeground(ps, elemPtr->fillFgColor); + if (elemPtr->fillBg != NULL) { + Blt_Ps_Append(ps, "gsave fill grestore\n"); + /* TBA: Transparent tiling is the hard part. */ + } else { + Blt_Ps_Append(ps, "gsave fill grestore\n"); + } + Blt_Ps_Append(ps, "% end fill area\n"); + } + + /* Draw lines (strip chart) or traces (xy graph) */ + if (elemPtr->lines.length > 0) { + for (link = Blt_Chain_FirstLink(elemPtr->styles); link != NULL; + link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + LinePen *penPtr; + + stylePtr = Blt_Chain_GetValue(link); + penPtr = (LinePen *)stylePtr->penPtr; + if ((stylePtr->lines.length > 0) && (penPtr->traceWidth > 0)) { + SetLineAttributes(ps, penPtr); + Blt_Ps_Append(ps, "% start segments\n"); + Blt_Ps_Draw2DSegments(ps, stylePtr->lines.segments, + stylePtr->lines.length); + Blt_Ps_Append(ps, "% end segments\n"); + } + } + } else { + LinePen *penPtr; + + penPtr = NORMALPEN(elemPtr); + if ((Blt_Chain_GetLength(elemPtr->traces) > 0) && + (penPtr->traceWidth > 0)) { + TracesToPostScript(ps, elemPtr, penPtr); + } + } + + /* Draw symbols, error bars, values. */ + + count = 0; + for (link = Blt_Chain_FirstLink(elemPtr->styles); link != NULL; + link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + LinePen *penPtr; + XColor *colorPtr; + + stylePtr = Blt_Chain_GetValue(link); + penPtr = (LinePen *)stylePtr->penPtr; + colorPtr = penPtr->errorBarColor; + if (colorPtr == COLOR_DEFAULT) { + colorPtr = penPtr->traceColor; + } + if ((stylePtr->xeb.length > 0) && (penPtr->errorBarShow & SHOW_X)) { + Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, + NULL, CapButt, JoinMiter); + Blt_Ps_Draw2DSegments(ps, stylePtr->xeb.segments, + stylePtr->xeb.length); + } + if ((stylePtr->yeb.length > 0) && (penPtr->errorBarShow & SHOW_Y)) { + Blt_Ps_XSetLineAttributes(ps, colorPtr, penPtr->errorBarLineWidth, + NULL, CapButt, JoinMiter); + Blt_Ps_Draw2DSegments(ps, stylePtr->yeb.segments, + stylePtr->yeb.length); + } + if ((stylePtr->symbolPts.length > 0) && + (penPtr->symbol.type != SYMBOL_NONE)) { + SymbolsToPostScript(graphPtr, ps, penPtr, stylePtr->symbolSize, + stylePtr->symbolPts.length, stylePtr->symbolPts.points); + } + if (penPtr->valueShow != SHOW_NONE) { + ValuesToPostScript(ps, elemPtr, penPtr, stylePtr->symbolPts.length, + stylePtr->symbolPts.points, elemPtr->symbolPts.map + count); + } + count += stylePtr->symbolPts.length; + } +} + +/* + *--------------------------------------------------------------------------- + * + * DestroyLineProc -- + * + * Release memory and resources allocated for the line element. + * + * Results: + * None. + * + * Side effects: + * Everything associated with the line element is freed up. + * + *--------------------------------------------------------------------------- + */ + +static void +DestroyLineProc(Graph *graphPtr, Element *basePtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + + DestroyPenProc(graphPtr, (Pen *)&elemPtr->builtinPen); + if (elemPtr->activePenPtr != NULL) { + Blt_FreePen((Pen *)elemPtr->activePenPtr); + } + ResetLine(elemPtr); + if (elemPtr->styles != NULL) { + Blt_FreeStylePalette(elemPtr->styles); + Blt_Chain_Destroy(elemPtr->styles); + } + if (elemPtr->activeIndices != NULL) { + Blt_Free(elemPtr->activeIndices); + } + if (elemPtr->fillPts != NULL) { + Blt_Free(elemPtr->fillPts); + } + if (elemPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, elemPtr->fillGC); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_LineElement -- + * + * Allocate memory and initialize methods for the new line element. + * + * Results: + * The pointer to the newly allocated element structure is returned. + * + * Side effects: + * Memory is allocated for the line element structure. + * + *--------------------------------------------------------------------------- + */ + +static ElementProcs lineProcs = +{ + ClosestLineProc, /* Finds the closest element/data + * point */ + ConfigureLineProc, /* Configures the element. */ + DestroyLineProc, /* Destroys the element. */ + DrawActiveLineProc, /* Draws active element */ + DrawNormalLineProc, /* Draws normal element */ + DrawSymbolProc, /* Draws the element symbol. */ + GetLineExtentsProc, /* Find the extents of the element's + * data. */ + ActiveLineToPostScriptProc, /* Prints active element. */ + NormalLineToPostScriptProc, /* Prints normal element. */ + SymbolToPostScriptProc, /* Prints the line's symbol. */ + MapLineProc /* Compute element's screen + * coordinates. */ +}; + +Element * +Blt_LineElement(Graph *graphPtr, const char *name, ClassId classId) +{ + LineElement *elemPtr; + + elemPtr = Blt_AssertCalloc(1, sizeof(LineElement)); + elemPtr->procsPtr = &lineProcs; + if (classId == CID_ELEM_LINE) { + elemPtr->configSpecs = lineElemConfigSpecs; + } else { + elemPtr->configSpecs = stripElemConfigSpecs; + } + elemPtr->obj.name = Blt_AssertStrdup(name); + Blt_GraphSetObjectClass(&elemPtr->obj, classId); + elemPtr->flags = SCALE_SYMBOL; + elemPtr->obj.graphPtr = graphPtr; + /* By default an element's name and label are the same. */ + elemPtr->label = Blt_AssertStrdup(name); + elemPtr->legendRelief = TK_RELIEF_FLAT; + elemPtr->penDir = PEN_BOTH_DIRECTIONS; + elemPtr->styles = Blt_Chain_Create(); + elemPtr->builtinPenPtr = &elemPtr->builtinPen; + elemPtr->reqSmooth = PEN_SMOOTH_LINEAR; + InitLinePen(elemPtr->builtinPenPtr); + bltLineStylesOption.clientData = (ClientData)sizeof(LineStyle); + return (Element *)elemPtr; +} + +#ifdef notdef +/* + *--------------------------------------------------------------------------- + * + * MapLineProc -- + * + * Calculates the actual window coordinates of the line element. The + * window coordinates are saved in an allocated point array. + * + * Results: + * None. + * + * Side effects: + * Memory is (re)allocated for the point array. + * + *--------------------------------------------------------------------------- + */ +static void +MapLineProc(Graph *graphPtr, Element *basePtr) +{ + LineElement *elemPtr = (LineElement *)basePtr; + MapInfo mi; + int size, np; + LineStyle **styleMap; + Blt_ChainLink link; + + ResetLine(elemPtr); + np = NUMBEROFPOINTS(elemPtr); + if (np < 1) { + return; /* No data points */ + } + GetScreenPoints(graphPtr, elemPtr, &mi); + MapSymbols(graphPtr, elemPtr, &mi); + + if ((elemPtr->flags & ACTIVE_PENDING) && (elemPtr->nActiveIndices > 0)) { + MapActiveSymbols(graphPtr, elemPtr); + } + /* + * Map connecting line segments if they are to be displayed. + */ + elemPtr->smooth = elemPtr->reqSmooth; + if ((np > 1) && ((graphPtr->classId == CID_ELEM_STRIP) || + (elemPtr->builtinPen.traceWidth > 0))) { + + /* + * Do smoothing if necessary. This can extend the coordinate array, + * so both mi.points and mi.nPoints may change. + */ + switch (elemPtr->smooth) { + case PEN_SMOOTH_STEP: + GenerateSteps(&mi); + break; + + case PEN_SMOOTH_NATURAL: + case PEN_SMOOTH_QUADRATIC: + if (mi.nScreenPts < 3) { + /* Can't interpolate with less than three points. */ + elemPtr->smooth = PEN_SMOOTH_LINEAR; + } else { + GenerateSpline(graphPtr, elemPtr, &mi); + } + break; + + case PEN_SMOOTH_CATROM: + if (mi.nScreenPts < 3) { + /* Can't interpolate with less than three points. */ + elemPtr->smooth = PEN_SMOOTH_LINEAR; + } else { + GenerateParametricSpline(graphPtr, elemPtr, &mi); + } + break; + + default: + break; + } + if (elemPtr->rTolerance > 0.0) { + ReducePoints(&mi, elemPtr->rTolerance); + } + if (elemPtr->fillBg != NULL) { + MapFillArea(graphPtr, elemPtr, &mi); + } + if (graphPtr->classId == CID_ELEM_STRIP) { + MapStrip(graphPtr, elemPtr, &mi); + } else { + MapTraces(graphPtr, elemPtr, &mi); + } + } + Blt_Free(mi.screenPts); + Blt_Free(mi.map); + + /* Set the symbol size of all the pen styles. */ + for (link = Blt_Chain_FirstLink(elemPtr->styles); link != NULL; + link = Blt_Chain_NextLink(link)) { + LineStyle *stylePtr; + LinePen *penPtr; + + stylePtr = Blt_Chain_GetValue(link); + penPtr = (LinePen *)stylePtr->penPtr; + size = ScaleSymbol(elemPtr, penPtr->symbol.size); + stylePtr->symbolSize = size; + stylePtr->errorBarCapWidth = (penPtr->errorBarCapWidth > 0) + ? penPtr->errorBarCapWidth : Round(size * 0.6666666); + stylePtr->errorBarCapWidth /= 2; + } + styleMap = (LineStyle **)Blt_StyleMap((Element *)elemPtr); + if (((elemPtr->yHigh.nValues > 0) && (elemPtr->yLow.nValues > 0)) || + ((elemPtr->xHigh.nValues > 0) && (elemPtr->xLow.nValues > 0)) || + (elemPtr->xError.nValues > 0) || (elemPtr->yError.nValues > 0)) { + MapErrorBars(graphPtr, elemPtr, styleMap); + } + MergePens(elemPtr, styleMap); + Blt_Free(styleMap); +} +#endif diff --git a/src/bltGrElemLineSpline.C b/src/bltGrElemLineSpline.C new file mode 100644 index 0000000..3f3b621 --- /dev/null +++ b/src/bltGrElemLineSpline.C @@ -0,0 +1,1399 @@ + +#include "bltInt.h" +#include "bltOp.h" +#include <bltVector.h> + +typedef int (SplineProc)(Point2d origPts[], int nOrigPts, Point2d intpPts[], + int nIntpPts); + +typedef double TriDiagonalMatrix[3]; +typedef struct { + double b, c, d; +} Cubic2D; + +typedef struct { + double b, c, d, e, f; +} Quint2D; + +/* + * Quadratic spline parameters + */ +#define E1 param[0] +#define E2 param[1] +#define V1 param[2] +#define V2 param[3] +#define W1 param[4] +#define W2 param[5] +#define Z1 param[6] +#define Z2 param[7] +#define Y1 param[8] +#define Y2 param[9] + +static Tcl_ObjCmdProc SplineCmd; + +/* + *--------------------------------------------------------------------------- + * + * Search -- + * + * Conducts a binary search for a value. This routine is called + * only if key is between x(0) and x(len - 1). + * + * Results: + * Returns the index of the largest value in xtab for which + * x[i] < key. + * + *--------------------------------------------------------------------------- + */ +static int +Search( + Point2d points[], /* Contains the abscissas of the data + * points of interpolation. */ + int nPoints, /* Dimension of x. */ + double key, /* Value whose relative position in + * x is to be located. */ + int *foundPtr) /* (out) Returns 1 if s is found in + * x and 0 otherwise. */ +{ + int high, low, mid; + + low = 0; + high = nPoints - 1; + + while (high >= low) { + mid = (high + low) / 2; + if (key > points[mid].x) { + low = mid + 1; + } else if (key < points[mid].x) { + high = mid - 1; + } else { + *foundPtr = 1; + return mid; + } + } + *foundPtr = 0; + return low; +} + +/* + *--------------------------------------------------------------------------- + * + * QuadChoose -- + * + * Determines the case needed for the computation of the parame- + * ters of the quadratic spline. + * + * Results: + * Returns a case number (1-4) which controls how the parameters + * of the quadratic spline are evaluated. + * + *--------------------------------------------------------------------------- + */ +static int +QuadChoose( + Point2d *p, /* Coordinates of one of the points of + * interpolation */ + Point2d *q, /* Coordinates of one of the points of + * interpolation */ + double m1, /* Derivative condition at point P */ + double m2, /* Derivative condition at point Q */ + double epsilon) /* Error tolerance used to distinguish + * cases when m1 or m2 is relatively + * close to the slope or twice the + * slope of the line segment joining + * the points P and Q. If + * epsilon is not 0.0, then epsilon + * should be greater than or equal to + * machine epsilon. */ +{ + double slope; + + /* Calculate the slope of the line joining P and Q. */ + slope = (q->y - p->y) / (q->x - p->x); + + if (slope != 0.0) { + double relerr; + double mref, mref1, mref2, prod1, prod2; + + prod1 = slope * m1; + prod2 = slope * m2; + + /* Find the absolute values of the slopes slope, m1, and m2. */ + mref = FABS(slope); + mref1 = FABS(m1); + mref2 = FABS(m2); + + /* + * If the relative deviation of m1 or m2 from slope is less than + * epsilon, then choose case 2 or case 3. + */ + relerr = epsilon * mref; + if ((FABS(slope - m1) > relerr) && (FABS(slope - m2) > relerr) && + (prod1 >= 0.0) && (prod2 >= 0.0)) { + double prod; + + prod = (mref - mref1) * (mref - mref2); + if (prod < 0.0) { + /* + * l1, the line through (x1,y1) with slope m1, and l2, + * the line through (x2,y2) with slope m2, intersect + * at a point whose abscissa is between x1 and x2. + * The abscissa becomes a knot of the spline. + */ + return 1; + } + if (mref1 > (mref * 2.0)) { + if (mref2 <= ((2.0 - epsilon) * mref)) { + return 3; + } + } else if (mref2 <= (mref * 2.0)) { + /* + * Both l1 and l2 cross the line through + * (x1+x2)/2.0,y1 and (x1+x2)/2.0,y2, which is the + * midline of the rectangle formed by P and Q or both + * m1 and m2 have signs different than the sign of + * slope, or one of m1 and m2 has opposite sign from + * slope and l1 and l2 intersect to the left of x1 or + * to the right of x2. The point (x1+x2)/2. is a knot + * of the spline. + */ + return 2; + } else if (mref1 <= ((2.0 - epsilon) * mref)) { + /* + * In cases 3 and 4, sign(m1)=sign(m2)=sign(slope). + * Either l1 or l2 crosses the midline, but not both. + * Choose case 4 if mref1 is greater than + * (2.-epsilon)*mref; otherwise, choose case 3. + */ + return 3; + } + /* + * If neither l1 nor l2 crosses the midline, the spline + * requires two knots between x1 and x2. + */ + return 4; + } else { + /* + * The sign of at least one of the slopes m1 or m2 does not + * agree with the sign of *slope*. + */ + if ((prod1 < 0.0) && (prod2 < 0.0)) { + return 2; + } else if (prod1 < 0.0) { + if (mref2 > ((epsilon + 1.0) * mref)) { + return 1; + } else { + return 2; + } + } else if (mref1 > ((epsilon + 1.0) * mref)) { + return 1; + } else { + return 2; + } + } + } else if ((m1 * m2) >= 0.0) { + return 2; + } else { + return 1; + } +} + +/* + *--------------------------------------------------------------------------- + * + * QuadCases -- + * + * Computes the knots and other parameters of the spline on the + * interval PQ. + * + * + * On input-- + * + * P and Q are the coordinates of the points of interpolation. + * + * m1 is the slope at P. + * + * m2 is the slope at Q. + * + * ncase controls the number and location of the knots. + * + * + * On output-- + * + * (v1,v2),(w1,w2),(z1,z2), and (e1,e2) are the coordinates of + * the knots and other parameters of the spline on P. + * (e1,e2) and Q are used only if ncase=4. + * + *--------------------------------------------------------------------------- + */ +static void +QuadCases(Point2d *p, Point2d *q, double m1, double m2, double param[], + int which) +{ + if ((which == 3) || (which == 4)) { /* Parameters used in both 3 and 4 */ + double mbar1, mbar2, mbar3, c1, d1, h1, j1, k1; + + c1 = p->x + (q->y - p->y) / m1; + d1 = q->x + (p->y - q->y) / m2; + h1 = c1 * 2.0 - p->x; + j1 = d1 * 2.0 - q->x; + mbar1 = (q->y - p->y) / (h1 - p->x); + mbar2 = (p->y - q->y) / (j1 - q->x); + + if (which == 4) { /* Case 4. */ + Y1 = (p->x + c1) / 2.0; + V1 = (p->x + Y1) / 2.0; + V2 = m1 * (V1 - p->x) + p->y; + Z1 = (d1 + q->x) / 2.0; + W1 = (q->x + Z1) / 2.0; + W2 = m2 * (W1 - q->x) + q->y; + mbar3 = (W2 - V2) / (W1 - V1); + Y2 = mbar3 * (Y1 - V1) + V2; + Z2 = mbar3 * (Z1 - V1) + V2; + E1 = (Y1 + Z1) / 2.0; + E2 = mbar3 * (E1 - V1) + V2; + } else { /* Case 3. */ + k1 = (p->y - q->y + q->x * mbar2 - p->x * mbar1) / (mbar2 - mbar1); + if (FABS(m1) > FABS(m2)) { + Z1 = (k1 + p->x) / 2.0; + } else { + Z1 = (k1 + q->x) / 2.0; + } + V1 = (p->x + Z1) / 2.0; + V2 = p->y + m1 * (V1 - p->x); + W1 = (q->x + Z1) / 2.0; + W2 = q->y + m2 * (W1 - q->x); + Z2 = V2 + (W2 - V2) / (W1 - V1) * (Z1 - V1); + } + } else if (which == 2) { /* Case 2. */ + Z1 = (p->x + q->x) / 2.0; + V1 = (p->x + Z1) / 2.0; + V2 = p->y + m1 * (V1 - p->x); + W1 = (Z1 + q->x) / 2.0; + W2 = q->y + m2 * (W1 - q->x); + Z2 = (V2 + W2) / 2.0; + } else { /* Case 1. */ + double ztwo; + + Z1 = (p->y - q->y + m2 * q->x - m1 * p->x) / (m2 - m1); + ztwo = p->y + m1 * (Z1 - p->x); + V1 = (p->x + Z1) / 2.0; + V2 = (p->y + ztwo) / 2.0; + W1 = (Z1 + q->x) / 2.0; + W2 = (ztwo + q->y) / 2.0; + Z2 = V2 + (W2 - V2) / (W1 - V1) * (Z1 - V1); + } +} + +static int +QuadSelect(Point2d *p, Point2d *q, double m1, double m2, double epsilon, + double param[]) +{ + int ncase; + + ncase = QuadChoose(p, q, m1, m2, epsilon); + QuadCases(p, q, m1, m2, param, ncase); + return ncase; +} + +/* + *--------------------------------------------------------------------------- + * + * QuadGetImage -- + * + *--------------------------------------------------------------------------- + */ +INLINE static double +QuadGetImage(double p1, double p2, double p3, double x1, double x2, double x3) +{ + double A, B, C; + double y; + + A = x1 - x2; + B = x2 - x3; + C = x1 - x3; + + y = (p1 * (A * A) + p2 * 2.0 * B * A + p3 * (B * B)) / (C * C); + return y; +} + +/* + *--------------------------------------------------------------------------- + * + * QuadSpline -- + * + * Finds the image of a point in x. + * + * On input + * + * x Contains the value at which the spline is evaluated. + * leftX, leftY + * Coordinates of the left-hand data point used in the + * evaluation of x values. + * rightX, rightY + * Coordinates of the right-hand data point used in the + * evaluation of x values. + * Z1, Z2, Y1, Y2, E2, W2, V2 + * Parameters of the spline. + * ncase Controls the evaluation of the spline by indicating + * whether one or two knots were placed in the interval + * (xtabs,xtabs1). + * + * Results: + * The image of the spline at x. + * + *--------------------------------------------------------------------------- + */ +static void +QuadSpline( + Point2d *intp, /* Value at which spline is evaluated */ + Point2d *left, /* Point to the left of the data point to + * be evaluated */ + Point2d *right, /* Point to the right of the data point to + * be evaluated */ + double param[], /* Parameters of the spline */ + int ncase) /* Controls the evaluation of the + * spline by indicating whether one or + * two knots were placed in the + * interval (leftX,rightX) */ +{ + double y; + + if (ncase == 4) { + /* + * Case 4: More than one knot was placed in the interval. + */ + + /* + * Determine the location of data point relative to the 1st knot. + */ + if (Y1 > intp->x) { + y = QuadGetImage(left->y, V2, Y2, Y1, intp->x, left->x); + } else if (Y1 < intp->x) { + /* + * Determine the location of the data point relative to + * the 2nd knot. + */ + if (Z1 > intp->x) { + y = QuadGetImage(Y2, E2, Z2, Z1, intp->x, Y1); + } else if (Z1 < intp->x) { + y = QuadGetImage(Z2, W2, right->y, right->x, intp->x, Z1); + } else { + y = Z2; + } + } else { + y = Y2; + } + } else { + + /* + * Cases 1, 2, or 3: + * + * Determine the location of the data point relative to the + * knot. + */ + if (Z1 < intp->x) { + y = QuadGetImage(Z2, W2, right->y, right->x, intp->x, Z1); + } else if (Z1 > intp->x) { + y = QuadGetImage(left->y, V2, Z2, Z1, intp->x, left->x); + } else { + y = Z2; + } + } + intp->y = y; +} + +/* + *--------------------------------------------------------------------------- + * + * QuadSlopes -- + * + * Calculates the derivative at each of the data points. The + * slopes computed will insure that an osculatory quadratic + * spline will have one additional knot between two adjacent + * points of interpolation. Convexity and monotonicity are + * preserved wherever these conditions are compatible with the + * data. + * + * Results: + * The output array "m" is filled with the derivates at each + * data point. + * + *--------------------------------------------------------------------------- + */ +static void +QuadSlopes(Point2d *points, double *m, int nPoints) +{ + double xbar, xmid, xhat, ydif1, ydif2; + double yxmid; + double m1, m2; + double m1s, m2s; + int i, n, l; + + m1s = m2s = m1 = m2 = 0; + for (l = 0, i = 1, n = 2; i < (nPoints - 1); l++, i++, n++) { + /* + * Calculate the slopes of the two lines joining three + * consecutive data points. + */ + ydif1 = points[i].y - points[l].y; + ydif2 = points[n].y - points[i].y; + m1 = ydif1 / (points[i].x - points[l].x); + m2 = ydif2 / (points[n].x - points[i].x); + if (i == 1) { + m1s = m1, m2s = m2; /* Save slopes of starting point */ + } + /* + * If one of the preceding slopes is zero or if they have opposite + * sign, assign the value zero to the derivative at the middle + * point. + */ + if ((m1 == 0.0) || (m2 == 0.0) || ((m1 * m2) <= 0.0)) { + m[i] = 0.0; + } else if (FABS(m1) > FABS(m2)) { + /* + * Calculate the slope by extending the line with slope m1. + */ + xbar = ydif2 / m1 + points[i].x; + xhat = (xbar + points[n].x) / 2.0; + m[i] = ydif2 / (xhat - points[i].x); + } else { + /* + * Calculate the slope by extending the line with slope m2. + */ + xbar = -ydif1 / m2 + points[i].x; + xhat = (points[l].x + xbar) / 2.0; + m[i] = ydif1 / (points[i].x - xhat); + } + } + + /* Calculate the slope at the last point, x(n). */ + i = nPoints - 2; + n = nPoints - 1; + if ((m1 * m2) < 0.0) { + m[n] = m2 * 2.0; + } else { + xmid = (points[i].x + points[n].x) / 2.0; + yxmid = m[i] * (xmid - points[i].x) + points[i].y; + m[n] = (points[n].y - yxmid) / (points[n].x - xmid); + if ((m[n] * m2) < 0.0) { + m[n] = 0.0; + } + } + + /* Calculate the slope at the first point, x(0). */ + if ((m1s * m2s) < 0.0) { + m[0] = m1s * 2.0; + } else { + xmid = (points[0].x + points[1].x) / 2.0; + yxmid = m[1] * (xmid - points[1].x) + points[1].y; + m[0] = (yxmid - points[0].y) / (xmid - points[0].x); + if ((m[0] * m1s) < 0.0) { + m[0] = 0.0; + } + } + +} + +/* + *--------------------------------------------------------------------------- + * + * QuadEval -- + * + * QuadEval controls the evaluation of an osculatory quadratic + * spline. The user may provide his own slopes at the points of + * interpolation or use the subroutine 'QuadSlopes' to calculate + * slopes which are consistent with the shape of the data. + * + * ON INPUT-- + * intpPts must be a nondecreasing vector of points at which the + * spline will be evaluated. + * origPts contains the abscissas of the data points to be + * interpolated. xtab must be increasing. + * y contains the ordinates of the data points to be + * interpolated. + * m contains the slope of the spline at each point of + * interpolation. + * nPoints number of data points (dimension of xtab and y). + * numEval is the number of points of evaluation (dimension of + * xval and yval). + * epsilon is a relative error tolerance used in subroutine + * 'QuadChoose' to distinguish the situation m(i) or + * m(i+1) is relatively close to the slope or twice + * the slope of the linear segment between xtab(i) and + * xtab(i+1). If this situation occurs, roundoff may + * cause a change in convexity or monotonicity of the + * resulting spline and a change in the case number + * provided by 'QuadChoose'. If epsilon is not equal to zero, + * then epsilon should be greater than or equal to machine + * epsilon. + * ON OUTPUT-- + * yval contains the images of the points in xval. + * err is one of the following error codes: + * 0 - QuadEval ran normally. + * 1 - xval(i) is less than xtab(1) for at least one + * i or xval(i) is greater than xtab(num) for at + * least one i. QuadEval will extrapolate to provide + * function values for these abscissas. + * 2 - xval(i+1) < xval(i) for some i. + * + * + * QuadEval calls the following subroutines or functions: + * Search + * QuadCases + * QuadChoose + * QuadSpline + *--------------------------------------------------------------------------- + */ +static int +QuadEval( + Point2d origPts[], + int nOrigPts, + Point2d intpPts[], + int nIntpPts, + double *m, /* Slope of the spline at each point + * of interpolation. */ + double epsilon) /* Relative error tolerance (see choose) */ +{ + int error; + int i, j; + double param[10]; + int ncase; + int start, end; + int l, p; + int n; + int found; + + /* Initialize indices and set error result */ + error = 0; + l = nOrigPts - 1; + p = l - 1; + ncase = 1; + + /* + * Determine if abscissas of new vector are non-decreasing. + */ + for (j = 1; j < nIntpPts; j++) { + if (intpPts[j].x < intpPts[j - 1].x) { + return 2; + } + } + /* + * Determine if any of the points in xval are LESS than the + * abscissa of the first data point. + */ + for (start = 0; start < nIntpPts; start++) { + if (intpPts[start].x >= origPts[0].x) { + break; + } + } + /* + * Determine if any of the points in xval are GREATER than the + * abscissa of the l data point. + */ + for (end = nIntpPts - 1; end >= 0; end--) { + if (intpPts[end].x <= origPts[l].x) { + break; + } + } + + if (start > 0) { + error = 1; /* Set error value to indicate that + * extrapolation has occurred. */ + /* + * Calculate the images of points of evaluation whose abscissas + * are less than the abscissa of the first data point. + */ + ncase = QuadSelect(origPts, origPts + 1, m[0], m[1], epsilon, param); + for (j = 0; j < (start - 1); j++) { + QuadSpline(intpPts + j, origPts, origPts + 1, param, ncase); + } + if (nIntpPts == 1) { + return error; + } + } + if ((nIntpPts == 1) && (end != (nIntpPts - 1))) { + goto noExtrapolation; + } + + /* + * Search locates the interval in which the first in-range + * point of evaluation lies. + */ + + i = Search(origPts, nOrigPts, intpPts[start].x, &found); + + n = i + 1; + if (n >= nOrigPts) { + n = nOrigPts - 1; + i = nOrigPts - 2; + } + /* + * If the first in-range point of evaluation is equal to one + * of the data points, assign the appropriate value from y. + * Continue until a point of evaluation is found which is not + * equal to a data point. + */ + if (found) { + do { + intpPts[start].y = origPts[i].y; + start++; + if (start >= nIntpPts) { + return error; + } + } while (intpPts[start - 1].x == intpPts[start].x); + + for (;;) { + if (intpPts[start].x < origPts[n].x) { + break; /* Break out of for-loop */ + } + if (intpPts[start].x == origPts[n].x) { + do { + intpPts[start].y = origPts[n].y; + start++; + if (start >= nIntpPts) { + return error; + } + } while (intpPts[start].x == intpPts[start - 1].x); + } + i++; + n++; + } + } + /* + * Calculate the images of all the points which lie within + * range of the data. + */ + if ((i > 0) || (error != 1)) { + ncase = QuadSelect(origPts + i, origPts + n, m[i], m[n], + epsilon, param); + } + for (j = start; j <= end; j++) { + /* + * If xx(j) - x(n) is negative, do not recalculate + * the parameters for this section of the spline since + * they are already known. + */ + if (intpPts[j].x == origPts[n].x) { + intpPts[j].y = origPts[n].y; + continue; + } else if (intpPts[j].x > origPts[n].x) { + double delta; + + /* Determine that the routine is in the correct part of + the spline. */ + do { + i++, n++; + delta = intpPts[j].x - origPts[n].x; + } while (delta > 0.0); + + if (delta < 0.0) { + ncase = QuadSelect(origPts + i, origPts + n, m[i], + m[n], epsilon, param); + } else if (delta == 0.0) { + intpPts[j].y = origPts[n].y; + continue; + } + } + QuadSpline(intpPts + j, origPts + i, origPts + n, param, ncase); + } + + if (end == (nIntpPts - 1)) { + return error; + } + if ((n == l) && (intpPts[end].x != origPts[l].x)) { + goto noExtrapolation; + } + + error = 1; /* Set error value to indicate that + * extrapolation has occurred. */ + ncase = QuadSelect(origPts + p, origPts + l, m[p], m[l], epsilon, param); + + noExtrapolation: + /* + * Calculate the images of the points of evaluation whose + * abscissas are greater than the abscissa of the last data point. + */ + for (j = (end + 1); j < nIntpPts; j++) { + QuadSpline(intpPts + j, origPts + p, origPts + l, param, ncase); + } + return error; +} + +/* + *--------------------------------------------------------------------------- + * + * Shape preserving quadratic splines + * by D.F.Mcallister & J.A.Roulier + * Coded by S.L.Dodd & M.Roulier + * N.C.State University + * + *--------------------------------------------------------------------------- + */ +/* + * Driver routine for quadratic spline package + * On input-- + * X,Y Contain n-long arrays of data (x is increasing) + * XM Contains m-long array of x values (increasing) + * eps Relative error tolerance + * n Number of input data points + * m Number of output data points + * On output-- + * work Contains the value of the first derivative at each data point + * ym Contains the interpolated spline value at each data point + */ +int +Blt_QuadraticSpline(Point2d *origPts, int nOrigPts, Point2d *intpPts, + int nIntpPts) +{ + double epsilon; + double *work; + int result; + + work = Blt_AssertMalloc(nOrigPts * sizeof(double)); + epsilon = 0.0; /* TBA: adjust error via command-line option */ + /* allocate space for vectors used in calculation */ + QuadSlopes(origPts, work, nOrigPts); + result = QuadEval(origPts, nOrigPts, intpPts, nIntpPts, work, epsilon); + Blt_Free(work); + if (result > 1) { + return FALSE; + } + return TRUE; +} + +/* + *--------------------------------------------------------------------------- + * + * Reference: + * Numerical Analysis, R. Burden, J. Faires and A. Reynolds. + * Prindle, Weber & Schmidt 1981 pp 112 + * + * Parameters: + * origPts - vector of points, assumed to be sorted along x. + * intpPts - vector of new points. + * + *--------------------------------------------------------------------------- + */ +int +Blt_NaturalSpline(Point2d *origPts, int nOrigPts, Point2d *intpPts, + int nIntpPts) +{ + Cubic2D *eq; + Point2d *ip, *iend; + TriDiagonalMatrix *A; + double *dx; /* vector of deltas in x */ + double x, dy, alpha; + int isKnot; + int i, j, n; + + dx = Blt_AssertMalloc(sizeof(double) * nOrigPts); + /* Calculate vector of differences */ + for (i = 0, j = 1; j < nOrigPts; i++, j++) { + dx[i] = origPts[j].x - origPts[i].x; + if (dx[i] < 0.0) { + return 0; + } + } + n = nOrigPts - 1; /* Number of intervals. */ + A = Blt_AssertMalloc(sizeof(TriDiagonalMatrix) * nOrigPts); + if (A == NULL) { + Blt_Free(dx); + return 0; + } + /* Vectors to solve the tridiagonal matrix */ + A[0][0] = A[n][0] = 1.0; + A[0][1] = A[n][1] = 0.0; + A[0][2] = A[n][2] = 0.0; + + /* Calculate the intermediate results */ + for (i = 0, j = 1; j < n; j++, i++) { + alpha = 3.0 * ((origPts[j + 1].y / dx[j]) - (origPts[j].y / dx[i]) - + (origPts[j].y / dx[j]) + (origPts[i].y / dx[i])); + A[j][0] = 2 * (dx[j] + dx[i]) - dx[i] * A[i][1]; + A[j][1] = dx[j] / A[j][0]; + A[j][2] = (alpha - dx[i] * A[i][2]) / A[j][0]; + } + + eq = Blt_Malloc(sizeof(Cubic2D) * nOrigPts); + if (eq == NULL) { + Blt_Free(A); + Blt_Free(dx); + return FALSE; + } + eq[0].c = eq[n].c = 0.0; + for (j = n, i = n - 1; i >= 0; i--, j--) { + eq[i].c = A[i][2] - A[i][1] * eq[j].c; + dy = origPts[i+1].y - origPts[i].y; + eq[i].b = (dy) / dx[i] - dx[i] * (eq[j].c + 2.0 * eq[i].c) / 3.0; + eq[i].d = (eq[j].c - eq[i].c) / (3.0 * dx[i]); + } + Blt_Free(A); + Blt_Free(dx); + + /* Now calculate the new values */ + for (ip = intpPts, iend = ip + nIntpPts; ip < iend; ip++) { + ip->y = 0.0; + x = ip->x; + + /* Is it outside the interval? */ + if ((x < origPts[0].x) || (x > origPts[n].x)) { + continue; + } + /* Search for the interval containing x in the point array */ + i = Search(origPts, nOrigPts, x, &isKnot); + if (isKnot) { + ip->y = origPts[i].y; + } else { + i--; + x -= origPts[i].x; + ip->y = origPts[i].y + x * (eq[i].b + x * (eq[i].c + x * eq[i].d)); + } + } + Blt_Free(eq); + return TRUE; +} + +static Blt_OpSpec splineOps[] = +{ + {"natural", 1, Blt_NaturalSpline, 6, 6, "x y splx sply",}, + {"quadratic", 1, Blt_QuadraticSpline, 6, 6, "x y splx sply",}, +}; +static int nSplineOps = sizeof(splineOps) / sizeof(Blt_OpSpec); + +/*ARGSUSED*/ +static int +SplineCmd( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + SplineProc *proc; + Blt_Vector *x, *y, *splX, *splY; + double *xArr, *yArr; + int i; + Point2d *origPts, *intpPts; + int nOrigPts, nIntpPts; + + proc = Blt_GetOpFromObj(interp, nSplineOps, splineOps, BLT_OP_ARG1, + objc, objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + if ((Blt_GetVectorFromObj(interp, objv[2], &x) != TCL_OK) || + (Blt_GetVectorFromObj(interp, objv[3], &y) != TCL_OK) || + (Blt_GetVectorFromObj(interp, objv[4], &splX) != TCL_OK)) { + return TCL_ERROR; + } + nOrigPts = Blt_VecLength(x); + if (nOrigPts < 3) { + Tcl_AppendResult(interp, "length of vector \"", Tcl_GetString(objv[2]), + "\" is < 3", (char *)NULL); + return TCL_ERROR; + } + for (i = 1; i < nOrigPts; i++) { + if (Blt_VecData(x)[i] < Blt_VecData(x)[i - 1]) { + Tcl_AppendResult(interp, "x vector \"", Tcl_GetString(objv[2]), + "\" must be monotonically increasing", (char *)NULL); + return TCL_ERROR; + } + } + /* Check that all the data points aren't the same. */ + if (Blt_VecData(x)[i - 1] <= Blt_VecData(x)[0]) { + Tcl_AppendResult(interp, "x vector \"", Tcl_GetString(objv[2]), + "\" must be monotonically increasing", (char *)NULL); + return TCL_ERROR; + } + if (nOrigPts != Blt_VecLength(y)) { + Tcl_AppendResult(interp, "vectors \"", Tcl_GetString(objv[2]), + "\" and \"", Tcl_GetString(objv[3]), + " have different lengths", (char *)NULL); + return TCL_ERROR; + } + nIntpPts = Blt_VecLength(splX); + if (Blt_GetVectorFromObj(interp, objv[5], &splY) != TCL_OK) { + /* + * If the named vector to hold the ordinates of the spline + * doesn't exist, create one the same size as the vector + * containing the abscissas. + */ + if (Blt_CreateVector(interp, Tcl_GetString(objv[5]), nIntpPts, &splY) + != TCL_OK) { + return TCL_ERROR; + } + } else if (nIntpPts != Blt_VecLength(splY)) { + /* + * The x and y vectors differ in size. Make the number of ordinates + * the same as the number of abscissas. + */ + if (Blt_ResizeVector(splY, nIntpPts) != TCL_OK) { + return TCL_ERROR; + } + } + origPts = Blt_Malloc(sizeof(Point2d) * nOrigPts); + if (origPts == NULL) { + Tcl_AppendResult(interp, "can't allocate \"", Blt_Itoa(nOrigPts), + "\" points", (char *)NULL); + return TCL_ERROR; + } + intpPts = Blt_Malloc(sizeof(Point2d) * nIntpPts); + if (intpPts == NULL) { + Tcl_AppendResult(interp, "can't allocate \"", Blt_Itoa(nIntpPts), + "\" points", (char *)NULL); + Blt_Free(origPts); + return TCL_ERROR; + } + xArr = Blt_VecData(x); + yArr = Blt_VecData(y); + for (i = 0; i < nOrigPts; i++) { + origPts[i].x = xArr[i]; + origPts[i].y = yArr[i]; + } + xArr = Blt_VecData(splX); + yArr = Blt_VecData(splY); + for (i = 0; i < nIntpPts; i++) { + intpPts[i].x = xArr[i]; + intpPts[i].y = yArr[i]; + } + if (!(*proc) (origPts, nOrigPts, intpPts, nIntpPts)) { + Tcl_AppendResult(interp, "error generating spline for \"", + Blt_NameOfVector(splY), "\"", (char *)NULL); + Blt_Free(origPts); + Blt_Free(intpPts); + return TCL_ERROR; + } + yArr = Blt_VecData(splY); + for (i = 0; i < nIntpPts; i++) { + yArr[i] = intpPts[i].y; + } + Blt_Free(origPts); + Blt_Free(intpPts); + + /* Finally update the vector. The size of the vector hasn't + * changed, just the data. Reset the vector using TCL_STATIC to + * indicate this. */ + if (Blt_ResetVector(splY, Blt_VecData(splY), Blt_VecLength(splY), + Blt_VecSize(splY), TCL_STATIC) != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + +int +Blt_SplineCmdInitProc(Tcl_Interp *interp) +{ + static Blt_InitCmdSpec cmdSpec = {"spline", SplineCmd,}; + + return Blt_InitCmd(interp, "::blt", &cmdSpec); +} + + +#define SQR(x) ((x)*(x)) + +typedef struct { + double t; /* Arc length of interval. */ + double x; /* 2nd derivative of X with respect to T */ + double y; /* 2nd derivative of Y with respect to T */ +} CubicSpline; + + +/* + * The following two procedures solve the special linear system which arise + * in cubic spline interpolation. If x is assumed cyclic ( x[i]=x[n+i] ) the + * equations can be written as (i=0,1,...,n-1): + * m[i][0] * x[i-1] + m[i][1] * x[i] + m[i][2] * x[i+1] = b[i] . + * In matrix notation one gets A * x = b, where the matrix A is tridiagonal + * with additional elements in the upper right and lower left position: + * A[i][0] = A_{i,i-1} for i=1,2,...,n-1 and m[0][0] = A_{0,n-1} , + * A[i][1] = A_{i, i } for i=0,1,...,n-1 + * A[i][2] = A_{i,i+1} for i=0,1,...,n-2 and m[n-1][2] = A_{n-1,0}. + * A should be symmetric (A[i+1][0] == A[i][2]) and positive definite. + * The size of the system is given in n (n>=1). + * + * In the first procedure the Cholesky decomposition A = C^T * D * C + * (C is upper triangle with unit diagonal, D is diagonal) is calculated. + * Return TRUE if decomposition exist. + */ +static int +SolveCubic1(TriDiagonalMatrix A[], int n) +{ + int i; + double m_ij, m_n, m_nn, d; + + if (n < 1) { + return FALSE; /* Dimension should be at least 1 */ + } + d = A[0][1]; /* D_{0,0} = A_{0,0} */ + if (d <= 0.0) { + return FALSE; /* A (or D) should be positive definite */ + } + m_n = A[0][0]; /* A_{0,n-1} */ + m_nn = A[n - 1][1]; /* A_{n-1,n-1} */ + for (i = 0; i < n - 2; i++) { + m_ij = A[i][2]; /* A_{i,1} */ + A[i][2] = m_ij / d; /* C_{i,i+1} */ + A[i][0] = m_n / d; /* C_{i,n-1} */ + m_nn -= A[i][0] * m_n; /* to get C_{n-1,n-1} */ + m_n = -A[i][2] * m_n; /* to get C_{i+1,n-1} */ + d = A[i + 1][1] - A[i][2] * m_ij; /* D_{i+1,i+1} */ + if (d <= 0.0) { + return FALSE; /* Elements of D should be positive */ + } + A[i + 1][1] = d; + } + if (n >= 2) { /* Complete last column */ + m_n += A[n - 2][2]; /* add A_{n-2,n-1} */ + A[n - 2][0] = m_n / d; /* C_{n-2,n-1} */ + A[n - 1][1] = d = m_nn - A[n - 2][0] * m_n; /* D_{n-1,n-1} */ + if (d <= 0.0) { + return FALSE; + } + } + return TRUE; +} + +/* + * The second procedure solves the linear system, with the Cholesky + * decomposition calculated above (in m[][]) and the right side b given + * in x[]. The solution x overwrites the right side in x[]. + */ +static void +SolveCubic2(TriDiagonalMatrix A[], CubicSpline spline[], int nIntervals) +{ + int i; + double x, y; + int n, m; + + n = nIntervals - 2; + m = nIntervals - 1; + + /* Division by transpose of C : b = C^{-T} * b */ + x = spline[m].x; + y = spline[m].y; + for (i = 0; i < n; i++) { + spline[i + 1].x -= A[i][2] * spline[i].x; /* C_{i,i+1} * x(i) */ + spline[i + 1].y -= A[i][2] * spline[i].y; /* C_{i,i+1} * x(i) */ + x -= A[i][0] * spline[i].x; /* C_{i,n-1} * x(i) */ + y -= A[i][0] * spline[i].y; /* C_{i,n-1} * x(i) */ + } + if (n >= 0) { + /* C_{n-2,n-1} * x_{n-1} */ + spline[m].x = x - A[n][0] * spline[n].x; + spline[m].y = y - A[n][0] * spline[n].y; + } + /* Division by D: b = D^{-1} * b */ + for (i = 0; i < nIntervals; i++) { + spline[i].x /= A[i][1]; + spline[i].y /= A[i][1]; + } + + /* Division by C: b = C^{-1} * b */ + x = spline[m].x; + y = spline[m].y; + if (n >= 0) { + /* C_{n-2,n-1} * x_{n-1} */ + spline[n].x -= A[n][0] * x; + spline[n].y -= A[n][0] * y; + } + for (i = (n - 1); i >= 0; i--) { + /* C_{i,i+1} * x_{i+1} + C_{i,n-1} * x_{n-1} */ + spline[i].x -= A[i][2] * spline[i + 1].x + A[i][0] * x; + spline[i].y -= A[i][2] * spline[i + 1].y + A[i][0] * y; + } +} + +/* + * Find second derivatives (x''(t_i),y''(t_i)) of cubic spline interpolation + * through list of points (x_i,y_i). The parameter t is calculated as the + * length of the linear stroke. The number of points must be at least 3. + * Note: For CLOSED_CONTOURs the first and last point must be equal. + */ +static CubicSpline * +CubicSlopes( + Point2d points[], + int nPoints, /* Number of points (nPoints>=3) */ + int isClosed, /* CLOSED_CONTOUR or OPEN_CONTOUR */ + double unitX, + double unitY) /* Unit length in x and y (norm=1) */ +{ + CubicSpline *spline; + CubicSpline *s1, *s2; + int n, i; + double norm, dx, dy; + TriDiagonalMatrix *A; /* The tri-diagonal matrix is saved here. */ + + spline = Blt_Malloc(sizeof(CubicSpline) * nPoints); + if (spline == NULL) { + return NULL; + } + A = Blt_Malloc(sizeof(TriDiagonalMatrix) * nPoints); + if (A == NULL) { + Blt_Free(spline); + return NULL; + } + /* + * Calculate first differences in (dxdt2[i], y[i]) and interval lengths + * in dist[i]: + */ + s1 = spline; + for (i = 0; i < nPoints - 1; i++) { + s1->x = points[i+1].x - points[i].x; + s1->y = points[i+1].y - points[i].y; + + /* + * The Norm of a linear stroke is calculated in "normal coordinates" + * and used as interval length: + */ + dx = s1->x / unitX; + dy = s1->y / unitY; + s1->t = sqrt(dx * dx + dy * dy); + + s1->x /= s1->t; /* first difference, with unit norm: */ + s1->y /= s1->t; /* || (dxdt2[i], y[i]) || = 1 */ + s1++; + } + + /* + * Setup linear System: Ax = b + */ + n = nPoints - 2; /* Without first and last point */ + if (isClosed) { + /* First and last points must be equal for CLOSED_CONTOURs */ + spline[nPoints - 1].t = spline[0].t; + spline[nPoints - 1].x = spline[0].x; + spline[nPoints - 1].y = spline[0].y; + n++; /* Add last point (= first point) */ + } + s1 = spline, s2 = s1 + 1; + for (i = 0; i < n; i++) { + /* Matrix A, mainly tridiagonal with cyclic second index + ("j = j+n mod n") + */ + A[i][0] = s1->t; /* Off-diagonal element A_{i,i-1} */ + A[i][1] = 2.0 * (s1->t + s2->t); /* A_{i,i} */ + A[i][2] = s2->t; /* Off-diagonal element A_{i,i+1} */ + + /* Right side b_x and b_y */ + s1->x = (s2->x - s1->x) * 6.0; + s1->y = (s2->y - s1->y) * 6.0; + + /* + * If the linear stroke shows a cusp of more than 90 degree, + * the right side is reduced to avoid oscillations in the + * spline: + */ + /* + * The Norm of a linear stroke is calculated in "normal coordinates" + * and used as interval length: + */ + dx = s1->x / unitX; + dy = s1->y / unitY; + norm = sqrt(dx * dx + dy * dy) / 8.5; + if (norm > 1.0) { + /* The first derivative will not be continuous */ + s1->x /= norm; + s1->y /= norm; + } + s1++, s2++; + } + + if (!isClosed) { + /* Third derivative is set to zero at both ends */ + A[0][1] += A[0][0]; /* A_{0,0} */ + A[0][0] = 0.0; /* A_{0,n-1} */ + A[n-1][1] += A[n-1][2]; /* A_{n-1,n-1} */ + A[n-1][2] = 0.0; /* A_{n-1,0} */ + } + /* Solve linear systems for dxdt2[] and y[] */ + + if (SolveCubic1(A, n)) { /* Cholesky decomposition */ + SolveCubic2(A, spline, n); /* A * dxdt2 = b_x */ + } else { /* Should not happen, but who knows ... */ + Blt_Free(A); + Blt_Free(spline); + return NULL; + } + /* Shift all second derivatives one place right and update the ends. */ + s2 = spline + n, s1 = s2 - 1; + for (/* empty */; s2 > spline; s2--, s1--) { + s2->x = s1->x; + s2->y = s1->y; + } + if (isClosed) { + spline[0].x = spline[n].x; + spline[0].y = spline[n].y; + } else { + /* Third derivative is 0.0 for the first and last interval. */ + spline[0].x = spline[1].x; + spline[0].y = spline[1].y; + spline[n + 1].x = spline[n].x; + spline[n + 1].y = spline[n].y; + } + Blt_Free( A); + return spline; +} + + +/* + * Calculate interpolated values of the spline function (defined via p_cntr + * and the second derivatives dxdt2[] and dydt2[]). The number of tabulated + * values is n. On an equidistant grid n_intpol values are calculated. + */ +static int +CubicEval(Point2d *origPts, int nOrigPts, Point2d *intpPts, int nIntpPts, + CubicSpline *spline) +{ + double t, tSkip, tMax; + Point2d q; + int i, j, count; + + /* Sum the lengths of all the segments (intervals). */ + tMax = 0.0; + for (i = 0; i < nOrigPts - 1; i++) { + tMax += spline[i].t; + } + + /* Need a better way of doing this... */ + + /* The distance between interpolated points */ + tSkip = (1. - 1e-7) * tMax / (nIntpPts - 1); + + t = 0.0; /* Spline parameter value. */ + q = origPts[0]; + count = 0; + + intpPts[count++] = q; /* First point. */ + t += tSkip; + + for (i = 0, j = 1; j < nOrigPts; i++, j++) { + Point2d p; + double d, hx, dx0, dx01, hy, dy0, dy01; + + d = spline[i].t; /* Interval length */ + p = q; + q = origPts[i+1]; + hx = (q.x - p.x) / d; + hy = (q.y - p.y) / d; + dx0 = (spline[j].x + 2 * spline[i].x) / 6.0; + dy0 = (spline[j].y + 2 * spline[i].y) / 6.0; + dx01 = (spline[j].x - spline[i].x) / (6.0 * d); + dy01 = (spline[j].y - spline[i].y) / (6.0 * d); + while (t <= spline[i].t) { /* t in current interval ? */ + p.x += t * (hx + (t - d) * (dx0 + t * dx01)); + p.y += t * (hy + (t - d) * (dy0 + t * dy01)); + intpPts[count++] = p; + t += tSkip; + } + /* Parameter t relative to start of next interval */ + t -= spline[i].t; + } + return count; +} + +/* + * Generate a cubic spline curve through the points (x_i,y_i) which are + * stored in the linked list p_cntr. + * The spline is defined as a 2d-function s(t) = (x(t),y(t)), where the + * parameter t is the length of the linear stroke. + */ +int +Blt_NaturalParametricSpline(Point2d *origPts, int nOrigPts, Region2d *extsPtr, + int isClosed, Point2d *intpPts, int nIntpPts) +{ + double unitX, unitY; /* To define norm (x,y)-plane */ + CubicSpline *spline; + int result; + + if (nOrigPts < 3) { + return 0; + } + if (isClosed) { + origPts[nOrigPts].x = origPts[0].x; + origPts[nOrigPts].y = origPts[0].y; + nOrigPts++; + } + /* Width and height of the grid is used at unit length (2d-norm) */ + unitX = extsPtr->right - extsPtr->left; + unitY = extsPtr->bottom - extsPtr->top; + + if (unitX < FLT_EPSILON) { + unitX = FLT_EPSILON; + } + if (unitY < FLT_EPSILON) { + unitY = FLT_EPSILON; + } + /* Calculate parameters for cubic spline: + * t = arc length of interval. + * dxdt2 = second derivatives of x with respect to t, + * dydt2 = second derivatives of y with respect to t, + */ + spline = CubicSlopes(origPts, nOrigPts, isClosed, unitX, unitY); + if (spline == NULL) { + return 0; + } + result= CubicEval(origPts, nOrigPts, intpPts, nIntpPts, spline); + Blt_Free(spline); + return result; +} + +static INLINE void +CatromCoeffs(Point2d *p, Point2d *a, Point2d *b, Point2d *c, Point2d *d) +{ + a->x = -p[0].x + 3.0 * p[1].x - 3.0 * p[2].x + p[3].x; + b->x = 2.0 * p[0].x - 5.0 * p[1].x + 4.0 * p[2].x - p[3].x; + c->x = -p[0].x + p[2].x; + d->x = 2.0 * p[1].x; + a->y = -p[0].y + 3.0 * p[1].y - 3.0 * p[2].y + p[3].y; + b->y = 2.0 * p[0].y - 5.0 * p[1].y + 4.0 * p[2].y - p[3].y; + c->y = -p[0].y + p[2].y; + d->y = 2.0 * p[1].y; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ParametricCatromSpline -- + * + * Computes a spline based upon the data points, returning a new (larger) + * coordinate array of points. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +int +Blt_CatromParametricSpline(Point2d *points, int nPoints, Point2d *intpPts, + int nIntpPts) +{ + int i; + Point2d *origPts; + double t; + int interval; + Point2d a, b, c, d; + + assert(nPoints > 0); + + /* + * The spline is computed in screen coordinates instead of data points so + * that we can select the abscissas of the interpolated points from each + * pixel horizontally across the plotting area. + */ + origPts = Blt_AssertMalloc((nPoints + 4) * sizeof(Point2d)); + memcpy(origPts + 1, points, sizeof(Point2d) * nPoints); + + origPts[0] = origPts[1]; + origPts[nPoints + 2] = origPts[nPoints + 1] = origPts[nPoints]; + + for (i = 0; i < nIntpPts; i++) { + interval = (int)intpPts[i].x; + t = intpPts[i].y; + assert(interval < nPoints); + CatromCoeffs(origPts + interval, &a, &b, &c, &d); + intpPts[i].x = (d.x + t * (c.x + t * (b.x + t * a.x))) / 2.0; + intpPts[i].y = (d.y + t * (c.y + t * (b.y + t * a.y))) / 2.0; + } + Blt_Free(origPts); + return 1; +} diff --git a/src/bltGrElemOp.C b/src/bltGrElemOp.C new file mode 100644 index 0000000..6f509ac --- /dev/null +++ b/src/bltGrElemOp.C @@ -0,0 +1,2456 @@ + +/* + * bltGrElem.c -- + * + * This module implements generic elements for the BLT graph widget. + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include "bltOp.h" +#include "bltChain.h" +#include <X11/Xutil.h> +#include <bltDataTable.h> + +#define GRAPH_KEY "BLT Graph Data" + +/* Ignore elements that aren't in the display list or have been deleted. */ +#define IGNORE_ELEMENT(e) (((e)->link == NULL) || ((e)->flags & DELETE_PENDING)) + +typedef struct { + Blt_Table table; + int refCount; +} TableClient; + +static Blt_OptionParseProc ObjToAlong; +static Blt_OptionPrintProc AlongToObj; +static Blt_CustomOption alongOption = +{ + ObjToAlong, AlongToObj, NULL, (ClientData)0 +}; +static Blt_OptionFreeProc FreeValues; +static Blt_OptionParseProc ObjToValues; +static Blt_OptionPrintProc ValuesToObj; +Blt_CustomOption bltValuesOption = +{ + ObjToValues, ValuesToObj, FreeValues, (ClientData)0 +}; +static Blt_OptionFreeProc FreeValuePairs; +static Blt_OptionParseProc ObjToValuePairs; +static Blt_OptionPrintProc ValuePairsToObj; +Blt_CustomOption bltValuePairsOption = +{ + ObjToValuePairs, ValuePairsToObj, FreeValuePairs, (ClientData)0 +}; + +static Blt_OptionFreeProc FreeStyles; +static Blt_OptionParseProc ObjToStyles; +static Blt_OptionPrintProc StylesToObj; +Blt_CustomOption bltLineStylesOption = +{ + ObjToStyles, StylesToObj, FreeStyles, (ClientData)0, +}; + +Blt_CustomOption bltBarStylesOption = +{ + ObjToStyles, StylesToObj, FreeStyles, (ClientData)0, +}; + +#include "bltGrElem.h" + +static Blt_VectorChangedProc VectorChangedProc; + +static void FindRange(ElemValues *valuesPtr); +static void FreeDataValues(ElemValues *valuesPtr); +static Tcl_FreeProc FreeElement; + +typedef int (GraphElementProc)(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +/* + *--------------------------------------------------------------------------- + * + * Blt_DestroyTableClients -- + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +void +Blt_DestroyTableClients(Graph *graphPtr) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->dataTables, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + TableClient *clientPtr; + + clientPtr = Blt_GetHashValue(hPtr); + if (clientPtr->table != NULL) { + Blt_Table_Close(clientPtr->table); + } + Blt_Free(clientPtr); + } + Blt_DeleteHashTable(&graphPtr->dataTables); +} + + +/* + *--------------------------------------------------------------------------- + * Custom option parse and print procedures + *--------------------------------------------------------------------------- + */ +static int +GetPenStyleFromObj( + Tcl_Interp *interp, + Graph *graphPtr, + Tcl_Obj *objPtr, + ClassId classId, + PenStyle *stylePtr) +{ + Pen *penPtr; + Tcl_Obj **objv; + int objc; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if ((objc != 1) && (objc != 3)) { + if (interp != NULL) { + Tcl_AppendResult(interp, "bad style entry \"", + Tcl_GetString(objPtr), + "\": should be \"penName\" or \"penName min max\"", + (char *)NULL); + } + return TCL_ERROR; + } + if (Blt_GetPenFromObj(interp, graphPtr, objv[0], classId, &penPtr) + != TCL_OK) { + return TCL_ERROR; + } + if (objc == 3) { + double min, max; + + if ((Tcl_GetDoubleFromObj(interp, objv[1], &min) != TCL_OK) || + (Tcl_GetDoubleFromObj(interp, objv[2], &max) != TCL_OK)) { + return TCL_ERROR; + } + SetWeight(stylePtr->weight, min, max); + } + stylePtr->penPtr = penPtr; + return TCL_OK; +} + +static void +FreeVectorSource(ElemValues *valuesPtr) +{ + if (valuesPtr->vectorSource.vector != NULL) { + Blt_SetVectorChangedProc(valuesPtr->vectorSource.vector, NULL, NULL); + Blt_FreeVectorId(valuesPtr->vectorSource.vector); + valuesPtr->vectorSource.vector = NULL; + } +} + +static int +FetchVectorValues(Tcl_Interp *interp, ElemValues *valuesPtr, Blt_Vector *vector) +{ + double *array; + + if (valuesPtr->values == NULL) { + array = Blt_Malloc(Blt_VecLength(vector) * sizeof(double)); + } else { + array = Blt_Realloc(valuesPtr->values, + Blt_VecLength(vector) * sizeof(double)); + } + if (array == NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "can't allocate new vector", (char *)NULL); + } + return TCL_ERROR; + } + memcpy(array, Blt_VecData(vector), sizeof(double) * Blt_VecLength(vector)); + valuesPtr->min = Blt_VecMin(vector); + valuesPtr->max = Blt_VecMax(vector); + valuesPtr->values = array; + valuesPtr->nValues = Blt_VecLength(vector); + /* FindRange(valuesPtr); */ + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * VectorChangedProc -- + * + * Results: + * None. + * + * Side Effects: + * Graph is redrawn. + * + *--------------------------------------------------------------------------- + */ +static void +VectorChangedProc( + Tcl_Interp *interp, + ClientData clientData, + Blt_VectorNotify notify) +{ + ElemValues *valuesPtr = clientData; + + if (notify == BLT_VECTOR_NOTIFY_DESTROY) { + FreeDataValues(valuesPtr); + } else { + Blt_Vector *vector; + + Blt_GetVectorById(interp, valuesPtr->vectorSource.vector, &vector); + if (FetchVectorValues(NULL, valuesPtr, vector) != TCL_OK) { + return; + } + } + { + Element *elemPtr = valuesPtr->elemPtr; + Graph *graphPtr; + + graphPtr = elemPtr->obj.graphPtr; + graphPtr->flags |= RESET_AXES; + elemPtr->flags |= MAP_ITEM; + if (!IGNORE_ELEMENT(elemPtr)) { + graphPtr->flags |= CACHE_DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); + } + } +} + +static int +GetVectorData(Tcl_Interp *interp, ElemValues *valuesPtr, const char *vecName) +{ + Blt_Vector *vecPtr; + VectorDataSource *srcPtr; + + srcPtr = &valuesPtr->vectorSource; + srcPtr->vector = Blt_AllocVectorId(interp, vecName); + if (Blt_GetVectorById(interp, srcPtr->vector, &vecPtr) != TCL_OK) { + return TCL_ERROR; + } + if (FetchVectorValues(interp, valuesPtr, vecPtr) != TCL_OK) { + FreeVectorSource(valuesPtr); + return TCL_ERROR; + } + Blt_SetVectorChangedProc(srcPtr->vector, VectorChangedProc, valuesPtr); + valuesPtr->type = ELEM_SOURCE_VECTOR; + return TCL_OK; +} + +static int +FetchTableValues(Tcl_Interp *interp, ElemValues *valuesPtr, Blt_TableColumn col) +{ + long i, j; + double *array; + Blt_Table table; + + table = valuesPtr->tableSource.table; + array = Blt_Malloc(sizeof(double) * Blt_Table_NumRows(table)); + if (array == NULL) { + return TCL_ERROR; + } + for (j = 0, i = 1; i <= Blt_Table_NumRows(table); i++) { + Blt_TableRow row; + double value; + + row = Blt_Table_FindRowByIndex(table, i); + value = Blt_Table_GetDouble(table, row, col); + if (FINITE(value)) { + array[j] = value; + j++; + } + } + if (valuesPtr->values != NULL) { + Blt_Free(valuesPtr->values); + } + valuesPtr->nValues = j; + valuesPtr->values = array; + FindRange(valuesPtr); + return TCL_OK; +} + +static void +FreeTableSource(ElemValues *valuesPtr) +{ + TableDataSource *srcPtr; + + srcPtr = &valuesPtr->tableSource; + if (srcPtr->trace != NULL) { + Blt_Table_DeleteTrace(srcPtr->trace); + } + if (srcPtr->notifier != NULL) { + Blt_Table_DeleteNotifier(srcPtr->notifier); + } + if (srcPtr->hashPtr != NULL) { + TableClient *clientPtr; + + clientPtr = Blt_GetHashValue(srcPtr->hashPtr); + clientPtr->refCount--; + if (clientPtr->refCount == 0) { + Graph *graphPtr; + + graphPtr = valuesPtr->elemPtr->obj.graphPtr; + if (srcPtr->table != NULL) { + Blt_Table_Close(srcPtr->table); + } + Blt_Free(clientPtr); + Blt_DeleteHashEntry(&graphPtr->dataTables, srcPtr->hashPtr); + srcPtr->hashPtr = NULL; + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * TableNotifyProc -- + * + * + * Results: + * None. + * + * Side Effects: + * Graph is redrawn. + * + *--------------------------------------------------------------------------- + */ +static int +TableNotifyProc(ClientData clientData, Blt_TableNotifyEvent *eventPtr) +{ + ElemValues *valuesPtr = clientData; + Element *elemPtr; + Graph *graphPtr; + + elemPtr = valuesPtr->elemPtr; + graphPtr = elemPtr->obj.graphPtr; + if ((eventPtr->type == TABLE_NOTIFY_COLUMN_DELETED) || + (FetchTableValues(graphPtr->interp, valuesPtr, + (Blt_TableColumn)eventPtr->header)) != TCL_OK) { + FreeTableSource(valuesPtr); + return TCL_ERROR; + } + /* Always redraw the element. */ + graphPtr->flags |= RESET_AXES; + elemPtr->flags |= MAP_ITEM; + if (!IGNORE_ELEMENT(elemPtr)) { + graphPtr->flags |= CACHE_DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * TableTraceProc -- + * + * + * Results: + * None. + * + * Side Effects: + * Graph is redrawn. + * + *--------------------------------------------------------------------------- + */ +static int +TableTraceProc(ClientData clientData, Blt_TableTraceEvent *eventPtr) +{ + ElemValues *valuesPtr = clientData; + Element *elemPtr; + Graph *graphPtr; + + elemPtr = valuesPtr->elemPtr; + graphPtr = elemPtr->obj.graphPtr; + assert((Blt_TableColumn)eventPtr->column == valuesPtr->tableSource.column); + + if (FetchTableValues(eventPtr->interp, valuesPtr, eventPtr->column) + != TCL_OK) { + FreeTableSource(valuesPtr); + return TCL_ERROR; + } + graphPtr->flags |= RESET_AXES; + elemPtr->flags |= MAP_ITEM; + if (!IGNORE_ELEMENT(elemPtr)) { + graphPtr->flags |= CACHE_DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); + } + return TCL_OK; +} + +static int +GetTableData(Tcl_Interp *interp, ElemValues *valuesPtr, const char *tableName, + Tcl_Obj *colObjPtr) +{ + TableDataSource *srcPtr; + TableClient *clientPtr; + int isNew; + Graph *graphPtr; + + memset(&valuesPtr->tableSource, 0, sizeof(TableDataSource)); + srcPtr = &valuesPtr->tableSource; + graphPtr = valuesPtr->elemPtr->obj.graphPtr; + /* See if the graph is already using this table. */ + srcPtr->hashPtr = Blt_CreateHashEntry(&graphPtr->dataTables, tableName, + &isNew); + if (isNew) { + if (Blt_Table_Open(interp, tableName, &srcPtr->table) != TCL_OK) { + return TCL_ERROR; + } + clientPtr = Blt_AssertMalloc(sizeof(TableClient)); + clientPtr->table = srcPtr->table; + clientPtr->refCount = 1; + Blt_SetHashValue(srcPtr->hashPtr, clientPtr); + } else { + clientPtr = Blt_GetHashValue(srcPtr->hashPtr); + srcPtr->table = clientPtr->table; + clientPtr->refCount++; + } + srcPtr->column = Blt_Table_FindColumn(interp, srcPtr->table, colObjPtr); + if (srcPtr->column == NULL) { + goto error; + } + if (FetchTableValues(interp, valuesPtr, srcPtr->column) != TCL_OK) { + goto error; + } + srcPtr->notifier = Blt_Table_CreateColumnNotifier(interp, srcPtr->table, + srcPtr->column, TABLE_NOTIFY_COLUMN_CHANGED, TableNotifyProc, + (Blt_TableNotifierDeleteProc *)NULL, valuesPtr); + srcPtr->trace = Blt_Table_CreateColumnTrace(srcPtr->table, srcPtr->column, + (TABLE_TRACE_WRITES | TABLE_TRACE_UNSETS | TABLE_TRACE_CREATES), TableTraceProc, + (Blt_TableTraceDeleteProc *)NULL, valuesPtr); + valuesPtr->type = ELEM_SOURCE_TABLE; + return TCL_OK; + error: + FreeTableSource(valuesPtr); + return TCL_ERROR; +} + +static int +ParseValues(Tcl_Interp *interp, Tcl_Obj *objPtr, int *nValuesPtr, + double **arrayPtr) +{ + int objc; + Tcl_Obj **objv; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + *arrayPtr = NULL; + *nValuesPtr = 0; + if (objc > 0) { + double *array; + double *p; + int i; + + array = Blt_Malloc(sizeof(double) * objc); + if (array == NULL) { + Tcl_AppendResult(interp, "can't allocate new vector", (char *)NULL); + return TCL_ERROR; + } + for (p = array, i = 0; i < objc; i++, p++) { + if (Blt_ExprDoubleFromObj(interp, objv[i], p) != TCL_OK) { + Blt_Free(array); + return TCL_ERROR; + } + } + *arrayPtr = array; + *nValuesPtr = objc; + } + return TCL_OK; +} + +static void +FreeDataValues(ElemValues *valuesPtr) +{ + switch (valuesPtr->type) { + case ELEM_SOURCE_VECTOR: + FreeVectorSource(valuesPtr); break; + case ELEM_SOURCE_TABLE: + FreeTableSource(valuesPtr); break; + case ELEM_SOURCE_VALUES: + break; + } + if (valuesPtr->values != NULL) { + Blt_Free(valuesPtr->values); + } + valuesPtr->values = NULL; + valuesPtr->nValues = 0; + valuesPtr->type = ELEM_SOURCE_VALUES; +} + +/* + *--------------------------------------------------------------------------- + * + * FindRange -- + * + * Find the minimum, positive minimum, and maximum values in a given + * vector and store the results in the vector structure. + * + * Results: + * None. + * + * Side Effects: + * Minimum, positive minimum, and maximum values are stored in the + * vector. + * + *--------------------------------------------------------------------------- + */ +static void +FindRange(ElemValues *valuesPtr) +{ + int i; + double *x; + double min, max; + + if ((valuesPtr->nValues < 1) || (valuesPtr->values == NULL)) { + return; /* This shouldn't ever happen. */ + } + x = valuesPtr->values; + + min = DBL_MAX, max = -DBL_MAX; + for(i = 0; i < valuesPtr->nValues; i++) { + if (FINITE(x[i])) { + min = max = x[i]; + break; + } + } + /* Initialize values to track the vector range */ + for (/* empty */; i < valuesPtr->nValues; i++) { + if (FINITE(x[i])) { + if (x[i] < min) { + min = x[i]; + } else if (x[i] > max) { + max = x[i]; + } + } + } + valuesPtr->min = min, valuesPtr->max = max; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_FindElemValuesMinimum -- + * + * Find the minimum, positive minimum, and maximum values in a given + * vector and store the results in the vector structure. + * + * Results: + * None. + * + * Side Effects: + * Minimum, positive minimum, and maximum values are stored in the + * vector. + * + *--------------------------------------------------------------------------- + */ +double +Blt_FindElemValuesMinimum(ElemValues *valuesPtr, double minLimit) +{ + int i; + double min; + + min = DBL_MAX; + for (i = 0; i < valuesPtr->nValues; i++) { + double x; + + x = valuesPtr->values[i]; + if (x < 0.0) { + /* What do you do about negative values when using log + * scale values seems like a grey area. Mirror. */ + x = -x; + } + if ((x > minLimit) && (min > x)) { + min = x; + } + } + if (min == DBL_MAX) { + min = minLimit; + } + return min; +} + +/*ARGSUSED*/ +static void +FreeValues( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + ElemValues *valuesPtr = (ElemValues *)(widgRec + offset); + + FreeDataValues(valuesPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToValues -- + * + * Given a TCL list of numeric expression representing the element + * values, convert into an array of double precision values. In addition, + * the minimum and maximum values are saved. Since elastic values are + * allow (values which translate to the min/max of the graph), we must + * try to get the non-elastic minimum and maximum. + * + * Results: + * The return value is a standard TCL result. The vector is passed + * back via the valuesPtr. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToValues( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* TCL list of expressions */ + char *widgRec, /* Element record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + ElemValues *valuesPtr = (ElemValues *)(widgRec + offset); + Element *elemPtr = (Element *)widgRec; + Tcl_Obj **objv; + int objc; + int result; + const char *string; + + valuesPtr->elemPtr = elemPtr; + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + elemPtr->flags |= MAP_ITEM; + + /* Release the current data sources. */ + FreeDataValues(valuesPtr); + if (objc == 0) { + return TCL_OK; /* Empty list of values. */ + } + string = Tcl_GetString(objv[0]); + if ((objc == 1) && (Blt_VectorExists2(interp, string))) { + result = GetVectorData(interp, valuesPtr, string); + } else if ((objc == 2) && (Blt_Table_TableExists(interp, string))) { + result = GetTableData(interp, valuesPtr, string, objv[1]); + } else { + double *values; + int nValues; + + result = ParseValues(interp, objPtr, &nValues, &values); + if (result != TCL_OK) { + return TCL_ERROR; /* Can't parse the values as numbers. */ + } + FreeDataValues(valuesPtr); + if (nValues > 0) { + valuesPtr->values = values; + } + valuesPtr->nValues = nValues; + FindRange(valuesPtr); + valuesPtr->type = ELEM_SOURCE_VALUES; + } + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * ValuesToObj -- + * + * Convert the vector of floating point values into a TCL list. + * + * Results: + * The string representation of the vector is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +ValuesToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Element record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + ElemValues *valuesPtr = (ElemValues *)(widgRec + offset); + + switch (valuesPtr->type) { + case ELEM_SOURCE_VECTOR: + { + const char *vecName; + + vecName = Blt_NameOfVectorId(valuesPtr->vectorSource.vector); + return Tcl_NewStringObj(vecName, -1); + } + case ELEM_SOURCE_TABLE: + { + Tcl_Obj *listObjPtr; + const char *tableName; + long i; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + tableName = Blt_Table_TableName(valuesPtr->tableSource.table); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(tableName, -1)); + + i = Blt_Table_ColumnIndex(valuesPtr->tableSource.column); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewLongObj(i)); + return listObjPtr; + } + case ELEM_SOURCE_VALUES: + { + Tcl_Obj *listObjPtr; + double *vp, *vend; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (vp = valuesPtr->values, vend = vp + valuesPtr->nValues; + vp < vend; vp++) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(*vp)); + } + return listObjPtr; + } + default: + abort(); + } + return Tcl_NewStringObj("", 0); +} + +/*ARGSUSED*/ +static void +FreeValuePairs( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) /* Not used. */ +{ + Element *elemPtr = (Element *)widgRec; + + FreeDataValues(&elemPtr->x); + FreeDataValues(&elemPtr->y); +} + + +/* + *--------------------------------------------------------------------------- + * + * ObjToValuePairs -- + * + * This procedure is like ObjToValues except that it interprets + * the list of numeric expressions as X Y coordinate pairs. The + * minimum and maximum for both the X and Y vectors are + * determined. + * + * Results: + * The return value is a standard TCL result. The vectors are + * passed back via the widget record (elemPtr). + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToValuePairs( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* TCL list of numeric expressions */ + char *widgRec, /* Element record */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Element *elemPtr = (Element *)widgRec; + double *values; + int nValues; + size_t newSize; + + if (ParseValues(interp, objPtr, &nValues, &values) != TCL_OK) { + return TCL_ERROR; + } + if (nValues & 1) { + Tcl_AppendResult(interp, "odd number of data points", (char *)NULL); + Blt_Free(values); + return TCL_ERROR; + } + nValues /= 2; + newSize = nValues * sizeof(double); + FreeDataValues(&elemPtr->x); /* Release the current data sources. */ + FreeDataValues(&elemPtr->y); + if (newSize > 0) { + double *p; + int i; + + elemPtr->x.values = Blt_AssertMalloc(newSize); + elemPtr->y.values = Blt_AssertMalloc(newSize); + elemPtr->x.nValues = elemPtr->y.nValues = nValues; + for (p = values, i = 0; i < nValues; i++) { + elemPtr->x.values[i] = *p++; + elemPtr->y.values[i] = *p++; + } + Blt_Free(values); + FindRange(&elemPtr->x); + FindRange(&elemPtr->y); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ValuePairsToObj -- + * + * Convert pairs of floating point values in the X and Y arrays + * into a TCL list. + * + * Results: + * The return value is a string (Tcl list). + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +ValuePairsToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Element information record */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Element *elemPtr = (Element *)widgRec; + Tcl_Obj *listObjPtr; + int i; + int length; + + length = NUMBEROFPOINTS(elemPtr); + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (i = 0; i < length; i++) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(elemPtr->x.values[i])); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(elemPtr->y.values[i])); + } + return listObjPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToAlong -- + * + * Given a TCL list of numeric expression representing the element + * values, convert into an array of double precision values. In + * addition, the minimum and maximum values are saved. Since + * elastic values are allow (values which translate to the + * min/max of the graph), we must try to get the non-elastic + * minimum and maximum. + * + * Results: + * The return value is a standard TCL result. The vector is passed + * back via the valuesPtr. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToAlong( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representation of value. */ + char *widgRec, /* Widget record. */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + int *intPtr = (int *)(widgRec + offset); + char *string; + + string = Tcl_GetString(objPtr); + if ((string[0] == 'x') && (string[1] == '\0')) { + *intPtr = SEARCH_X; + } else if ((string[0] == 'y') && (string[1] == '\0')) { + *intPtr = SEARCH_Y; + } else if ((string[0] == 'b') && (strcmp(string, "both") == 0)) { + *intPtr = SEARCH_BOTH; + } else { + Tcl_AppendResult(interp, "bad along value \"", string, "\"", + (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * AlongToObj -- + * + * Convert the vector of floating point values into a TCL list. + * + * Results: + * The string representation of the vector is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +AlongToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Widget record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + int along = *(int *)(widgRec + offset); + Tcl_Obj *objPtr; + + switch (along) { + case SEARCH_X: + objPtr = Tcl_NewStringObj("x", 1); + break; + case SEARCH_Y: + objPtr = Tcl_NewStringObj("y", 1); + break; + case SEARCH_BOTH: + objPtr = Tcl_NewStringObj("both", 4); + break; + default: + objPtr = Tcl_NewStringObj("unknown along value", 4); + break; + } + return objPtr; +} + +void +Blt_FreeStylePalette(Blt_Chain stylePalette) +{ + Blt_ChainLink link; + + /* Skip the first slot. It contains the built-in "normal" pen of + * the element. */ + link = Blt_Chain_FirstLink(stylePalette); + if (link != NULL) { + Blt_ChainLink next; + + for (link = Blt_Chain_NextLink(link); link != NULL; link = next) { + PenStyle *stylePtr; + + next = Blt_Chain_NextLink(link); + stylePtr = Blt_Chain_GetValue(link); + Blt_FreePen(stylePtr->penPtr); + Blt_Chain_DeleteLink(stylePalette, link); + } + } +} + +/*ARGSUSED*/ +static void +FreeStyles( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + Blt_Chain stylePalette = *(Blt_Chain *)(widgRec + offset); + + Blt_FreeStylePalette(stylePalette); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ObjToStyles -- + * + * Parse the list of style names. + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToStyles( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing style list */ + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Blt_Chain stylePalette = *(Blt_Chain *)(widgRec + offset); + Blt_ChainLink link; + Element *elemPtr = (Element *)(widgRec); + PenStyle *stylePtr; + Tcl_Obj **objv; + int objc; + int i; + size_t size = (size_t)clientData; + + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + /* Reserve the first entry for the "normal" pen. We'll set the + * style later */ + Blt_FreeStylePalette(stylePalette); + link = Blt_Chain_FirstLink(stylePalette); + if (link == NULL) { + link = Blt_Chain_AllocLink(size); + Blt_Chain_LinkAfter(stylePalette, link, NULL); + } + stylePtr = Blt_Chain_GetValue(link); + stylePtr->penPtr = elemPtr->normalPenPtr; + for (i = 0; i < objc; i++) { + link = Blt_Chain_AllocLink(size); + stylePtr = Blt_Chain_GetValue(link); + stylePtr->weight.min = (double)i; + stylePtr->weight.max = (double)i + 1.0; + stylePtr->weight.range = 1.0; + if (GetPenStyleFromObj(interp, elemPtr->obj.graphPtr, objv[i], + elemPtr->obj.classId, (PenStyle *)stylePtr) != TCL_OK) { + Blt_FreeStylePalette(stylePalette); + return TCL_ERROR; + } + Blt_Chain_LinkAfter(stylePalette, link, NULL); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * StylesToObj -- + * + * Convert the style information into a Tcl_Obj. + * + * Results: + * The string representing the style information is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +StylesToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Blt_Chain stylePalette = *(Blt_Chain *)(widgRec + offset); + Blt_ChainLink link; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + link = Blt_Chain_FirstLink(stylePalette); + if (link != NULL) { + /* Skip the first style (it's the default) */ + for (link = Blt_Chain_NextLink(link); link != NULL; + link = Blt_Chain_NextLink(link)) { + PenStyle *stylePtr; + Tcl_Obj *subListObjPtr; + + stylePtr = Blt_Chain_GetValue(link); + subListObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + Tcl_ListObjAppendElement(interp, subListObjPtr, + Tcl_NewStringObj(stylePtr->penPtr->name, -1)); + Tcl_ListObjAppendElement(interp, subListObjPtr, + Tcl_NewDoubleObj(stylePtr->weight.min)); + Tcl_ListObjAppendElement(interp, subListObjPtr, + Tcl_NewDoubleObj(stylePtr->weight.max)); + Tcl_ListObjAppendElement(interp, listObjPtr, subListObjPtr); + } + } + return listObjPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_StyleMap -- + * + * Creates an array of style indices and fills it based on the weight + * of each data point. + * + * Results: + * None. + * + * Side effects: + * Memory is freed and allocated for the index array. + * + *--------------------------------------------------------------------------- + */ + +PenStyle ** +Blt_StyleMap(Element *elemPtr) +{ + int i; + int nWeights; /* Number of weights to be examined. + * If there are more data points than + * weights, they will default to the + * normal pen. */ + + PenStyle **dataToStyle; /* Directory of styles. Each array + * element represents the style for + * the data point at that index */ + Blt_ChainLink link; + PenStyle *stylePtr; + double *w; /* Weight vector */ + int nPoints; + + nPoints = NUMBEROFPOINTS(elemPtr); + nWeights = MIN(elemPtr->w.nValues, nPoints); + w = elemPtr->w.values; + link = Blt_Chain_FirstLink(elemPtr->stylePalette); + stylePtr = Blt_Chain_GetValue(link); + + /* + * Create a style mapping array (data point index to style), + * initialized to the default style. + */ + dataToStyle = Blt_AssertMalloc(nPoints * sizeof(PenStyle *)); + for (i = 0; i < nPoints; i++) { + dataToStyle[i] = stylePtr; + } + + for (i = 0; i < nWeights; i++) { + for (link = Blt_Chain_LastLink(elemPtr->stylePalette); link != NULL; + link = Blt_Chain_PrevLink(link)) { + stylePtr = Blt_Chain_GetValue(link); + + if (stylePtr->weight.range > 0.0) { + double norm; + + norm = (w[i] - stylePtr->weight.min) / stylePtr->weight.range; + if (((norm - 1.0) <= DBL_EPSILON) && + (((1.0 - norm) - 1.0) <= DBL_EPSILON)) { + dataToStyle[i] = stylePtr; + break; /* Done: found range that matches. */ + } + } + } + } + return dataToStyle; +} + + +/* + *--------------------------------------------------------------------------- + * + * GetIndex -- + * + * Given a string representing the index of a pair of x,y + * coordinates, return the numeric index. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +static int +GetIndex(Tcl_Interp *interp, Element *elemPtr, Tcl_Obj *objPtr, int *indexPtr) +{ + char *string; + + string = Tcl_GetString(objPtr); + if ((*string == 'e') && (strcmp("end", string) == 0)) { + *indexPtr = NUMBEROFPOINTS(elemPtr) - 1; + } else if (Blt_ExprIntFromObj(interp, objPtr, indexPtr) != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetElement -- + * + * Find the element represented the given name, returning a pointer to + * its data structure via elemPtrPtr. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +int +Blt_GetElement(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, + Element **elemPtrPtr) +{ + Blt_HashEntry *hPtr; + char *name; + + name = Tcl_GetString(objPtr); + hPtr = Blt_FindHashEntry(&graphPtr->elements.table, name); + if (hPtr == NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "can't find element \"", name, + "\" in \"", Tk_PathName(graphPtr->tkwin), "\"", (char *)NULL); + } + return TCL_ERROR; + } + *elemPtrPtr = Blt_GetHashValue(hPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DestroyElement -- + * + * Add a new element to the graph. + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +static void +DestroyElement(Element *elemPtr) +{ + Graph *graphPtr = elemPtr->obj.graphPtr; + + Blt_DeleteBindings(graphPtr->bindTable, elemPtr); + Blt_Legend_RemoveElement(graphPtr, elemPtr); + + Blt_FreeOptions(elemPtr->configSpecs, (char *)elemPtr,graphPtr->display, 0); + /* + * Call the element's own destructor to release the memory and + * resources allocated for it. + */ + (*elemPtr->procsPtr->destroyProc) (graphPtr, elemPtr); + + /* Remove it also from the element display list */ + if (elemPtr->link != NULL) { + Blt_Chain_DeleteLink(graphPtr->elements.displayList, elemPtr->link); + if (!IGNORE_ELEMENT(elemPtr)) { + graphPtr->flags |= RESET_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + } + } + /* Remove the element for the graph's hash table of elements */ + if (elemPtr->hashPtr != NULL) { + Blt_DeleteHashEntry(&graphPtr->elements.table, elemPtr->hashPtr); + } + if (elemPtr->obj.name != NULL) { + Blt_Free(elemPtr->obj.name); + } + if (elemPtr->label != NULL) { + Blt_Free(elemPtr->label); + } + Blt_Free(elemPtr); +} + +static void +FreeElement(DestroyData data) +{ + Element *elemPtr = (Element *)data; + DestroyElement(elemPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * CreateElement -- + * + * Add a new element to the graph. + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +static int +CreateElement(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv, ClassId classId) +{ + Element *elemPtr; + Blt_HashEntry *hPtr; + int isNew; + char *string; + + string = Tcl_GetString(objv[3]); + if (string[0] == '-') { + Tcl_AppendResult(graphPtr->interp, "name of element \"", string, + "\" can't start with a '-'", (char *)NULL); + return TCL_ERROR; + } + hPtr = Blt_CreateHashEntry(&graphPtr->elements.table, string, &isNew); + if (!isNew) { + Tcl_AppendResult(interp, "element \"", string, + "\" already exists in \"", Tcl_GetString(objv[0]), + "\"", (char *)NULL); + return TCL_ERROR; + } + if (classId == CID_ELEM_BAR) { + elemPtr = Blt_BarElement(graphPtr, string, classId); + } else { + /* Stripcharts are line graphs with some options enabled. */ + elemPtr = Blt_LineElement(graphPtr, string, classId); + } + assert(elemPtr->configSpecs != NULL); + elemPtr->hashPtr = hPtr; + Blt_SetHashValue(hPtr, elemPtr); + + if (Blt_ConfigureComponentFromObj(interp, graphPtr->tkwin, + elemPtr->obj.name, "Element", elemPtr->configSpecs, objc - 4, objv + 4, + (char *)elemPtr, 0) != TCL_OK) { + DestroyElement(elemPtr); + return TCL_ERROR; + } + (*elemPtr->procsPtr->configProc) (graphPtr, elemPtr); + elemPtr->link = Blt_Chain_Append(graphPtr->elements.displayList, elemPtr); + graphPtr->flags |= CACHE_DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); + elemPtr->flags |= MAP_ITEM; + graphPtr->flags |= RESET_AXES; + Tcl_SetObjResult(interp, objv[3]); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DestroyElements -- + * + * Removes all the graph's elements. This routine is called when + * the graph is destroyed. + * + * Results: + * None. + * + * Side effects: + * Memory allocated for the graph's elements is freed. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DestroyElements(Graph *graphPtr) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + Element *elemPtr; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + elemPtr = Blt_GetHashValue(hPtr); + elemPtr->hashPtr = NULL; + DestroyElement(elemPtr); + } + Blt_DeleteHashTable(&graphPtr->elements.table); + Blt_DeleteHashTable(&graphPtr->elements.tagTable); + Blt_Chain_Destroy(graphPtr->elements.displayList); +} + +void +Blt_ConfigureElements(Graph *graphPtr) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + (*elemPtr->procsPtr->configProc) (graphPtr, elemPtr); + } +} + +void +Blt_MapElements(Graph *graphPtr) +{ + Blt_ChainLink link; + + if (graphPtr->mode != BARS_INFRONT) { + Blt_ResetBarGroups(graphPtr); + } + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (IGNORE_ELEMENT(elemPtr)) { + continue; + } + if ((graphPtr->flags & MAP_ALL) || (elemPtr->flags & MAP_ITEM)) { + (*elemPtr->procsPtr->mapProc) (graphPtr, elemPtr); + elemPtr->flags &= ~MAP_ITEM; + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DrawElements -- + * + * Calls the individual element drawing routines for each + * element. + * + * Results: + * None + * + * Side Effects: + * Elements are drawn into the drawable (pixmap) which will + * eventually be displayed in the graph window. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DrawElements(Graph *graphPtr, Drawable drawable) +{ + Blt_ChainLink link; + + /* Draw with respect to the stacking order. */ + for (link = Blt_Chain_LastLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if ((elemPtr->flags & (HIDE|DELETE_PENDING)) == 0) { + (*elemPtr->procsPtr->drawNormalProc)(graphPtr, drawable, elemPtr); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DrawActiveElements -- + * + * Calls the individual element drawing routines to display + * the active colors for each element. + * + * Results: + * None + * + * Side Effects: + * Elements are drawn into the drawable (pixmap) which will + * eventually be displayed in the graph window. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DrawActiveElements(Graph *graphPtr, Drawable drawable) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_LastLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if ((elemPtr->flags & (HIDE|ACTIVE|DELETE_PENDING)) == ACTIVE) { + (*elemPtr->procsPtr->drawActiveProc)(graphPtr, drawable, elemPtr); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ElementsToPostScript -- + * + * Generates PostScript output for each graph element in the + * element display list. + * + *--------------------------------------------------------------------------- + */ +void +Blt_ElementsToPostScript(Graph *graphPtr, Blt_Ps ps) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_LastLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->flags & (HIDE|DELETE_PENDING)) { + continue; + } + /* Comment the PostScript to indicate the start of the element */ + Blt_Ps_Format(ps, "\n%% Element \"%s\"\n\n", elemPtr->obj.name); + (*elemPtr->procsPtr->printNormalProc) (graphPtr, ps, elemPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ActiveElementsToPostScript -- + * + *--------------------------------------------------------------------------- + */ +void +Blt_ActiveElementsToPostScript( Graph *graphPtr, Blt_Ps ps) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_LastLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if ((elemPtr->flags & (DELETE_PENDING|HIDE|ACTIVE)) == ACTIVE) { + Blt_Ps_Format(ps, "\n%% Active Element \"%s\"\n\n", + elemPtr->obj.name); + (*elemPtr->procsPtr->printActiveProc)(graphPtr, ps, elemPtr); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * ActivateOp -- + * + * Marks data points of elements (given by their index) as active. + * + * Results: + * Returns TCL_OK if no errors occurred. + * + *--------------------------------------------------------------------------- + */ +static int +ActivateOp( + Graph *graphPtr, /* Graph widget */ + Tcl_Interp *interp, /* Interpreter to report errors to */ + int objc, /* Number of element names */ + Tcl_Obj *const *objv) /* List of element names */ +{ + Element *elemPtr; + int i; + int *indices; + int nIndices; + + if (objc == 3) { + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + /* List all the currently active elements */ + for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + elemPtr = Blt_GetHashValue(hPtr); + if (elemPtr->flags & ACTIVE) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(elemPtr->obj.name, -1)); + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; + } + if (Blt_GetElement(interp, graphPtr, objv[3], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + elemPtr->flags |= ACTIVE | ACTIVE_PENDING; + + indices = NULL; + nIndices = -1; + if (objc > 4) { + int *activePtr; + + nIndices = objc - 4; + activePtr = indices = Blt_AssertMalloc(sizeof(int) * nIndices); + for (i = 4; i < objc; i++) { + if (GetIndex(interp, elemPtr, objv[i], activePtr) != TCL_OK) { + return TCL_ERROR; + } + activePtr++; + } + } + if (elemPtr->activeIndices != NULL) { + Blt_Free(elemPtr->activeIndices); + } + elemPtr->nActiveIndices = nIndices; + elemPtr->activeIndices = indices; + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +ClientData +Blt_MakeElementTag(Graph *graphPtr, const char *tagName) +{ + Blt_HashEntry *hPtr; + int isNew; + + hPtr = Blt_CreateHashEntry(&graphPtr->elements.tagTable, tagName, &isNew); + return Blt_GetHashKey(&graphPtr->elements.tagTable, hPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * BindOp -- + * + * .g element bind elemName sequence command + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +BindOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + if (objc == 3) { + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + char *tagName; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.tagTable, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + tagName = Blt_GetHashKey(&graphPtr->elements.tagTable, hPtr); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(tagName, -1)); + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; + } + return Blt_ConfigureBindingsFromObj(interp, graphPtr->bindTable, + Blt_MakeElementTag(graphPtr, Tcl_GetString(objv[3])), + objc - 4, objv + 4); +} + +/* + *--------------------------------------------------------------------------- + * + * CreateOp -- + * + * Add a new element to the graph (using the default type of the + * graph). + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +static int +CreateOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv, + ClassId classId) +{ + return CreateElement(graphPtr, interp, objc, objv, classId); +} + +/* + *--------------------------------------------------------------------------- + * + * CgetOp -- + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +CgetOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, /* Not used. */ + Tcl_Obj *const *objv) +{ + Element *elemPtr; + + if (Blt_GetElement(interp, graphPtr, objv[3], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + if (Blt_ConfigureValueFromObj(interp, graphPtr->tkwin, elemPtr->configSpecs, + (char *)elemPtr, objv[4], 0) != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ClosestOp -- + * + * Find the element closest to the specified screen coordinates. + * Options: + * -halo Consider points only with this maximum distance + * from the picked coordinate. + * -interpolate Find closest point along element traces, not just + * data points. + * -along + * + * Results: + * A standard TCL result. If an element could be found within + * the halo distance, the interpreter result is "1", otherwise + * "0". If a closest element exists, the designated TCL array + * variable will be set with the following information: + * + * 1) the element name, + * 2) the index of the closest point, + * 3) the distance (in screen coordinates) from the picked X-Y + * coordinate and the closest point, + * 4) the X coordinate (graph coordinate) of the closest point, + * 5) and the Y-coordinate. + * + *--------------------------------------------------------------------------- + */ + +static Blt_ConfigSpec closestSpecs[] = { + {BLT_CONFIG_PIXELS_NNEG, "-halo", (char *)NULL, (char *)NULL, + (char *)NULL, Blt_Offset(ClosestSearch, halo), 0}, + {BLT_CONFIG_BOOLEAN, "-interpolate", (char *)NULL, (char *)NULL, + (char *)NULL, Blt_Offset(ClosestSearch, mode), 0 }, + {BLT_CONFIG_CUSTOM, "-along", (char *)NULL, (char *)NULL, + (char *)NULL, Blt_Offset(ClosestSearch, along), 0, &alongOption}, + {BLT_CONFIG_END, (char *)NULL, (char *)NULL, (char *)NULL, + (char *)NULL, 0, 0} +}; + +static int +ClosestOp( + Graph *graphPtr, /* Graph widget */ + Tcl_Interp *interp, /* Interpreter to report results to */ + int objc, /* Number of element names */ + Tcl_Obj *const *objv) /* List of element names */ +{ + Element *elemPtr; + ClosestSearch search; + int i, x, y; + char *string; + + if (graphPtr->flags & RESET_AXES) { + Blt_ResetAxes(graphPtr); + } + if (Tcl_GetIntFromObj(interp, objv[3], &x) != TCL_OK) { + Tcl_AppendResult(interp, ": bad window x-coordinate", (char *)NULL); + return TCL_ERROR; + } + if (Tcl_GetIntFromObj(interp, objv[4], &y) != TCL_OK) { + Tcl_AppendResult(interp, ": bad window y-coordinate", (char *)NULL); + return TCL_ERROR; + } + for (i = 5; i < objc; i += 2) { /* Count switches-value pairs */ + string = Tcl_GetString(objv[i]); + if ((string[0] != '-') || + ((string[1] == '-') && (string[2] == '\0'))) { + break; + } + } + if (i > objc) { + i = objc; + } + + search.mode = SEARCH_POINTS; + search.halo = graphPtr->halo; + search.index = -1; + search.along = SEARCH_BOTH; + search.x = x; + search.y = y; + + if (Blt_ConfigureWidgetFromObj(interp, graphPtr->tkwin, closestSpecs, i - 5, + objv + 5, (char *)&search, BLT_CONFIG_OBJV_ONLY) != TCL_OK) { + return TCL_ERROR; /* Error occurred processing an option. */ + } + if (i < objc) { + string = Tcl_GetString(objv[i]); + if (string[0] == '-') { + i++; /* Skip "--" */ + } + } + search.dist = (double)(search.halo + 1); + + if (i < objc) { + for ( /* empty */ ; i < objc; i++) { + if (Blt_GetElement(interp, graphPtr, objv[i], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + if (IGNORE_ELEMENT(elemPtr)) { + continue; + } + if (elemPtr->flags & (HIDE|MAP_ITEM)) { + continue; + } + (*elemPtr->procsPtr->closestProc) (graphPtr, elemPtr, &search); + } + } else { + Blt_ChainLink link; + + /* + * Find the closest point from the set of displayed elements, + * searching the display list from back to front. That way if + * the points from two different elements overlay each other + * exactly, the last one picked will be the topmost. + */ + for (link = Blt_Chain_LastLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->flags & (HIDE|MAP_ITEM|DELETE_PENDING)) { + continue; + } + (*elemPtr->procsPtr->closestProc) (graphPtr, elemPtr, &search); + } + } + if (search.dist < (double)search.halo) { + Tcl_Obj *listObjPtr; + /* + * Return a list of name value pairs. + */ + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj("name", -1)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(search.elemPtr->obj.name, -1)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj("index", -1)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(search.index)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj("x", -1)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(search.point.x)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj("y", -1)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(search.point.y)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj("dist", -1)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(search.dist)); + Tcl_SetObjResult(interp, listObjPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureOp -- + * + * Sets the element specifications by the given the command line + * arguments and calls the element specification configuration + * routine. If zero or one command line options are given, only + * information about the option(s) is returned in interp->result. + * If the element configuration has changed and the element is + * currently displayed, the axis limits are updated and + * recomputed. + * + * Results: + * The return value is a standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new display list. + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + int nNames, nOpts; + Tcl_Obj *const *options; + int i; + + /* Figure out where the option value pairs begin */ + objc -= 3; + objv += 3; + for (i = 0; i < objc; i++) { + Element *elemPtr; + char *string; + + string = Tcl_GetString(objv[i]); + if (string[0] == '-') { + break; + } + if (Blt_GetElement(interp, graphPtr, objv[i], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + } + nNames = i; /* Number of element names specified */ + nOpts = objc - i; /* Number of options specified */ + options = objv + nNames; /* Start of options in objv */ + + for (i = 0; i < nNames; i++) { + Element *elemPtr; + int flags; + + if (Blt_GetElement(interp, graphPtr, objv[i], &elemPtr) != TCL_OK) { + return TCL_ERROR; + } + flags = BLT_CONFIG_OBJV_ONLY; + if (nOpts == 0) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, + elemPtr->configSpecs, (char *)elemPtr, (Tcl_Obj *)NULL, flags); + } else if (nOpts == 1) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, + elemPtr->configSpecs, (char *)elemPtr, options[0], flags); + } + if (Blt_ConfigureWidgetFromObj(interp, graphPtr->tkwin, + elemPtr->configSpecs, nOpts, options, (char *)elemPtr, flags) + != TCL_OK) { + return TCL_ERROR; + } + if ((*elemPtr->procsPtr->configProc) (graphPtr, elemPtr) != TCL_OK) { + return TCL_ERROR; /* Failed to configure element */ + } + if (Blt_ConfigModified(elemPtr->configSpecs, "-hide", (char *)NULL)) { + graphPtr->flags |= RESET_AXES; + elemPtr->flags |= MAP_ITEM; + } + /* If data points or axes have changed, reset the axes (may + * affect autoscaling) and recalculate the screen points of + * the element. */ + + if (Blt_ConfigModified(elemPtr->configSpecs, "-*data", "-map*", "-x", + "-y", (char *)NULL)) { + graphPtr->flags |= RESET_WORLD; + elemPtr->flags |= MAP_ITEM; + } + /* The new label may change the size of the legend */ + if (Blt_ConfigModified(elemPtr->configSpecs, "-label", (char *)NULL)) { + graphPtr->flags |= (MAP_WORLD | REDRAW_WORLD); + } + } + /* Update the pixmap if any configuration option changed */ + graphPtr->flags |= CACHE_DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DeactivateOp -- + * + * Clears the active bit for the named elements. + * + * Results: + * Returns TCL_OK if no errors occurred. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +DeactivateOp( + Graph *graphPtr, /* Graph widget */ + Tcl_Interp *interp, /* Not used. */ + int objc, /* Number of element names */ + Tcl_Obj *const *objv) /* List of element names */ +{ + int i; + + for (i = 3; i < objc; i++) { + Element *elemPtr; + + if (Blt_GetElement(interp, graphPtr, objv[i], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + elemPtr->flags &= ~(ACTIVE | ACTIVE_PENDING); + if (elemPtr->activeIndices != NULL) { + Blt_Free(elemPtr->activeIndices); + elemPtr->activeIndices = NULL; + } + elemPtr->nActiveIndices = 0; + } + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DeleteOp -- + * + * Delete the named elements from the graph. + * + * Results: + * TCL_ERROR is returned if any of the named elements can not be + * found. Otherwise TCL_OK is returned; + * + * Side Effects: + * If the element is currently displayed, the plotting area of + * the graph is redrawn. Memory and resources allocated by the + * elements are released. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +DeleteOp( + Graph *graphPtr, /* Graph widget */ + Tcl_Interp *interp, /* Not used. */ + int objc, /* Number of element names */ + Tcl_Obj *const *objv) /* List of element names */ +{ + int i; + + for (i = 3; i < objc; i++) { + Element *elemPtr; + + if (Blt_GetElement(interp, graphPtr, objv[i], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + elemPtr->flags |= DELETE_PENDING; + Tcl_EventuallyFree(elemPtr, FreeElement); + } + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ExistsOp -- + * + * Indicates if the named element exists in the graph. + * + * Results: + * The return value is a standard TCL result. The interpreter + * result will contain "1" or "0". + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static int +ExistsOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, /* Not used. */ + Tcl_Obj *const *objv) +{ + Blt_HashEntry *hPtr; + + hPtr = Blt_FindHashEntry(&graphPtr->elements.table, Tcl_GetString(objv[3])); + Tcl_SetBooleanObj(Tcl_GetObjResult(interp), (hPtr != NULL)); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * GetOp -- + * + * Returns the name of the picked element (using the element + * bind operation). Right now, the only name accepted is + * "current". + * + * Results: + * A standard TCL result. The interpreter result will contain + * the name of the element. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +GetOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, /* Not used. */ + Tcl_Obj *const *objv) +{ + char *string; + + string = Tcl_GetString(objv[3]); + if ((string[0] == 'c') && (strcmp(string, "current") == 0)) { + Element *elemPtr; + + elemPtr = Blt_GetCurrentItem(graphPtr->bindTable); + /* Report only on elements. */ + if ((elemPtr != NULL) && ((elemPtr->flags & DELETE_PENDING) == 0) && + (elemPtr->obj.classId >= CID_ELEM_BAR) && + (elemPtr->obj.classId <= CID_ELEM_STRIP)) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), elemPtr->obj.name,-1); + } + } + return TCL_OK; +} + +static Tcl_Obj * +DisplayListObj(Graph *graphPtr) +{ + Tcl_Obj *listObjPtr; + Blt_ChainLink link; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + Tcl_Obj *objPtr; + + elemPtr = Blt_Chain_GetValue(link); + objPtr = Tcl_NewStringObj(elemPtr->obj.name, -1); + Tcl_ListObjAppendElement(graphPtr->interp, listObjPtr, objPtr); + } + return listObjPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * LowerOp -- + * + * Lowers the named elements to the bottom of the display list. + * + * Results: + * A standard TCL result. The interpreter result will contain the new + * display list of element names. + * + * .g element lower elem ?elem...? + * + *--------------------------------------------------------------------------- + */ +static int +LowerOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Blt_Chain chain; + Blt_ChainLink link, next; + int i; + + /* Move the links of lowered elements out of the display list into + * a temporary list. */ + chain = Blt_Chain_Create(); + for (i = 3; i < objc; i++) { + Element *elemPtr; + + if (Blt_GetElement(interp, graphPtr, objv[i], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + Blt_Chain_UnlinkLink(graphPtr->elements.displayList, elemPtr->link); + Blt_Chain_LinkAfter(chain, elemPtr->link, NULL); + } + /* Append the links to end of the display list. */ + for (link = Blt_Chain_FirstLink(chain); link != NULL; link = next) { + next = Blt_Chain_NextLink(link); + Blt_Chain_UnlinkLink(chain, link); + Blt_Chain_LinkAfter(graphPtr->elements.displayList, link, NULL); + } + Blt_Chain_Destroy(chain); + Tcl_SetObjResult(interp, DisplayListObj(graphPtr)); + graphPtr->flags |= RESET_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NamesOp -- + * + * Returns the names of the elements is the graph matching + * one of more patterns provided. If no pattern arguments + * are given, then all element names will be returned. + * + * Results: + * The return value is a standard TCL result. The interpreter + * result will contain a TCL list of the element names. + * + *--------------------------------------------------------------------------- + */ +static int +NamesOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (objc == 3) { + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + Element *elemPtr; + Tcl_Obj *objPtr; + + elemPtr = Blt_GetHashValue(hPtr); + objPtr = Tcl_NewStringObj(elemPtr->obj.name, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + } else { + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.table, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + Element *elemPtr; + int i; + + elemPtr = Blt_GetHashValue(hPtr); + for (i = 3; i < objc; i++) { + if (Tcl_StringMatch(elemPtr->obj.name,Tcl_GetString(objv[i]))) { + Tcl_Obj *objPtr; + + objPtr = Tcl_NewStringObj(elemPtr->obj.name, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + break; + } + } + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * RaiseOp -- + * + * Reset the element within the display list. + * + * Results: + * The return value is a standard TCL result. The interpreter + * result will contain the new display list of element names. + * + * .g element raise ?elem...? + * + *--------------------------------------------------------------------------- + */ +static int +RaiseOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Blt_Chain chain; + Blt_ChainLink link, prev; + int i; + + /* Move the links of lowered elements out of the display list into + * a temporary list. */ + chain = Blt_Chain_Create(); + for (i = 3; i < objc; i++) { + Element *elemPtr; + + if (Blt_GetElement(interp, graphPtr, objv[i], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + Blt_Chain_UnlinkLink(graphPtr->elements.displayList, elemPtr->link); + Blt_Chain_LinkAfter(chain, elemPtr->link, NULL); + } + /* Prepend the links to beginning of the display list in reverse order. */ + for (link = Blt_Chain_LastLink(chain); link != NULL; link = prev) { + prev = Blt_Chain_PrevLink(link); + Blt_Chain_UnlinkLink(chain, link); + Blt_Chain_LinkBefore(graphPtr->elements.displayList, link, NULL); + } + Blt_Chain_Destroy(chain); + Tcl_SetObjResult(interp, DisplayListObj(graphPtr)); + graphPtr->flags |= RESET_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ShowOp -- + * + * Queries or resets the element display list. + * + * Results: + * The return value is a standard TCL result. The interpreter + * result will contain the new display list of element names. + * + *--------------------------------------------------------------------------- + */ +static int +ShowOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + if (objc == 4) { + Blt_Chain chain; + Blt_ChainLink link; + Tcl_Obj **elem; + int i, n; + + if (Tcl_ListObjGetElements(interp, objv[3], &n, &elem) != TCL_OK) { + return TCL_ERROR; + } + /* Collect the named elements into a list. */ + chain = Blt_Chain_Create(); + for (i = 0; i < n; i++) { + Element *elemPtr; /* Element information record */ + + if (Blt_GetElement(interp, graphPtr, elem[i], &elemPtr) != TCL_OK) { + Blt_Chain_Destroy(chain); + return TCL_ERROR; + } + Blt_Chain_Append(chain, elemPtr); + } + /* Clear the links from the currently displayed elements. */ + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + elemPtr->link = NULL; + } + Blt_Chain_Destroy(graphPtr->elements.displayList); + graphPtr->elements.displayList = chain; + /* Set links on all the displayed elements. */ + for (link = Blt_Chain_FirstLink(chain); link != NULL; + link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + elemPtr->link = link; + } + graphPtr->flags |= RESET_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + } + Tcl_SetObjResult(interp, DisplayListObj(graphPtr)); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * TypeOp -- + * + * Returns the name of the type of the element given by some + * element name. + * + * Results: + * A standard TCL result. Returns the type of the element in + * interp->result. If the identifier given doesn't represent an + * element, then an error message is left in interp->result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +TypeOp( + Graph *graphPtr, /* Graph widget */ + Tcl_Interp *interp, + int objc, /* Not used. */ + Tcl_Obj *const *objv) /* Element name */ +{ + Element *elemPtr; + const char *string; + + if (Blt_GetElement(interp, graphPtr, objv[3], &elemPtr) != TCL_OK) { + return TCL_ERROR; /* Can't find named element */ + } + switch (elemPtr->obj.classId) { + case CID_ELEM_BAR: string = "bar"; break; + case CID_ELEM_CONTOUR: string = "contour"; break; + case CID_ELEM_LINE: string = "line"; break; + case CID_ELEM_STRIP: string = "strip"; break; + default: string = "???"; break; + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), string, -1); + return TCL_OK; +} + +/* + * Global routines: + */ +static Blt_OpSpec elemOps[] = { + {"activate", 1, ActivateOp, 3, 0, "?elemName? ?index...?",}, + {"bind", 1, BindOp, 3, 6, "elemName sequence command",}, + {"cget", 2, CgetOp, 5, 5, "elemName option",}, + {"closest", 2, ClosestOp, 5, 0, + "x y ?option value?... ?elemName?...",}, + {"configure", 2, ConfigureOp, 4, 0, + "elemName ?elemName?... ?option value?...",}, + {"create", 2, CreateOp, 4, 0, "elemName ?option value?...",}, + {"deactivate", 3, DeactivateOp, 3, 0, "?elemName?...",}, + {"delete", 3, DeleteOp, 3, 0, "?elemName?...",}, + {"exists", 1, ExistsOp, 4, 4, "elemName",}, + {"get", 1, GetOp, 4, 4, "name",}, + {"lower", 1, LowerOp, 3, 0, "?elemName?...",}, + {"names", 1, NamesOp, 3, 0, "?pattern?...",}, + {"raise", 1, RaiseOp, 3, 0, "?elemName?...",}, + {"show", 1, ShowOp, 3, 4, "?elemList?",}, + {"type", 1, TypeOp, 4, 4, "elemName",}, +}; +static int numElemOps = sizeof(elemOps) / sizeof(Blt_OpSpec); + + +/* + *--------------------------------------------------------------------------- + * + * Blt_ElementOp -- + * + * This procedure is invoked to process the TCL command that + * corresponds to a widget managed by this module. See the user + * documentation for details on what it does. + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ElementOp( + Graph *graphPtr, /* Graph widget record */ + Tcl_Interp *interp, + int objc, /* # arguments */ + Tcl_Obj *const *objv, /* Argument list */ + ClassId classId) +{ + void *ptr; + int result; + + ptr = Blt_GetOpFromObj(interp, numElemOps, elemOps, BLT_OP_ARG2, + objc, objv, 0); + if (ptr == NULL) { + return TCL_ERROR; + } + if (ptr == CreateOp) { + result = CreateOp(graphPtr, interp, objc, objv, classId); + } else { + GraphElementProc *proc; + + proc = ptr; + result = (*proc) (graphPtr, interp, objc, objv); + } + return result; +} diff --git a/src/bltGrElemOp.h b/src/bltGrElemOp.h new file mode 100644 index 0000000..f0e3969 --- /dev/null +++ b/src/bltGrElemOp.h @@ -0,0 +1,271 @@ + +/* + * bltGrElem.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_GR_ELEM_H +#define _BLT_GR_ELEM_H + +#include <bltVector.h> +#include <bltDataTable.h> + +#define ELEM_SOURCE_VALUES 0 +#define ELEM_SOURCE_VECTOR 1 +#define ELEM_SOURCE_TABLE 2 + +#define SEARCH_X 0 +#define SEARCH_Y 1 +#define SEARCH_BOTH 2 + +#define SHOW_NONE 0 +#define SHOW_X 1 +#define SHOW_Y 2 +#define SHOW_BOTH 3 + +#define SEARCH_POINTS 0 /* Search for closest data point. */ +#define SEARCH_TRACES 1 /* Search for closest point on trace. + * Interpolate the connecting line segments if + * necessary. */ +#define SEARCH_AUTO 2 /* Automatically determine whether to search + * for data points or traces. Look for traces + * if the linewidth is > 0 and if there is + * more than one data point. */ + +#define LABEL_ACTIVE (1<<9) /* Non-zero indicates that the element's entry + * in the legend should be drawn in its active + * foreground and background colors. */ +#define SCALE_SYMBOL (1<<10) + +#define NUMBEROFPOINTS(e) MIN((e)->x.nValues, (e)->y.nValues) + +#define NORMALPEN(e) ((((e)->normalPenPtr == NULL) ? \ + (e)->builtinPenPtr : \ + (e)->normalPenPtr)) + +/* + *--------------------------------------------------------------------------- + * + * Weight -- + * + * Designates a range of values by a minimum and maximum limit. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + double min, max, range; +} Weight; + +#define SetRange(l) \ + ((l).range = ((l).max > (l).min) ? ((l).max - (l).min) : DBL_EPSILON) +#define SetScale(l) \ + ((l).scale = 1.0 / (l).range) +#define SetWeight(l, lo, hi) \ + ((l).min = (lo), (l).max = (hi), SetRange(l)) + +typedef struct { + Segment2d *segments; /* Point to start of this pen's X-error bar + * segments in the element's array. */ + int nSegments; +} ErrorBarSegments; + +/* + * An element has one or more vectors plus several attributes, such as line + * style, thickness, color, and symbol type. It has an identifier which + * distinguishes it among the list of all elements. + */ +typedef struct { + Weight weight; /* Weight range where this pen is valid. */ + Pen *penPtr; /* Pen to use. */ +} PenStyle; + + +typedef struct { + XColor *color; /* Color of error bar */ + int lineWidth; /* Width of the error bar segments. */ + GC gc; + int show; /* Flags for errorbars: none, x, y, or both */ +} ErrorBarAttributes; + +typedef struct { + /* Inputs */ + int halo; /* Maximal screen distance a candidate point + * can be from the sample window coordinate */ + + int mode; /* Indicates whether to find the closest data + * point or the closest point on the trace by + * interpolating the line segments. Can also + * be SEARCH_AUTO, indicating to choose how to + * search.*/ + + int x, y; /* Screen coordinates of test point */ + + int along; /* Indicates to let search run along a + * particular axis: x, y, or both. */ + + /* Outputs */ + Element *elemPtr; /* Name of the closest element */ + + Point2d point; /* Graph coordinates of closest point */ + + int index; /* Index of closest data point */ + + double dist; /* Distance in screen coordinates */ + +} ClosestSearch; + +typedef void (ElementDrawProc) (Graph *graphPtr, Drawable drawable, + Element *elemPtr); + +typedef void (ElementToPostScriptProc) (Graph *graphPtr, Blt_Ps ps, + Element *elemPtr); + +typedef void (ElementDestroyProc) (Graph *graphPtr, Element *elemPtr); + +typedef int (ElementConfigProc) (Graph *graphPtr, Element *elemPtr); + +typedef void (ElementMapProc) (Graph *graphPtr, Element *elemPtr); + +typedef void (ElementExtentsProc) (Element *elemPtr, Region2d *extsPtr); + +typedef void (ElementClosestProc) (Graph *graphPtr, Element *elemPtr, + ClosestSearch *searchPtr); + +typedef void (ElementDrawSymbolProc) (Graph *graphPtr, Drawable drawable, + Element *elemPtr, int x, int y, int symbolSize); + +typedef void (ElementSymbolToPostScriptProc) (Graph *graphPtr, + Blt_Ps ps, Element *elemPtr, double x, double y, int symSize); + +typedef struct { + ElementClosestProc *closestProc; + ElementConfigProc *configProc; + ElementDestroyProc *destroyProc; + ElementDrawProc *drawActiveProc; + ElementDrawProc *drawNormalProc; + ElementDrawSymbolProc *drawSymbolProc; + ElementExtentsProc *extentsProc; + ElementToPostScriptProc *printActiveProc; + ElementToPostScriptProc *printNormalProc; + ElementSymbolToPostScriptProc *printSymbolProc; + ElementMapProc *mapProc; +} ElementProcs; + +typedef struct { + Blt_VectorId vector; +} VectorDataSource; + +typedef struct { + Blt_Table table; /* Data table. */ + Blt_TableColumn column; /* Column of data used. */ + Blt_TableNotifier notifier; /* Notifier used for column destroy + * event. */ + Blt_TableTrace trace; /* Trace used for column + * (set/get/unset). */ + Blt_HashEntry *hashPtr; /* Pointer to the entry of the data + * source in graph's hash table of + * datatables. One graph may use + * multiple columns from the same data + * table. */ +} TableDataSource; + +/* + * The data structure below contains information pertaining to a line vector. + * It consists of an array of floating point data values and for convenience, + * the number and minimum/maximum values. + */ +typedef struct { + int type; /* Selects the type of data populating this + * vector: ELEM_SOURCE_VECTOR, + * ELEM_SOURCE_TABLE, or ELEM_SOURCE_VALUES + */ + Element *elemPtr; /* Element associated with vector. */ + union { + TableDataSource tableSource; + VectorDataSource vectorSource; + }; + double *values; + int nValues; + int arraySize; + double min, max; +} ElemValues; + + +struct _Element { + GraphObj obj; /* Must be first field in element. */ + unsigned int flags; + Blt_HashEntry *hashPtr; + + /* Fields specific to elements. */ + const char *label; /* Label displayed in legend */ + unsigned short row, col; /* Position of the entry in the + * legend. */ + int legendRelief; /* Relief of label in legend. */ + Axis2d axes; /* X-axis and Y-axis mapping the + * element */ + ElemValues x, y, w; /* Contains array of floating point + * graph coordinate values. Also holds + * min/max and the number of + * coordinates */ + int *activeIndices; /* Array of indices (malloc-ed) which + * indicate which data points are + * active (drawn with "active" + * colors). */ + int nActiveIndices; /* Number of active data points. + * Special case: if nActiveIndices < 0 + * and the active bit is set in + * "flags", then all data points are + * drawn active. */ + ElementProcs *procsPtr; + Blt_ConfigSpec *configSpecs; /* Configuration specifications. */ + Pen *activePenPtr; /* Standard Pens */ + Pen *normalPenPtr; + Pen *builtinPenPtr; + Blt_Chain stylePalette; /* Palette of pens. */ + + /* Symbol scaling */ + int scaleSymbols; /* If non-zero, the symbols will scale + * in size as the graph is zoomed + * in/out. */ + double xRange, yRange; /* Initial X-axis and Y-axis ranges: + * used to scale the size of element's + * symbol. */ + int state; + Blt_ChainLink link; /* Element's link in display list. */ +}; + + +BLT_EXTERN double Blt_FindElemValuesMinimum(ElemValues *vecPtr, double minLimit); +BLT_EXTERN void Blt_ResizeStatusArray(Element *elemPtr, int nPoints); +BLT_EXTERN int Blt_GetPenStyle(Graph *graphPtr, char *name, size_t classId, + PenStyle *stylePtr); +BLT_EXTERN void Blt_FreeStylePalette (Blt_Chain stylePalette); +BLT_EXTERN PenStyle **Blt_StyleMap (Element *elemPtr); +BLT_EXTERN void Blt_MapErrorBars(Graph *graphPtr, Element *elemPtr, + PenStyle **dataToStyle); +BLT_EXTERN void Blt_FreeDataValues(ElemValues *evPtr); +BLT_EXTERN int Blt_GetElement(Tcl_Interp *interp, Graph *graphPtr, + Tcl_Obj *objPtr, Element **elemPtrPtr); +BLT_EXTERN void Blt_DestroyTableClients(Graph *graphPtr); + +#endif /* _BLT_GR_ELEM_H */ diff --git a/src/bltGrHairs.C b/src/bltGrHairs.C new file mode 100644 index 0000000..86ebb57 --- /dev/null +++ b/src/bltGrHairs.C @@ -0,0 +1,534 @@ + +/* + * bltGrHairs.c -- + * + * This module implements crosshairs for the BLT graph widget. + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include "bltOp.h" + +typedef int (GraphCrosshairProc)(Graph *graphPtr, Tcl_Interp *interp, + int objc, Tcl_Obj *const *objv); + +/* + *--------------------------------------------------------------------------- + * + * Crosshairs + * + * Contains the line segments positions and graphics context used + * to simulate crosshairs (by XORing) on the graph. + * + *--------------------------------------------------------------------------- + */ + +struct _Crosshairs { + + XPoint hotSpot; /* Hot spot for crosshairs */ + int visible; /* Internal state of crosshairs. If non-zero, + * crosshairs are displayed. */ + int hidden; /* If non-zero, crosshairs are not displayed. + * This is not necessarily consistent with the + * internal state variable. This is true when + * the hot spot is off the graph. */ + Blt_Dashes dashes; /* Dashstyle of the crosshairs. This represents + * an array of alternatingly drawn pixel + * values. If NULL, the hairs are drawn as a + * solid line */ + int lineWidth; /* Width of the simulated crosshair lines */ + XSegment segArr[2]; /* Positions of line segments representing the + * simulated crosshairs. */ + XColor *colorPtr; /* Foreground color of crosshairs */ + GC gc; /* Graphics context for crosshairs. Set to + * GXxor to not require redraws of graph */ +}; + +#define DEF_HAIRS_DASHES (char *)NULL +#define DEF_HAIRS_FOREGROUND RGB_BLACK +#define DEF_HAIRS_LINE_WIDTH "0" +#define DEF_HAIRS_HIDE "yes" +#define DEF_HAIRS_POSITION (char *)NULL + +BLT_EXTERN Blt_CustomOption bltPointOption; + +static Blt_ConfigSpec configSpecs[] = +{ + {BLT_CONFIG_COLOR, "-color", "color", "Color", DEF_HAIRS_FOREGROUND, + Blt_Offset(Crosshairs, colorPtr), 0}, + {BLT_CONFIG_DASHES, "-dashes", "dashes", "Dashes", DEF_HAIRS_DASHES, + Blt_Offset(Crosshairs, dashes), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BOOLEAN, "-hide", "hide", "Hide", DEF_HAIRS_HIDE, + Blt_Offset(Crosshairs, hidden), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-linewidth", "lineWidth", "Linewidth", + DEF_HAIRS_LINE_WIDTH, Blt_Offset(Crosshairs, lineWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-position", "position", "Position", + DEF_HAIRS_POSITION, Blt_Offset(Crosshairs, hotSpot), 0, &bltPointOption}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +/* + *--------------------------------------------------------------------------- + * + * TurnOffHairs -- + * + * XOR's the existing line segments (representing the crosshairs), + * thereby erasing them. The internal state of the crosshairs is + * tracked. + * + * Results: + * None + * + * Side Effects: + * Crosshairs are erased. + * + *--------------------------------------------------------------------------- + */ +static void +TurnOffHairs(Tk_Window tkwin, Crosshairs *chPtr) +{ + if (Tk_IsMapped(tkwin) && (chPtr->visible)) { + XDrawSegments(Tk_Display(tkwin), Tk_WindowId(tkwin), chPtr->gc, + chPtr->segArr, 2); + chPtr->visible = FALSE; + } +} + +/* + *--------------------------------------------------------------------------- + * + * TurnOnHairs -- + * + * Draws (by XORing) new line segments, creating the effect of + * crosshairs. The internal state of the crosshairs is tracked. + * + * Results: + * None + * + * Side Effects: + * Crosshairs are displayed. + * + *--------------------------------------------------------------------------- + */ +static void +TurnOnHairs(Graph *graphPtr, Crosshairs *chPtr) +{ + if (Tk_IsMapped(graphPtr->tkwin) && (!chPtr->visible)) { + if (!PointInGraph(graphPtr, chPtr->hotSpot.x, chPtr->hotSpot.y)) { + return; /* Coordinates are off the graph */ + } + XDrawSegments(graphPtr->display, Tk_WindowId(graphPtr->tkwin), + chPtr->gc, chPtr->segArr, 2); + chPtr->visible = TRUE; + } +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureCrosshairs -- + * + * Configures attributes of the crosshairs such as line width, + * dashes, and position. The crosshairs are first turned off + * before any of the attributes changes. + * + * Results: + * None + * + * Side Effects: + * Crosshair GC is allocated. + * + *--------------------------------------------------------------------------- + */ +void +Blt_ConfigureCrosshairs(Graph *graphPtr) +{ + XGCValues gcValues; + unsigned long gcMask; + GC newGC; + unsigned long int pixel; + Crosshairs *chPtr = graphPtr->crosshairs; + + /* + * Turn off the crosshairs temporarily. This is in case the new + * configuration changes the size, style, or position of the lines. + */ + TurnOffHairs(graphPtr->tkwin, chPtr); + + gcValues.function = GXxor; + + if (graphPtr->plotBg == NULL) { + /* The graph's color option may not have been set yet */ + pixel = WhitePixelOfScreen(Tk_Screen(graphPtr->tkwin)); + } else { + pixel = Blt_BackgroundBorderColor(graphPtr->plotBg)->pixel; + } + gcValues.background = pixel; + gcValues.foreground = (pixel ^ chPtr->colorPtr->pixel); + + gcValues.line_width = LineWidth(chPtr->lineWidth); + gcMask = (GCForeground | GCBackground | GCFunction | GCLineWidth); + if (LineIsDashed(chPtr->dashes)) { + gcValues.line_style = LineOnOffDash; + gcMask |= GCLineStyle; + } + newGC = Blt_GetPrivateGC(graphPtr->tkwin, gcMask, &gcValues); + if (LineIsDashed(chPtr->dashes)) { + Blt_SetDashes(graphPtr->display, newGC, &chPtr->dashes); + } + if (chPtr->gc != NULL) { + Blt_FreePrivateGC(graphPtr->display, chPtr->gc); + } + chPtr->gc = newGC; + + /* + * Are the new coordinates on the graph? + */ + chPtr->segArr[0].x2 = chPtr->segArr[0].x1 = chPtr->hotSpot.x; + chPtr->segArr[0].y1 = graphPtr->bottom; + chPtr->segArr[0].y2 = graphPtr->top; + chPtr->segArr[1].y2 = chPtr->segArr[1].y1 = chPtr->hotSpot.y; + chPtr->segArr[1].x1 = graphPtr->left; + chPtr->segArr[1].x2 = graphPtr->right; + + if (!chPtr->hidden) { + TurnOnHairs(graphPtr, chPtr); + } +} + +void +Blt_EnableCrosshairs(Graph *graphPtr) +{ + if (!graphPtr->crosshairs->hidden) { + TurnOnHairs(graphPtr, graphPtr->crosshairs); + } +} + +void +Blt_DisableCrosshairs(Graph *graphPtr) +{ + if (!graphPtr->crosshairs->hidden) { + TurnOffHairs(graphPtr->tkwin, graphPtr->crosshairs); + } +} + +/* + *--------------------------------------------------------------------------- + * + * UpdateCrosshairs -- + * + * Update the length of the hairs (not the hot spot). + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_UpdateCrosshairs(Graph *graphPtr) +{ + Crosshairs *chPtr = graphPtr->crosshairs; + + chPtr->segArr[0].y1 = graphPtr->bottom; + chPtr->segArr[0].y2 = graphPtr->top; + chPtr->segArr[1].x1 = graphPtr->left; + chPtr->segArr[1].x2 = graphPtr->right; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DestroyCrosshairs -- + * + * Results: + * None + * + * Side Effects: + * Crosshair GC is allocated. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DestroyCrosshairs(Graph *graphPtr) +{ + if (graphPtr->crosshairs != NULL) { + Crosshairs *chPtr = graphPtr->crosshairs; + + Blt_FreeOptions(configSpecs, (char *)chPtr, graphPtr->display, 0); + if (chPtr->gc != NULL) { + Blt_FreePrivateGC(graphPtr->display, chPtr->gc); + } + Blt_Free(chPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_CreateCrosshairs -- + * + * Creates and initializes a new crosshair structure. + * + * Results: + * Returns TCL_ERROR if the crosshair structure can't be created, + * otherwise TCL_OK. + * + * Side Effects: + * Crosshair GC is allocated. + * + *--------------------------------------------------------------------------- + */ +int +Blt_CreateCrosshairs(Graph *graphPtr) +{ + Crosshairs *chPtr; + + chPtr = Blt_AssertCalloc(1, sizeof(Crosshairs)); + chPtr->hidden = TRUE; + chPtr->hotSpot.x = chPtr->hotSpot.y = -1; + graphPtr->crosshairs = chPtr; + + if (Blt_ConfigureComponentFromObj(graphPtr->interp, graphPtr->tkwin, + "crosshairs", "Crosshairs", configSpecs, 0, (Tcl_Obj **)NULL, + (char *)chPtr, 0) != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * CgetOp -- + * + * Queries configuration attributes of the crosshairs such as + * line width, dashes, and position. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static int +CgetOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, /* Not used. */ + Tcl_Obj *const *objv) +{ + Crosshairs *chPtr = graphPtr->crosshairs; + + return Blt_ConfigureValueFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)chPtr, objv[3], 0); +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureOp -- + * + * Queries or resets configuration attributes of the crosshairs + * such as line width, dashes, and position. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Crosshairs are reset. + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + Crosshairs *chPtr = graphPtr->crosshairs; + + if (objc == 3) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)chPtr, (Tcl_Obj *)NULL, 0); + } else if (objc == 4) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)chPtr, objv[3], 0); + } + if (Blt_ConfigureWidgetFromObj(interp, graphPtr->tkwin, configSpecs, + objc - 3, objv + 3, (char *)chPtr, BLT_CONFIG_OBJV_ONLY) != TCL_OK) { + return TCL_ERROR; + } + Blt_ConfigureCrosshairs(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * OnOp -- + * + * Maps the crosshairs. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Crosshairs are reset if necessary. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +OnOp( + Graph *graphPtr, + Tcl_Interp *interp, /* Not used. */ + int objc, /* Not used. */ + Tcl_Obj *const *objv) /* Not used. */ +{ + Crosshairs *chPtr = graphPtr->crosshairs; + + if (chPtr->hidden) { + TurnOnHairs(graphPtr, chPtr); + chPtr->hidden = FALSE; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * OffOp -- + * + * Unmaps the crosshairs. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Crosshairs are reset if necessary. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +OffOp( + Graph *graphPtr, + Tcl_Interp *interp, /* Not used. */ + int objc, /* Not used. */ + Tcl_Obj *const *objv) /* Not used. */ +{ + Crosshairs *chPtr = graphPtr->crosshairs; + + if (!chPtr->hidden) { + TurnOffHairs(graphPtr->tkwin, chPtr); + chPtr->hidden = TRUE; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ToggleOp -- + * + * Toggles the state of the crosshairs. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Crosshairs are reset. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ToggleOp( + Graph *graphPtr, + Tcl_Interp *interp, /* Not used. */ + int objc, /* Not used. */ + Tcl_Obj *const *objv) /* Not used. */ +{ + Crosshairs *chPtr = graphPtr->crosshairs; + + chPtr->hidden = (chPtr->hidden == 0); + if (chPtr->hidden) { + TurnOffHairs(graphPtr->tkwin, chPtr); + } else { + TurnOnHairs(graphPtr, chPtr); + } + return TCL_OK; +} + + +static Blt_OpSpec xhairOps[] = +{ + {"cget", 2, CgetOp, 4, 4, "option",}, + {"configure", 2, ConfigureOp, 3, 0, "?options...?",}, + {"off", 2, OffOp, 3, 3, "",}, + {"on", 2, OnOp, 3, 3, "",}, + {"toggle", 1, ToggleOp, 3, 3, "",}, +}; +static int nXhairOps = sizeof(xhairOps) / sizeof(Blt_OpSpec); + +/* + *--------------------------------------------------------------------------- + * + * Blt_CrosshairsOp -- + * + * User routine to configure crosshair simulation. Crosshairs + * are simulated by drawing line segments parallel to both axes + * using the XOR drawing function. The allows the lines to be + * erased (by drawing them again) without redrawing the entire + * graph. Care must be taken to erase crosshairs before redrawing + * the graph and redraw them after the graph is redraw. + * + * Results: + * The return value is a standard TCL result. + * + * Side Effects: + * Crosshairs may be drawn in the plotting area. + * + *--------------------------------------------------------------------------- + */ +int +Blt_CrosshairsOp( + Graph *graphPtr, + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + GraphCrosshairProc *proc; + + proc = Blt_GetOpFromObj(interp, nXhairOps, xhairOps, BLT_OP_ARG2, + objc, objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + return (*proc) (graphPtr, interp, objc, objv); +} diff --git a/src/bltGrLegd.C b/src/bltGrLegd.C new file mode 100644 index 0000000..9ed3169 --- /dev/null +++ b/src/bltGrLegd.C @@ -0,0 +1,3047 @@ + +/* + * bltGrLegd.c -- + * + * This module implements the legend for the BLT graph widget. + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include "bltOp.h" +#include "bltGrElem.h" +#include "bltPicture.h" +#include <X11/Xutil.h> +#include <X11/Xatom.h> + +/* + * Selection related flags: + * + * SELECT_EXPORT Export the selection to X11. + * + * SELECT_PENDING A "selection" command idle task is pending. + * + * SELECT_CLEAR Clear selection flag of entry. + * + * SELECT_SET Set selection flag of entry. + * + * SELECT_TOGGLE Toggle selection flag of entry. + * + * SELECT_MASK Mask of selection set/clear/toggle flags. + * + * SELECT_SORTED Indicates if the entries in the selection + * should be sorted or displayed in the order + * they were selected. + * + */ + +#define SELECT_CLEAR (1<<16) +#define SELECT_EXPORT (1<<17) +#define SELECT_PENDING (1<<18) +#define SELECT_SET (1<<19) +#define SELECT_TOGGLE (SELECT_SET | SELECT_CLEAR) +#define SELECT_MASK (SELECT_SET | SELECT_CLEAR) +#define SELECT_SORTED (1<<20) + +#define RAISED (1<<21) + +#define SELECT_MODE_SINGLE (1<<0) +#define SELECT_MODE_MULTIPLE (1<<1) + +typedef int (GraphLegendProc)(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +/* + * Legend -- + * + * Contains information specific to how the legend will be displayed. + */ +struct _Legend { + unsigned int flags; + ClassId classId; /* Type: Element or Marker. */ + + int nEntries; /* Number of element entries in + * table. */ + short int nColumns, nRows; /* Number of columns and rows in + * legend */ + short int width, height; /* Dimensions of the legend */ + short int entryWidth, entryHeight; + + int site; + short int xReq, yReq; /* User-requested site of legend, not + * the final actual position. Used in + * conjunction with the anchor below + * to determine location of the + * legend. */ + + Tk_Anchor anchor; /* Anchor of legend. Used to interpret + * the positioning point of the legend + * in the graph*/ + + int x, y; /* Computed origin of legend. */ + + Graph *graphPtr; + Tcl_Command cmdToken; /* Token for graph's widget command. */ + int reqColumns, reqRows; + + Blt_Pad ixPad, iyPad; /* # of pixels interior padding around + * legend entries */ + Blt_Pad xPad, yPad; /* # of pixels padding to exterior of + * legend */ + Tk_Window tkwin; /* If non-NULL, external window to draw + * legend. */ + TextStyle style; + + int maxSymSize; /* Size of largest symbol to be + * displayed. Used to calculate size + * of legend */ + XColor *fgColor; + Blt_Background activeBg; /* Active legend entry background + * color. */ + XColor *activeFgColor; + int activeRelief; /* 3-D effect on active entry. */ + int entryBW; /* Border width around each entry in + * legend. */ + Blt_Background normalBg; /* 3-D effect of legend. */ + int borderWidth; /* Width of legend 3-D border */ + int relief; /* 3-d effect of border around the + * legend: TK_RELIEF_RAISED etc. */ + + Blt_BindTable bindTable; + + int selRelief; + int selBW; + + XColor *selInFocusFgColor; /* Text color of a selected entry. */ + XColor *selOutFocusFgColor; + + Blt_Background selInFocusBg; + Blt_Background selOutFocusBg; + + XColor *focusColor; + Blt_Dashes focusDashes; /* Dash on-off value. */ + GC focusGC; /* Graphics context for the active + * label. */ + + const char *takeFocus; + int focus; /* Position of the focus entry. */ + + int cursorX, cursorY; /* Position of the insertion cursor in + * the textbox window. */ + short int cursorWidth; /* Size of the insertion cursor + * symbol. */ + short int cursorHeight; + Element *focusPtr; /* Element that currently has the + * focus. If NULL, no legend entry has + * the focus. */ + Element *selAnchorPtr; /* Fixed end of selection. Used to + * extend the selection while + * maintaining the other end of the + * selection. */ + Element *selMarkPtr; + Element *selFirstPtr; /* First element selected in current + * pick. */ + Element *selLastPtr; /* Last element selected in current + * pick. */ + int exportSelection; + int active; + int cursorOn; /* Indicates if the cursor is + * displayed. */ + int onTime, offTime; /* Time in milliseconds to wait before + * changing the cursor from off-to-on + * and on-to-off. Setting offTime to 0 + * makes the * cursor steady. */ + Tcl_TimerToken timerToken; /* Handle for a timer event called + * periodically to blink the cursor. */ + const char *selectCmd; /* TCL script that's invoked whenever + * the selection changes. */ + int selectMode; /* Mode of selection: single or + * multiple. */ + Blt_HashTable selectTable; /* Table of selected elements. Used to + * quickly determine whether an element + * is selected. */ + Blt_Chain selected; /* List of selected elements. */ + + const char *title; + unsigned int titleWidth, titleHeight; + TextStyle titleStyle; /* Legend title attributes */ +}; + +#define padLeft xPad.side1 +#define padRight xPad.side2 +#define padTop yPad.side1 +#define padBottom yPad.side2 +#define PADDING(x) ((x).side1 + (x).side2) +#define LABEL_PAD 2 + +#define DEF_LEGEND_ACTIVEBACKGROUND RGB_SKYBLUE4 +#define DEF_LEGEND_ACTIVEBORDERWIDTH "2" +#define DEF_LEGEND_ACTIVEFOREGROUND RGB_WHITE +#define DEF_LEGEND_ACTIVERELIEF "flat" +#define DEF_LEGEND_ANCHOR "n" +#define DEF_LEGEND_BACKGROUND (char *)NULL +#define DEF_LEGEND_BORDERWIDTH STD_BORDERWIDTH +#define DEF_LEGEND_COLUMNS "0" +#define DEF_LEGEND_EXPORTSELECTION "no" +#define DEF_LEGEND_FONT "{Sans Serif} 8" +#define DEF_LEGEND_FOREGROUND STD_NORMAL_FOREGROUND +#define DEF_LEGEND_HIDE "no" +#define DEF_LEGEND_IPADX "1" +#define DEF_LEGEND_IPADY "1" +#define DEF_LEGEND_PADX "1" +#define DEF_LEGEND_PADY "1" +#define DEF_LEGEND_POSITION "rightmargin" +#define DEF_LEGEND_RAISED "no" +#define DEF_LEGEND_RELIEF "flat" +#define DEF_LEGEND_ROWS "0" +#define DEF_LEGEND_SELECTBACKGROUND RGB_SKYBLUE4 +#define DEF_LEGEND_SELECT_BG_MONO STD_SELECT_BG_MONO +#define DEF_LEGEND_SELECTBORDERWIDTH "1" +#define DEF_LEGEND_SELECTMODE "multiple" +#define DEF_LEGEND_SELECT_FG_MONO STD_SELECT_FG_MONO +#define DEF_LEGEND_SELECTFOREGROUND RGB_WHITE /*STD_SELECT_FOREGROUND*/ +#define DEF_LEGEND_SELECTRELIEF "flat" +#define DEF_LEGEND_FOCUSDASHES "dot" +#define DEF_LEGEND_FOCUSEDIT "no" +#define DEF_LEGEND_FOCUSFOREGROUND STD_ACTIVE_FOREGROUND +#define DEF_LEGEND_FOCUS_FG_MONO STD_ACTIVE_FG_MONO +#define DEF_LEGEND_TAKEFOCUS "1" +#define DEF_LEGEND_TITLE (char *)NULL +#define DEF_LEGEND_TITLECOLOR STD_NORMAL_FOREGROUND +#define DEF_LEGEND_TITLEFONT "{Sans Serif} 8 bold" + +static Blt_OptionParseProc ObjToPosition; +static Blt_OptionPrintProc PositionToObj; +static Blt_CustomOption legendPositionOption = +{ + ObjToPosition, PositionToObj, NULL, (ClientData)0 +}; + +static Blt_OptionParseProc ObjToSelectmode; +static Blt_OptionPrintProc SelectmodeToObj; +static Blt_CustomOption selectmodeOption = { + ObjToSelectmode, SelectmodeToObj, NULL, NULL, +}; + +static Blt_ConfigSpec configSpecs[] = +{ + {BLT_CONFIG_BACKGROUND, "-activebackground", "activeBackground", + "ActiveBackground", DEF_LEGEND_ACTIVEBACKGROUND, + Blt_Offset(Legend, activeBg), 0}, + {BLT_CONFIG_PIXELS_NNEG, "-activeborderwidth", "activeBorderWidth", + "BorderWidth", DEF_LEGEND_BORDERWIDTH, + Blt_Offset(Legend, entryBW), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_COLOR, "-activeforeground", "activeForeground", + "ActiveForeground", DEF_LEGEND_ACTIVEFOREGROUND, + Blt_Offset(Legend, activeFgColor), 0}, + {BLT_CONFIG_RELIEF, "-activerelief", "activeRelief", "Relief", + DEF_LEGEND_ACTIVERELIEF, Blt_Offset(Legend, activeRelief), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_ANCHOR, "-anchor", "anchor", "Anchor", DEF_LEGEND_ANCHOR, + Blt_Offset(Legend, anchor), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_SYNONYM, "-bg", "background", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_BACKGROUND, "-background", "background", "Background", + DEF_LEGEND_BACKGROUND, Blt_Offset(Legend, normalBg),BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_PIXELS_NNEG, "-borderwidth", "borderWidth", "BorderWidth", + DEF_LEGEND_BORDERWIDTH, Blt_Offset(Legend, borderWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_SYNONYM, "-bd", "borderWidth", (char *)NULL, (char *)NULL, 0,0}, + {BLT_CONFIG_INT_NNEG, "-columns", "columns", "columns", + DEF_LEGEND_COLUMNS, Blt_Offset(Legend, reqColumns), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-exportselection", "exportSelection", + "ExportSelection", DEF_LEGEND_EXPORTSELECTION, + Blt_Offset(Legend, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)SELECT_EXPORT}, + {BLT_CONFIG_DASHES, "-focusdashes", "focusDashes", "FocusDashes", + DEF_LEGEND_FOCUSDASHES, Blt_Offset(Legend, focusDashes), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-focusforeground", "focusForeground", "FocusForeground", + DEF_LEGEND_FOCUSFOREGROUND, Blt_Offset(Legend, focusColor), + BLT_CONFIG_COLOR_ONLY}, + {BLT_CONFIG_COLOR, "-focusforeground", "focusForeground", "FocusForeground", + DEF_LEGEND_FOCUS_FG_MONO, Blt_Offset(Legend, focusColor), + BLT_CONFIG_MONO_ONLY}, + {BLT_CONFIG_FONT, "-font", "font", "Font", DEF_LEGEND_FONT, + Blt_Offset(Legend, style.font), 0}, + {BLT_CONFIG_SYNONYM, "-fg", "foreground", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_COLOR, "-foreground", "foreground", "Foreground", + DEF_LEGEND_FOREGROUND, Blt_Offset(Legend, fgColor), 0}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_LEGEND_HIDE, + Blt_Offset(Legend, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_PAD, "-ipadx", "iPadX", "Pad", DEF_LEGEND_IPADX, + Blt_Offset(Legend, ixPad), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PAD, "-ipady", "iPadY", "Pad", DEF_LEGEND_IPADY, + Blt_Offset(Legend, iyPad), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BACKGROUND, "-nofocusselectbackground", + "noFocusSelectBackground", "NoFocusSelectBackground", + DEF_LEGEND_SELECTBACKGROUND, Blt_Offset(Legend, selOutFocusBg), 0}, + {BLT_CONFIG_COLOR, "-nofocusselectforeground", "noFocusSelectForeground", + "NoFocusSelectForeground", DEF_LEGEND_SELECTFOREGROUND, + Blt_Offset(Legend, selOutFocusFgColor), 0}, + {BLT_CONFIG_PAD, "-padx", "padX", "Pad", DEF_LEGEND_PADX, + Blt_Offset(Legend, xPad), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PAD, "-pady", "padY", "Pad", DEF_LEGEND_PADY, + Blt_Offset(Legend, yPad), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-position", "position", "Position", + DEF_LEGEND_POSITION, 0, BLT_CONFIG_DONT_SET_DEFAULT, + &legendPositionOption}, + {BLT_CONFIG_BITMASK, "-raised", "raised", "Raised", DEF_LEGEND_RAISED, + Blt_Offset(Legend, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)RAISED}, + {BLT_CONFIG_RELIEF, "-relief", "relief", "Relief", DEF_LEGEND_RELIEF, + Blt_Offset(Legend, relief), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_INT_NNEG, "-rows", "rows", "rows", DEF_LEGEND_ROWS, + Blt_Offset(Legend, reqRows), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BACKGROUND, "-selectbackground", "selectBackground", + "Background", DEF_LEGEND_SELECTBACKGROUND, + Blt_Offset(Legend, selInFocusBg), 0}, + {BLT_CONFIG_PIXELS_NNEG, "-selectborderwidth", "selectBorderWidth", + "BorderWidth", DEF_LEGEND_SELECTBORDERWIDTH, + Blt_Offset(Legend, selBW), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-selectcommand", "selectCommand", "SelectCommand", + (char *)NULL, Blt_Offset(Legend, selectCmd), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-selectforeground", "selectForeground", "Foreground", + DEF_LEGEND_SELECT_FG_MONO, Blt_Offset(Legend, selInFocusFgColor), + BLT_CONFIG_MONO_ONLY}, + {BLT_CONFIG_COLOR, "-selectforeground", "selectForeground", "Foreground", + DEF_LEGEND_SELECTFOREGROUND, Blt_Offset(Legend, selInFocusFgColor), + BLT_CONFIG_COLOR_ONLY}, + {BLT_CONFIG_CUSTOM, "-selectmode", "selectMode", "SelectMode", + DEF_LEGEND_SELECTMODE, Blt_Offset(Legend, selectMode), + BLT_CONFIG_DONT_SET_DEFAULT, &selectmodeOption}, + {BLT_CONFIG_RELIEF, "-selectrelief", "selectRelief", "Relief", + DEF_LEGEND_SELECTRELIEF, Blt_Offset(Legend, selRelief), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-takefocus", "takeFocus", "TakeFocus", + DEF_LEGEND_TAKEFOCUS, Blt_Offset(Legend, takeFocus), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STRING, "-title", "title", "Title", DEF_LEGEND_TITLE, + Blt_Offset(Legend, title), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-titlecolor", "titleColor", "Foreground", + DEF_LEGEND_TITLECOLOR, Blt_Offset(Legend, titleStyle.color), 0}, + {BLT_CONFIG_FONT, "-titlefont", "titleFont", "Font", + DEF_LEGEND_TITLEFONT, Blt_Offset(Legend, titleStyle.font), 0}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static Tcl_IdleProc DisplayLegend; +static Blt_BindPickProc PickEntryProc; +static Tk_EventProc LegendEventProc; +static Tcl_TimerProc BlinkCursorProc; +static Tk_LostSelProc LostSelectionProc; +static Tk_SelectionProc SelectionProc; + +BLT_EXTERN Tcl_ObjCmdProc Blt_GraphInstCmdProc; + +/* + *--------------------------------------------------------------------------- + * + * Blt_Legend_EventuallyRedraw -- + * + * Tells the Tk dispatcher to call the graph display routine at the next + * idle point. This request is made only if the window is displayed and + * no other redraw request is pending. + * + * Results: None. + * + * Side effects: + * The window is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Legend_EventuallyRedraw(Graph *graphPtr) +{ + Legend *legendPtr = graphPtr->legend; + + if ((legendPtr->tkwin != NULL) && !(legendPtr->flags & REDRAW_PENDING)) { + Tcl_DoWhenIdle(DisplayLegend, legendPtr); + legendPtr->flags |= REDRAW_PENDING; + } +} + +/* + *--------------------------------------------------------------------------- + * + * SelectCmdProc -- + * + * Invoked at the next idle point whenever the current selection changes. + * Executes some application-specific code in the -selectcommand option. + * This provides a way for applications to handle selection changes. + * + * Results: + * None. + * + * Side effects: + * TCL code gets executed for some application-specific task. + * + *--------------------------------------------------------------------------- + */ +static void +SelectCmdProc(ClientData clientData) +{ + Legend *legendPtr = clientData; + + Tcl_Preserve(legendPtr); + legendPtr->flags &= ~SELECT_PENDING; + if (legendPtr->selectCmd != NULL) { + Tcl_Interp *interp; + + interp = legendPtr->graphPtr->interp; + if (Tcl_GlobalEval(interp, legendPtr->selectCmd) != TCL_OK) { + Tcl_BackgroundError(interp); + } + } + Tcl_Release(legendPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * EventuallyInvokeSelectCmd -- + * + * Queues a request to execute the -selectcommand code associated with + * the widget at the next idle point. Invoked whenever the selection + * changes. + * + * Results: + * None. + * + * Side effects: + * TCL code gets executed for some application-specific task. + * + *--------------------------------------------------------------------------- + */ +static void +EventuallyInvokeSelectCmd(Legend *legendPtr) +{ + if ((legendPtr->flags & SELECT_PENDING) == 0) { + legendPtr->flags |= SELECT_PENDING; + Tcl_DoWhenIdle(SelectCmdProc, legendPtr); + } +} + +static void +ClearSelection(Legend *legendPtr) +{ + Blt_DeleteHashTable(&legendPtr->selectTable); + Blt_InitHashTable(&legendPtr->selectTable, BLT_ONE_WORD_KEYS); + Blt_Chain_Reset(legendPtr->selected); + Blt_Legend_EventuallyRedraw(legendPtr->graphPtr); + if (legendPtr->selectCmd != NULL) { + EventuallyInvokeSelectCmd(legendPtr); + } +} + + +/* + *--------------------------------------------------------------------------- + * + * LostSelectionProc -- + * + * This procedure is called back by Tk when the selection is grabbed away + * from a Text widget. + * + * Results: + * None. + * + * Side effects: + * The existing selection is unhighlighted, and the window is marked as + * not containing a selection. + * + *--------------------------------------------------------------------------- + */ +static void +LostSelectionProc(ClientData clientData) +{ + Legend *legendPtr = clientData; + + if (legendPtr->flags & SELECT_EXPORT) { + ClearSelection(legendPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * LegendEventProc -- + * + * This procedure is invoked by the Tk dispatcher for various events on + * graphs. + * + * Results: + * None. + * + * Side effects: + * When the window gets deleted, internal structures get cleaned up. + * When it gets exposed, the graph is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +static void +LegendEventProc(ClientData clientData, XEvent *eventPtr) +{ + Graph *graphPtr = clientData; + Legend *legendPtr; + + legendPtr = graphPtr->legend; + if (eventPtr->type == Expose) { + if (eventPtr->xexpose.count == 0) { + Blt_Legend_EventuallyRedraw(graphPtr); + } + } else if ((eventPtr->type == FocusIn) || (eventPtr->type == FocusOut)) { + if (eventPtr->xfocus.detail == NotifyInferior) { + return; + } + if (eventPtr->type == FocusIn) { + legendPtr->flags |= FOCUS; + } else { + legendPtr->flags &= ~FOCUS; + } + Tcl_DeleteTimerHandler(legendPtr->timerToken); + if ((legendPtr->active) && (legendPtr->flags & FOCUS)) { + legendPtr->cursorOn = TRUE; + if (legendPtr->offTime != 0) { + legendPtr->timerToken = Tcl_CreateTimerHandler( + legendPtr->onTime, BlinkCursorProc, graphPtr); + } + } else { + legendPtr->cursorOn = FALSE; + legendPtr->timerToken = (Tcl_TimerToken)NULL; + } + Blt_Legend_EventuallyRedraw(graphPtr); + } else if (eventPtr->type == DestroyNotify) { + Graph *graphPtr = legendPtr->graphPtr; + + if (legendPtr->site == LEGEND_WINDOW) { + Blt_DeleteWindowInstanceData(legendPtr->tkwin); + if (legendPtr->cmdToken != NULL) { + Tcl_DeleteCommandFromToken(graphPtr->interp, + legendPtr->cmdToken); + legendPtr->cmdToken = NULL; + } + legendPtr->tkwin = graphPtr->tkwin; + } + if (legendPtr->flags & REDRAW_PENDING) { + Tcl_CancelIdleCall(DisplayLegend, legendPtr); + legendPtr->flags &= ~REDRAW_PENDING; + } + legendPtr->site = LEGEND_RIGHT; + legendPtr->flags |= HIDE; + graphPtr->flags |= (MAP_WORLD | REDRAW_WORLD); + Blt_MoveBindingTable(legendPtr->bindTable, graphPtr->tkwin); + Blt_EventuallyRedrawGraph(graphPtr); + } else if (eventPtr->type == ConfigureNotify) { + Blt_Legend_EventuallyRedraw(graphPtr); + } +} + +static int +CreateLegendWindow(Tcl_Interp *interp, Legend *legendPtr, const char *pathName) +{ + Graph *graphPtr; + Tk_Window tkwin; + + graphPtr = legendPtr->graphPtr; + tkwin = Tk_CreateWindowFromPath(interp, graphPtr->tkwin, pathName, NULL); + if (tkwin == NULL) { + return TCL_ERROR; + } + Blt_SetWindowInstanceData(tkwin, legendPtr); + Tk_CreateEventHandler(tkwin, ExposureMask | StructureNotifyMask, + LegendEventProc, graphPtr); + /* Move the legend's binding table to the new window. */ + Blt_MoveBindingTable(legendPtr->bindTable, tkwin); + if (legendPtr->tkwin != graphPtr->tkwin) { + Tk_DestroyWindow(legendPtr->tkwin); + } + /* Create a command by the same name as the legend window so that Legend + * bindings can use %W interchangably. */ + legendPtr->cmdToken = Tcl_CreateObjCommand(interp, pathName, + Blt_GraphInstCmdProc, graphPtr, NULL); + legendPtr->tkwin = tkwin; + legendPtr->site = LEGEND_WINDOW; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToPosition -- + * + * Convert the string representation of a legend XY position into window + * coordinates. The form of the string must be "@x,y" or none. + * + * Results: + * The return value is a standard TCL result. The symbol type is written + * into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToPosition( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back + * to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* New legend position string */ + char *widgRec, /* Widget record */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Graph *graphPtr; + Legend *legendPtr = (Legend *)widgRec; + char c; + int length; + const char *string; + + graphPtr = legendPtr->graphPtr; + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[0]; + if (c == '\0') { + legendPtr->site = LEGEND_RIGHT; + } else if ((c == 'l') && (strncmp(string, "leftmargin", length) == 0)) { + legendPtr->site = LEGEND_LEFT; + } else if ((c == 'r') && (strncmp(string, "rightmargin", length) == 0)) { + legendPtr->site = LEGEND_RIGHT; + } else if ((c == 't') && (strncmp(string, "topmargin", length) == 0)) { + legendPtr->site = LEGEND_TOP; + } else if ((c == 'b') && (strncmp(string, "bottommargin", length) == 0)) { + legendPtr->site = LEGEND_BOTTOM; + } else if ((c == 'p') && (strncmp(string, "plotarea", length) == 0)) { + legendPtr->site = LEGEND_PLOT; + } else if (c == '@') { + char *comma; + long x, y; + int result; + + comma = strchr(string + 1, ','); + if (comma == NULL) { + Tcl_AppendResult(interp, "bad screen position \"", string, + "\": should be @x,y", (char *)NULL); + return TCL_ERROR; + } + x = y = 0; + *comma = '\0'; + result = ((Tcl_ExprLong(interp, string + 1, &x) == TCL_OK) && + (Tcl_ExprLong(interp, comma + 1, &y) == TCL_OK)); + *comma = ','; + if (!result) { + return TCL_ERROR; + } + legendPtr->xReq = x; + legendPtr->yReq = y; + legendPtr->site = LEGEND_XY; + } else if (c == '.') { + if (CreateLegendWindow(interp, legendPtr, string) != TCL_OK) { + return TCL_ERROR; + } + Blt_Legend_EventuallyRedraw(graphPtr); + } else { + Tcl_AppendResult(interp, "bad position \"", string, "\": should be \ +\"leftmargin\", \"rightmargin\", \"topmargin\", \"bottommargin\", \ +\"plotarea\", windowName or @x,y", (char *)NULL); + return TCL_ERROR; + } + graphPtr->flags |= RESET_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * PositionToObj -- + * + * Convert the window coordinates into a string. + * + * Results: + * The string representing the coordinate position is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +PositionToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Widget record */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Legend *legendPtr = (Legend *)widgRec; + Tcl_Obj *objPtr; + + switch (legendPtr->site) { + case LEGEND_LEFT: + objPtr = Tcl_NewStringObj("leftmargin", -1); + break; + + case LEGEND_RIGHT: + objPtr = Tcl_NewStringObj("rightmargin", -1); + break; + + case LEGEND_TOP: + objPtr = Tcl_NewStringObj("topmargin", -1); + break; + + case LEGEND_BOTTOM: + objPtr = Tcl_NewStringObj("bottommargin", -1); + break; + + case LEGEND_PLOT: + objPtr = Tcl_NewStringObj("plotarea", -1); + break; + + case LEGEND_WINDOW: + objPtr = Tcl_NewStringObj(Tk_PathName(legendPtr->tkwin), -1); + break; + + case LEGEND_XY: + { + char string[200]; + + sprintf_s(string, 200, "@%d,%d", legendPtr->xReq, legendPtr->yReq); + objPtr = Tcl_NewStringObj(string, -1); + } + default: + objPtr = Tcl_NewStringObj("unknown legend position", -1); + } + return objPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToSelectmode -- + * + * Convert the string reprsenting a select mode, to its numeric form. + * + * Results: + * If the string is successfully converted, TCL_OK is returned. + * Otherwise, TCL_ERROR is returned and an error message is left + * in interpreter's result field. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToSelectmode( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* Tcl_Obj representing the new value. */ + char *widgRec, + int offset, /* Offset to field in structure */ + int flags) +{ + char *string; + char c; + int *modePtr = (int *)(widgRec + offset); + + string = Tcl_GetString(objPtr); + c = string[0]; + if ((c == 's') && (strcmp(string, "single") == 0)) { + *modePtr = SELECT_MODE_SINGLE; + } else if ((c == 'm') && (strcmp(string, "multiple") == 0)) { + *modePtr = SELECT_MODE_MULTIPLE; + } else if ((c == 'a') && (strcmp(string, "active") == 0)) { + *modePtr = SELECT_MODE_SINGLE; + } else { + Tcl_AppendResult(interp, "bad select mode \"", string, + "\": should be \"single\" or \"multiple\"", (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SelectmodeToObj -- + * + * Results: + * The string representation of the select mode is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +SelectmodeToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, + int offset, /* Offset to field in structure */ + int flags) +{ + int mode = *(int *)(widgRec + offset); + + switch (mode) { + case SELECT_MODE_SINGLE: + return Tcl_NewStringObj("single", -1); + case SELECT_MODE_MULTIPLE: + return Tcl_NewStringObj("multiple", -1); + default: + return Tcl_NewStringObj("unknown scroll mode", -1); + } +} + + +static void +SetLegendOrigin(Legend *legendPtr) +{ + Graph *graphPtr; + int x, y, w, h; + + graphPtr = legendPtr->graphPtr; + x = y = w = h = 0; /* Suppress compiler warning. */ + switch (legendPtr->site) { + case LEGEND_RIGHT: + w = graphPtr->rightMargin.width - graphPtr->rightMargin.axesOffset; + h = graphPtr->bottom - graphPtr->top; + x = graphPtr->right + graphPtr->rightMargin.axesOffset; + y = graphPtr->top; + break; + + case LEGEND_LEFT: + w = graphPtr->leftMargin.width - graphPtr->leftMargin.axesOffset; + h = graphPtr->bottom - graphPtr->top; + x = graphPtr->inset; + y = graphPtr->top; + break; + + case LEGEND_TOP: + w = graphPtr->right - graphPtr->left; + h = graphPtr->topMargin.height - graphPtr->topMargin.axesOffset; + if (graphPtr->title != NULL) { + h -= graphPtr->titleHeight; + } + x = graphPtr->left; + y = graphPtr->inset; + if (graphPtr->title != NULL) { + y += graphPtr->titleHeight; + } + break; + + case LEGEND_BOTTOM: + w = graphPtr->right - graphPtr->left; + h = graphPtr->bottomMargin.height - graphPtr->bottomMargin.axesOffset; + x = graphPtr->left; + y = graphPtr->bottom + graphPtr->bottomMargin.axesOffset; + break; + + case LEGEND_PLOT: + w = graphPtr->right - graphPtr->left; + h = graphPtr->bottom - graphPtr->top; + x = graphPtr->left; + y = graphPtr->top; + break; + + case LEGEND_XY: + w = legendPtr->width; + h = legendPtr->height; + x = legendPtr->xReq; + y = legendPtr->yReq; + if (x < 0) { + x += graphPtr->width; + } + if (y < 0) { + y += graphPtr->height; + } + break; + + case LEGEND_WINDOW: + legendPtr->anchor = TK_ANCHOR_NW; + legendPtr->x = legendPtr->y = 0; + return; + } + + switch (legendPtr->anchor) { + case TK_ANCHOR_NW: /* Upper left corner */ + break; + case TK_ANCHOR_W: /* Left center */ + if (h > legendPtr->height) { + y += (h - legendPtr->height) / 2; + } + break; + case TK_ANCHOR_SW: /* Lower left corner */ + if (h > legendPtr->height) { + y += (h - legendPtr->height); + } + break; + case TK_ANCHOR_N: /* Top center */ + if (w > legendPtr->width) { + x += (w - legendPtr->width) / 2; + } + break; + case TK_ANCHOR_CENTER: /* Center */ + if (h > legendPtr->height) { + y += (h - legendPtr->height) / 2; + } + if (w > legendPtr->width) { + x += (w - legendPtr->width) / 2; + } + break; + case TK_ANCHOR_S: /* Bottom center */ + if (w > legendPtr->width) { + x += (w - legendPtr->width) / 2; + } + if (h > legendPtr->height) { + y += (h - legendPtr->height); + } + break; + case TK_ANCHOR_NE: /* Upper right corner */ + if (w > legendPtr->width) { + x += w - legendPtr->width; + } + break; + case TK_ANCHOR_E: /* Right center */ + if (w > legendPtr->width) { + x += w - legendPtr->width; + } + if (h > legendPtr->height) { + y += (h - legendPtr->height) / 2; + } + break; + case TK_ANCHOR_SE: /* Lower right corner */ + if (w > legendPtr->width) { + x += w - legendPtr->width; + } + if (h > legendPtr->height) { + y += (h - legendPtr->height); + } + break; + } + legendPtr->x = x + legendPtr->padLeft; + legendPtr->y = y + legendPtr->padTop; +} + +static int +EntryIsSelected(Legend *legendPtr, Element *elemPtr) +{ + Blt_HashEntry *hPtr; + + hPtr = Blt_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr); + return (hPtr != NULL); +} + +static void +SelectElement(Legend *legendPtr, Element *elemPtr) +{ + int isNew; + Blt_HashEntry *hPtr; + + hPtr = Blt_CreateHashEntry(&legendPtr->selectTable, (char *)elemPtr,&isNew); + if (isNew) { + Blt_ChainLink link; + + link = Blt_Chain_Append(legendPtr->selected, elemPtr); + Blt_SetHashValue(hPtr, link); + } +} + +static void +DeselectElement(Legend *legendPtr, Element *elemPtr) +{ + Blt_HashEntry *hPtr; + + hPtr = Blt_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr); + if (hPtr != NULL) { + Blt_ChainLink link; + + link = Blt_GetHashValue(hPtr); + Blt_Chain_DeleteLink(legendPtr->selected, link); + Blt_DeleteHashEntry(&legendPtr->selectTable, hPtr); + } +} + +static void +SelectEntry(Legend *legendPtr, Element *elemPtr) +{ + Blt_HashEntry *hPtr; + + switch (legendPtr->flags & SELECT_MASK) { + case SELECT_CLEAR: + DeselectElement(legendPtr, elemPtr); + break; + + case SELECT_SET: + SelectElement(legendPtr, elemPtr); + break; + + case SELECT_TOGGLE: + hPtr = Blt_FindHashEntry(&legendPtr->selectTable, (char *)elemPtr); + if (hPtr != NULL) { + DeselectElement(legendPtr, elemPtr); + } else { + SelectElement(legendPtr, elemPtr); + } + break; + } +} + +#ifdef notdef +static Element * +PointerToElement(Legend *legendPtr, int x, int y) +{ + Graph *graphPtr = legendPtr->graphPtr; + int w, h; + int n; + + w = legendPtr->width; + h = legendPtr->height; + + x -= legendPtr->x + legendPtr->borderWidth; + y -= legendPtr->y + legendPtr->borderWidth; + w -= 2 * legendPtr->borderWidth + PADDING(legendPtr->xPad); + h -= 2 * legendPtr->borderWidth + PADDING(legendPtr->yPad); + + if ((x < 0) || (x >= w) || (y < 0) || (y >= h)) { + return NULL; + } + + /* It's in the bounding box, so compute the index. */ + { + int row, column; + + row = y / legendPtr->entryHeight; + column = x / legendPtr->entryWidth; + n = (column * legendPtr->nRows) + row; + } + if (n < legendPtr->nEntries) { + Blt_ChainLink link; + int count; + + count = 0; + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label == NULL) { + continue; + } + if (count > n) { + return NULL; + } else if (count == n) { + return elemPtr; + } + count++; + } + } + return NULL; +} +#endif + +/*ARGSUSED*/ +static ClientData +PickEntryProc(ClientData clientData, int x, int y, ClientData *contextPtr) +{ + Graph *graphPtr = clientData; + Legend *legendPtr; + int w, h; + + legendPtr = graphPtr->legend; + w = legendPtr->width; + h = legendPtr->height; + + if (legendPtr->titleHeight > 0) { + y -= legendPtr->titleHeight + legendPtr->yPad.side1; + } + x -= legendPtr->x + legendPtr->borderWidth; + y -= legendPtr->y + legendPtr->borderWidth; + w -= 2 * legendPtr->borderWidth + PADDING(legendPtr->xPad); + h -= 2 * legendPtr->borderWidth + PADDING(legendPtr->yPad); + + if ((x >= 0) && (x < w) && (y >= 0) && (y < h)) { + int row, column; + int n; + + /* + * It's in the bounding box, so compute the index. + */ + row = y / legendPtr->entryHeight; + column = x / legendPtr->entryWidth; + n = (column * legendPtr->nRows) + row; + if (n < legendPtr->nEntries) { + Blt_ChainLink link; + int count; + + /* Legend entries are stored in bottom-to-top. */ + count = 0; + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label != NULL) { + if (count == n) { + return elemPtr; + } + count++; + } + } + if (link != NULL) { + return Blt_Chain_GetValue(link); + } + } + } + return NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_MapLegend -- + * + * Calculates the dimensions (width and height) needed for the legend. + * Also determines the number of rows and columns necessary to list all + * the valid element labels. + * + * Results: + * None. + * + * Side effects: + * The following fields of the legend are calculated and set. + * + * nEntries - number of valid labels of elements in the + * display list. + * nRows - number of rows of entries + * nColumns - number of columns of entries + * entryHeight - height of each entry + * entryWidth - width of each entry + * height - width of legend (includes borders and padding) + * width - height of legend (includes borders and padding) + * + *--------------------------------------------------------------------------- + */ +void +Blt_MapLegend( + Graph *graphPtr, + int plotWidth, /* Maximum width available in window + * to draw the legend. Will calculate + * # of columns from this. */ + int plotHeight) /* Maximum height available in window + * to draw the legend. Will calculate + * # of rows from this. */ +{ + Legend *legendPtr = graphPtr->legend; + Blt_ChainLink link; + int nRows, nColumns, nEntries; + int lw, lh; + int maxWidth, maxHeight; + int symbolWidth; + Blt_FontMetrics fontMetrics; + + /* Initialize legend values to default (no legend displayed) */ + legendPtr->entryWidth = legendPtr->entryHeight = 0; + legendPtr->nRows = legendPtr->nColumns = legendPtr->nEntries = 0; + legendPtr->height = legendPtr->width = 0; + + if (legendPtr->site == LEGEND_WINDOW) { + if (Tk_Width(legendPtr->tkwin) > 1) { + plotWidth = Tk_Width(legendPtr->tkwin); + } + if (Tk_Height(legendPtr->tkwin) > 1) { + plotHeight = Tk_Height(legendPtr->tkwin); + } + } + Blt_Ts_GetExtents(&legendPtr->titleStyle, legendPtr->title, + &legendPtr->titleWidth, &legendPtr->titleHeight); + /* + * Count the number of legend entries and determine the widest and tallest + * label. The number of entries would normally be the number of elements, + * but elements can have no legend entry (-label ""). + */ + nEntries = 0; + maxWidth = maxHeight = 0; + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + unsigned int w, h; + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label == NULL) { + continue; /* Element has no legend entry. */ + } + Blt_Ts_GetExtents(&legendPtr->style, elemPtr->label, &w, &h); + if (maxWidth < w) { + maxWidth = w; + } + if (maxHeight < h) { + maxHeight = h; + } + nEntries++; + } + if (nEntries == 0) { + return; /* No visible legend entries. */ + } + + + Blt_GetFontMetrics(legendPtr->style.font, &fontMetrics); + symbolWidth = 2 * fontMetrics.ascent; + + maxWidth += 2 * legendPtr->entryBW + PADDING(legendPtr->ixPad) + + + symbolWidth + 3 * LABEL_PAD; + + maxHeight += 2 * legendPtr->entryBW + PADDING(legendPtr->iyPad); + + maxWidth |= 0x01; + maxHeight |= 0x01; + + lw = plotWidth - 2 * legendPtr->borderWidth - PADDING(legendPtr->xPad); + lh = plotHeight - 2 * legendPtr->borderWidth - PADDING(legendPtr->yPad); + + /* + * The number of rows and columns is computed as one of the following: + * + * both options set User defined. + * -rows Compute columns from rows. + * -columns Compute rows from columns. + * neither set Compute rows and columns from + * size of plot. + */ + if (legendPtr->reqRows > 0) { + nRows = MIN(legendPtr->reqRows, nEntries); + if (legendPtr->reqColumns > 0) { + nColumns = MIN(legendPtr->reqColumns, nEntries); + } else { + nColumns = ((nEntries - 1) / nRows) + 1; /* Only -rows. */ + } + } else if (legendPtr->reqColumns > 0) { /* Only -columns. */ + nColumns = MIN(legendPtr->reqColumns, nEntries); + nRows = ((nEntries - 1) / nColumns) + 1; + } else { + /* Compute # of rows and columns from the legend size. */ + nRows = lh / maxHeight; + nColumns = lw / maxWidth; + if (nRows < 1) { + nRows = nEntries; + } + if (nColumns < 1) { + nColumns = nEntries; + } + if (nRows > nEntries) { + nRows = nEntries; + } + switch (legendPtr->site) { + case LEGEND_TOP: + case LEGEND_BOTTOM: + nRows = ((nEntries - 1) / nColumns) + 1; + break; + case LEGEND_LEFT: + case LEGEND_RIGHT: + default: + nColumns = ((nEntries - 1) / nRows) + 1; + break; + } + } + if (nColumns < 1) { + nColumns = 1; + } + if (nRows < 1) { + nRows = 1; + } + + lh = (nRows * maxHeight); + if (legendPtr->titleHeight > 0) { + lh += legendPtr->titleHeight + legendPtr->yPad.side1; + } + lw = nColumns * maxWidth; + if (lw < legendPtr->titleWidth) { + lw = legendPtr->titleWidth; + } + legendPtr->width = lw + 2 * legendPtr->borderWidth + + PADDING(legendPtr->xPad); + legendPtr->height = lh + 2 * legendPtr->borderWidth + + PADDING(legendPtr->yPad); + legendPtr->nRows = nRows; + legendPtr->nColumns = nColumns; + legendPtr->nEntries = nEntries; + legendPtr->entryHeight = maxHeight; + legendPtr->entryWidth = maxWidth; + + { + int row, col, count; + + row = col = count = 0; + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + count++; + elemPtr->row = row; + elemPtr->col = col; + row++; + if ((count % nRows) == 0) { + col++; + row = 0; + } + } + } + if ((legendPtr->site == LEGEND_WINDOW) && + ((Tk_ReqWidth(legendPtr->tkwin) != legendPtr->width) || + (Tk_ReqHeight(legendPtr->tkwin) != legendPtr->height))) { + Tk_GeometryRequest(legendPtr->tkwin,legendPtr->width,legendPtr->height); + } +} + +void +Blt_DrawLegend(Graph *graphPtr, Drawable drawable) +{ + Blt_Background bg; + Blt_ChainLink link; + Blt_FontMetrics fontMetrics; + Legend *legendPtr = graphPtr->legend; + Pixmap pixmap; + Tk_Window tkwin; + int count; + int symbolSize, xMid, yMid; + int x, y, w, h; + int xLabel, yStart, xSymbol, ySymbol; + + if ((legendPtr->flags & HIDE) || (legendPtr->nEntries == 0)) { + return; + } + + SetLegendOrigin(legendPtr); + graphPtr = legendPtr->graphPtr; + tkwin = legendPtr->tkwin; + if (legendPtr->site == LEGEND_WINDOW) { + w = Tk_Width(tkwin); + h = Tk_Height(tkwin); + } else { + w = legendPtr->width; + h = legendPtr->height; + } + + pixmap = Tk_GetPixmap(graphPtr->display, Tk_WindowId(tkwin), w, h, + Tk_Depth(tkwin)); + + if (legendPtr->normalBg != NULL) { + Blt_FillBackgroundRectangle(tkwin, pixmap, legendPtr->normalBg, 0, 0, + w, h, 0, TK_RELIEF_FLAT); + } else if (legendPtr->site & LEGEND_PLOTAREA_MASK) { + /* + * Legend background is transparent and is positioned over the the + * plot area. Either copy the part of the background from the backing + * store pixmap or (if no backing store exists) just fill it with the + * background color of the plot. + */ + if (graphPtr->cache != None) { + XCopyArea(graphPtr->display, graphPtr->cache, pixmap, + graphPtr->drawGC, legendPtr->x, legendPtr->y, w, h, 0, 0); + } else { + Blt_FillBackgroundRectangle(tkwin, pixmap, graphPtr->plotBg, 0, 0, + w, h, TK_RELIEF_FLAT, 0); + } + } else { + int xOrigin, yOrigin; + /* + * The legend is located in one of the margins or the external window. + */ + Blt_GetBackgroundOrigin(graphPtr->normalBg, &xOrigin, &yOrigin); + Blt_SetBackgroundOrigin(graphPtr->tkwin, graphPtr->normalBg, + xOrigin - legendPtr->x,yOrigin - legendPtr->y); + Blt_FillBackgroundRectangle(tkwin, pixmap, graphPtr->normalBg, 0, 0, + w, h, 0, TK_RELIEF_FLAT); + Blt_SetBackgroundOrigin(tkwin, graphPtr->normalBg, xOrigin, yOrigin); + } + Blt_GetFontMetrics(legendPtr->style.font, &fontMetrics); + + symbolSize = fontMetrics.ascent; + xMid = symbolSize + 1 + legendPtr->entryBW; + yMid = (symbolSize / 2) + 1 + legendPtr->entryBW; + xLabel = 2 * symbolSize + legendPtr->entryBW + + legendPtr->ixPad.side1 + 2 * LABEL_PAD; + ySymbol = yMid + legendPtr->iyPad.side1; + xSymbol = xMid + LABEL_PAD; + + x = legendPtr->padLeft + legendPtr->borderWidth; + y = legendPtr->padTop + legendPtr->borderWidth; + Blt_DrawText(tkwin, pixmap, legendPtr->title, &legendPtr->titleStyle, x, y); + if (legendPtr->titleHeight > 0) { + y += legendPtr->titleHeight + legendPtr->yPad.side1; + } + count = 0; + yStart = y; + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + int isSelected; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label == NULL) { + continue; /* Skip this entry */ + } + isSelected = EntryIsSelected(legendPtr, elemPtr); + if (elemPtr->flags & LABEL_ACTIVE) { + int xOrigin, yOrigin; + + Blt_GetBackgroundOrigin(legendPtr->activeBg, &xOrigin, &yOrigin); + Blt_SetBackgroundOrigin(tkwin, legendPtr->activeBg, + xOrigin - legendPtr->x, yOrigin - legendPtr->y); + Blt_Ts_SetForeground(legendPtr->style, legendPtr->activeFgColor); + Blt_FillBackgroundRectangle(tkwin, pixmap, legendPtr->activeBg, + x, y, legendPtr->entryWidth, legendPtr->entryHeight, + legendPtr->entryBW, legendPtr->activeRelief); + Blt_SetBackgroundOrigin(tkwin, legendPtr->activeBg, + xOrigin, yOrigin); + } else if (isSelected) { + int xOrigin, yOrigin; + Blt_Background bg; + XColor *fg; + + fg = (legendPtr->flags & FOCUS) ? + legendPtr->selInFocusFgColor : legendPtr->selOutFocusFgColor; + bg = (legendPtr->flags & FOCUS) ? + legendPtr->selInFocusBg : legendPtr->selOutFocusBg; + Blt_GetBackgroundOrigin(bg, &xOrigin, &yOrigin); + Blt_SetBackgroundOrigin(tkwin, bg, xOrigin - legendPtr->x, + yOrigin - legendPtr->y); + Blt_Ts_SetForeground(legendPtr->style, fg); + Blt_FillBackgroundRectangle(tkwin, pixmap, bg, x, y, + legendPtr->entryWidth, legendPtr->entryHeight, + legendPtr->selBW, legendPtr->selRelief); + Blt_SetBackgroundOrigin(tkwin, bg, xOrigin, yOrigin); + } else { + Blt_Ts_SetForeground(legendPtr->style, legendPtr->fgColor); + if (elemPtr->legendRelief != TK_RELIEF_FLAT) { + Blt_FillBackgroundRectangle(tkwin, pixmap, graphPtr->normalBg, + x, y, legendPtr->entryWidth, + legendPtr->entryHeight, legendPtr->entryBW, + elemPtr->legendRelief); + } + } + (*elemPtr->procsPtr->drawSymbolProc) (graphPtr, pixmap, elemPtr, + x + xSymbol, y + ySymbol, symbolSize); + Blt_DrawText(tkwin, pixmap, elemPtr->label, &legendPtr->style, + x + xLabel, + y + legendPtr->entryBW + legendPtr->iyPad.side1); + count++; + if (legendPtr->focusPtr == elemPtr) { /* Focus outline */ + if (isSelected) { + XColor *color; + + color = (legendPtr->flags & FOCUS) ? + legendPtr->selInFocusFgColor : + legendPtr->selOutFocusFgColor; + XSetForeground(graphPtr->display, legendPtr->focusGC, + color->pixel); + } + XDrawRectangle(graphPtr->display, pixmap, legendPtr->focusGC, + x + 1, y + 1, legendPtr->entryWidth - 3, + legendPtr->entryHeight - 3); + if (isSelected) { + XSetForeground(graphPtr->display, legendPtr->focusGC, + legendPtr->focusColor->pixel); + } + } + /* Check when to move to the next column */ + if ((count % legendPtr->nRows) > 0) { + y += legendPtr->entryHeight; + } else { + x += legendPtr->entryWidth; + y = yStart; + } + } + /* + * Draw the border and/or background of the legend. + */ + bg = legendPtr->normalBg; + if (bg == NULL) { + bg = graphPtr->normalBg; + } + /* Disable crosshairs before redisplaying to the screen */ + if (legendPtr->site & LEGEND_PLOTAREA_MASK) { + Blt_DisableCrosshairs(graphPtr); + } + Blt_DrawBackgroundRectangle(tkwin, pixmap, bg, 0, 0, w, h, + legendPtr->borderWidth, legendPtr->relief); + XCopyArea(graphPtr->display, pixmap, drawable, graphPtr->drawGC, 0, 0, w, h, + legendPtr->x, legendPtr->y); + if (legendPtr->site & LEGEND_PLOTAREA_MASK) { + Blt_EnableCrosshairs(graphPtr); + } + Tk_FreePixmap(graphPtr->display, pixmap); + graphPtr->flags &= ~DRAW_LEGEND; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_LegendToPostScript -- + * + *--------------------------------------------------------------------------- + */ +void +Blt_LegendToPostScript(Graph *graphPtr, Blt_Ps ps) +{ + Legend *legendPtr = graphPtr->legend; + double x, y, yStart; + int xLabel, xSymbol, ySymbol; + int count; + Blt_ChainLink link; + int symbolSize, xMid, yMid; + int width, height; + Blt_FontMetrics fontMetrics; + + if ((legendPtr->flags & HIDE) || (legendPtr->nEntries == 0)) { + return; + } + SetLegendOrigin(legendPtr); + + x = legendPtr->x, y = legendPtr->y; + width = legendPtr->width - PADDING(legendPtr->xPad); + height = legendPtr->height - PADDING(legendPtr->yPad); + + Blt_Ps_Append(ps, "% Legend\n"); + graphPtr = legendPtr->graphPtr; + if (graphPtr->pageSetup->flags & PS_DECORATIONS) { + if (legendPtr->normalBg != NULL) { + Tk_3DBorder border; + + border = Blt_BackgroundBorder(legendPtr->normalBg); + Blt_Ps_Fill3DRectangle(ps, border, x, y, width, height, + legendPtr->borderWidth, legendPtr->relief); + } else { + Tk_3DBorder border; + + border = Blt_BackgroundBorder(graphPtr->normalBg); + Blt_Ps_Draw3DRectangle(ps, border, x, y, width, height, + legendPtr->borderWidth, legendPtr->relief); + } + } else { + Blt_Ps_SetClearBackground(ps); + Blt_Ps_XFillRectangle(ps, x, y, width, height); + } + Blt_GetFontMetrics(legendPtr->style.font, &fontMetrics); + symbolSize = fontMetrics.ascent; + xMid = symbolSize + 1 + legendPtr->entryBW; + yMid = (symbolSize / 2) + 1 + legendPtr->entryBW; + xLabel = 2 * symbolSize + legendPtr->entryBW + legendPtr->ixPad.side1 + 5; + xSymbol = xMid + legendPtr->ixPad.side1; + ySymbol = yMid + legendPtr->iyPad.side1; + + x += legendPtr->borderWidth; + y += legendPtr->borderWidth; + Blt_Ps_DrawText(ps, legendPtr->title, &legendPtr->titleStyle, x, y); + if (legendPtr->titleHeight > 0) { + y += legendPtr->titleHeight + legendPtr->yPad.side1; + } + + count = 0; + yStart = y; + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label == NULL) { + continue; /* Skip this label */ + } + if (elemPtr->flags & LABEL_ACTIVE) { + Tk_3DBorder border; + + border = Blt_BackgroundBorder(legendPtr->activeBg); + Blt_Ts_SetForeground(legendPtr->style, legendPtr->activeFgColor); + Blt_Ps_Fill3DRectangle(ps, border, x, y, legendPtr->entryWidth, + legendPtr->entryHeight, legendPtr->entryBW, + legendPtr->activeRelief); + } else { + Blt_Ts_SetForeground(legendPtr->style, legendPtr->fgColor); + if (elemPtr->legendRelief != TK_RELIEF_FLAT) { + Tk_3DBorder border; + + border = Blt_BackgroundBorder(graphPtr->normalBg); + Blt_Ps_Draw3DRectangle(ps, border, x, y, legendPtr->entryWidth, + legendPtr->entryHeight, legendPtr->entryBW, + elemPtr->legendRelief); + } + } + (*elemPtr->procsPtr->printSymbolProc) (graphPtr, ps, elemPtr, + x + xSymbol, y + ySymbol, symbolSize); + Blt_Ps_DrawText(ps, elemPtr->label, &legendPtr->style, + x + xLabel, y + legendPtr->entryBW + legendPtr->iyPad.side1); + count++; + if ((count % legendPtr->nRows) > 0) { + y += legendPtr->entryHeight; + } else { + x += legendPtr->entryWidth; + y = yStart; + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * DisplayLegend -- + * + *--------------------------------------------------------------------------- + */ +static void +DisplayLegend(ClientData clientData) +{ + Legend *legendPtr = clientData; + Graph *graphPtr; + + legendPtr->flags &= ~REDRAW_PENDING; + if (legendPtr->tkwin == NULL) { + return; /* Window has been destroyed. */ + } + graphPtr = legendPtr->graphPtr; + if (legendPtr->site == LEGEND_WINDOW) { + int w, h; + + w = Tk_Width(legendPtr->tkwin); + h = Tk_Height(legendPtr->tkwin); + if ((w != legendPtr->width) || (h != legendPtr->height)) { + Blt_MapLegend(graphPtr, w, h); + } + } + if (Tk_IsMapped(legendPtr->tkwin)) { + Blt_DrawLegend(graphPtr, Tk_WindowId(legendPtr->tkwin)); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ConfigureLegend -- + * + * Routine to configure the legend. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new legend attributes. + * + *--------------------------------------------------------------------------- + */ +void +Blt_ConfigureLegend(Graph *graphPtr) +{ + GC newGC; + XGCValues gcValues; + unsigned long gcMask; + Legend *legendPtr; + + legendPtr = graphPtr->legend; + /* GC for active label. Dashed outline. */ + gcMask = GCForeground | GCLineStyle; + gcValues.foreground = legendPtr->focusColor->pixel; + gcValues.line_style = (LineIsDashed(legendPtr->focusDashes)) + ? LineOnOffDash : LineSolid; + newGC = Blt_GetPrivateGC(legendPtr->tkwin, gcMask, &gcValues); + if (LineIsDashed(legendPtr->focusDashes)) { + legendPtr->focusDashes.offset = 2; + Blt_SetDashes(graphPtr->display, newGC, &legendPtr->focusDashes); + } + if (legendPtr->focusGC != NULL) { + Blt_FreePrivateGC(graphPtr->display, legendPtr->focusGC); + } + legendPtr->focusGC = newGC; + + /* + * Update the layout of the graph (and redraw the elements) if any of + * the following legend options (all of which affect the size of the + * legend) have changed. + * + * -activeborderwidth, -borderwidth + * -border + * -font + * -hide + * -ipadx, -ipady, -padx, -pady + * -rows + * + * If the position of the legend changed to/from the default + * position, also indicate that a new layout is needed. + * + */ + if (legendPtr->site == LEGEND_WINDOW) { + Blt_Legend_EventuallyRedraw(graphPtr); + } else if (Blt_ConfigModified(configSpecs, "-*border*", "-*pad?", + "-hide", "-font", "-rows", (char *)NULL)) { + graphPtr->flags |= RESET_WORLD; + graphPtr->flags |= (REDRAW_WORLD | CACHE_DIRTY); + Blt_EventuallyRedrawGraph(graphPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DestroyLegend -- + * + * Results: + * None. + * + * Side effects: + * Resources associated with the legend are freed. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DestroyLegend(Graph *graphPtr) +{ + Legend *legendPtr = graphPtr->legend; + + if (graphPtr->legend == NULL) { + return; + } + + Blt_FreeOptions(configSpecs, (char *)legendPtr, graphPtr->display, 0); + Blt_Ts_FreeStyle(graphPtr->display, &legendPtr->style); + Blt_Ts_FreeStyle(graphPtr->display, &legendPtr->titleStyle); + Blt_DestroyBindingTable(legendPtr->bindTable); + + if (legendPtr->focusGC != NULL) { + Blt_FreePrivateGC(graphPtr->display, legendPtr->focusGC); + } + if (legendPtr->timerToken != NULL) { + Tcl_DeleteTimerHandler(legendPtr->timerToken); + } + if (legendPtr->tkwin != NULL) { + Tk_DeleteSelHandler(legendPtr->tkwin, XA_PRIMARY, XA_STRING); + } + if (legendPtr->site == LEGEND_WINDOW) { + Tk_Window tkwin; + + /* The graph may be in the process of being torn down */ + if (legendPtr->cmdToken != NULL) { + Tcl_DeleteCommandFromToken(graphPtr->interp, legendPtr->cmdToken); + } + if (legendPtr->flags & REDRAW_PENDING) { + Tcl_CancelIdleCall(DisplayLegend, legendPtr); + legendPtr->flags &= ~REDRAW_PENDING; + } + tkwin = legendPtr->tkwin; + legendPtr->tkwin = NULL; + if (tkwin != NULL) { + Tk_DeleteEventHandler(tkwin, ExposureMask | StructureNotifyMask, + LegendEventProc, graphPtr); + Blt_DeleteWindowInstanceData(tkwin); + Tk_DestroyWindow(tkwin); + } + } + Blt_Free(legendPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_CreateLegend -- + * + * Creates and initializes a legend structure with default settings + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +int +Blt_CreateLegend(Graph *graphPtr) +{ + Legend *legendPtr; + + legendPtr = Blt_AssertCalloc(1, sizeof(Legend)); + graphPtr->legend = legendPtr; + legendPtr->graphPtr = graphPtr; + legendPtr->tkwin = graphPtr->tkwin; + legendPtr->xReq = legendPtr->yReq = -SHRT_MAX; + legendPtr->relief = TK_RELIEF_SUNKEN; + legendPtr->activeRelief = TK_RELIEF_FLAT; + legendPtr->entryBW = 2; + legendPtr->borderWidth = 2; + legendPtr->ixPad.side1 = legendPtr->ixPad.side2 = 1; + legendPtr->iyPad.side1 = legendPtr->iyPad.side2 = 1; + legendPtr->xPad.side1 = legendPtr->xPad.side2 = 1; + legendPtr->yPad.side1 = legendPtr->yPad.side2 = 1; + legendPtr->anchor = TK_ANCHOR_N; + legendPtr->site = LEGEND_RIGHT; + legendPtr->selectMode = SELECT_MODE_MULTIPLE; + Blt_Ts_InitStyle(legendPtr->style); + Blt_Ts_InitStyle(legendPtr->titleStyle); + legendPtr->style.justify = TK_JUSTIFY_LEFT; + legendPtr->style.anchor = TK_ANCHOR_NW; + legendPtr->titleStyle.justify = TK_JUSTIFY_LEFT; + legendPtr->titleStyle.anchor = TK_ANCHOR_NW; + legendPtr->bindTable = Blt_CreateBindingTable(graphPtr->interp, + graphPtr->tkwin, graphPtr, PickEntryProc, Blt_GraphTags); + + Blt_InitHashTable(&legendPtr->selectTable, BLT_ONE_WORD_KEYS); + legendPtr->selected = Blt_Chain_Create(); + Tk_CreateSelHandler(legendPtr->tkwin, XA_PRIMARY, XA_STRING, + SelectionProc, legendPtr, XA_STRING); + legendPtr->selRelief = TK_RELIEF_FLAT; + legendPtr->selBW = 1; + legendPtr->onTime = 600; + legendPtr->offTime = 300; + if (Blt_ConfigureComponentFromObj(graphPtr->interp, graphPtr->tkwin, + "legend", "Legend", configSpecs, 0, (Tcl_Obj **)NULL, + (char *)legendPtr, 0) != TCL_OK) { + return TCL_ERROR; + } + Blt_ConfigureLegend(graphPtr); + return TCL_OK; +} + +static Element * +GetNextRow(Graph *graphPtr, Element *focusPtr) +{ + Blt_ChainLink link; + int row, col; + + col = focusPtr->col; + row = focusPtr->row + 1; + for (link = focusPtr->link; link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label == NULL) { + continue; + } + if ((elemPtr->col == col) && (elemPtr->row == row)) { + return elemPtr; + } + } + return NULL; +} + +static Element * +GetNextColumn(Graph *graphPtr, Element *focusPtr) +{ + Blt_ChainLink link; + int row, col; + + col = focusPtr->col + 1; + row = focusPtr->row; + for (link = focusPtr->link; link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label == NULL) { + continue; + } + if ((elemPtr->col == col) && (elemPtr->row == row)) { + return elemPtr; /* Don't go beyond legend boundaries. */ + } + } + return NULL; +} + +static Element * +GetPreviousRow(Graph *graphPtr, Element *focusPtr) +{ + Blt_ChainLink link; + int row, col; + + col = focusPtr->col; + row = focusPtr->row - 1; + for (link = focusPtr->link; link != NULL; link = Blt_Chain_PrevLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label == NULL) { + continue; + } + if ((elemPtr->col == col) && (elemPtr->row == row)) { + return elemPtr; + } + } + return NULL; +} + +static Element * +GetPreviousColumn(Graph *graphPtr, Element *focusPtr) +{ + Blt_ChainLink link; + int row, col; + + col = focusPtr->col - 1; + row = focusPtr->row; + for (link = focusPtr->link; link != NULL; link = Blt_Chain_PrevLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label == NULL) { + continue; + } + if ((elemPtr->col == col) && (elemPtr->row == row)) { + return elemPtr; + } + } + return NULL; +} + +static Element * +GetFirstElement(Graph *graphPtr) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label != NULL) { + return elemPtr; + } + } + return NULL; +} + +static Element * +GetLastElement(Graph *graphPtr) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_LastLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->label != NULL) { + return elemPtr; + } + } + return NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * GetElementFromObj -- + * + * Parse an index into an entry and return either its value or an error. + * + * Results: + * A standard TCL result. If all went well, then *indexPtr is filled in + * with the character index (into entryPtr) corresponding to string. The + * index value is guaranteed to lie between 0 and the number of characters + * in the string, inclusive. If an error occurs then an error message is + * left in the interp's result. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static int +GetElementFromObj(Graph *graphPtr, Tcl_Obj *objPtr, Element **elemPtrPtr) +{ + Element *elemPtr; + Legend *legendPtr; + Tcl_Interp *interp; + char c; + const char *string; + int last; + int index; + + legendPtr = graphPtr->legend; + interp = graphPtr->interp; + string = Tcl_GetString(objPtr); + c = string[0]; + elemPtr = NULL; + + last = Blt_Chain_GetLength(graphPtr->elements.displayList) - 1; + if ((c == 'a') && (strcmp(string, "anchor") == 0)) { + elemPtr = legendPtr->selAnchorPtr; + } else if ((c == 'c') && (strcmp(string, "current") == 0)) { + elemPtr = (Element *)Blt_GetCurrentItem(legendPtr->bindTable); + } else if ((c == 'f') && (strcmp(string, "first") == 0)) { + elemPtr = GetFirstElement(graphPtr); + } else if ((c == 'f') && (strcmp(string, "focus") == 0)) { + elemPtr = legendPtr->focusPtr; + } else if ((c == 'l') && (strcmp(string, "last") == 0)) { + elemPtr = GetLastElement(graphPtr); + } else if ((c == 'e') && (strcmp(string, "end") == 0)) { + elemPtr = GetLastElement(graphPtr); + } else if ((c == 'n') && (strcmp(string, "next.row") == 0)) { + elemPtr = GetNextRow(graphPtr, legendPtr->focusPtr); + } else if ((c == 'n') && (strcmp(string, "next.column") == 0)) { + elemPtr = GetNextColumn(graphPtr, legendPtr->focusPtr); + } else if ((c == 'p') && (strcmp(string, "previous.row") == 0)) { + elemPtr = GetPreviousRow(graphPtr, legendPtr->focusPtr); + } else if ((c == 'p') && (strcmp(string, "previous.column") == 0)) { + elemPtr = GetPreviousColumn(graphPtr, legendPtr->focusPtr); + } else if ((c == 's') && (strcmp(string, "sel.first") == 0)) { + elemPtr = legendPtr->selFirstPtr; + } else if ((c == 's') && (strcmp(string, "sel.last") == 0)) { + elemPtr = legendPtr->selLastPtr; + } else if (c == '@') { + int x, y; + + if (Blt_GetXY(interp, legendPtr->tkwin, string, &x, &y) != TCL_OK) { + return TCL_ERROR; + } + elemPtr = (Element *)PickEntryProc(graphPtr, x, y, NULL); + } else { + if (Blt_GetElement(interp, graphPtr, objPtr, &elemPtr) != TCL_OK) { + return TCL_ERROR; + } + if (elemPtr->link == NULL) { + Tcl_AppendResult(interp, "bad legend index \"", string, "\"", + (char *)NULL); + return TCL_ERROR; + } + if (elemPtr->label == NULL) { + elemPtr = NULL; + } + } + *elemPtrPtr = elemPtr; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SelectRange -- + * + * Sets the selection flag for a range of nodes. The range is determined + * by two pointers which designate the first/last nodes of the range. + * + * Results: + * Always returns TCL_OK. + * + *--------------------------------------------------------------------------- + */ +static int +SelectRange(Legend *legendPtr, Element *fromPtr, Element *toPtr) +{ + + if (Blt_Chain_IsBefore(fromPtr->link, toPtr->link)) { + Blt_ChainLink link; + + for (link = fromPtr->link; link != NULL; + link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + SelectEntry(legendPtr, elemPtr); + if (link == toPtr->link) { + break; + } + } + } else { + Blt_ChainLink link; + + for (link = fromPtr->link; link != NULL; + link = Blt_Chain_PrevLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + SelectEntry(legendPtr, elemPtr); + if (link == toPtr->link) { + break; + } + } + } + return TCL_OK; +} + + +#ifdef notdef +/* + *--------------------------------------------------------------------------- + * + * SelectText -- + * + * Modify the selection by moving its un-anchored end. This could make + * the selection either larger or smaller. + * + * Results: + * None. + * + * Side effects: + * The selection changes. + * + *--------------------------------------------------------------------------- + */ +static int +SelectText(Legend *legendPtr, Element *elemPtr) +{ + Element *firstPtr, *lastPtr; + Graph *graphPtr = legendPtr->graphPtr; + + /* Grab the selection if we don't own it already. */ + if ((legendPtr->flags&SELECT_EXPORT) && (legendPtr->selFirstPtr == NULL)) { + Tk_OwnSelection(legendPtr->tkwin, XA_PRIMARY, LostSelectionProc, + legendPtr); + } + /* If the anchor hasn't been set, assume the beginning of the legend. */ + if (legendPtr->selAnchorPtr == NULL) { + legendPtr->selAnchorPtr = GetFirstElement(graphPtr); + } + if (legendPtr->selAnchorPtr != elemPtr) { + firstPtr = legendPtr->selAnchorPtr; + lastPtr = elemPtr; + } else { + firstPtr = elemPtr; + lastPtr = legendPtr->selAnchorPtr; + } + if ((legendPtr->selFirstPtr != firstPtr) || + (legendPtr->selLastPtr != lastPtr)) { + legendPtr->selFirstPtr = firstPtr; + legendPtr->selLastPtr = lastPtr; + SelectRange(legendPtr, firstPtr, lastPtr); + Blt_Legend_EventuallyRedraw(graphPtr); + } + return TCL_OK; +} +#endif + +/* + *--------------------------------------------------------------------------- + * + * ActivateOp -- + * + * Activates a particular label in the legend. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new legend attributes. + * + *--------------------------------------------------------------------------- + */ +static int +ActivateOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + unsigned int active, redraw; + const char *string; + int i; + + string = Tcl_GetString(objv[2]); + active = (string[0] == 'a') ? LABEL_ACTIVE : 0; + redraw = FALSE; + for (i = 3; i < objc; i++) { + Blt_ChainLink link; + const char *pattern; + + pattern = Tcl_GetString(objv[i]); + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (Tcl_StringMatch(elemPtr->obj.name, pattern)) { + fprintf(stderr, "legend %s(%s) %s is currently %d\n", + string, pattern, elemPtr->obj.name, + (elemPtr->flags & LABEL_ACTIVE)); + if (active) { + if ((elemPtr->flags & LABEL_ACTIVE) == 0) { + elemPtr->flags |= LABEL_ACTIVE; + redraw = TRUE; + } + } else { + if (elemPtr->flags & LABEL_ACTIVE) { + elemPtr->flags &= ~LABEL_ACTIVE; + redraw = TRUE; + } + } + fprintf(stderr, "legend %s(%s) %s is now %d\n", + string, pattern, elemPtr->obj.name, + (elemPtr->flags & LABEL_ACTIVE)); + } + } + } + if ((redraw) && ((legendPtr->flags & HIDE) == 0)) { + /* + * See if how much we need to draw. If the graph is already scheduled + * for a redraw, just make sure the right flags are set. Otherwise + * redraw only the legend: it's either in an external window or it's + * the only thing that need updating. + */ + if ((legendPtr->site != LEGEND_WINDOW) && + (graphPtr->flags & REDRAW_PENDING)) { + graphPtr->flags |= CACHE_DIRTY; + graphPtr->flags |= REDRAW_WORLD; /* Redraw entire graph. */ + } else { + Blt_Legend_EventuallyRedraw(graphPtr); + } + } + { + Blt_ChainLink link; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + /* List active elements in stacking order. */ + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->flags & LABEL_ACTIVE) { + Tcl_Obj *objPtr; + + objPtr = Tcl_NewStringObj(elemPtr->obj.name, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + } + Tcl_SetObjResult(interp, listObjPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * BindOp -- + * + * .t bind index sequence command + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +BindOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + if (objc == 3) { + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (hPtr = Blt_FirstHashEntry(&graphPtr->elements.tagTable, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + const char *tagName; + Tcl_Obj *objPtr; + + tagName = Blt_GetHashKey(&graphPtr->elements.tagTable, hPtr); + objPtr = Tcl_NewStringObj(tagName, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; + } + return Blt_ConfigureBindingsFromObj(interp, graphPtr->legend->bindTable, + Blt_MakeElementTag(graphPtr, Tcl_GetString(objv[3])), objc - 4, + objv + 4); +} + +/* + *--------------------------------------------------------------------------- + * + * CgetOp -- + * + * Queries or resets options for the legend. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new legend attributes. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static int +CgetOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + return Blt_ConfigureValueFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)graphPtr->legend, objv[3], 0); +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureOp -- + * + * Queries or resets options for the legend. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new legend attributes. + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int flags = BLT_CONFIG_OBJV_ONLY; + Legend *legendPtr; + + legendPtr = graphPtr->legend; + if (objc == 3) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)legendPtr, (Tcl_Obj *)NULL, flags); + } else if (objc == 4) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)legendPtr, objv[3], flags); + } + if (Blt_ConfigureWidgetFromObj(interp, graphPtr->tkwin, configSpecs, + objc - 3, objv + 3, (char *)legendPtr, flags) != TCL_OK) { + return TCL_ERROR; + } + Blt_ConfigureLegend(graphPtr); + return TCL_OK; +} + + +/*ARGSUSED*/ +static int +CurselectionOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (legendPtr->flags & SELECT_SORTED) { + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(legendPtr->selected); link != NULL; + link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + Tcl_Obj *objPtr; + + elemPtr = Blt_Chain_GetValue(link); + objPtr = Tcl_NewStringObj(elemPtr->obj.name, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + } else { + Blt_ChainLink link; + + /* List of selected entries is in stacking order. */ + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + + if (EntryIsSelected(legendPtr, elemPtr)) { + Tcl_Obj *objPtr; + + objPtr = Tcl_NewStringObj(elemPtr->obj.name, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/*ARGSUSED*/ +static int +FocusOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + + if (objc == 4) { + Element *elemPtr; + + if (GetElementFromObj(graphPtr, objv[3], &elemPtr) != TCL_OK) { + return TCL_ERROR; + } + if ((elemPtr != NULL) && (elemPtr != legendPtr->focusPtr)) { + /* Changing focus can only affect the visible entries. The entry + * layout stays the same. */ + legendPtr->focusPtr = elemPtr; + } + Blt_SetFocusItem(legendPtr->bindTable, legendPtr->focusPtr, + CID_LEGEND_ENTRY); + Blt_Legend_EventuallyRedraw(graphPtr); + } + if (legendPtr->focusPtr != NULL) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), + legendPtr->focusPtr->obj.name, -1); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * GetOp -- + * + * Find the legend entry from the given argument. The argument can be + * either a screen position "@x,y" or the name of an element. + * + * I don't know how useful it is to test with the name of an element. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new legend attributes. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +GetOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + + if (((legendPtr->flags & HIDE) == 0) && (legendPtr->nEntries > 0)) { + Element *elemPtr; + + if (GetElementFromObj(graphPtr, objv[3], &elemPtr) != TCL_OK) { + return TCL_ERROR; + } + if (elemPtr != NULL) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), elemPtr->obj.name,-1); + } + } + return TCL_OK; +} + +/* + *---------------------------------------------------------------------- + * + * IconOp -- + * + * Find the legend entry from the given argument. The argument + * can be either a screen position "@x,y" or the name of an + * element. + * + * I don't know how useful it is to test with the name of an + * element. + * + * Results: + * A standard Tcl result. + * + * Side Effects: + * Graph will be redrawn to reflect the new legend attributes. + * + * .g legend icon elemName image + * + *---------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +IconOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Blt_Picture picture; + Element *elemPtr; + Legend *legendPtr = graphPtr->legend; + Pixmap pixmap; + Blt_FontMetrics fontMetrics; + Tk_PhotoHandle photo; + const char *imageName; + int isPicture; + int w, h, x, y, s; + + if (GetElementFromObj(graphPtr, objv[3], &elemPtr) != TCL_OK) { + return TCL_ERROR; + } + if (elemPtr == NULL) { + return TCL_OK; /* Unknown index. */ + } + imageName = Tcl_GetString(objv[4]); + photo = Tk_FindPhoto(interp, imageName); + if (photo != NULL) { + isPicture = FALSE; + } else if (Blt_GetPicture(interp, imageName, &picture) == TCL_OK) { + isPicture = TRUE; + } else { + return TCL_ERROR; + } + Blt_GetFontMetrics(legendPtr->style.font, &fontMetrics); + s = fontMetrics.ascent; + h = s + PADDING(legendPtr->iyPad) + 1; + w = s + s + 1 + PADDING(legendPtr->ixPad); + x = (w / 2); + y = (h / 2); + + pixmap = Tk_GetPixmap(graphPtr->display, Tk_RootWindow(graphPtr->tkwin), + w, h, Tk_Depth(graphPtr->tkwin)); + Blt_FillBackgroundRectangle(graphPtr->tkwin, pixmap, graphPtr->plotBg, + 0, 0, w, h, TK_RELIEF_FLAT, 0); + (*elemPtr->procsPtr->drawSymbolProc) (graphPtr, pixmap, elemPtr, x, y, s); + picture = Blt_DrawableToPicture(graphPtr->tkwin, pixmap, 0, 0, w, h, 1.0); + Tk_FreePixmap(graphPtr->display, pixmap); + if (picture == NULL) { + Tcl_AppendResult(interp, "can't get picture of symbol.", (char *)NULL); + return TCL_ERROR; + } + /* Make the background transparent. */ + { + int y; + Blt_Pixel bg; + Blt_Pixel *destRowPtr; + XColor *colorPtr; + + colorPtr = Blt_BackgroundBorderColor(graphPtr->plotBg); + bg.Red = colorPtr->red >> 8; + bg.Green = colorPtr->green >> 8; + bg.Blue = colorPtr->blue >> 8; + bg.Alpha = 0xFF; + + destRowPtr = Blt_PictureBits(picture); + for (y = 0; y < h; y++) { + Blt_Pixel *dp, *dend; + + for (dp = destRowPtr, dend = dp + w; dp < dend; dp++) { + if (dp->u32 == bg.u32) { + dp->Alpha = 0x0; + } + } + destRowPtr += Blt_PictureStride(picture); + } + } + Blt_ClassifyPicture(picture); + if (isPicture) { + Blt_ResetPicture(interp, imageName, picture); + } else { + Blt_PictureToPhoto(picture, photo); + Blt_FreePicture(picture); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SelectionAnchorOp -- + * + * Sets the selection anchor to the element given by a index. The + * selection anchor is the end of the selection that is fixed while + * dragging out a selection with the mouse. The index "anchor" may be + * used to refer to the anchor element. + * + * Results: + * None. + * + * Side effects: + * The selection changes. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SelectionAnchorOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + Element *elemPtr; + + if (GetElementFromObj(graphPtr, objv[4], &elemPtr) != TCL_OK) { + return TCL_ERROR; + } + /* Set both the anchor and the mark. Indicates that a single entry + * is selected. */ + legendPtr->selAnchorPtr = elemPtr; + legendPtr->selMarkPtr = NULL; + if (elemPtr != NULL) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), elemPtr->obj.name, -1); + } + Blt_Legend_EventuallyRedraw(graphPtr); + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * SelectionClearallOp + * + * Clears the entire selection. + * + * Results: + * None. + * + * Side effects: + * The selection changes. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SelectionClearallOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + + ClearSelection(legendPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SelectionIncludesOp + * + * Returns 1 if the element indicated by index is currently + * selected, 0 if it isn't. + * + * Results: + * None. + * + * Side effects: + * The selection changes. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SelectionIncludesOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + Element *elemPtr; + int bool; + + if (GetElementFromObj(graphPtr, objv[4], &elemPtr) != TCL_OK) { + return TCL_ERROR; + } + bool = EntryIsSelected(legendPtr, elemPtr); + Tcl_SetBooleanObj(Tcl_GetObjResult(interp), bool); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SelectionMarkOp -- + * + * Sets the selection mark to the element given by a index. The + * selection anchor is the end of the selection that is movable while + * dragging out a selection with the mouse. The index "mark" may be used + * to refer to the anchor element. + * + * Results: + * None. + * + * Side effects: + * The selection changes. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SelectionMarkOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + Element *elemPtr; + + if (GetElementFromObj(graphPtr, objv[4], &elemPtr) != TCL_OK) { + return TCL_ERROR; + } + if (legendPtr->selAnchorPtr == NULL) { + Tcl_AppendResult(interp, "selection anchor must be set first", + (char *)NULL); + return TCL_ERROR; + } + if (legendPtr->selMarkPtr != elemPtr) { + Blt_ChainLink link, next; + + /* Deselect entry from the list all the way back to the anchor. */ + for (link = Blt_Chain_LastLink(legendPtr->selected); link != NULL; + link = next) { + Element *selectPtr; + + next = Blt_Chain_PrevLink(link); + selectPtr = Blt_Chain_GetValue(link); + if (selectPtr == legendPtr->selAnchorPtr) { + break; + } + DeselectElement(legendPtr, selectPtr); + } + legendPtr->flags &= ~SELECT_MASK; + legendPtr->flags |= SELECT_SET; + SelectRange(legendPtr, legendPtr->selAnchorPtr, elemPtr); + Tcl_SetStringObj(Tcl_GetObjResult(interp), elemPtr->obj.name, -1); + legendPtr->selMarkPtr = elemPtr; + + Blt_Legend_EventuallyRedraw(graphPtr); + if (legendPtr->selectCmd != NULL) { + EventuallyInvokeSelectCmd(legendPtr); + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SelectionPresentOp + * + * Returns 1 if there is a selection and 0 if it isn't. + * + * Results: + * A standard TCL result. interp->result will contain a boolean string + * indicating if there is a selection. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SelectionPresentOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + int bool; + + bool = (Blt_Chain_GetLength(legendPtr->selected) > 0); + Tcl_SetBooleanObj(Tcl_GetObjResult(interp), bool); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SelectionSetOp + * + * Selects, deselects, or toggles all of the elements in the range + * between first and last, inclusive, without affecting the selection + * state of elements outside that range. + * + * Results: + * None. + * + * Side effects: + * The selection changes. + * + * .g legend selection set first last + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SelectionSetOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Legend *legendPtr = graphPtr->legend; + Element *firstPtr, *lastPtr; + const char *string; + + legendPtr->flags &= ~SELECT_MASK; + string = Tcl_GetString(objv[3]); + switch (string[0]) { + case 's': + legendPtr->flags |= SELECT_SET; + break; + case 'c': + legendPtr->flags |= SELECT_CLEAR; + break; + case 't': + legendPtr->flags |= SELECT_TOGGLE; + break; + } + if (GetElementFromObj(graphPtr, objv[4], &firstPtr) != TCL_OK) { + return TCL_ERROR; + } + if ((firstPtr->flags & HIDE) && ((legendPtr->flags & SELECT_CLEAR)==0)) { + Tcl_AppendResult(interp, "can't select hidden node \"", + Tcl_GetString(objv[4]), "\"", (char *)NULL); + return TCL_ERROR; + } + lastPtr = firstPtr; + if (objc > 5) { + if (GetElementFromObj(graphPtr, objv[5], &lastPtr) != TCL_OK) { + return TCL_ERROR; + } + if ((lastPtr->flags & HIDE) && + ((legendPtr->flags & SELECT_CLEAR) == 0)) { + Tcl_AppendResult(interp, "can't select hidden node \"", + Tcl_GetString(objv[5]), "\"", (char *)NULL); + return TCL_ERROR; + } + } + if (firstPtr == lastPtr) { + SelectEntry(legendPtr, firstPtr); + } else { + SelectRange(legendPtr, firstPtr, lastPtr); + } + /* Set both the anchor and the mark. Indicates that a single entry is + * selected. */ + if (legendPtr->selAnchorPtr == NULL) { + legendPtr->selAnchorPtr = firstPtr; + } + if (legendPtr->flags & SELECT_EXPORT) { + Tk_OwnSelection(legendPtr->tkwin, XA_PRIMARY, LostSelectionProc, + legendPtr); + } + Blt_Legend_EventuallyRedraw(graphPtr); + if (legendPtr->selectCmd != NULL) { + EventuallyInvokeSelectCmd(legendPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SelectionOp -- + * + * This procedure handles the individual options for text selections. + * The selected text is designated by start and end indices into the text + * pool. The selected segment has both a anchored and unanchored ends. + * + * Results: + * None. + * + * Side effects: + * The selection changes. + * + * .g legend selection anchor + *--------------------------------------------------------------------------- + */ +static Blt_OpSpec selectionOps[] = +{ + {"anchor", 1, SelectionAnchorOp, 5, 5, "elem",}, + {"clear", 5, SelectionSetOp, 5, 6, "firstElem ?lastElem?",}, + {"clearall", 6, SelectionClearallOp, 4, 4, "",}, + {"includes", 1, SelectionIncludesOp, 5, 5, "elem",}, + {"mark", 1, SelectionMarkOp, 5, 5, "elem",}, + {"present", 1, SelectionPresentOp, 4, 4, "",}, + {"set", 1, SelectionSetOp, 5, 6, "firstElem ?lastElem?",}, + {"toggle", 1, SelectionSetOp, 5, 6, "firstElem ?lastElem?",}, +}; +static int nSelectionOps = sizeof(selectionOps) / sizeof(Blt_OpSpec); + +static int +SelectionOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + GraphLegendProc *proc; + int result; + + proc = Blt_GetOpFromObj(interp, nSelectionOps, selectionOps, BLT_OP_ARG3, + objc, objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + result = (*proc) (graphPtr, interp, objc, objv); + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_LegendOp -- + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Legend is possibly redrawn. + * + *--------------------------------------------------------------------------- + */ + +static Blt_OpSpec legendOps[] = +{ + {"activate", 1, ActivateOp, 3, 0, "?pattern?...",}, + {"bind", 1, BindOp, 3, 6, "elem sequence command",}, + {"cget", 2, CgetOp, 4, 4, "option",}, + {"configure", 2, ConfigureOp, 3, 0, "?option value?...",}, + {"curselection", 2, CurselectionOp, 3, 3, "",}, + {"deactivate", 1, ActivateOp, 3, 0, "?pattern?...",}, + {"focus", 1, FocusOp, 4, 4, "elem",}, + {"get", 1, GetOp, 4, 4, "elem",}, + {"icon", 1, IconOp, 5, 5, "elem image",}, + {"selection", 1, SelectionOp, 3, 0, "args"}, +}; +static int nLegendOps = sizeof(legendOps) / sizeof(Blt_OpSpec); + +int +Blt_LegendOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + GraphLegendProc *proc; + + proc = Blt_GetOpFromObj(interp, nLegendOps, legendOps, BLT_OP_ARG2, + objc, objv,0); + if (proc == NULL) { + return TCL_ERROR; + } + return (*proc) (graphPtr, interp, objc, objv); +} + +int +Blt_Legend_Site(Graph *graphPtr) +{ + return graphPtr->legend->site; +} + +int +Blt_Legend_Width(Graph *graphPtr) +{ + return graphPtr->legend->width; +} + +int +Blt_Legend_Height(Graph *graphPtr) +{ + return graphPtr->legend->height; +} + +int +Blt_Legend_IsHidden(Graph *graphPtr) +{ + return (graphPtr->legend->flags & HIDE); +} + +int +Blt_Legend_IsRaised(Graph *graphPtr) +{ + return (graphPtr->legend->flags & RAISED); +} + +int +Blt_Legend_X(Graph *graphPtr) +{ + return graphPtr->legend->x; +} + +int +Blt_Legend_Y(Graph *graphPtr) +{ + return graphPtr->legend->y; +} + +void +Blt_Legend_RemoveElement(Graph *graphPtr, Element *elemPtr) +{ + Blt_DeleteBindings(graphPtr->legend->bindTable, elemPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * SelectionProc -- + * + * This procedure is called back by Tk when the selection is requested by + * someone. It returns part or all of the selection in a buffer provided + * by the caller. + * + * Results: + * The return value is the number of non-NULL bytes stored at buffer. + * Buffer is filled (or partially filled) with a NUL-terminated string + * containing part or all of the selection, as given by offset and + * maxBytes. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static int +SelectionProc( + ClientData clientData, /* Information about the widget. */ + int offset, /* Offset within selection of first + * character to be returned. */ + char *buffer, /* Location in which to place + * selection. */ + int maxBytes) /* Maximum number of bytes to place at + * buffer, not including terminating + * NULL character. */ +{ + Legend *legendPtr = clientData; + int nBytes; + Tcl_DString dString; + + if ((legendPtr->flags & SELECT_EXPORT) == 0) { + return -1; + } + /* Retrieve the names of the selected entries. */ + Tcl_DStringInit(&dString); + if (legendPtr->flags & SELECT_SORTED) { + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(legendPtr->selected); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + Tcl_DStringAppend(&dString, elemPtr->obj.name, -1); + Tcl_DStringAppend(&dString, "\n", -1); + } + } else { + Blt_ChainLink link; + Graph *graphPtr; + + graphPtr = legendPtr->graphPtr; + /* List of selected entries is in stacking order. */ + for (link = Blt_Chain_FirstLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Element *elemPtr; + + elemPtr = Blt_Chain_GetValue(link); + if (EntryIsSelected(legendPtr, elemPtr)) { + Tcl_DStringAppend(&dString, elemPtr->obj.name, -1); + Tcl_DStringAppend(&dString, "\n", -1); + } + } + } + nBytes = Tcl_DStringLength(&dString) - offset; + strncpy(buffer, Tcl_DStringValue(&dString) + offset, maxBytes); + Tcl_DStringFree(&dString); + buffer[maxBytes] = '\0'; + return MIN(nBytes, maxBytes); +} + + +/* + *--------------------------------------------------------------------------- + * + * BlinkCursorProc -- + * + * This procedure is called as a timer handler to blink the insertion + * cursor off and on. + * + * Results: + * None. + * + * Side effects: + * The cursor gets turned on or off, redisplay gets invoked, and this + * procedure reschedules itself. + * + *--------------------------------------------------------------------------- + */ +static void +BlinkCursorProc(ClientData clientData) +{ + Graph *graphPtr = clientData; + Legend *legendPtr; + + legendPtr = graphPtr->legend; + if (!(legendPtr->flags & FOCUS) || (legendPtr->offTime == 0)) { + return; + } + if (legendPtr->active) { + int time; + + legendPtr->cursorOn ^= 1; + time = (legendPtr->cursorOn) ? legendPtr->onTime : legendPtr->offTime; + legendPtr->timerToken = Tcl_CreateTimerHandler(time, BlinkCursorProc, + graphPtr); + Blt_Legend_EventuallyRedraw(graphPtr); + } +} diff --git a/src/bltGrLegd.h b/src/bltGrLegd.h new file mode 100644 index 0000000..0ba1cb3 --- /dev/null +++ b/src/bltGrLegd.h @@ -0,0 +1,60 @@ +/* + * bltGrLegd.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_GR_LEGEND_H +#define _BLT_GR_LEGEND_H + +#define LEGEND_RIGHT (1<<0) /* Right margin */ +#define LEGEND_LEFT (1<<1) /* Left margin */ +#define LEGEND_BOTTOM (1<<2) /* Bottom margin */ +#define LEGEND_TOP (1<<3) /* Top margin, below the graph title. */ +#define LEGEND_PLOT (1<<4) /* Plot area */ +#define LEGEND_XY (1<<5) /* Screen coordinates in the plotting + * area. */ +#define LEGEND_WINDOW (1<<6) /* External window. */ +#define LEGEND_MARGIN_MASK \ + (LEGEND_RIGHT | LEGEND_LEFT | LEGEND_BOTTOM | LEGEND_TOP) +#define LEGEND_PLOTAREA_MASK (LEGEND_PLOT | LEGEND_XY) + +BLT_EXTERN int Blt_CreateLegend(Graph *graphPtr); +BLT_EXTERN void Blt_DestroyLegend(Graph *graphPtr); +BLT_EXTERN void Blt_DrawLegend(Graph *graphPtr, Drawable drawable); +BLT_EXTERN void Blt_MapLegend(Graph *graphPtr, int width, int height); +BLT_EXTERN int Blt_LegendOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); +BLT_EXTERN int Blt_Legend_Site(Graph *graphPtr); +BLT_EXTERN int Blt_Legend_Width(Graph *graphPtr); +BLT_EXTERN int Blt_Legend_Height(Graph *graphPtr); +BLT_EXTERN int Blt_Legend_IsHidden(Graph *graphPtr); +BLT_EXTERN int Blt_Legend_IsRaised(Graph *graphPtr); +BLT_EXTERN int Blt_Legend_X(Graph *graphPtr); +BLT_EXTERN int Blt_Legend_Y(Graph *graphPtr); +BLT_EXTERN void Blt_Legend_RemoveElement(Graph *graphPtr, Element *elemPtr); +BLT_EXTERN void Blt_Legend_EventuallyRedraw(Graph *graphPtr); + +#endif /* BLT_GR_LEGEND_H */ diff --git a/src/bltGrMarker.C b/src/bltGrMarker.C new file mode 100644 index 0000000..c9546f6 --- /dev/null +++ b/src/bltGrMarker.C @@ -0,0 +1,5196 @@ + +/* + * bltGrMarker.c -- + * + * This module implements markers for the BLT graph widget. + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include "bltOp.h" +#include "bltImage.h" +#include "bltPicture.h" +#include "bltPainter.h" +#include "bltChain.h" +#include "bltGrElem.h" +#include "bltBitmap.h" + +typedef int (GraphMarkerProc)(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +#define GETBITMAP(b) \ + (((b)->destBitmap == None) ? (b)->srcBitmap : (b)->destBitmap) + +#define MAX_OUTLINE_POINTS 12 + +#define IMAGE_PHOTO (1<<7) + +/* Map graph coordinates to normalized coordinates [0..1] */ +#define NORMALIZE(A,x) (((x) - (A)->axisRange.min) * (A)->axisRange.scale) + +#define DEF_MARKER_ANCHOR "center" +#define DEF_MARKER_BACKGROUND RGB_WHITE +#define DEF_MARKER_BITMAP (char *)NULL +#define DEF_MARKER_CAP_STYLE "butt" +#define DEF_MARKER_COORDS (char *)NULL +#define DEF_MARKER_DASHES (char *)NULL +#define DEF_MARKER_DASH_OFFSET "0" +#define DEF_MARKER_ELEMENT (char *)NULL +#define DEF_MARKER_FOREGROUND RGB_BLACK +#define DEF_MARKER_FILL_COLOR RGB_RED +#define DEF_MARKER_FONT STD_FONT +#define DEF_MARKER_GAP_COLOR RGB_PINK +#define DEF_MARKER_HEIGHT "0" +#define DEF_MARKER_HIDE "no" +#define DEF_MARKER_JOIN_STYLE "miter" +#define DEF_MARKER_JUSTIFY "left" +#define DEF_MARKER_LINE_WIDTH "1" +#define DEF_MARKER_MAP_X "x" +#define DEF_MARKER_MAP_Y "y" +#define DEF_MARKER_NAME (char *)NULL +#define DEF_MARKER_OUTLINE_COLOR RGB_BLACK +#define DEF_MARKER_PAD "4" +#define DEF_MARKER_ANGLE "0.0" +#define DEF_MARKER_SCALE "1.0" +#define DEF_MARKER_STATE "normal" +#define DEF_MARKER_STIPPLE (char *)NULL +#define DEF_MARKER_TEXT (char *)NULL +#define DEF_MARKER_UNDER "no" +#define DEF_MARKER_WIDTH "0" +#define DEF_MARKER_WINDOW (char *)NULL +#define DEF_MARKER_XOR "no" +#define DEF_MARKER_X_OFFSET "0" +#define DEF_MARKER_Y_OFFSET "0" +#define DEF_MARKER_FILTER "box" + +#define DEF_TEXT_TAGS "Text all" +#define DEF_IMAGE_TAGS "Image all" +#define DEF_BITMAP_TAGS "Bitmap all" +#define DEF_WINDOW_TAGS "Window all" +#define DEF_POLYGON_TAGS "Polygon all" +#define DEF_LINE_TAGS "Line all" + +static Blt_OptionParseProc ObjToCoordsProc; +static Blt_OptionPrintProc CoordsToObjProc; +static Blt_OptionFreeProc FreeCoordsProc; +static Blt_CustomOption coordsOption = +{ + ObjToCoordsProc, CoordsToObjProc, FreeCoordsProc, (ClientData)0 +}; +static Blt_OptionFreeProc FreeColorPairProc; +static Blt_OptionParseProc ObjToColorPairProc; +static Blt_OptionPrintProc ColorPairToObjProc; +static Blt_CustomOption colorPairOption = +{ + ObjToColorPairProc, ColorPairToObjProc, FreeColorPairProc, (ClientData)0 +}; + +static Blt_OptionParseProc ObjToPictImageProc; +static Blt_OptionPrintProc PictImageToObjProc; +static Blt_OptionFreeProc FreePictImageProc; +static Blt_CustomOption pictImageOption = +{ + ObjToPictImageProc, PictImageToObjProc, FreePictImageProc, (ClientData)0 +}; + +BLT_EXTERN Blt_CustomOption bltXAxisOption; +BLT_EXTERN Blt_CustomOption bltYAxisOption; +BLT_EXTERN Blt_CustomOption bltFilterOption; + +typedef Marker *(MarkerCreateProc)(void); +typedef void (MarkerDrawProc)(Marker *markerPtr, Drawable drawable); +typedef void (MarkerFreeProc)(Marker *markerPtr); +typedef int (MarkerConfigProc)(Marker *markerPtr); +typedef void (MarkerMapProc)(Marker *markerPtr); +typedef void (MarkerPostscriptProc)(Marker *markerPtr, Blt_Ps ps); +typedef int (MarkerPointProc)(Marker *markerPtr, Point2d *samplePtr); +typedef int (MarkerRegionProc)(Marker *markerPtr, Region2d *extsPtr, + int enclosed); + +static Tcl_FreeProc FreeMarker; + +typedef struct { + Blt_ConfigSpec *configSpecs; /* Marker configuration + * specifications */ + MarkerConfigProc *configProc; + MarkerDrawProc *drawProc; + MarkerFreeProc *freeProc; + MarkerMapProc *mapProc; + MarkerPointProc *pointProc; + MarkerRegionProc *regionProc; + MarkerPostscriptProc *postscriptProc; + +} MarkerClass; + +/* + *--------------------------------------------------------------------------- + * + * Marker -- + * + * Structure defining the generic marker. In C++ parlance this would be + * the base class from which all markers are derived. + * + * This structure corresponds with the specific types of markers. Don't + * change this structure without changing the individual marker + * structures of each type below. + * + * -------------------------------------------------------------------------- + */ +struct _Marker { + GraphObj obj; /* Must be first field in marker. */ + + MarkerClass *classPtr; + + Blt_HashEntry *hashPtr; + + Blt_ChainLink link; + + const char *elemName; /* Element associated with marker. Let's + * you link a marker to an element. The + * marker is drawn only if the element + * is also visible. */ + Axis2d axes; + Point2d *worldPts; /* Coordinate array to position + * marker */ + int nWorldPts; /* Number of points in above array */ + int drawUnder; /* If non-zero, draw the marker + * underneath any elements. This can be + * a performance penalty because the + * graph must be redraw entirely each + * time the marker is redrawn. */ + + int clipped; /* Indicates if the marker is totally + * clipped by the plotting area. */ + + unsigned int flags; + + + int xOffset, yOffset; /* Pixel offset from graph position */ + + int state; +}; +/* + *--------------------------------------------------------------------------- + * + * BitmapMarker -- + * + *--------------------------------------------------------------------------- + */ +typedef struct { + GraphObj obj; /* Must be first field in marker. */ + + MarkerClass *classPtr; + + Blt_HashEntry *hashPtr; + + Blt_ChainLink link; + + const char *elemName; /* Element associated with marker. Let's + * you link a marker to an element. The + * marker is drawn only if the element + * is also visible. */ + Axis2d axes; + + Point2d *worldPts; /* Coordinate array to position + * marker. */ + int nWorldPts; /* # of points in above array. */ + + int drawUnder; /* If non-zero, draw the marker + * underneath any elements. This can be + * a performance penalty because the + * graph must be redraw entirely each + * time the marker is redrawn. */ + + int clipped; /* Indicates if the marker is totally + * clipped by the plotting area. */ + + unsigned int flags; + + + int xOffset, yOffset; /* Pixel offset from graph position */ + + int state; + + /* Fields specific to bitmap markers. */ + + Pixmap srcBitmap; /* Original bitmap. May be further + * scaled or rotated. */ + float reqAngle; /* Requested rotation of the bitmap */ + float angle; /* Normalized rotation (0..360 + * degrees) */ + Tk_Anchor anchor; /* If only one X-Y coordinate is given, + * indicates how to translate the given + * marker position. Otherwise, if there + * are two X-Y coordinates, then this + * value is ignored. */ + Point2d anchorPt; /* Translated anchor point. */ + + XColor *outlineColor; /* Foreground color */ + XColor *fillColor; /* Background color */ + + GC gc; /* Private graphic context */ + GC fillGC; /* Shared graphic context */ + Pixmap destBitmap; /* Bitmap to be drawn. */ + int destWidth, destHeight; /* Dimensions of the final bitmap */ + + Point2d outline[MAX_OUTLINE_POINTS];/* Polygon representing the background + * of the bitmap. */ + int nOutlinePts; +} BitmapMarker; + +static Blt_ConfigSpec bitmapConfigSpecs[] = +{ + {BLT_CONFIG_ANCHOR, "-anchor", "anchor", "Anchor", DEF_MARKER_ANCHOR, + Blt_Offset(BitmapMarker, anchor), 0}, + {BLT_CONFIG_COLOR, "-background", "background", "Background", + DEF_MARKER_BACKGROUND, Blt_Offset(BitmapMarker, fillColor), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-bg", "background", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_BITMAP_TAGS, + Blt_Offset(BitmapMarker, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BITMAP, "-bitmap", "bitmap", "Bitmap", DEF_MARKER_BITMAP, + Blt_Offset(BitmapMarker, srcBitmap), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-coords", "coords", "Coords", DEF_MARKER_COORDS, + Blt_Offset(BitmapMarker, worldPts), BLT_CONFIG_NULL_OK, + &coordsOption}, + {BLT_CONFIG_STRING, "-element", "element", "Element", DEF_MARKER_ELEMENT, + Blt_Offset(BitmapMarker, elemName), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-fg", "foreground", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_SYNONYM, "-fill", "background", (char *)NULL, (char *)NULL, + 0, 0}, + {BLT_CONFIG_COLOR, "-foreground", "foreground", "Foreground", + DEF_MARKER_FOREGROUND, Blt_Offset(BitmapMarker, outlineColor), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_MARKER_HIDE, + Blt_Offset(BitmapMarker, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", DEF_MARKER_MAP_X, + Blt_Offset(BitmapMarker, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", DEF_MARKER_MAP_Y, + Blt_Offset(BitmapMarker, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_STRING, "-name", (char *)NULL, (char *)NULL, DEF_MARKER_NAME, + Blt_Offset(BitmapMarker, obj.name), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-outline", "foreground", (char *)NULL, (char *)NULL, + 0, 0}, + {BLT_CONFIG_FLOAT, "-rotate", "rotate", "Rotate", DEF_MARKER_ANGLE, + Blt_Offset(BitmapMarker, reqAngle), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STATE, "-state", "state", "State", DEF_MARKER_STATE, + Blt_Offset(BitmapMarker, state), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-under", "under", "Under", DEF_MARKER_UNDER, + Blt_Offset(BitmapMarker, drawUnder), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-xoffset", "xOffset", "XOffset", DEF_MARKER_X_OFFSET, + Blt_Offset(BitmapMarker, xOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-yoffset", "yOffset", "YOffset", DEF_MARKER_Y_OFFSET, + Blt_Offset(BitmapMarker, yOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static MarkerConfigProc ConfigureBitmapProc; +static MarkerCreateProc CreateBitmapProc; +static MarkerDrawProc DrawBitmapProc; +static MarkerFreeProc FreeBitmapProc; +static MarkerMapProc MapBitmapProc; +static MarkerPointProc PointInBitmapProc; +static MarkerPostscriptProc BitmapToPostscriptProc; +static MarkerRegionProc RegionInBitmapProc; + +static MarkerClass bitmapMarkerClass = { + bitmapConfigSpecs, + ConfigureBitmapProc, + DrawBitmapProc, + FreeBitmapProc, + MapBitmapProc, + PointInBitmapProc, + RegionInBitmapProc, + BitmapToPostscriptProc, +}; + +/* + *--------------------------------------------------------------------------- + * + * ImageMarker -- + * + *--------------------------------------------------------------------------- + */ +typedef struct { + GraphObj obj; /* Must be first field in marker. */ + + MarkerClass *classPtr; + + Blt_HashEntry *hashPtr; + + Blt_ChainLink link; + + const char *elemName; /* Element associated with marker. Let's + * you link a marker to an element. The + * marker is drawn only if the element + * is also visible. */ + Axis2d axes; + + Point2d *worldPts; /* Coordinate array to position + * marker. */ + + int nWorldPts; /* # of points in above array. */ + + int drawUnder; /* If non-zero, draw the marker + * underneath any elements. This can be + * a performance penalty because the + * graph must be redraw entirely each + * time the marker is redrawn. */ + + int clipped; /* Indicates if the marker is totally + * clipped by the plotting area. */ + + unsigned int flags; + + + int xOffset, yOffset; /* Pixel offset from graph position */ + + int state; + + Tk_Image tkImage; /* Tk image to be displayed. */ + Tk_Anchor anchor; /* Indicates how to translate the given + * marker position. */ + Point2d anchorPt; /* Translated anchor point. */ + int width, height; /* Dimensions of the possibly scaled + * image. */ + Blt_Painter painter; + Blt_Picture picture; + Blt_ResampleFilter filter; + int pictX, pictY; /* */ + Blt_Picture scaled; /* Pixmap containing the scaled image */ + GC gc; + +} ImageMarker; + +static Blt_ConfigSpec imageConfigSpecs[] = +{ + {BLT_CONFIG_ANCHOR, "-anchor", "anchor", "Anchor", DEF_MARKER_ANCHOR, + Blt_Offset(ImageMarker, anchor), 0}, + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_IMAGE_TAGS, + Blt_Offset(ImageMarker, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-coords", "coords", "Coords", DEF_MARKER_COORDS, + Blt_Offset(ImageMarker, worldPts), BLT_CONFIG_NULL_OK, &coordsOption}, + {BLT_CONFIG_STRING, "-element", "element", "Element", DEF_MARKER_ELEMENT, + Blt_Offset(ImageMarker, elemName), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_MARKER_HIDE, + Blt_Offset(ImageMarker, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_CUSTOM, "-image", "image", "Image", (char *)NULL, + Blt_Offset(ImageMarker, picture), BLT_CONFIG_NULL_OK, &pictImageOption}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", DEF_MARKER_MAP_X, + Blt_Offset(ImageMarker, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", DEF_MARKER_MAP_Y, + Blt_Offset(ImageMarker, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_STRING, "-name", (char *)NULL, (char *)NULL, DEF_MARKER_NAME, + Blt_Offset(ImageMarker, obj.name), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-resamplefilter", "resampleFilter", "ResampleFilter", + DEF_MARKER_FILTER, Blt_Offset(ImageMarker, filter), + BLT_CONFIG_NULL_OK | BLT_CONFIG_DONT_SET_DEFAULT, &bltFilterOption}, + {BLT_CONFIG_STATE, "-state", "state", "State", DEF_MARKER_STATE, + Blt_Offset(ImageMarker, state), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-under", "under", "Under", DEF_MARKER_UNDER, + Blt_Offset(ImageMarker, drawUnder), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-xoffset", "xOffset", "XOffset", DEF_MARKER_X_OFFSET, + Blt_Offset(ImageMarker, xOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-yoffset", "yOffset", "YOffset", DEF_MARKER_Y_OFFSET, + Blt_Offset(ImageMarker, yOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static MarkerConfigProc ConfigureImageProc; +static MarkerCreateProc CreateImageProc; +static MarkerDrawProc DrawImageProc; +static MarkerFreeProc FreeImageProc; +static MarkerMapProc MapImageProc; +static MarkerPointProc PointInImageProc; +static MarkerPostscriptProc ImageToPostscriptProc; +static MarkerRegionProc RegionInImageProc; + +static MarkerClass imageMarkerClass = { + imageConfigSpecs, + ConfigureImageProc, + DrawImageProc, + FreeImageProc, + MapImageProc, + PointInImageProc, + RegionInImageProc, + ImageToPostscriptProc, +}; + +/* + *--------------------------------------------------------------------------- + * + * LineMarker -- + * + *--------------------------------------------------------------------------- + */ +typedef struct { + GraphObj obj; /* Must be first field in marker. */ + + MarkerClass *classPtr; + + Blt_HashEntry *hashPtr; + + Blt_ChainLink link; + + const char *elemName; /* Element associated with marker. Let's + * you link a marker to an element. The + * marker is drawn only if the element + * is also visible. */ + Axis2d axes; + + Point2d *worldPts; /* Coordinate array to position + * marker. */ + + int nWorldPts; /* Number of points in above array */ + + int drawUnder; /* If non-zero, draw the marker + * underneath any elements. This can be + * a performance penalty because the + * graph must be redraw entirely each + * time the marker is redrawn. */ + + int clipped; /* Indicates if the marker is totally + * clipped by the plotting area. */ + + unsigned int flags; + + + int xOffset, yOffset; /* Pixel offset from graph position */ + + int state; + + XColor *fillColor; + XColor *outlineColor; /* Foreground and background colors */ + + int lineWidth; /* Line width. */ + int capStyle; /* Cap style. */ + int joinStyle; /* Join style.*/ + Blt_Dashes dashes; /* Dash list values (max 11) */ + + GC gc; /* Private graphic context */ + + Segment2d *segments; /* Malloc'ed array of points. + * Represents individual line segments + * (2 points per segment) comprising the + * mapped line. The segments may not + * necessarily be connected after + * clipping. */ + int nSegments; /* # segments in the above array. */ + int xor; + int xorState; /* State of the XOR drawing. Indicates + * if the marker is currently drawn. */ +} LineMarker; + +static Blt_ConfigSpec lineConfigSpecs[] = +{ + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_LINE_TAGS, + Blt_Offset(LineMarker, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CAP_STYLE, "-cap", "cap", "Cap", DEF_MARKER_CAP_STYLE, + Blt_Offset(LineMarker, capStyle), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-coords", "coords", "Coords", DEF_MARKER_COORDS, + Blt_Offset(LineMarker, worldPts), BLT_CONFIG_NULL_OK, &coordsOption}, + {BLT_CONFIG_DASHES, "-dashes", "dashes", "Dashes", DEF_MARKER_DASHES, + Blt_Offset(LineMarker, dashes), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_PIXELS_NNEG, "-dashoffset", "dashOffset", "DashOffset", + DEF_MARKER_DASH_OFFSET, Blt_Offset(LineMarker, dashes.offset), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-element", "element", "Element", DEF_MARKER_ELEMENT, + Blt_Offset(LineMarker, elemName), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-fill", "fill", "Fill", (char *)NULL, + Blt_Offset(LineMarker, fillColor), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_JOIN_STYLE, "-join", "join", "Join", DEF_MARKER_JOIN_STYLE, + Blt_Offset(LineMarker, joinStyle), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-linewidth", "lineWidth", "LineWidth", + DEF_MARKER_LINE_WIDTH, Blt_Offset(LineMarker, lineWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_MARKER_HIDE, + Blt_Offset(LineMarker, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", DEF_MARKER_MAP_X, + Blt_Offset(LineMarker, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", DEF_MARKER_MAP_Y, + Blt_Offset(LineMarker, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_STRING, "-name", (char *)NULL, (char *)NULL, DEF_MARKER_NAME, + Blt_Offset(LineMarker, obj.name), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_COLOR, "-outline", "outline", "Outline", + DEF_MARKER_OUTLINE_COLOR, Blt_Offset(LineMarker, outlineColor), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STATE, "-state", "state", "State", DEF_MARKER_STATE, + Blt_Offset(LineMarker, state), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-under", "under", "Under", DEF_MARKER_UNDER, + Blt_Offset(LineMarker, drawUnder), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-xoffset", "xOffset", "XOffset", DEF_MARKER_X_OFFSET, + Blt_Offset(LineMarker, xOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-xor", "xor", "Xor", DEF_MARKER_XOR, + Blt_Offset(LineMarker, xor), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-yoffset", "yOffset", "YOffset", DEF_MARKER_Y_OFFSET, + Blt_Offset(LineMarker, yOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static MarkerConfigProc ConfigureLineProc; +static MarkerCreateProc CreateLineProc; +static MarkerDrawProc DrawLineProc; +static MarkerFreeProc FreeLineProc; +static MarkerMapProc MapLineProc; +static MarkerPointProc PointInLineProc; +static MarkerPostscriptProc LineToPostscriptProc; +static MarkerRegionProc RegionInLineProc; + +static MarkerClass lineMarkerClass = { + lineConfigSpecs, + ConfigureLineProc, + DrawLineProc, + FreeLineProc, + MapLineProc, + PointInLineProc, + RegionInLineProc, + LineToPostscriptProc, +}; + +/* + *--------------------------------------------------------------------------- + * + * PolygonMarker -- + * + *--------------------------------------------------------------------------- + */ +typedef struct { + GraphObj obj; /* Must be first field in marker. */ + + MarkerClass *classPtr; + + Blt_HashEntry *hashPtr; + + Blt_ChainLink link; + + const char *elemName; /* Element associated with marker. Let's + * you link a marker to an element. The + * marker is drawn only if the element + * is also visible. */ + Axis2d axes; + + Point2d *worldPts; /* Coordinate array to position + * marker. */ + + int nWorldPts; /* Number of points in above array */ + + int drawUnder; /* If non-zero, draw the marker + * underneath any elements. This can be + * a performance penalty because the + * graph must be redraw entirely each + * time the marker is redrawn. */ + + int clipped; /* Indicates if the marker is totally + * clipped by the plotting area. */ + + unsigned int flags; + + + int xOffset, yOffset; /* Pixel offset from graph position */ + + int state; + + Point2d *screenPts; /* Array of points representing the + * polygon in screen coordinates. It's + * not used for drawing, but to generate + * the outlinePts and fillPts arrays + * that are the coordinates of the + * possibly clipped outline and filled + * polygon. */ + + ColorPair outline; + ColorPair fill; + + Pixmap stipple; /* Stipple pattern to fill the + * polygon. */ + int lineWidth; /* Width of polygon outline. */ + int capStyle; + int joinStyle; + Blt_Dashes dashes; /* List of dash values. Indicates how + * to draw the dashed line. If no dash + * values are provided, or the first + * value is zero, then the line is drawn + * solid. */ + + GC outlineGC; /* Graphics context to draw the outline + * of the polygon. */ + GC fillGC; /* Graphics context to draw the filled + * polygon. */ + + Point2d *fillPts; /* Malloc'ed array of points used to + * draw the filled polygon. These points + * may form a degenerate polygon after + * clipping. */ + int nFillPts; /* # points in the above array. */ + Segment2d *outlinePts; /* Malloc'ed array of points. + * Represents individual line segments + * (2 points per segment) comprising the + * outline of the polygon. The segments + * may not necessarily be closed or + * connected after clipping. */ + int nOutlinePts; /* # points in the above array. */ + int xor; + int xorState; /* State of the XOR drawing. Indicates + * if the marker is visible. We have to + * drawn it again to erase it. */ +} PolygonMarker; + +static Blt_ConfigSpec polygonConfigSpecs[] = +{ + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_POLYGON_TAGS, + Blt_Offset(PolygonMarker, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CAP_STYLE, "-cap", "cap", "Cap", DEF_MARKER_CAP_STYLE, + Blt_Offset(PolygonMarker, capStyle), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_CUSTOM, "-coords", "coords", "Coords", DEF_MARKER_COORDS, + Blt_Offset(PolygonMarker, worldPts), BLT_CONFIG_NULL_OK, &coordsOption}, + {BLT_CONFIG_DASHES, "-dashes", "dashes", "Dashes", DEF_MARKER_DASHES, + Blt_Offset(PolygonMarker, dashes), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STRING, "-element", "element", "Element", DEF_MARKER_ELEMENT, + Blt_Offset(PolygonMarker, elemName), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-fill", "fill", "Fill", DEF_MARKER_FILL_COLOR, + Blt_Offset(PolygonMarker, fill), BLT_CONFIG_NULL_OK, &colorPairOption}, + {BLT_CONFIG_JOIN_STYLE, "-join", "join", "Join", DEF_MARKER_JOIN_STYLE, + Blt_Offset(PolygonMarker, joinStyle), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-linewidth", "lineWidth", "LineWidth", + DEF_MARKER_LINE_WIDTH, Blt_Offset(PolygonMarker, lineWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_MARKER_HIDE, + Blt_Offset(PolygonMarker, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", DEF_MARKER_MAP_X, + Blt_Offset(PolygonMarker, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", DEF_MARKER_MAP_Y, + Blt_Offset(PolygonMarker, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_STRING, "-name", (char *)NULL, (char *)NULL, DEF_MARKER_NAME, + Blt_Offset(PolygonMarker, obj.name), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-outline", "outline", "Outline", + DEF_MARKER_OUTLINE_COLOR, Blt_Offset(PolygonMarker, outline), + BLT_CONFIG_NULL_OK, &colorPairOption}, + {BLT_CONFIG_STATE, "-state", "state", "State", DEF_MARKER_STATE, + Blt_Offset(PolygonMarker, state), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMAP, "-stipple", "stipple", "Stipple", DEF_MARKER_STIPPLE, + Blt_Offset(PolygonMarker, stipple), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BOOLEAN, "-under", "under", "Under", DEF_MARKER_UNDER, + Blt_Offset(PolygonMarker, drawUnder), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-xoffset", "xOffset", "XOffset", DEF_MARKER_X_OFFSET, + Blt_Offset(PolygonMarker, xOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-xor", "xor", "Xor", DEF_MARKER_XOR, + Blt_Offset(PolygonMarker, xor), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-yoffset", "yOffset", "YOffset", DEF_MARKER_Y_OFFSET, + Blt_Offset(PolygonMarker, yOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static MarkerConfigProc ConfigurePolygonProc; +static MarkerCreateProc CreatePolygonProc; +static MarkerDrawProc DrawPolygonProc; +static MarkerFreeProc FreePolygonProc; +static MarkerMapProc MapPolygonProc; +static MarkerPointProc PointInPolygonProc; +static MarkerPostscriptProc PolygonToPostscriptProc; +static MarkerRegionProc RegionInPolygonProc; + +static MarkerClass polygonMarkerClass = { + polygonConfigSpecs, + ConfigurePolygonProc, + DrawPolygonProc, + FreePolygonProc, + MapPolygonProc, + PointInPolygonProc, + RegionInPolygonProc, + PolygonToPostscriptProc, +}; + + +/* + *--------------------------------------------------------------------------- + * + * TextMarker -- + * + *--------------------------------------------------------------------------- + */ +typedef struct { + GraphObj obj; /* Must be first field in marker. */ + MarkerClass *classPtr; + Blt_HashEntry *hashPtr; + Blt_ChainLink link; + const char *elemName; /* Element associated with marker. Let's + * you link a marker to an element. The + * marker is drawn only if the element + * is also visible. */ + Axis2d axes; + Point2d *worldPts; /* Coordinate array to position + * marker. */ + int nWorldPts; /* # of points in above array */ + int drawUnder; /* If non-zero, draw the marker + * underneath any elements. This can be + * a performance penalty because the + * graph must be redraw entirely each + * time the marker is redrawn. */ + int clipped; /* Indicates if the marker is totally + * clipped by the plotting area. */ + unsigned int flags; + + + int xOffset, yOffset; /* Pixel offset from graph position */ + int state; + + /* Fields specific to text markers. */ +#ifdef notdef + const char *textVarName; /* Name of variable (malloc'ed) or + * NULL. If non-NULL, graph displays the + * contents of this variable. */ +#endif + const char *string; /* Text string to be display. The + * string make contain newlines. */ + Tk_Anchor anchor; /* Indicates how to translate the given + * marker position. */ + Point2d anchorPt; /* Translated anchor point. */ + int width, height; /* Dimension of bounding box. */ + TextStyle style; /* Text attributes (font, fg, anchor, + * etc) */ + Point2d outline[5]; + XColor *fillColor; + GC fillGC; +} TextMarker; + + +static Blt_ConfigSpec textConfigSpecs[] = +{ + {BLT_CONFIG_ANCHOR, "-anchor", "anchor", "Anchor", DEF_MARKER_ANCHOR, + Blt_Offset(TextMarker, anchor), 0}, + {BLT_CONFIG_COLOR, "-background", "background", "MarkerBackground", + (char *)NULL, Blt_Offset(TextMarker, fillColor), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-bg", "background", "Background", (char *)NULL, 0, 0}, + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_TEXT_TAGS, + Blt_Offset(TextMarker, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-coords", "coords", "Coords", DEF_MARKER_COORDS, + Blt_Offset(TextMarker, worldPts), BLT_CONFIG_NULL_OK, + &coordsOption}, + {BLT_CONFIG_STRING, "-element", "element", "Element", + DEF_MARKER_ELEMENT, Blt_Offset(TextMarker, elemName), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-fg", "foreground", "Foreground", (char *)NULL, 0, 0}, + {BLT_CONFIG_SYNONYM, "-fill", "background", (char *)NULL, (char *)NULL, + 0, 0}, + {BLT_CONFIG_FONT, "-font", "font", "Font", DEF_MARKER_FONT, + Blt_Offset(TextMarker, style.font), 0}, + {BLT_CONFIG_COLOR, "-foreground", "foreground", "Foreground", + DEF_MARKER_FOREGROUND, Blt_Offset(TextMarker, style.color), 0}, + {BLT_CONFIG_JUSTIFY, "-justify", "justify", "Justify", + DEF_MARKER_JUSTIFY, Blt_Offset(TextMarker, style.justify), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_MARKER_HIDE, + Blt_Offset(TextMarker, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", DEF_MARKER_MAP_X, + Blt_Offset(TextMarker, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", DEF_MARKER_MAP_Y, + Blt_Offset(TextMarker, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_STRING, "-name", (char *)NULL, (char *)NULL, DEF_MARKER_NAME, + Blt_Offset(TextMarker, obj.name), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-outline", "foreground", (char *)NULL, (char *)NULL, + 0, 0}, + {BLT_CONFIG_PAD, "-padx", "padX", "PadX", DEF_MARKER_PAD, + Blt_Offset(TextMarker, style.xPad), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PAD, "-pady", "padY", "PadY", DEF_MARKER_PAD, + Blt_Offset(TextMarker, style.yPad), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_FLOAT, "-rotate", "rotate", "Rotate", DEF_MARKER_ANGLE, + Blt_Offset(TextMarker, style.angle), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STATE, "-state", "state", "State", DEF_MARKER_STATE, + Blt_Offset(TextMarker, state), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-text", "text", "Text", DEF_MARKER_TEXT, + Blt_Offset(TextMarker, string), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BOOLEAN, "-under", "under", "Under", DEF_MARKER_UNDER, + Blt_Offset(TextMarker, drawUnder), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-xoffset", "xOffset", "XOffset", DEF_MARKER_X_OFFSET, + Blt_Offset(TextMarker, xOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-yoffset", "yOffset", "YOffset", DEF_MARKER_Y_OFFSET, + Blt_Offset(TextMarker, yOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static MarkerConfigProc ConfigureTextProc; +static MarkerCreateProc CreateTextProc; +static MarkerDrawProc DrawTextProc; +static MarkerFreeProc FreeTextProc; +static MarkerMapProc MapTextProc; +static MarkerPointProc PointInTextProc; +static MarkerPostscriptProc TextToPostscriptProc; +static MarkerRegionProc RegionInTextProc; + +static MarkerClass textMarkerClass = { + textConfigSpecs, + ConfigureTextProc, + DrawTextProc, + FreeTextProc, + MapTextProc, + PointInTextProc, + RegionInTextProc, + TextToPostscriptProc, +}; + +/* + *--------------------------------------------------------------------------- + * + * WindowMarker -- + * + *--------------------------------------------------------------------------- + */ +typedef struct { + GraphObj obj; /* Must be first field in marker. */ + + MarkerClass *classPtr; + + Blt_HashEntry *hashPtr; + + Blt_ChainLink link; + + const char *elemName; /* Element associated with marker. Let's + * you link a marker to an element. The + * marker is drawn only if the element + * is also visible. */ + Axis2d axes; + + Point2d *worldPts; /* Coordinate array to position + * marker */ + + int nWorldPts; /* # of points in above array */ + + int drawUnder; /* If non-zero, draw the marker + * underneath any elements. This can be + * a performance penalty because the + * graph must be redraw entirely each + * time the marker is redrawn. */ + + int clipped; /* Indicates if the marker is totally + * clipped by the plotting area. */ + + unsigned int flags; + + + int xOffset, yOffset; /* Pixel offset from graph position */ + + int state; + + /* Fields specific to window markers. */ + + const char *childName; /* Name of child widget. */ + Tk_Window child; /* Window to display. */ + int reqWidth, reqHeight; /* If non-zero, this overrides the size + * requested by the child widget. */ + + Tk_Anchor anchor; /* Indicates how to translate the given + * marker position. */ + + Point2d anchorPt; /* Translated anchor point. */ + int width, height; /* Current size of the child window. */ + +} WindowMarker; + +static Blt_ConfigSpec windowConfigSpecs[] = +{ + {BLT_CONFIG_ANCHOR, "-anchor", "anchor", "Anchor", DEF_MARKER_ANCHOR, + Blt_Offset(WindowMarker, anchor), 0}, + {BLT_CONFIG_LIST, "-bindtags", "bindTags", "BindTags", DEF_WINDOW_TAGS, + Blt_Offset(WindowMarker, obj.tags), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_CUSTOM, "-coords", "coords", "Coords", DEF_MARKER_COORDS, + Blt_Offset(WindowMarker, worldPts), BLT_CONFIG_NULL_OK, + &coordsOption}, + {BLT_CONFIG_STRING, "-element", "element", "Element", DEF_MARKER_ELEMENT, + Blt_Offset(WindowMarker, elemName), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_PIXELS_POS, "-height", "height", "Height", DEF_MARKER_HEIGHT, + Blt_Offset(WindowMarker, reqHeight), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-hide", "hide", "Hide", DEF_MARKER_HIDE, + Blt_Offset(WindowMarker, flags), BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)HIDE}, + {BLT_CONFIG_CUSTOM, "-mapx", "mapX", "MapX", DEF_MARKER_MAP_X, + Blt_Offset(WindowMarker, axes.x), 0, &bltXAxisOption}, + {BLT_CONFIG_CUSTOM, "-mapy", "mapY", "MapY", DEF_MARKER_MAP_Y, + Blt_Offset(WindowMarker, axes.y), 0, &bltYAxisOption}, + {BLT_CONFIG_STRING, "-name", (char *)NULL, (char *)NULL, DEF_MARKER_NAME, + Blt_Offset(WindowMarker, obj.name), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STATE, "-state", "state", "State", DEF_MARKER_STATE, + Blt_Offset(WindowMarker, state), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-under", "under", "Under", DEF_MARKER_UNDER, + Blt_Offset(WindowMarker, drawUnder), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_POS, "-width", "width", "Width", DEF_MARKER_WIDTH, + Blt_Offset(WindowMarker, reqWidth), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-window", "window", "Window", DEF_MARKER_WINDOW, + Blt_Offset(WindowMarker, childName), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_PIXELS, "-xoffset", "xOffset", "XOffset", DEF_MARKER_X_OFFSET, + Blt_Offset(WindowMarker, xOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS, "-yoffset", "yOffset", "YOffset", DEF_MARKER_Y_OFFSET, + Blt_Offset(WindowMarker, yOffset), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static MarkerConfigProc ConfigureWindowProc; +static MarkerCreateProc CreateWindowProc; +static MarkerDrawProc DrawWindowProc; +static MarkerFreeProc FreeWindowProc; +static MarkerMapProc MapWindowProc; +static MarkerPointProc PointInWindowProc; +static MarkerPostscriptProc WindowToPostscriptProc; +static MarkerRegionProc RegionInWindowProc; + +static MarkerClass windowMarkerClass = { + windowConfigSpecs, + ConfigureWindowProc, + DrawWindowProc, + FreeWindowProc, + MapWindowProc, + PointInWindowProc, + RegionInWindowProc, + WindowToPostscriptProc, +}; + +static Tk_ImageChangedProc ImageChangedProc; + + + +#ifdef notdef +static MarkerClass rectangleMarkerClass = { + rectangleConfigSpecs, + ConfigureRectangleProc, + DrawRectangleProc, + FreeRectangleProc, + MapRectangleProc, + PointInRectangleProc, + RegionInRectangleProc, + RectangleToPostscriptProc, +}; + +static MarkerClass ovalMarkerClass = { + ovalConfigSpecs, + ConfigureOvalProc, + DrawOvalProc, + FreeOvalProc, + MapOvalProc, + PointInOvalProc, + RegionInOvalProc, + OvalToPostscriptProc, +}; +#endif + +/* + *--------------------------------------------------------------------------- + * + * BoxesDontOverlap -- + * + * Tests if the bounding box of a marker overlaps the plotting area in + * any way. If so, the marker will be drawn. Just do a min/max test on + * the extents of both boxes. + * + * Note: It's assumed that the extents of the bounding box lie + * within the area. So for a 10x10 rectangle, bottom and + * left would be 9. + * + * Results: + * Returns 0 is the marker is visible in the plotting area, and 1 + * otherwise (marker is clipped). + * + *--------------------------------------------------------------------------- + */ +static int +BoxesDontOverlap(Graph *graphPtr, Region2d *extsPtr) +{ + assert(extsPtr->right >= extsPtr->left); + assert(extsPtr->bottom >= extsPtr->top); + assert(graphPtr->right >= graphPtr->left); + assert(graphPtr->bottom >= graphPtr->top); + + return (((double)graphPtr->right < extsPtr->left) || + ((double)graphPtr->bottom < extsPtr->top) || + (extsPtr->right < (double)graphPtr->left) || + (extsPtr->bottom < (double)graphPtr->top)); +} + + +/* + *--------------------------------------------------------------------------- + * + * GetCoordinate -- + * + * Convert the expression string into a floating point value. The * only + * reason we use this routine instead of Blt_ExprDouble is to * handle + * "elastic" bounds. That is, convert the strings "-Inf", * "Inf" into + * -(DBL_MAX) and DBL_MAX respectively. + * + * Results: + * The return value is a standard TCL result. The value of the + * expression is passed back via valuePtr. + * + *--------------------------------------------------------------------------- + */ +static int +GetCoordinate( + Tcl_Interp *interp, /* Interpreter to return results */ + Tcl_Obj *objPtr, /* Numeric expression string to + * parse */ + double *valuePtr) /* Real-valued result of expression */ +{ + char c; + const char *expr; + + expr = Tcl_GetString(objPtr); + c = expr[0]; + if ((c == 'I') && (strcmp(expr, "Inf") == 0)) { + *valuePtr = DBL_MAX; /* Elastic upper bound */ + } else if ((c == '-') && (expr[1] == 'I') && (strcmp(expr, "-Inf") == 0)) { + *valuePtr = -DBL_MAX; /* Elastic lower bound */ + } else if ((c == '+') && (expr[1] == 'I') && (strcmp(expr, "+Inf") == 0)) { + *valuePtr = DBL_MAX; /* Elastic upper bound */ + } else if (Blt_ExprDoubleFromObj(interp, objPtr, valuePtr) != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * PrintCoordinate -- + * + * Convert the floating point value into its string representation. The + * only reason this routine is used in instead of sprintf, is to handle + * the "elastic" bounds. That is, convert the values DBL_MAX and + * -(DBL_MAX) into "+Inf" and "-Inf" respectively. + * + * Results: + * The return value is a standard TCL result. The string of the * + * expression is passed back via string. + * + * -------------------------------------------------------------------------- */ +static Tcl_Obj * +PrintCoordinate(double x) +{ + if (x == DBL_MAX) { + return Tcl_NewStringObj("+Inf", -1); + } else if (x == -DBL_MAX) { + return Tcl_NewStringObj("-Inf", -1); + } else { + return Tcl_NewDoubleObj(x); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ParseCoordinates -- + * + * The TCL coordinate list is converted to their floating point + * values. It will then replace the current marker coordinates. + * + * Since different marker types require different number of coordinates + * this must be checked here. + * + * Results: + * The return value is a standard TCL result. + * + * Side effects: + * If the marker coordinates are reset, the graph is eventually redrawn + * with at the new marker coordinates. + * + *--------------------------------------------------------------------------- + */ +static int +ParseCoordinates( + Tcl_Interp *interp, + Marker *markerPtr, + int objc, + Tcl_Obj *const *objv) +{ + int nWorldPts; + int minArgs, maxArgs; + Point2d *worldPts; + int i; + + if (objc == 0) { + return TCL_OK; + } + if (objc & 1) { + Tcl_AppendResult(interp, "odd number of marker coordinates specified", + (char *)NULL); + return TCL_ERROR; + } + switch (markerPtr->obj.classId) { + case CID_MARKER_LINE: + minArgs = 4, maxArgs = 0; + break; + case CID_MARKER_POLYGON: + minArgs = 6, maxArgs = 0; + break; + case CID_MARKER_WINDOW: + case CID_MARKER_TEXT: + minArgs = 2, maxArgs = 2; + break; + case CID_MARKER_IMAGE: + case CID_MARKER_BITMAP: + minArgs = 2, maxArgs = 4; + break; + default: + Tcl_AppendResult(interp, "unknown marker type", (char *)NULL); + return TCL_ERROR; + } + + if (objc < minArgs) { + Tcl_AppendResult(interp, "too few marker coordinates specified", + (char *)NULL); + return TCL_ERROR; + } + if ((maxArgs > 0) && (objc > maxArgs)) { + Tcl_AppendResult(interp, "too many marker coordinates specified", + (char *)NULL); + return TCL_ERROR; + } + nWorldPts = objc / 2; + worldPts = Blt_Malloc(nWorldPts * sizeof(Point2d)); + if (worldPts == NULL) { + Tcl_AppendResult(interp, "can't allocate new coordinate array", + (char *)NULL); + return TCL_ERROR; + } + + { + Point2d *pp; + + pp = worldPts; + for (i = 0; i < objc; i += 2) { + double x, y; + + if ((GetCoordinate(interp, objv[i], &x) != TCL_OK) || + (GetCoordinate(interp, objv[i + 1], &y) != TCL_OK)) { + Blt_Free(worldPts); + return TCL_ERROR; + } + pp->x = x, pp->y = y, pp++; + } + } + /* Don't free the old coordinate array until we've parsed the new + * coordinates without errors. */ + if (markerPtr->worldPts != NULL) { + Blt_Free(markerPtr->worldPts); + } + markerPtr->worldPts = worldPts; + markerPtr->nWorldPts = nWorldPts; + markerPtr->flags |= MAP_ITEM; + return TCL_OK; +} + +/*ARGSUSED*/ +static void +FreeCoordsProc( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + Marker *markerPtr = (Marker *)widgRec; + Point2d **pointsPtr = (Point2d **)(widgRec + offset); + + if (*pointsPtr != NULL) { + Blt_Free(*pointsPtr); + *pointsPtr = NULL; + } + markerPtr->nWorldPts = 0; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToCoordsProc -- + * + * Given a TCL list of numeric expression representing the element + * values, convert into an array of floating point values. In addition, + * the minimum and maximum values are saved. Since elastic values are + * allow (values which translate to the min/max of the graph), we must + * try to get the non-elastic minimum and maximum. + * + * Results: + * The return value is a standard TCL result. The vector is + * passed back via the vecPtr. + * + * -------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToCoordsProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to return results */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* TCL list of numeric expressions */ + char *widgRec, /* Marker record */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Marker *markerPtr = (Marker *)widgRec; + int objc; + Tcl_Obj **objv; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if (objc == 0) { + return TCL_OK; + } + return ParseCoordinates(interp, markerPtr, objc, objv); +} + +/* + *--------------------------------------------------------------------------- + * + * CoordsToObjProc -- + * + * Convert the vector of floating point values into a TCL list. + * + * Results: + * The string representation of the vector is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +CoordsToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Marker record */ + int offset, /* Not used. */ + int flags) /* Not used. */ +{ + Marker *markerPtr = (Marker *)widgRec; + Tcl_Obj *listObjPtr; + Point2d *pp, *pend; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (pp = markerPtr->worldPts, pend = pp + markerPtr->nWorldPts; pp < pend; + pp++) { + Tcl_ListObjAppendElement(interp, listObjPtr, PrintCoordinate(pp->x)); + Tcl_ListObjAppendElement(interp, listObjPtr, PrintCoordinate(pp->y)); + } + return listObjPtr; +} + +/*LINTLIBRARY*/ +static int +GetColorPair( + Tcl_Interp *interp, + Tk_Window tkwin, + Tcl_Obj *fgObjPtr, Tcl_Obj *bgObjPtr, + ColorPair *pairPtr, + int allowDefault) +{ + XColor *fgColor, *bgColor; + const char *string; + + fgColor = bgColor = NULL; + if (fgObjPtr != NULL) { + int length; + + string = Tcl_GetStringFromObj(fgObjPtr, &length); + if (string[0] == '\0') { + fgColor = NULL; + } else if ((allowDefault) && (string[0] == 'd') && + (strncmp(string, "defcolor", length) == 0)) { + fgColor = COLOR_DEFAULT; + } else { + fgColor = Tk_AllocColorFromObj(interp, tkwin, fgObjPtr); + if (fgColor == NULL) { + return TCL_ERROR; + } + } + } + if (bgObjPtr != NULL) { + int length; + + string = Tcl_GetStringFromObj(bgObjPtr, &length); + if (string[0] == '\0') { + bgColor = NULL; + } else if ((allowDefault) && (string[0] == 'd') && + (strncmp(string, "defcolor", length) == 0)) { + bgColor = COLOR_DEFAULT; + } else { + bgColor = Tk_AllocColorFromObj(interp, tkwin, bgObjPtr); + if (bgColor == NULL) { + return TCL_ERROR; + } + } + } + if (pairPtr->fgColor != NULL) { + Tk_FreeColor(pairPtr->fgColor); + } + if (pairPtr->bgColor != NULL) { + Tk_FreeColor(pairPtr->bgColor); + } + pairPtr->fgColor = fgColor; + pairPtr->bgColor = bgColor; + return TCL_OK; +} + +void +Blt_FreeColorPair(ColorPair *pairPtr) +{ + if ((pairPtr->bgColor != NULL) && (pairPtr->bgColor != COLOR_DEFAULT)) { + Tk_FreeColor(pairPtr->bgColor); + } + if ((pairPtr->fgColor != NULL) && (pairPtr->fgColor != COLOR_DEFAULT)) { + Tk_FreeColor(pairPtr->fgColor); + } + pairPtr->bgColor = pairPtr->fgColor = NULL; +} + +static void +FreeColorPairProc( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + ColorPair *pairPtr = (ColorPair *)(widgRec + offset); + + Blt_FreeColorPair(pairPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToColorPairProc -- + * + * Convert the color names into pair of XColor pointers. + * + * Results: + * A standard TCL result. The color pointer is written into the + * widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToColorPairProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to return results */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing color */ + char *widgRec, /* Widget record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + ColorPair *pairPtr = (ColorPair *)(widgRec + offset); + long longValue = (long)clientData; + int bool; + int objc; + Tcl_Obj **objv; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if (objc > 2) { + Tcl_AppendResult(interp, "too many names in colors list", + (char *)NULL); + return TCL_ERROR; + } + if (objc == 0) { + Blt_FreeColorPair(pairPtr); + return TCL_OK; + } + bool = (int)longValue; + if (objc == 1) { + if (GetColorPair(interp, tkwin, objv[0], NULL, pairPtr, bool) + != TCL_OK) { + return TCL_ERROR; + } + } else { + if (GetColorPair(interp, tkwin, objv[0], objv[1], pairPtr, bool) + != TCL_OK) { + return TCL_ERROR; + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NameOfColor -- + * + * Convert the color option value into a string. + * + * Results: + * The static string representing the color option is returned. + * + *--------------------------------------------------------------------------- + */ +static const char * +NameOfColor(XColor *colorPtr) +{ + if (colorPtr == NULL) { + return ""; + } else if (colorPtr == COLOR_DEFAULT) { + return "defcolor"; + } else { + return Tk_NameOfColor(colorPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ColorPairToObjProc -- + * + * Convert the color pairs into color names. + * + * Results: + * The string representing the symbol color is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +ColorPairToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Element information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + ColorPair *pairPtr = (ColorPair *)(widgRec + offset); + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(NameOfColor(pairPtr->fgColor), -1)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(NameOfColor(pairPtr->bgColor), -1)); + return listObjPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ImageChangedProc + * + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static void +ImageChangedProc( + ClientData clientData, + int x, int y, int w, int h, /* Not used. */ + int imageWidth, int imageHeight) /* Not used. */ +{ + Graph *graphPtr; + ImageMarker *imPtr = clientData; + int isPhoto; + + graphPtr = imPtr->obj.graphPtr; + if ((imPtr->picture != NULL) && (imPtr->flags & IMAGE_PHOTO)) { + Blt_FreePicture(imPtr->picture); + } + imPtr->picture = NULL; + imPtr->flags &= ~IMAGE_PHOTO; + if (Blt_Image_IsDeleted(imPtr->tkImage)) { + Tk_FreeImage(imPtr->tkImage); + imPtr->tkImage = NULL; + return; + } + imPtr->picture = Blt_GetPictureFromImage(graphPtr->interp, imPtr->tkImage, + &isPhoto); + if (isPhoto) { + imPtr->flags |= IMAGE_PHOTO; + } + graphPtr->flags |= CACHE_DIRTY; + imPtr->flags |= MAP_ITEM; + Blt_EventuallyRedrawGraph(graphPtr); +} + +/*ARGSUSED*/ +static void +FreePictImageProc( + ClientData clientData, + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + ImageMarker *imPtr = (ImageMarker *)widgRec; + + if ((imPtr->picture != NULL) && (imPtr->flags & IMAGE_PHOTO)) { + Blt_FreePicture(imPtr->picture); + } + imPtr->picture = NULL; + if (imPtr->tkImage != NULL) { + Tk_FreeImage(imPtr->tkImage); + } + imPtr->tkImage = NULL; + imPtr->flags &= ~IMAGE_PHOTO; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToPictImageProc -- + * + * Given an image name, get the Tk image associated with it. + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToPictImageProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to return results */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representation of value. */ + char *widgRec, /* Widget record. */ + int offset, /* Offset to field in structure */ + int flags) +{ + Blt_Picture *picturePtr = (Blt_Picture *)(widgRec + offset); + Graph *graphPtr; + ImageMarker *imPtr = (ImageMarker *)widgRec; + Tk_Image tkImage; + const char *name; + int isPhoto; + + name = Tcl_GetString(objPtr); + tkImage = Tk_GetImage(interp, tkwin, name, ImageChangedProc, imPtr); + if (tkImage == NULL) { + return TCL_ERROR; + } + if (imPtr->tkImage != NULL) { + Tk_FreeImage(imPtr->tkImage); + } + imPtr->flags &= ~IMAGE_PHOTO; + if (*picturePtr != NULL) { + Blt_FreePicture(*picturePtr); + } + *picturePtr = NULL; + imPtr->tkImage = tkImage; + graphPtr = imPtr->obj.graphPtr; + *picturePtr = Blt_GetPictureFromImage(graphPtr->interp, tkImage, &isPhoto); + if (isPhoto) { + imPtr->flags |= IMAGE_PHOTO; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * PictImageToObjProc -- + * + * Convert the image name into a string Tcl_Obj. + * + * Results: + * The string representation of the image is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +PictImageToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Widget record */ + int offset, /* Offset to field in structure */ + int flags) +{ + ImageMarker *imPtr = (ImageMarker *)(widgRec); + + if (imPtr->tkImage == NULL) { + return Tcl_NewStringObj("", -1); + } + return Tcl_NewStringObj(Blt_Image_Name(imPtr->tkImage), -1); +} + +static INLINE int +IsElementHidden(Marker *markerPtr) +{ + Blt_HashEntry *hPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + + /* Look up the named element and see if it's hidden */ + hPtr = Blt_FindHashEntry(&graphPtr->elements.table, markerPtr->elemName); + if (hPtr != NULL) { + Element *elemPtr; + + elemPtr = Blt_GetHashValue(hPtr); + if ((elemPtr->link == NULL) || (elemPtr->flags & HIDE)) { + return TRUE; + } + } + return FALSE; +} + +/* + *--------------------------------------------------------------------------- + * + * HMap -- + * + * Maps the given graph coordinate value to its axis, returning a window + * position. This is a slight variation on the normal Blt_HMap routine. + * It treats -Inf as the minimum axis value and Inf as the maximum. + * + * Results: + * Returns a floating point number representing the window coordinate + * position on the given axis. + * + * -------------------------------------------------------------------------- + */ +static double +HMap(Axis *axisPtr, double x) +{ + if (x == DBL_MAX) { + x = 1.0; + } else if (x == -DBL_MAX) { + x = 0.0; + } else { + if (axisPtr->logScale) { + if (x > 0.0) { + x = log10(x); + } else if (x < 0.0) { + x = 0.0; + } + } + x = NORMALIZE(axisPtr, x); + } + if (axisPtr->descending) { + x = 1.0 - x; + } + /* Horizontal transformation */ + return (x * axisPtr->screenRange + axisPtr->screenMin); +} + +/* + *--------------------------------------------------------------------------- + * + * VMap -- + * + * Map the given graph coordinate value to its axis, returning a window + * position. This is a slight variation on the normal Blt_VMap routine. + * It treats -Inf as the minimum axis value and Inf as the maximum. + * + * Results: + * Returns a double precision number representing the window coordinate + * position on the given axis. + * + *--------------------------------------------------------------------------- + */ +static double +VMap(Axis *axisPtr, double y) +{ + if (y == DBL_MAX) { + y = 1.0; + } else if (y == -DBL_MAX) { + y = 0.0; + } else { + if (axisPtr->logScale) { + if (y > 0.0) { + y = log10(y); + } else if (y < 0.0) { + y = 0.0; + } + } + y = NORMALIZE(axisPtr, y); + } + if (axisPtr->descending) { + y = 1.0 - y; + } + /* Vertical transformation. */ + return (((1.0 - y) * axisPtr->screenRange) + axisPtr->screenMin); +} + +/* + *--------------------------------------------------------------------------- + * + * MapPoint -- + * + * Maps the given graph x,y coordinate values to a window position. + * + * Results: + * Returns a XPoint structure containing the window coordinates of the + * given graph x,y coordinate. + * + *--------------------------------------------------------------------------- + */ +static Point2d +MapPoint( + Point2d *pointPtr, /* Graph X-Y coordinate. */ + Axis2d *axesPtr) /* Specifies which axes to use */ +{ + Point2d result; + Graph *graphPtr = axesPtr->y->obj.graphPtr; + + if (graphPtr->inverted) { + result.x = HMap(axesPtr->y, pointPtr->y); + result.y = VMap(axesPtr->x, pointPtr->x); + } else { + result.x = HMap(axesPtr->x, pointPtr->x); + result.y = VMap(axesPtr->y, pointPtr->y); + } + return result; /* Result is screen coordinate. */ +} + +static Marker * +CreateMarker( + Graph *graphPtr, + const char *name, + ClassId classId) +{ + Marker *markerPtr; + + /* Create the new marker based upon the given type */ + switch (classId) { + case CID_MARKER_BITMAP: + markerPtr = CreateBitmapProc(); /* bitmap */ + break; + case CID_MARKER_LINE: + markerPtr = CreateLineProc(); /* line */ + break; + case CID_MARKER_IMAGE: + markerPtr = CreateImageProc(); /* image */ + break; + case CID_MARKER_TEXT: + markerPtr = CreateTextProc(); /* text */ + break; + case CID_MARKER_POLYGON: + markerPtr = CreatePolygonProc(); /* polygon */ + break; + case CID_MARKER_WINDOW: + markerPtr = CreateWindowProc(); /* window */ + break; + default: + return NULL; + } + markerPtr->obj.graphPtr = graphPtr; + markerPtr->drawUnder = FALSE; + markerPtr->flags |= MAP_ITEM; + markerPtr->obj.name = Blt_AssertStrdup(name); + Blt_GraphSetObjectClass(&markerPtr->obj, classId); + return markerPtr; +} + + +static void +DestroyMarker(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + + if (markerPtr->drawUnder) { + /* If the marker to be deleted is currently displayed below the + * elements, then backing store needs to be repaired. */ + graphPtr->flags |= CACHE_DIRTY; + } + /* + * Call the marker's type-specific deallocation routine. We do it first + * while all the marker fields are still valid. + */ + (*markerPtr->classPtr->freeProc)(markerPtr); + + /* Dump any bindings that might be registered for the marker. */ + Blt_DeleteBindings(graphPtr->bindTable, markerPtr); + + /* Release all the X resources associated with the marker. */ + Blt_FreeOptions(markerPtr->classPtr->configSpecs, (char *)markerPtr, + graphPtr->display, 0); + + if (markerPtr->hashPtr != NULL) { + Blt_DeleteHashEntry(&graphPtr->markers.table, + markerPtr->hashPtr); + } + if (markerPtr->link != NULL) { + Blt_Chain_DeleteLink(graphPtr->markers.displayList, markerPtr->link); + } + if (markerPtr->obj.name != NULL) { + Blt_Free(markerPtr->obj.name); + } + Blt_Free(markerPtr); +} + +static void +FreeMarker(DestroyData dataPtr) +{ + Marker *markerPtr = (Marker *)dataPtr; + DestroyMarker(markerPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureBitmapProc -- + * + * This procedure is called to process an objv/objc list, plus the Tk + * option database, in order to configure (or reconfigure) a bitmap + * marker. + * + * Results: + * A standard TCL result. If TCL_ERROR is returned, then interp->result + * contains an error message. + * + * Side effects: + * Configuration information, such as bitmap pixmap, colors, rotation, + * etc. get set for markerPtr; old resources get freed, if there were + * any. The marker is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static int +ConfigureBitmapProc(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + BitmapMarker *bmPtr = (BitmapMarker *)markerPtr; + GC newGC; + XGCValues gcValues; + unsigned long gcMask; + + if (bmPtr->srcBitmap == None) { + return TCL_OK; + } + bmPtr->angle = FMOD(bmPtr->reqAngle, 360.0); + if (bmPtr->angle < 0.0) { + bmPtr->angle += 360.0; + } + gcMask = 0; + + if (bmPtr->outlineColor != NULL) { + gcMask |= GCForeground; + gcValues.foreground = bmPtr->outlineColor->pixel; + } + + if (bmPtr->fillColor != NULL) { + /* Opaque bitmap: both foreground and background (fill) colors + * are used. */ + gcValues.background = bmPtr->fillColor->pixel; + gcMask |= GCBackground; + } else { + /* Transparent bitmap: set the clip mask to the current bitmap. */ + gcValues.clip_mask = bmPtr->srcBitmap; + gcMask |= GCClipMask; + } + + /* + * This is technically a shared GC, but we're going to set/change the clip + * origin anyways before we draw the bitmap. This relies on the fact that + * no other client will be allocated this GC with the GCClipMask set to + * this particular bitmap. + */ + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (bmPtr->gc != NULL) { + Tk_FreeGC(graphPtr->display, bmPtr->gc); + } + bmPtr->gc = newGC; + + /* Create the background GC containing the fill color. */ + + if (bmPtr->fillColor != NULL) { + gcValues.foreground = bmPtr->fillColor->pixel; + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (bmPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, bmPtr->fillGC); + } + bmPtr->fillGC = newGC; + } + + markerPtr->flags |= MAP_ITEM; + if (markerPtr->drawUnder) { + graphPtr->flags |= CACHE_DIRTY; + } + + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +#ifdef notdef +static void +PrintPolyPoint(char *mesg, Point2d *points, int nPoints) +{ + int i; + + fprintf(stderr, "%s:\t\tpoint[0]=%g,%g\n", mesg, points[0].x, points[0].y); + for (i = 1; i < nPoints; i++) { + fprintf(stderr, "\t\tpoint[%d]=%g,%g\n", i, points[i].x, points[i].y); + } +} +#endif + +/* + *--------------------------------------------------------------------------- + * + * MapBitmapProc -- + * + * This procedure gets called each time the layout of the graph changes. + * The x, y window coordinates of the bitmap marker are saved in the + * marker structure. + * + * Additionly, if no background color was specified, the + * GCTileStipXOrigin and GCTileStipYOrigin attributes are set in the + * private GC. + * + * Results: + * None. + * + * Side effects: + * Window coordinates are saved and if no background color was set, the + * GC stipple origins are changed to calculated window coordinates. + * + *--------------------------------------------------------------------------- + */ +static void +MapBitmapProc(Marker *markerPtr) +{ + BitmapMarker *bmPtr = (BitmapMarker *)markerPtr; + Region2d extents; + Graph *graphPtr = markerPtr->obj.graphPtr; + Point2d anchorPt; + Point2d corner1, corner2; + int destWidth, destHeight; + int srcWidth, srcHeight; + int i; + + if (bmPtr->srcBitmap == None) { + return; + } + if (bmPtr->destBitmap != None) { + Tk_FreePixmap(graphPtr->display, bmPtr->destBitmap); + bmPtr->destBitmap = None; + } + /* + * Collect the coordinates. The number of coordinates will determine the + * calculations to be made. + * + * x1 y1 A single pair of X-Y coordinates. They represent + * the anchor position of the bitmap. + * + * x1 y1 x2 y2 Two pairs of X-Y coordinates. They represent + * two opposite corners of a bounding rectangle. The + * bitmap is possibly rotated and scaled to fit into + * this box. + * + */ + Tk_SizeOfBitmap(graphPtr->display, bmPtr->srcBitmap, &srcWidth, + &srcHeight); + corner1 = MapPoint(markerPtr->worldPts, &markerPtr->axes); + if (markerPtr->nWorldPts > 1) { + double hold; + + corner2 = MapPoint(markerPtr->worldPts + 1, &markerPtr->axes); + /* Flip the corners if necessary */ + if (corner1.x > corner2.x) { + hold = corner1.x, corner1.x = corner2.x, corner2.x = hold; + } + if (corner1.y > corner2.y) { + hold = corner1.y, corner1.y = corner2.y, corner2.y = hold; + } + } else { + corner2.x = corner1.x + srcWidth - 1; + corner2.y = corner1.y + srcHeight - 1; + } + destWidth = (int)(corner2.x - corner1.x) + 1; + destHeight = (int)(corner2.y - corner1.y) + 1; + + if (markerPtr->nWorldPts == 1) { + anchorPt = Blt_AnchorPoint(corner1.x, corner1.y, (double)destWidth, + (double)destHeight, bmPtr->anchor); + } else { + anchorPt = corner1; + } + anchorPt.x += markerPtr->xOffset; + anchorPt.y += markerPtr->yOffset; + + /* Check if the bitmap sits at least partially in the plot area. */ + extents.left = anchorPt.x; + extents.top = anchorPt.y; + extents.right = anchorPt.x + destWidth - 1; + extents.bottom = anchorPt.y + destHeight - 1; + markerPtr->clipped = BoxesDontOverlap(graphPtr, &extents); + if (markerPtr->clipped) { + return; /* Bitmap is offscreen. Don't generate + * rotated or scaled bitmaps. */ + } + + /* + * Scale the bitmap if necessary. It's a little tricky because we only + * want to scale what's visible on the screen, not the entire bitmap. + */ + if ((bmPtr->angle != 0.0f) || (destWidth != srcWidth) || + (destHeight != srcHeight)) { + int regionX, regionY, regionWidth, regionHeight; + double left, right, top, bottom; + + /* Ignore parts of the bitmap outside of the plot area. */ + left = MAX(graphPtr->left, extents.left); + right = MIN(graphPtr->right, extents.right); + top = MAX(graphPtr->top, extents.top); + bottom = MIN(graphPtr->bottom, extents.bottom); + + /* Determine the portion of the scaled bitmap to display. */ + regionX = regionY = 0; + if (graphPtr->left > extents.left) { + regionX = (int)(graphPtr->left - extents.left); + } + if (graphPtr->top > extents.top) { + regionY = (int)(graphPtr->top - extents.top); + } + regionWidth = (int)(right - left) + 1; + regionHeight = (int)(bottom - top) + 1; + + anchorPt.x = left; + anchorPt.y = top; + bmPtr->destBitmap = Blt_ScaleRotateBitmapArea(graphPtr->tkwin, + bmPtr->srcBitmap, srcWidth, srcHeight, regionX, regionY, + regionWidth, regionHeight, destWidth, destHeight, bmPtr->angle); + bmPtr->destWidth = regionWidth; + bmPtr->destHeight = regionHeight; + } else { + bmPtr->destWidth = srcWidth; + bmPtr->destHeight = srcHeight; + bmPtr->destBitmap = None; + } + bmPtr->anchorPt = anchorPt; + { + double xScale, yScale; + double tx, ty; + double rotWidth, rotHeight; + Point2d polygon[5]; + int n; + + /* + * Compute a polygon to represent the background area of the bitmap. + * This is needed for backgrounds of arbitrarily rotated bitmaps. We + * also use it to print a background in PostScript. + */ + Blt_GetBoundingBox(srcWidth, srcHeight, bmPtr->angle, &rotWidth, + &rotHeight, polygon); + xScale = (double)destWidth / rotWidth; + yScale = (double)destHeight / rotHeight; + + /* + * Adjust each point of the polygon. Both scale it to the new size and + * translate it to the actual screen position of the bitmap. + */ + tx = extents.left + destWidth * 0.5; + ty = extents.top + destHeight * 0.5; + for (i = 0; i < 4; i++) { + polygon[i].x = (polygon[i].x * xScale) + tx; + polygon[i].y = (polygon[i].y * yScale) + ty; + } + Blt_GraphExtents(graphPtr, &extents); + n = Blt_PolyRectClip(&extents, polygon, 4, bmPtr->outline); + assert(n <= MAX_OUTLINE_POINTS); + if (n < 3) { + memcpy(&bmPtr->outline, polygon, sizeof(Point2d) * 4); + bmPtr->nOutlinePts = 4; + } else { + bmPtr->nOutlinePts = n; + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * PointInBitmapProc -- + * + * Indicates if the given point is over the bitmap marker. The area of + * the bitmap is the rectangle. + * + * Results: + * Returns 1 is the point is over the bitmap marker, 0 otherwise. + * + *--------------------------------------------------------------------------- + */ +static int +PointInBitmapProc(Marker *markerPtr, Point2d *samplePtr) +{ + BitmapMarker *bmPtr = (BitmapMarker *)markerPtr; + + if (bmPtr->srcBitmap == None) { + return 0; + } + if (bmPtr->angle != 0.0f) { + Point2d points[MAX_OUTLINE_POINTS]; + int i; + + /* + * Generate the bounding polygon (isolateral) for the bitmap and see + * if the point is inside of it. + */ + for (i = 0; i < bmPtr->nOutlinePts; i++) { + points[i].x = bmPtr->outline[i].x + bmPtr->anchorPt.x; + points[i].y = bmPtr->outline[i].y + bmPtr->anchorPt.y; + } + return Blt_PointInPolygon(samplePtr, points, bmPtr->nOutlinePts); + } + return ((samplePtr->x >= bmPtr->anchorPt.x) && + (samplePtr->x < (bmPtr->anchorPt.x + bmPtr->destWidth)) && + (samplePtr->y >= bmPtr->anchorPt.y) && + (samplePtr->y < (bmPtr->anchorPt.y + bmPtr->destHeight))); +} + + +/* + *--------------------------------------------------------------------------- + * + * RegionInBitmapProc -- + * + *--------------------------------------------------------------------------- + */ +static int +RegionInBitmapProc(Marker *markerPtr, Region2d *extsPtr, int enclosed) +{ + BitmapMarker *bmPtr = (BitmapMarker *)markerPtr; + + if (markerPtr->nWorldPts < 1) { + return FALSE; + } + if (bmPtr->angle != 0.0f) { + Point2d points[MAX_OUTLINE_POINTS]; + int i; + + /* + * Generate the bounding polygon (isolateral) for the bitmap and see + * if the point is inside of it. + */ + for (i = 0; i < bmPtr->nOutlinePts; i++) { + points[i].x = bmPtr->outline[i].x + bmPtr->anchorPt.x; + points[i].y = bmPtr->outline[i].y + bmPtr->anchorPt.y; + } + return Blt_RegionInPolygon(extsPtr, points, bmPtr->nOutlinePts, + enclosed); + } + if (enclosed) { + return ((bmPtr->anchorPt.x >= extsPtr->left) && + (bmPtr->anchorPt.y >= extsPtr->top) && + ((bmPtr->anchorPt.x + bmPtr->destWidth) <= extsPtr->right) && + ((bmPtr->anchorPt.y + bmPtr->destHeight) <= extsPtr->bottom)); + } + return !((bmPtr->anchorPt.x >= extsPtr->right) || + (bmPtr->anchorPt.y >= extsPtr->bottom) || + ((bmPtr->anchorPt.x + bmPtr->destWidth) <= extsPtr->left) || + ((bmPtr->anchorPt.y + bmPtr->destHeight) <= extsPtr->top)); +} + +/* + *--------------------------------------------------------------------------- + * + * DrawBitmapProc -- + * + * Draws the bitmap marker that have a transparent of filled background. + * + * Results: + * None. + * + * Side effects: + * GC stipple origins are changed to current window coordinates. + * Commands are output to X to draw the marker in its current mode. + * + *--------------------------------------------------------------------------- + */ +static void +DrawBitmapProc(Marker *markerPtr, Drawable drawable) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + BitmapMarker *bmPtr = (BitmapMarker *)markerPtr; + double rangle; + Pixmap bitmap; + + bitmap = GETBITMAP(bmPtr); + if ((bitmap == None) || (bmPtr->destWidth < 1) || (bmPtr->destHeight < 1)) { + return; + } + rangle = FMOD(bmPtr->angle, 90.0); + if ((bmPtr->fillColor == NULL) || (rangle != 0.0)) { + + /* + * If the bitmap is rotated and a filled background is required, then + * a filled polygon is drawn before the bitmap. + */ + if (bmPtr->fillColor != NULL) { + int i; + XPoint polygon[MAX_OUTLINE_POINTS]; + + for (i = 0; i < bmPtr->nOutlinePts; i++) { + polygon[i].x = (short int)bmPtr->outline[i].x; + polygon[i].y = (short int)bmPtr->outline[i].y; + } + XFillPolygon(graphPtr->display, drawable, bmPtr->fillGC, + polygon, bmPtr->nOutlinePts, Convex, CoordModeOrigin); + } + XSetClipMask(graphPtr->display, bmPtr->gc, bitmap); + XSetClipOrigin(graphPtr->display, bmPtr->gc, (int)bmPtr->anchorPt.x, + (int)bmPtr->anchorPt.y); + } else { + XSetClipMask(graphPtr->display, bmPtr->gc, None); + XSetClipOrigin(graphPtr->display, bmPtr->gc, 0, 0); + } + XCopyPlane(graphPtr->display, bitmap, drawable, bmPtr->gc, 0, 0, + bmPtr->destWidth, bmPtr->destHeight, (int)bmPtr->anchorPt.x, + (int)bmPtr->anchorPt.y, 1); +} + +/* + *--------------------------------------------------------------------------- + * + * BitmapToPostscriptProc -- + * + * Generates PostScript to print a bitmap marker. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +BitmapToPostscriptProc(Marker *markerPtr, Blt_Ps ps) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + BitmapMarker *bmPtr = (BitmapMarker *)markerPtr; + Pixmap bitmap; + + bitmap = GETBITMAP(bmPtr); + if ((bitmap == None) || (bmPtr->destWidth < 1) || (bmPtr->destHeight < 1)) { + return; /* No bitmap to display. */ + } + if (bmPtr->fillColor != NULL) { + Blt_Ps_XSetBackground(ps, bmPtr->fillColor); + Blt_Ps_XFillPolygon(ps, bmPtr->outline, 4); + } + Blt_Ps_XSetForeground(ps, bmPtr->outlineColor); + + Blt_Ps_Format(ps, + " gsave\n %g %g translate\n %d %d scale\n", + bmPtr->anchorPt.x, bmPtr->anchorPt.y + bmPtr->destHeight, + bmPtr->destWidth, -bmPtr->destHeight); + Blt_Ps_Format(ps, " %d %d true [%d 0 0 %d 0 %d] {", + bmPtr->destWidth, bmPtr->destHeight, bmPtr->destWidth, + -bmPtr->destHeight, bmPtr->destHeight); + Blt_Ps_XSetBitmapData(ps, graphPtr->display, bitmap, + bmPtr->destWidth, bmPtr->destHeight); + Blt_Ps_VarAppend(ps, + " } imagemask\n", + "grestore\n", (char *)NULL); +} + +/* + *--------------------------------------------------------------------------- + * + * FreeBitmapProc -- + * + * Releases the memory and attributes of the bitmap marker. + * + * Results: + * None. + * + * Side effects: + * Bitmap attributes (GCs, colors, bitmap, etc) get destroyed. Memory is + * released, X resources are freed, and the graph is redrawn. + * + *--------------------------------------------------------------------------- + */ +static void +FreeBitmapProc(Marker *markerPtr) +{ + BitmapMarker *bmPtr = (BitmapMarker *)markerPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + + if (bmPtr->gc != NULL) { + Tk_FreeGC(graphPtr->display, bmPtr->gc); + } + if (bmPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, bmPtr->fillGC); + } + if (bmPtr->destBitmap != None) { + Tk_FreePixmap(graphPtr->display, bmPtr->destBitmap); + } +} + +/* + *--------------------------------------------------------------------------- + * + * CreateBitmapProc -- + * + * Allocate memory and initialize methods for the new bitmap marker. + * + * Results: + * The pointer to the newly allocated marker structure is returned. + * + * Side effects: + * Memory is allocated for the bitmap marker structure. + * + *--------------------------------------------------------------------------- + */ +static Marker * +CreateBitmapProc(void) +{ + BitmapMarker *bmPtr; + + bmPtr = Blt_AssertCalloc(1, sizeof(BitmapMarker)); + bmPtr->classPtr = &bitmapMarkerClass; + return (Marker *)bmPtr; +} + + +/* + *--------------------------------------------------------------------------- + * + * ConfigureImageProc -- + * + * This procedure is called to process an objv/objc list, plus the Tk + * option database, in order to configure (or reconfigure) a image + * marker. + * + * Results: + * A standard TCL result. If TCL_ERROR is returned, then interp->result + * contains an error message. + * + * Side effects: + * Configuration information, such as image pixmap, colors, rotation, + * etc. get set for markerPtr; old resources get freed, if there were + * any. The marker is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureImageProc(Marker *markerPtr) +{ + ImageMarker *imPtr = (ImageMarker *)markerPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + Blt_Painter painter; + GC newGC; + + newGC = Tk_GetGC(graphPtr->tkwin, 0L, (XGCValues *)NULL); + if (imPtr->gc != NULL) { + Tk_FreeGC(graphPtr->display, imPtr->gc); + } + imPtr->gc = newGC; + + painter = Blt_GetPainter(graphPtr->tkwin, 1.0); + if (imPtr->painter != NULL) { + Blt_FreePainter(painter); + } + imPtr->painter = painter; + markerPtr->flags |= MAP_ITEM; + if (markerPtr->drawUnder) { + graphPtr->flags |= CACHE_DIRTY; + } + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * MapImageProc -- + * + * This procedure gets called each time the layout of the graph changes. + * The x, y window coordinates of the image marker are saved in the + * marker structure. + * + * In addition, if no background color was specified, the + * GCTileStipXOrigin and GCTileStipYOrigin attributes will not set in the + * private GC. + * + * Results: + * None. + * + * Side effects: + * Window coordinates are saved and if no background color was set, the + * GC stipple origins are changed to calculated window coordinates. + * + *--------------------------------------------------------------------------- + */ +static void +MapImageProc(Marker *markerPtr) +{ + Region2d extents; + Graph *graphPtr; + ImageMarker *imPtr; + Point2d anchorPt; + Point2d c1, c2; + int newWidth, newHeight; + int srcWidth, srcHeight; + int x, y, w, h; + int left, right, top, bottom; + + imPtr = (ImageMarker *)markerPtr; + if (imPtr->picture == NULL) { + return; + } + if (imPtr->scaled != NULL) { + Blt_FreePicture(imPtr->scaled); + imPtr->scaled = NULL; + } + graphPtr = markerPtr->obj.graphPtr; + c1 = MapPoint(markerPtr->worldPts, &markerPtr->axes); + + imPtr->width = srcWidth = Blt_PictureWidth(imPtr->picture); + imPtr->height = srcHeight = Blt_PictureHeight(imPtr->picture); + + if ((srcWidth == 0) || (srcHeight == 0)) { + markerPtr->clipped = TRUE; + return; /* Empty image. */ + } + if (markerPtr->nWorldPts > 1) { + double hold; + + c2 = MapPoint(markerPtr->worldPts + 1, &markerPtr->axes); + /* Flip the corners if necessary */ + if (c1.x > c2.x) { + hold = c1.x, c1.x = c2.x, c2.x = hold; + } + if (c1.y > c2.y) { + hold = c1.y, c1.y = c2.y, c2.y = hold; + } + } else { + c2.x = c1.x + srcWidth - 1; + c2.y = c1.y + srcHeight - 1; + } + newWidth = (int)(c2.x - c1.x) + 1; + newHeight = (int)(c2.y - c1.y) + 1; + + if (markerPtr->nWorldPts == 1) { + anchorPt = Blt_AnchorPoint(c1.x, c1.y, (double)newWidth, + (double)newHeight, imPtr->anchor); + } else { + anchorPt = c1; + } + anchorPt.x += markerPtr->xOffset; + anchorPt.y += markerPtr->yOffset; + + /* Check if the image sits at least partially in the plot area. */ + extents.left = anchorPt.x; + extents.top = anchorPt.y; + extents.right = anchorPt.x + newWidth - 1; + extents.bottom = anchorPt.y + newHeight - 1; + + markerPtr->clipped = BoxesDontOverlap(graphPtr, &extents); + if (markerPtr->clipped) { + return; /* Image is offscreen. Don't generate + * rotated or scaled images. */ + } + + /* Determine the extents of the subimage inside of the destination + * image. */ + left = MAX((int)extents.left, graphPtr->left); + top = MAX((int)extents.top, graphPtr->top); + right = MIN((int)extents.right, graphPtr->right); + bottom = MIN((int)extents.bottom, graphPtr->bottom); + + /* Reset image location and coordinates to that of the region */ + anchorPt.x = left; + anchorPt.y = top; + + x = y = 0; + if (graphPtr->left > (int)extents.left) { + x = graphPtr->left - (int)extents.left; + } + if (graphPtr->top > (int)extents.top) { + y = graphPtr->top - (int)extents.top; + } + w = (int)(right - left + 1); + h = (int)(bottom - top + 1); + + if (markerPtr->nWorldPts > 1) { + Blt_Picture scaled; + + scaled = Blt_ScalePictureArea(imPtr->picture, x, y, w, h, + newWidth, newHeight); + imPtr->scaled = scaled; + imPtr->pictX = 0; + imPtr->pictY = 0; + } else { + imPtr->pictX = x; + imPtr->pictY = y; + } + imPtr->width = newWidth; + imPtr->height = newHeight; + imPtr->anchorPt = anchorPt; +} + +/* + *--------------------------------------------------------------------------- + * + * PointInWindowProc -- + * + * Indicates if the given point is over the window marker. The area of + * the window is the rectangle. + * + * Results: + * Returns 1 is the point is over the window marker, 0 otherwise. + * + *--------------------------------------------------------------------------- + */ +static int +PointInImageProc(Marker *markerPtr, Point2d *samplePtr) +{ + ImageMarker *imPtr = (ImageMarker *)markerPtr; + double left, right, top, bottom; + + left = imPtr->anchorPt.x; + right = imPtr->anchorPt.x + imPtr->width; + top = imPtr->anchorPt.y; + bottom = imPtr->anchorPt.y + imPtr->height; + + return ((samplePtr->x >= left) && (samplePtr->x < right) && + (samplePtr->y >= top) && (samplePtr->y < bottom)); +} + +/* + *--------------------------------------------------------------------------- + * + * RegionInImageProc -- + * + *--------------------------------------------------------------------------- + */ +static int +RegionInImageProc(Marker *markerPtr, Region2d *regPtr, int enclosed) +{ + ImageMarker *imPtr = (ImageMarker *)markerPtr; + + if (markerPtr->nWorldPts > 0) { + double left, right, top, bottom; + + left = imPtr->anchorPt.x; + right = imPtr->anchorPt.x + imPtr->width; + top = imPtr->anchorPt.y; + bottom = imPtr->anchorPt.y + imPtr->height; + if (enclosed) { + return ((left >= regPtr->left) && (top >= regPtr->top) && + (right <= regPtr->right) && (bottom <= regPtr->bottom)); + } + return !((left >= regPtr->right) || (top >= regPtr->bottom) || + (right <= regPtr->left) || (bottom <= regPtr->top)); + } + return FALSE; +} + +/* + *--------------------------------------------------------------------------- + * + * DrawImageProc -- + * + * This procedure is invoked to draw a image marker. + * + * Results: + * None. + * + * Side effects: + * GC stipple origins are changed to current window coordinates. + * Commands are output to X to draw the marker in its current mode. + * + *--------------------------------------------------------------------------- + */ +static void +DrawImageProc(Marker *markerPtr, Drawable drawable) +{ + ImageMarker *imPtr = (ImageMarker *)markerPtr; + Blt_Picture picture; + + picture = (imPtr->scaled != NULL) ? imPtr->scaled : imPtr->picture; + if (picture != NULL) { + Blt_PaintPictureWithBlend(imPtr->painter, drawable, picture, + imPtr->pictX, imPtr->pictY, imPtr->width, imPtr->height, + (int)imPtr->anchorPt.x, (int)imPtr->anchorPt.y, 0, 0.4); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ImageToPostscriptProc -- + * + * This procedure is invoked to print a image marker. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +ImageToPostscriptProc(Marker *markerPtr, Blt_Ps ps) +{ + ImageMarker *imPtr = (ImageMarker *)markerPtr; + Blt_Picture picture; + + picture = (imPtr->scaled != NULL) ? imPtr->scaled : imPtr->picture; + if (picture != NULL) { + Blt_Ps_DrawPicture(ps, picture, imPtr->anchorPt.x, imPtr->anchorPt.y); + } +} + +/* + *--------------------------------------------------------------------------- + * + * FreeImageProc -- + * + * Destroys the structure containing the attributes of the image marker. + * + * Results: + * None. + * + * Side effects: + * Image attributes (GCs, colors, image, etc) get destroyed. Memory is + * released, X resources are freed, and the graph is redrawn. + * + *--------------------------------------------------------------------------- + */ +static void +FreeImageProc(Marker *markerPtr) +{ + ImageMarker *imPtr = (ImageMarker *)markerPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + + if (imPtr->painter != NULL) { + Blt_FreePainter(imPtr->painter); + } + if (imPtr->scaled != NULL) { + Blt_FreePicture(imPtr->scaled); + } + if (imPtr->gc != NULL) { + Tk_FreeGC(graphPtr->display, imPtr->gc); + } +} + +/* + *--------------------------------------------------------------------------- + * + * CreateImageProc -- + * + * Allocate memory and initialize methods for the new image marker. + * + * Results: + * The pointer to the newly allocated marker structure is returned. + * + * Side effects: + * Memory is allocated for the image marker structure. + * + *--------------------------------------------------------------------------- + */ +static Marker * +CreateImageProc(void) +{ + ImageMarker *imPtr; + + imPtr = Blt_AssertCalloc(1, sizeof(ImageMarker)); + imPtr->classPtr = &imageMarkerClass; + return (Marker *)imPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureTextProc -- + * + * This procedure is called to process an objv/objc list, plus the Tk + * option database, in order to configure (or reconfigure) a text marker. + * + * Results: + * A standard TCL result. If TCL_ERROR is returned, then interp->result + * contains an error message. + * + * Side effects: + * Configuration information, such as text string, colors, font, etc. get + * set for markerPtr; old resources get freed, if there were any. The + * marker is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureTextProc(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + TextMarker *tmPtr = (TextMarker *)markerPtr; + GC newGC; + XGCValues gcValues; + unsigned long gcMask; + + tmPtr->style.angle = (float)FMOD(tmPtr->style.angle, 360.0); + if (tmPtr->style.angle < 0.0f) { + tmPtr->style.angle += 360.0f; + } + newGC = NULL; + if (tmPtr->fillColor != NULL) { + gcMask = GCForeground; + gcValues.foreground = tmPtr->fillColor->pixel; + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + } + if (tmPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, tmPtr->fillGC); + } + tmPtr->fillGC = newGC; + + markerPtr->flags |= MAP_ITEM; + if (markerPtr->drawUnder) { + graphPtr->flags |= CACHE_DIRTY; + } + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * MapTextProc -- + * + * Calculate the layout position for a text marker. Positional information + * is saved in the marker. If the text is rotated, a bitmap containing the + * text is created. + * + * Results: + * None. + * + * Side effects: + * If no background color has been specified, the GC stipple origins are + * changed to current window coordinates. For both rotated and + * non-rotated text, if any old bitmap is leftover, it is freed. + * + *--------------------------------------------------------------------------- + */ +static void +MapTextProc(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + TextMarker *tmPtr = (TextMarker *)markerPtr; + Region2d extents; + Point2d anchorPt; + int i; + unsigned int w, h; + double rw, rh; + + tmPtr->width = tmPtr->height = 0; + if (tmPtr->string == NULL) { + return; + } + Blt_Ts_GetExtents(&tmPtr->style, tmPtr->string, &w, &h); + Blt_GetBoundingBox(w, h, tmPtr->style.angle, &rw, &rh, tmPtr->outline); + tmPtr->width = ROUND(rw); + tmPtr->height = ROUND(rh); + for (i = 0; i < 4; i++) { + tmPtr->outline[i].x += ROUND(rw * 0.5); + tmPtr->outline[i].y += ROUND(rh * 0.5); + } + tmPtr->outline[4].x = tmPtr->outline[0].x; + tmPtr->outline[4].y = tmPtr->outline[0].y; + anchorPt = MapPoint(markerPtr->worldPts, &markerPtr->axes); + anchorPt = Blt_AnchorPoint(anchorPt.x, anchorPt.y, (double)(tmPtr->width), + (double)(tmPtr->height), tmPtr->anchor); + anchorPt.x += markerPtr->xOffset; + anchorPt.y += markerPtr->yOffset; + /* + * Determine the bounding box of the text and test to see if it is at + * least partially contained within the plotting area. + */ + extents.left = anchorPt.x; + extents.top = anchorPt.y; + extents.right = anchorPt.x + tmPtr->width - 1; + extents.bottom = anchorPt.y + tmPtr->height - 1; + markerPtr->clipped = BoxesDontOverlap(graphPtr, &extents); + tmPtr->anchorPt = anchorPt; + +} + +static int +PointInTextProc(Marker *markerPtr, Point2d *samplePtr) +{ + TextMarker *tmPtr = (TextMarker *)markerPtr; + + if (tmPtr->string == NULL) { + return 0; + } + if (tmPtr->style.angle != 0.0f) { + Point2d points[5]; + int i; + + /* + * Figure out the bounding polygon (isolateral) for the text and see + * if the point is inside of it. + */ + for (i = 0; i < 5; i++) { + points[i].x = tmPtr->outline[i].x + tmPtr->anchorPt.x; + points[i].y = tmPtr->outline[i].y + tmPtr->anchorPt.y; + } + return Blt_PointInPolygon(samplePtr, points, 5); + } + return ((samplePtr->x >= tmPtr->anchorPt.x) && + (samplePtr->x < (tmPtr->anchorPt.x + tmPtr->width)) && + (samplePtr->y >= tmPtr->anchorPt.y) && + (samplePtr->y < (tmPtr->anchorPt.y + tmPtr->height))); +} + +/* + *--------------------------------------------------------------------------- + * + * RegionInTextProc -- + * + *--------------------------------------------------------------------------- + */ +static int +RegionInTextProc(Marker *markerPtr, Region2d *extsPtr, int enclosed) +{ + TextMarker *tmPtr = (TextMarker *)markerPtr; + + if (markerPtr->nWorldPts < 1) { + return FALSE; + } + if (tmPtr->style.angle != 0.0f) { + Point2d points[5]; + int i; + + /* + * Generate the bounding polygon (isolateral) for the bitmap and see + * if the point is inside of it. + */ + for (i = 0; i < 4; i++) { + points[i].x = tmPtr->outline[i].x + tmPtr->anchorPt.x; + points[i].y = tmPtr->outline[i].y + tmPtr->anchorPt.y; + } + return Blt_RegionInPolygon(extsPtr, points, 4, enclosed); + } + if (enclosed) { + return ((tmPtr->anchorPt.x >= extsPtr->left) && + (tmPtr->anchorPt.y >= extsPtr->top) && + ((tmPtr->anchorPt.x + tmPtr->width) <= extsPtr->right) && + ((tmPtr->anchorPt.y + tmPtr->height) <= extsPtr->bottom)); + } + return !((tmPtr->anchorPt.x >= extsPtr->right) || + (tmPtr->anchorPt.y >= extsPtr->bottom) || + ((tmPtr->anchorPt.x + tmPtr->width) <= extsPtr->left) || + ((tmPtr->anchorPt.y + tmPtr->height) <= extsPtr->top)); +} + +/* + *--------------------------------------------------------------------------- + * + * DrawTextProc -- + * + * Draws the text marker on the graph. + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to draw the marker in its current mode. + * + *--------------------------------------------------------------------------- + */ +static void +DrawTextProc(Marker *markerPtr, Drawable drawable) +{ + TextMarker *tmPtr = (TextMarker *)markerPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + + if (tmPtr->string == NULL) { + return; + } + if (tmPtr->fillGC != NULL) { + XPoint points[4]; + int i; + + /* + * Simulate the rotated background of the bitmap by filling a bounding + * polygon with the background color. + */ + for (i = 0; i < 4; i++) { + points[i].x = (short int)(tmPtr->outline[i].x + tmPtr->anchorPt.x); + points[i].y = (short int)(tmPtr->outline[i].y + tmPtr->anchorPt.y); + } + XFillPolygon(graphPtr->display, drawable, tmPtr->fillGC, points, 4, + Convex, CoordModeOrigin); + } + if (tmPtr->style.color != NULL) { + Blt_Ts_DrawText(graphPtr->tkwin, drawable, tmPtr->string, -1, + &tmPtr->style, (int)tmPtr->anchorPt.x, (int)tmPtr->anchorPt.y); + } +} + +/* + *--------------------------------------------------------------------------- + * + * TextToPostscriptProc -- + * + * Outputs PostScript commands to draw a text marker at a given x,y + * coordinate, rotation, anchor, and font. + * + * Results: + * None. + * + * Side effects: + * PostScript font and color settings are changed. + * + *--------------------------------------------------------------------------- + */ +static void +TextToPostscriptProc(Marker *markerPtr, Blt_Ps ps) +{ + TextMarker *tmPtr = (TextMarker *)markerPtr; + + if (tmPtr->string == NULL) { + return; + } + if (tmPtr->fillGC != NULL) { + Point2d points[4]; + int i; + + /* + * Simulate the rotated background of the bitmap by filling a bounding + * polygon with the background color. + */ + for (i = 0; i < 4; i++) { + points[i].x = tmPtr->outline[i].x + tmPtr->anchorPt.x; + points[i].y = tmPtr->outline[i].y + tmPtr->anchorPt.y; + } + Blt_Ps_XSetBackground(ps, tmPtr->fillColor); + Blt_Ps_XFillPolygon(ps, points, 4); + } + Blt_Ps_DrawText(ps, tmPtr->string, &tmPtr->style, tmPtr->anchorPt.x, + tmPtr->anchorPt.y); +} + +/* + *--------------------------------------------------------------------------- + * + * FreeTextProc -- + * + * Destroys the structure containing the attributes of the text marker. + * + * Results: + * None. + * + * Side effects: + * Text attributes (GCs, colors, stipple, font, etc) get destroyed. + * Memory is released, X resources are freed, and the graph is redrawn. + * + *--------------------------------------------------------------------------- + */ +static void +FreeTextProc(Marker *markerPtr) +{ + TextMarker *tmPtr = (TextMarker *)markerPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + + Blt_Ts_FreeStyle(graphPtr->display, &tmPtr->style); +} + +/* + *--------------------------------------------------------------------------- + + * CreateTextProc -- + * + * Allocate memory and initialize methods for the new text marker. + * + * Results: + * The pointer to the newly allocated marker structure is returned. + * + * Side effects: + * Memory is allocated for the text marker structure. + * + *--------------------------------------------------------------------------- + */ +static Marker * +CreateTextProc(void) +{ + TextMarker *tmPtr; + + tmPtr = Blt_AssertCalloc(1, sizeof(TextMarker)); + tmPtr->classPtr = &textMarkerClass; + Blt_Ts_InitStyle(tmPtr->style); + tmPtr->style.anchor = TK_ANCHOR_NW; + tmPtr->style.padLeft = tmPtr->style.padRight = 4; + tmPtr->style.padTop = tmPtr->style.padBottom = 4; + return (Marker *)tmPtr; +} + +static Tk_EventProc ChildEventProc; +static Tk_GeomRequestProc ChildGeometryProc; +static Tk_GeomLostSlaveProc ChildCustodyProc; +static Tk_GeomMgr winMarkerMgrInfo = +{ + (char *)"graph", /* Name of geometry manager used by + * winfo */ + ChildGeometryProc, /* Procedure to for new geometry + * requests. */ + ChildCustodyProc, /* Procedure when window is taken + * away. */ +}; + +/* + *--------------------------------------------------------------------------- + * + * ConfigureWindowProc -- + * + * This procedure is called to process an objv/objc list, plus the Tk + * option database, in order to configure (or reconfigure) a window + * marker. + * + * Results: + * A standard TCL result. If TCL_ERROR is returned, then interp->result + * contains an error message. + * + * Side effects: + * Configuration information, such as window pathname, placement, + * etc. get set for markerPtr; old resources get freed, if there were + * any. The marker is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureWindowProc(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + WindowMarker *wmPtr = (WindowMarker *)markerPtr; + Tk_Window tkwin; + + if (wmPtr->childName == NULL) { + return TCL_OK; + } + tkwin = Tk_NameToWindow(graphPtr->interp, wmPtr->childName, + graphPtr->tkwin); + if (tkwin == NULL) { + return TCL_ERROR; + } + if (Tk_Parent(tkwin) != graphPtr->tkwin) { + Tcl_AppendResult(graphPtr->interp, "\"", wmPtr->childName, + "\" is not a child of \"", Tk_PathName(graphPtr->tkwin), "\"", + (char *)NULL); + return TCL_ERROR; + } + if (tkwin != wmPtr->child) { + if (wmPtr->child != NULL) { + Tk_DeleteEventHandler(wmPtr->child, StructureNotifyMask, + ChildEventProc, wmPtr); + Tk_ManageGeometry(wmPtr->child, (Tk_GeomMgr *) 0, (ClientData)0); + Tk_UnmapWindow(wmPtr->child); + } + Tk_CreateEventHandler(tkwin, StructureNotifyMask, ChildEventProc, + wmPtr); + Tk_ManageGeometry(tkwin, &winMarkerMgrInfo, wmPtr); + } + wmPtr->child = tkwin; + markerPtr->flags |= MAP_ITEM; + if (markerPtr->drawUnder) { + graphPtr->flags |= CACHE_DIRTY; + } + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * MapWindowProc -- + * + * Calculate the layout position for a window marker. Positional + * information is saved in the marker. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +MapWindowProc(Marker *markerPtr) +{ + WindowMarker *wmPtr = (WindowMarker *)markerPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + Point2d anchorPt; + Region2d extents; + int width, height; + + if (wmPtr->child == (Tk_Window)NULL) { + return; + } + anchorPt = MapPoint(markerPtr->worldPts, &markerPtr->axes); + + width = Tk_ReqWidth(wmPtr->child); + height = Tk_ReqHeight(wmPtr->child); + if (wmPtr->reqWidth > 0) { + width = wmPtr->reqWidth; + } + if (wmPtr->reqHeight > 0) { + height = wmPtr->reqHeight; + } + wmPtr->anchorPt = Blt_AnchorPoint(anchorPt.x, anchorPt.y, (double)width, + (double)height, wmPtr->anchor); + wmPtr->anchorPt.x += markerPtr->xOffset; + wmPtr->anchorPt.y += markerPtr->yOffset; + wmPtr->width = width; + wmPtr->height = height; + + /* + * Determine the bounding box of the window and test to see if it is at + * least partially contained within the plotting area. + */ + extents.left = wmPtr->anchorPt.x; + extents.top = wmPtr->anchorPt.y; + extents.right = wmPtr->anchorPt.x + wmPtr->width - 1; + extents.bottom = wmPtr->anchorPt.y + wmPtr->height - 1; + markerPtr->clipped = BoxesDontOverlap(graphPtr, &extents); +} + +/* + *--------------------------------------------------------------------------- + * + * PointInWindowProc -- + * + *--------------------------------------------------------------------------- + */ +static int +PointInWindowProc(Marker *markerPtr, Point2d *samplePtr) +{ + WindowMarker *wmPtr = (WindowMarker *)markerPtr; + + return ((samplePtr->x >= wmPtr->anchorPt.x) && + (samplePtr->x < (wmPtr->anchorPt.x + wmPtr->width)) && + (samplePtr->y >= wmPtr->anchorPt.y) && + (samplePtr->y < (wmPtr->anchorPt.y + wmPtr->height))); +} + +/* + *--------------------------------------------------------------------------- + * + * RegionInWindowProc -- + * + *--------------------------------------------------------------------------- + */ +static int +RegionInWindowProc(Marker *markerPtr, Region2d *extsPtr, int enclosed) +{ + WindowMarker *wmPtr = (WindowMarker *)markerPtr; + + if (markerPtr->nWorldPts < 1) { + return FALSE; + } + if (enclosed) { + return ((wmPtr->anchorPt.x >= extsPtr->left) && + (wmPtr->anchorPt.y >= extsPtr->top) && + ((wmPtr->anchorPt.x + wmPtr->width) <= extsPtr->right) && + ((wmPtr->anchorPt.y + wmPtr->height) <= extsPtr->bottom)); + } + return !((wmPtr->anchorPt.x >= extsPtr->right) || + (wmPtr->anchorPt.y >= extsPtr->bottom) || + ((wmPtr->anchorPt.x + wmPtr->width) <= extsPtr->left) || + ((wmPtr->anchorPt.y + wmPtr->height) <= extsPtr->top)); +} + +/* + *--------------------------------------------------------------------------- + * + * DrawWindowProc -- + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static void +DrawWindowProc(Marker *markerPtr, Drawable drawable) +{ + WindowMarker *wmPtr = (WindowMarker *)markerPtr; + + if (wmPtr->child == NULL) { + return; + } + if ((wmPtr->height != Tk_Height(wmPtr->child)) || + (wmPtr->width != Tk_Width(wmPtr->child)) || + ((int)wmPtr->anchorPt.x != Tk_X(wmPtr->child)) || + ((int)wmPtr->anchorPt.y != Tk_Y(wmPtr->child))) { + Tk_MoveResizeWindow(wmPtr->child, (int)wmPtr->anchorPt.x, + (int)wmPtr->anchorPt.y, wmPtr->width, wmPtr->height); + } + if (!Tk_IsMapped(wmPtr->child)) { + Tk_MapWindow(wmPtr->child); + } +} + +/* + *--------------------------------------------------------------------------- + * + * WindowToPostscriptProc -- + * + *--------------------------------------------------------------------------- + */ +static void +WindowToPostscriptProc(Marker *markerPtr, Blt_Ps ps) +{ + WindowMarker *wmPtr = (WindowMarker *)markerPtr; + + if (wmPtr->child == NULL) { + return; + } + if (Tk_IsMapped(wmPtr->child)) { + Blt_Ps_XDrawWindow(ps, wmPtr->child, wmPtr->anchorPt.x, + wmPtr->anchorPt.y); + } +} + +/* + *--------------------------------------------------------------------------- + * + * FreeWindowProc -- + * + * Destroys the structure containing the attributes of the window * + * marker. + * + * Results: + * None. + * + * Side effects: + * Window is destroyed and removed from the screen. + * + *--------------------------------------------------------------------------- + */ +static void +FreeWindowProc(Marker *markerPtr) +{ + WindowMarker *wmPtr = (WindowMarker *)markerPtr; + + if (wmPtr->child != NULL) { + Tk_DeleteEventHandler(wmPtr->child, StructureNotifyMask, + ChildEventProc, wmPtr); + Tk_ManageGeometry(wmPtr->child, (Tk_GeomMgr *) 0, (ClientData)0); + Tk_DestroyWindow(wmPtr->child); + } +} + +/* + *--------------------------------------------------------------------------- + * + * CreateWindowProc -- + * + * Allocate memory and initialize methods for the new window marker. + * + * Results: + * The pointer to the newly allocated marker structure is returned. + * + * Side effects: + * Memory is allocated for the window marker structure. + * + *--------------------------------------------------------------------------- + */ +static Marker * +CreateWindowProc(void) +{ + WindowMarker *wmPtr; + + wmPtr = Blt_AssertCalloc(1, sizeof(WindowMarker)); + wmPtr->classPtr = &windowMarkerClass; + return (Marker *)wmPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ChildEventProc -- + * + * This procedure is invoked whenever StructureNotify events occur for a + * window that's managed as part of a graph window marker. This + * procedure's only purpose is to clean up when windows are deleted. + * + * Results: + * None. + * + * Side effects: + * The window is disassociated from the window item when it is + * deleted. + * + *--------------------------------------------------------------------------- + */ +static void +ChildEventProc(ClientData clientData, XEvent *eventPtr) +{ + WindowMarker *wmPtr = clientData; + + if (eventPtr->type == DestroyNotify) { + wmPtr->child = NULL; + } +} + +/* + *--------------------------------------------------------------------------- + * + * ChildGeometryProc -- + * + * This procedure is invoked whenever a window that's associated with a + * window item changes its requested dimensions. + * + * Results: + * None. + * + * Side effects: + * The size and location on the window of the window may change, + * depending on the options specified for the window item. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static void +ChildGeometryProc(ClientData clientData, Tk_Window tkwin) +{ + WindowMarker *wmPtr = clientData; + + if (wmPtr->reqWidth == 0) { + wmPtr->width = Tk_ReqWidth(tkwin); + } + if (wmPtr->reqHeight == 0) { + wmPtr->height = Tk_ReqHeight(tkwin); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ChildCustodyProc -- + * + * This procedure is invoked when an embedded window has been stolen by + * another geometry manager. The information and memory associated with + * the widget is released. + * + * Results: + * None. + * + * Side effects: + * Arranges for the graph to be redrawn without the embedded widget at + * the next idle point. + * + *--------------------------------------------------------------------------- + */ + /* ARGSUSED */ +static void +ChildCustodyProc(ClientData clientData, Tk_Window tkwin) +{ + Marker *markerPtr = clientData; + Graph *graphPtr; + + graphPtr = markerPtr->obj.graphPtr; + markerPtr->flags |= DELETE_PENDING; + Tcl_EventuallyFree(markerPtr, FreeMarker); + /* + * Not really needed. We should get an Expose event when the child window + * is unmapped. + */ + Blt_EventuallyRedrawGraph(graphPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * MapLineProc -- + * + * Calculate the layout position for a line marker. Positional + * information is saved in the marker. The line positions are stored in + * an array of points (malloc'ed). + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +MapLineProc(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + LineMarker *lmPtr = (LineMarker *)markerPtr; + Point2d *srcPtr, *pend; + Segment2d *segments, *segPtr; + Point2d p, q; + Region2d extents; + + lmPtr->nSegments = 0; + if (lmPtr->segments != NULL) { + Blt_Free(lmPtr->segments); + } + if (markerPtr->nWorldPts < 2) { + return; /* Too few points */ + } + Blt_GraphExtents(graphPtr, &extents); + + /* + * Allow twice the number of world coordinates. The line will represented + * as series of line segments, not one continous polyline. This is + * because clipping against the plot area may chop the line into several + * disconnected segments. + */ + segments = Blt_AssertMalloc(markerPtr->nWorldPts * sizeof(Segment2d)); + srcPtr = markerPtr->worldPts; + p = MapPoint(srcPtr, &markerPtr->axes); + p.x += markerPtr->xOffset; + p.y += markerPtr->yOffset; + + segPtr = segments; + for (srcPtr++, pend = markerPtr->worldPts + markerPtr->nWorldPts; + srcPtr < pend; srcPtr++) { + Point2d next; + + next = MapPoint(srcPtr, &markerPtr->axes); + next.x += markerPtr->xOffset; + next.y += markerPtr->yOffset; + q = next; + if (Blt_LineRectClip(&extents, &p, &q)) { + segPtr->p = p; + segPtr->q = q; + segPtr++; + } + p = next; + } + lmPtr->nSegments = segPtr - segments; + lmPtr->segments = segments; + markerPtr->clipped = (lmPtr->nSegments == 0); +} + +static int +PointInLineProc(Marker *markerPtr, Point2d *samplePtr) +{ + LineMarker *lmPtr = (LineMarker *)markerPtr; + + return Blt_PointInSegments(samplePtr, lmPtr->segments, lmPtr->nSegments, + (double)markerPtr->obj.graphPtr->halo); +} + +/* + *--------------------------------------------------------------------------- + * + * RegionInLineProc -- + * + *--------------------------------------------------------------------------- + */ +static int +RegionInLineProc(Marker *markerPtr, Region2d *extsPtr, int enclosed) +{ + if (markerPtr->nWorldPts < 2) { + return FALSE; + } + if (enclosed) { + Point2d *pp, *pend; + + for (pp = markerPtr->worldPts, pend = pp + markerPtr->nWorldPts; + pp < pend; pp++) { + Point2d p; + + p = MapPoint(pp, &markerPtr->axes); + if ((p.x < extsPtr->left) && (p.x > extsPtr->right) && + (p.y < extsPtr->top) && (p.y > extsPtr->bottom)) { + return FALSE; + } + } + return TRUE; /* All points inside bounding box. */ + } else { + int count; + Point2d *pp, *pend; + + count = 0; + for (pp = markerPtr->worldPts, pend = pp + (markerPtr->nWorldPts - 1); + pp < pend; pp++) { + Point2d p, q; + + p = MapPoint(pp, &markerPtr->axes); + q = MapPoint(pp + 1, &markerPtr->axes); + if (Blt_LineRectClip(extsPtr, &p, &q)) { + count++; + } + } + return (count > 0); /* At least 1 segment passes through + * region. */ + } +} + +/* + *--------------------------------------------------------------------------- + * + * DrawLineProc -- + * + *--------------------------------------------------------------------------- + */ +static void +DrawLineProc(Marker *markerPtr, Drawable drawable) +{ + LineMarker *lmPtr = (LineMarker *)markerPtr; + + if (lmPtr->nSegments > 0) { + Graph *graphPtr = markerPtr->obj.graphPtr; + + Blt_Draw2DSegments(graphPtr->display, drawable, lmPtr->gc, + lmPtr->segments, lmPtr->nSegments); + if (lmPtr->xor) { /* Toggle the drawing state */ + lmPtr->xorState = (lmPtr->xorState == 0); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureLineProc -- + * + * This procedure is called to process an objv/objc list, plus the Tk + * option database, in order to configure (or reconfigure) a line marker. + * + * Results: + * A standard TCL result. If TCL_ERROR is returned, then interp->result + * contains an error message. + * + * Side effects: + * Configuration information, such as line width, colors, dashes, + * etc. get set for markerPtr; old resources get freed, if there were + * any. The marker is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ConfigureLineProc(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + LineMarker *lmPtr = (LineMarker *)markerPtr; + GC newGC; + XGCValues gcValues; + unsigned long gcMask; + Drawable drawable; + + drawable = Tk_WindowId(graphPtr->tkwin); + gcMask = (GCLineWidth | GCLineStyle | GCCapStyle | GCJoinStyle); + if (lmPtr->outlineColor != NULL) { + gcMask |= GCForeground; + gcValues.foreground = lmPtr->outlineColor->pixel; + } + if (lmPtr->fillColor != NULL) { + gcMask |= GCBackground; + gcValues.background = lmPtr->fillColor->pixel; + } + gcValues.cap_style = lmPtr->capStyle; + gcValues.join_style = lmPtr->joinStyle; + gcValues.line_width = LineWidth(lmPtr->lineWidth); + gcValues.line_style = LineSolid; + if (LineIsDashed(lmPtr->dashes)) { + gcValues.line_style = + (gcMask & GCBackground) ? LineDoubleDash : LineOnOffDash; + } + if (lmPtr->xor) { + unsigned long pixel; + gcValues.function = GXxor; + + gcMask |= GCFunction; + if (graphPtr->plotBg == NULL) { + pixel = WhitePixelOfScreen(Tk_Screen(graphPtr->tkwin)); + } else { + pixel = Blt_BackgroundBorderColor(graphPtr->plotBg)->pixel; + } + if (gcMask & GCBackground) { + gcValues.background ^= pixel; + } + gcValues.foreground ^= pixel; + if (drawable != None) { + DrawLineProc(markerPtr, drawable); + } + } + newGC = Blt_GetPrivateGC(graphPtr->tkwin, gcMask, &gcValues); + if (lmPtr->gc != NULL) { + Blt_FreePrivateGC(graphPtr->display, lmPtr->gc); + } + if (LineIsDashed(lmPtr->dashes)) { + Blt_SetDashes(graphPtr->display, newGC, &lmPtr->dashes); + } + lmPtr->gc = newGC; + if (lmPtr->xor) { + if (drawable != None) { + MapLineProc(markerPtr); + DrawLineProc(markerPtr, drawable); + } + return TCL_OK; + } + markerPtr->flags |= MAP_ITEM; + if (markerPtr->drawUnder) { + graphPtr->flags |= CACHE_DIRTY; + } + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * LineToPostscriptProc -- + * + * Prints postscript commands to display the connect line. Dashed lines + * need to be handled specially, especially if a background color is + * designated. + * + * Results: + * None. + * + * Side effects: + * PostScript output commands are saved in the interpreter + * (infoPtr->interp) result field. + * + *--------------------------------------------------------------------------- + */ +static void +LineToPostscriptProc(Marker *markerPtr, Blt_Ps ps) +{ + LineMarker *lmPtr = (LineMarker *)markerPtr; + + if (lmPtr->nSegments > 0) { + Blt_Ps_XSetLineAttributes(ps, lmPtr->outlineColor, + lmPtr->lineWidth, &lmPtr->dashes, lmPtr->capStyle, + lmPtr->joinStyle); + if ((LineIsDashed(lmPtr->dashes)) && (lmPtr->fillColor != NULL)) { + Blt_Ps_Append(ps, "/DashesProc {\n gsave\n "); + Blt_Ps_XSetBackground(ps, lmPtr->fillColor); + Blt_Ps_Append(ps, " "); + Blt_Ps_XSetDashes(ps, (Blt_Dashes *)NULL); + Blt_Ps_VarAppend(ps, + "stroke\n", + " grestore\n", + "} def\n", (char *)NULL); + } else { + Blt_Ps_Append(ps, "/DashesProc {} def\n"); + } + Blt_Ps_Draw2DSegments(ps, lmPtr->segments, lmPtr->nSegments); + } +} + +/* + *--------------------------------------------------------------------------- + * + * FreeLineProc -- + * + * Destroys the structure and attributes of a line marker. + * + * Results: + * None. + * + * Side effects: + * Line attributes (GCs, colors, stipple, etc) get released. Memory is + * deallocated, X resources are freed. + * + *--------------------------------------------------------------------------- + */ +static void +FreeLineProc(Marker *markerPtr) +{ + LineMarker *lmPtr = (LineMarker *)markerPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + + if (lmPtr->gc != NULL) { + Blt_FreePrivateGC(graphPtr->display, lmPtr->gc); + } + if (lmPtr->segments != NULL) { + Blt_Free(lmPtr->segments); + } +} + + +/* + *--------------------------------------------------------------------------- + * + * CreateLineProc -- + * + * Allocate memory and initialize methods for a new line marker. + * + * Results: + * The pointer to the newly allocated marker structure is returned. + * + * Side effects: + * Memory is allocated for the line marker structure. + * + *--------------------------------------------------------------------------- + */ +static Marker * +CreateLineProc(void) +{ + LineMarker *lmPtr; + + lmPtr = Blt_AssertCalloc(1, sizeof(LineMarker)); + lmPtr->classPtr = &lineMarkerClass; + lmPtr->xor = FALSE; + lmPtr->capStyle = CapButt; + lmPtr->joinStyle = JoinMiter; + return (Marker *)lmPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * MapPolygonProc -- + * + * Calculate the layout position for a polygon marker. Positional + * information is saved in the polygon in an array of points (malloc'ed). + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +MapPolygonProc(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + PolygonMarker *pmPtr = (PolygonMarker *)markerPtr; + Point2d *screenPts; + Region2d extents; + int nScreenPts; + + if (pmPtr->outlinePts != NULL) { + Blt_Free(pmPtr->outlinePts); + pmPtr->outlinePts = NULL; + pmPtr->nOutlinePts = 0; + } + if (pmPtr->fillPts != NULL) { + Blt_Free(pmPtr->fillPts); + pmPtr->fillPts = NULL; + pmPtr->nFillPts = 0; + } + if (pmPtr->screenPts != NULL) { + Blt_Free(pmPtr->screenPts); + pmPtr->screenPts = NULL; + } + if (markerPtr->nWorldPts < 3) { + return; /* Too few points */ + } + + /* + * Allocate and fill a temporary array to hold the screen coordinates of + * the polygon. + */ + nScreenPts = markerPtr->nWorldPts + 1; + screenPts = Blt_AssertMalloc((nScreenPts + 1) * sizeof(Point2d)); + { + Point2d *sp, *dp, *send; + + dp = screenPts; + for (sp = markerPtr->worldPts, send = sp + markerPtr->nWorldPts; + sp < send; sp++) { + *dp = MapPoint(sp, &markerPtr->axes); + dp->x += markerPtr->xOffset; + dp->y += markerPtr->yOffset; + dp++; + } + *dp = screenPts[0]; + } + Blt_GraphExtents(graphPtr, &extents); + markerPtr->clipped = TRUE; + if (pmPtr->fill.fgColor != NULL) { /* Polygon fill required. */ + Point2d *fillPts; + int n; + + fillPts = Blt_AssertMalloc(sizeof(Point2d) * nScreenPts * 3); + n = Blt_PolyRectClip(&extents, screenPts, markerPtr->nWorldPts,fillPts); + if (n < 3) { + Blt_Free(fillPts); + } else { + pmPtr->nFillPts = n; + pmPtr->fillPts = fillPts; + markerPtr->clipped = FALSE; + } + } + if ((pmPtr->outline.fgColor != NULL) && (pmPtr->lineWidth > 0)) { + Segment2d *outlinePts; + Segment2d *segPtr; + Point2d *sp, *send; + + /* + * Generate line segments representing the polygon outline. The + * resulting outline may or may not be closed from viewport clipping. + */ + outlinePts = Blt_Malloc(nScreenPts * sizeof(Segment2d)); + if (outlinePts == NULL) { + return; /* Can't allocate point array */ + } + /* + * Note that this assumes that the point array contains an extra point + * that closes the polygon. + */ + segPtr = outlinePts; + for (sp = screenPts, send = sp + (nScreenPts - 1); sp < send; sp++) { + segPtr->p = sp[0]; + segPtr->q = sp[1]; + if (Blt_LineRectClip(&extents, &segPtr->p, &segPtr->q)) { + segPtr++; + } + } + pmPtr->nOutlinePts = segPtr - outlinePts; + pmPtr->outlinePts = outlinePts; + if (pmPtr->nOutlinePts > 0) { + markerPtr->clipped = FALSE; + } + } + pmPtr->screenPts = screenPts; +} + +static int +PointInPolygonProc(Marker *markerPtr, Point2d *samplePtr) +{ + PolygonMarker *pmPtr = (PolygonMarker *)markerPtr; + + if ((markerPtr->nWorldPts >= 3) && (pmPtr->screenPts != NULL)) { + return Blt_PointInPolygon(samplePtr, pmPtr->screenPts, + markerPtr->nWorldPts + 1); + } + return FALSE; +} + +/* + *--------------------------------------------------------------------------- + * + * RegionInPolygonProc -- + * + *--------------------------------------------------------------------------- + */ +static int +RegionInPolygonProc(Marker *markerPtr, Region2d *extsPtr, int enclosed) +{ + PolygonMarker *pmPtr = (PolygonMarker *)markerPtr; + + if ((markerPtr->nWorldPts >= 3) && (pmPtr->screenPts != NULL)) { + return Blt_RegionInPolygon(extsPtr, pmPtr->screenPts, + markerPtr->nWorldPts, enclosed); + } + return FALSE; +} + +static void +DrawPolygonProc(Marker *markerPtr, Drawable drawable) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + PolygonMarker *pmPtr = (PolygonMarker *)markerPtr; + + /* Draw polygon fill region */ + if ((pmPtr->nFillPts > 0) && (pmPtr->fill.fgColor != NULL)) { + XPoint *dp, *points; + Point2d *sp, *send; + + points = Blt_Malloc(pmPtr->nFillPts * sizeof(XPoint)); + if (points == NULL) { + return; + } + dp = points; + for (sp = pmPtr->fillPts, send = sp + pmPtr->nFillPts; sp < send; + sp++) { + dp->x = (short int)sp->x; + dp->y = (short int)sp->y; + dp++; + } + + XFillPolygon(graphPtr->display, drawable, pmPtr->fillGC, points, + pmPtr->nFillPts, Complex, CoordModeOrigin); + Blt_Free(points); + } + /* and then the outline */ + if ((pmPtr->nOutlinePts > 0) && (pmPtr->lineWidth > 0) && + (pmPtr->outline.fgColor != NULL)) { + Blt_Draw2DSegments(graphPtr->display, drawable, pmPtr->outlineGC, + pmPtr->outlinePts, pmPtr->nOutlinePts); + } +} + + +static void +PolygonToPostscriptProc(Marker *markerPtr, Blt_Ps ps) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + PolygonMarker *pmPtr = (PolygonMarker *)markerPtr; + + if (pmPtr->fill.fgColor != NULL) { + + /* + * Options: fg bg + * Draw outline only. + * x Draw solid or stipple. + * x x Draw solid or stipple. + */ + + /* Create a path to use for both the polygon and its outline. */ + Blt_Ps_Polyline(ps, pmPtr->fillPts, pmPtr->nFillPts); + + /* If the background fill color was specified, draw the polygon in a + * solid fashion with that color. */ + if (pmPtr->fill.bgColor != NULL) { + /* Draw the solid background as the background layer of the opaque + * stipple */ + Blt_Ps_XSetBackground(ps, pmPtr->fill.bgColor); + /* Retain the path. We'll need it for the foreground layer. */ + Blt_Ps_Append(ps, "gsave fill grestore\n"); + } + Blt_Ps_XSetForeground(ps, pmPtr->fill.fgColor); + if (pmPtr->stipple != None) { + /* Draw the stipple in the foreground color. */ + Blt_Ps_XSetStipple(ps, graphPtr->display, pmPtr->stipple); + } else { + Blt_Ps_Append(ps, "fill\n"); + } + } + + /* Draw the outline in the foreground color. */ + if ((pmPtr->lineWidth > 0) && (pmPtr->outline.fgColor != NULL)) { + + /* Set up the line attributes. */ + Blt_Ps_XSetLineAttributes(ps, pmPtr->outline.fgColor, + pmPtr->lineWidth, &pmPtr->dashes, pmPtr->capStyle, + pmPtr->joinStyle); + + /* + * Define on-the-fly a PostScript macro "DashesProc" that will be + * executed for each call to the Polygon drawing routine. If the line + * isn't dashed, simply make this an empty definition. + */ + if ((pmPtr->outline.bgColor != NULL) && (LineIsDashed(pmPtr->dashes))) { + Blt_Ps_Append(ps, "/DashesProc {\ngsave\n "); + Blt_Ps_XSetBackground(ps, pmPtr->outline.bgColor); + Blt_Ps_Append(ps, " "); + Blt_Ps_XSetDashes(ps, (Blt_Dashes *)NULL); + Blt_Ps_Append(ps, "stroke\n grestore\n} def\n"); + } else { + Blt_Ps_Append(ps, "/DashesProc {} def\n"); + } + Blt_Ps_Draw2DSegments(ps, pmPtr->outlinePts, pmPtr->nOutlinePts); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigurePolygonProc -- + * + * This procedure is called to process an objv/objc list, plus the Tk + * option database, in order to configure (or reconfigure) a polygon + * marker. + * + * Results: + * A standard TCL result. If TCL_ERROR is returned, then interp->result + * contains an error message. + * + * Side effects: + * Configuration information, such as polygon color, dashes, fillstyle, + * etc. get set for markerPtr; old resources get freed, if there were + * any. The marker is eventually redisplayed. + * + * -------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ConfigurePolygonProc(Marker *markerPtr) +{ + Graph *graphPtr = markerPtr->obj.graphPtr; + PolygonMarker *pmPtr = (PolygonMarker *)markerPtr; + GC newGC; + XGCValues gcValues; + unsigned long gcMask; + Drawable drawable; + + drawable = Tk_WindowId(graphPtr->tkwin); + gcMask = (GCLineWidth | GCLineStyle); + if (pmPtr->outline.fgColor != NULL) { + gcMask |= GCForeground; + gcValues.foreground = pmPtr->outline.fgColor->pixel; + } + if (pmPtr->outline.bgColor != NULL) { + gcMask |= GCBackground; + gcValues.background = pmPtr->outline.bgColor->pixel; + } + gcMask |= (GCCapStyle | GCJoinStyle); + gcValues.cap_style = pmPtr->capStyle; + gcValues.join_style = pmPtr->joinStyle; + gcValues.line_style = LineSolid; + gcValues.dash_offset = 0; + gcValues.line_width = LineWidth(pmPtr->lineWidth); + if (LineIsDashed(pmPtr->dashes)) { + gcValues.line_style = (pmPtr->outline.bgColor == NULL) + ? LineOnOffDash : LineDoubleDash; + } + if (pmPtr->xor) { + unsigned long pixel; + gcValues.function = GXxor; + + gcMask |= GCFunction; + if (graphPtr->plotBg == NULL) { + /* The graph's color option may not have been set yet */ + pixel = WhitePixelOfScreen(Tk_Screen(graphPtr->tkwin)); + } else { + pixel = Blt_BackgroundBorderColor(graphPtr->plotBg)->pixel; + } + if (gcMask & GCBackground) { + gcValues.background ^= pixel; + } + gcValues.foreground ^= pixel; + if (drawable != None) { + DrawPolygonProc(markerPtr, drawable); + } + } + newGC = Blt_GetPrivateGC(graphPtr->tkwin, gcMask, &gcValues); + if (LineIsDashed(pmPtr->dashes)) { + Blt_SetDashes(graphPtr->display, newGC, &pmPtr->dashes); + } + if (pmPtr->outlineGC != NULL) { + Blt_FreePrivateGC(graphPtr->display, pmPtr->outlineGC); + } + pmPtr->outlineGC = newGC; + + gcMask = 0; + if (pmPtr->fill.fgColor != NULL) { + gcMask |= GCForeground; + gcValues.foreground = pmPtr->fill.fgColor->pixel; + } + if (pmPtr->fill.bgColor != NULL) { + gcMask |= GCBackground; + gcValues.background = pmPtr->fill.bgColor->pixel; + } + if (pmPtr->stipple != None) { + gcValues.stipple = pmPtr->stipple; + gcValues.fill_style = (pmPtr->fill.bgColor != NULL) + ? FillOpaqueStippled : FillStippled; + gcMask |= (GCStipple | GCFillStyle); + } + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (pmPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, pmPtr->fillGC); + } + pmPtr->fillGC = newGC; + + if ((gcMask == 0) && !(graphPtr->flags & RESET_AXES) && (pmPtr->xor)) { + if (drawable != None) { + MapPolygonProc(markerPtr); + DrawPolygonProc(markerPtr, drawable); + } + return TCL_OK; + } + markerPtr->flags |= MAP_ITEM; + if (markerPtr->drawUnder) { + graphPtr->flags |= CACHE_DIRTY; + } + graphPtr->flags |= RESET_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * FreePolygonProc -- + * + * Release memory and resources allocated for the polygon element. + * + * Results: + * None. + * + * Side effects: + * Everything associated with the polygon element is freed up. + * + *--------------------------------------------------------------------------- + */ +static void +FreePolygonProc(Marker *markerPtr) +{ + PolygonMarker *pmPtr = (PolygonMarker *)markerPtr; + Graph *graphPtr = markerPtr->obj.graphPtr; + + if (pmPtr->fillGC != NULL) { + Tk_FreeGC(graphPtr->display, pmPtr->fillGC); + } + if (pmPtr->outlineGC != NULL) { + Blt_FreePrivateGC(graphPtr->display, pmPtr->outlineGC); + } + if (pmPtr->fillPts != NULL) { + Blt_Free(pmPtr->fillPts); + } + if (pmPtr->outlinePts != NULL) { + Blt_Free(pmPtr->outlinePts); + } + if (pmPtr->screenPts != NULL) { + Blt_Free(pmPtr->screenPts); + } +} + +/* + *--------------------------------------------------------------------------- + * + * CreatePolygonProc -- + * + * Allocate memory and initialize methods for the new polygon marker. + * + * Results: + * The pointer to the newly allocated marker structure is returned. + * + * Side effects: + * Memory is allocated for the polygon marker structure. + * + * -------------------------------------------------------------------------- + */ +static Marker * +CreatePolygonProc(void) +{ + PolygonMarker *pmPtr; + + pmPtr = Blt_AssertCalloc(1, sizeof(PolygonMarker)); + pmPtr->classPtr = &polygonMarkerClass; + pmPtr->capStyle = CapButt; + pmPtr->joinStyle = JoinMiter; + return (Marker *)pmPtr; +} + +static int +GetMarkerFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, + Marker **markerPtrPtr) +{ + Blt_HashEntry *hPtr; + const char *string; + + string = Tcl_GetString(objPtr); + hPtr = Blt_FindHashEntry(&graphPtr->markers.table, string); + if (hPtr != NULL) { + *markerPtrPtr = Blt_GetHashValue(hPtr); + return TCL_OK; + } + if (interp != NULL) { + Tcl_AppendResult(interp, "can't find marker \"", string, + "\" in \"", Tk_PathName(graphPtr->tkwin), (char *)NULL); + } + return TCL_ERROR; +} + + +static int +RenameMarker(Graph *graphPtr, Marker *markerPtr, const char *oldName, + const char *newName) +{ + int isNew; + Blt_HashEntry *hPtr; + + /* Rename the marker only if no marker already exists by that name */ + hPtr = Blt_CreateHashEntry(&graphPtr->markers.table, newName, &isNew); + if (!isNew) { + Tcl_AppendResult(graphPtr->interp, "can't rename marker: \"", newName, + "\" already exists", (char *)NULL); + return TCL_ERROR; + } + markerPtr->obj.name = Blt_AssertStrdup(newName); + markerPtr->hashPtr = hPtr; + Blt_SetHashValue(hPtr, (char *)markerPtr); + + /* Delete the old hash entry */ + hPtr = Blt_FindHashEntry(&graphPtr->markers.table, oldName); + Blt_DeleteHashEntry(&graphPtr->markers.table, hPtr); + if (oldName != NULL) { + Blt_Free(oldName); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NamesOp -- + * + * Returns a list of marker identifiers in interp->result; + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +static int +NamesOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (objc == 3) { + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(graphPtr->markers.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Marker *markerPtr; + + markerPtr = Blt_Chain_GetValue(link); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(markerPtr->obj.name, -1)); + } + } else { + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(graphPtr->markers.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Marker *markerPtr; + int i; + + markerPtr = Blt_Chain_GetValue(link); + for (i = 3; i < objc; i++) { + const char *pattern; + + pattern = Tcl_GetString(objv[i]); + if (Tcl_StringMatch(markerPtr->obj.name, pattern)) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(markerPtr->obj.name, -1)); + break; + } + } + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * BindOp -- + * + * .g element bind elemName sequence command + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +BindOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + if (objc == 3) { + Blt_HashEntry *hp; + Blt_HashSearch iter; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (hp = Blt_FirstHashEntry(&graphPtr->markers.tagTable, &iter); + hp != NULL; hp = Blt_NextHashEntry(&iter)) { + const char *tag; + Tcl_Obj *objPtr; + + tag = Blt_GetHashKey(&graphPtr->markers.tagTable, hp); + objPtr = Tcl_NewStringObj(tag, -1); + Tcl_ListObjAppendElement(interp, listObjPtr, objPtr); + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; + } + return Blt_ConfigureBindingsFromObj(interp, graphPtr->bindTable, + Blt_MakeMarkerTag(graphPtr, Tcl_GetString(objv[3])), + objc - 4, objv + 4); +} + +/* + *--------------------------------------------------------------------------- + * + * CgetOp -- + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +CgetOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Marker *markerPtr; + + if (GetMarkerFromObj(interp, graphPtr, objv[3], &markerPtr) != TCL_OK) { + return TCL_ERROR; + } + if (Blt_ConfigureValueFromObj(interp, graphPtr->tkwin, + markerPtr->classPtr->configSpecs, (char *)markerPtr, objv[4], 0) + != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureOp -- + * + * Results: + * The return value is a standard TCL result. + * + * Side Effects: + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Marker *markerPtr; + Tcl_Obj *const *options; + const char *oldName; + const char *string; + int flags = BLT_CONFIG_OBJV_ONLY; + int nNames, nOpts; + int i; + int under; + + markerPtr = NULL; /* Suppress compiler warning. */ + + /* Figure out where the option value pairs begin */ + objc -= 3; + objv += 3; + for (i = 0; i < objc; i++) { + string = Tcl_GetString(objv[i]); + if (string[0] == '-') { + break; + } + if (GetMarkerFromObj(interp, graphPtr, objv[i], &markerPtr) != TCL_OK) { + return TCL_ERROR; + } + } + nNames = i; /* # of element names specified */ + nOpts = objc - i; /* # of options specified */ + options = objv + nNames; /* Start of options in objv */ + + for (i = 0; i < nNames; i++) { + GetMarkerFromObj(interp, graphPtr, objv[i], &markerPtr); + if (nOpts == 0) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, + markerPtr->classPtr->configSpecs, (char *)markerPtr, + (Tcl_Obj *)NULL, flags); + } else if (nOpts == 1) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, + markerPtr->classPtr->configSpecs, (char *)markerPtr, + options[0], flags); + } + /* Save the old marker name. */ + oldName = markerPtr->obj.name; + under = markerPtr->drawUnder; + if (Blt_ConfigureWidgetFromObj(interp, graphPtr->tkwin, + markerPtr->classPtr->configSpecs, nOpts, options, + (char *)markerPtr, flags) != TCL_OK) { + return TCL_ERROR; + } + if (oldName != markerPtr->obj.name) { + if (RenameMarker(graphPtr, markerPtr, oldName, markerPtr->obj.name) + != TCL_OK) { + markerPtr->obj.name = oldName; + return TCL_ERROR; + } + } + if ((*markerPtr->classPtr->configProc) (markerPtr) != TCL_OK) { + + return TCL_ERROR; + } + if (markerPtr->drawUnder != under) { + graphPtr->flags |= CACHE_DIRTY; + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * CreateOp -- + * + * This procedure creates and initializes a new marker. + * + * Results: + * The return value is a pointer to a structure describing the new + * element. If an error occurred, then the return value is NULL and an + * error message is left in interp->result. + * + * Side effects: + * Memory is allocated, etc. + * + *--------------------------------------------------------------------------- + */ +static int +CreateOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Marker *markerPtr; + Blt_HashEntry *hPtr; + int isNew; + ClassId classId; + int i; + const char *name; + char ident[200]; + const char *string; + char c; + + string = Tcl_GetString(objv[3]); + c = string[0]; + /* Create the new marker based upon the given type */ + if ((c == 't') && (strcmp(string, "text") == 0)) { + classId = CID_MARKER_TEXT; + } else if ((c == 'l') && (strcmp(string, "line") == 0)) { + classId = CID_MARKER_LINE; + } else if ((c == 'p') && (strcmp(string, "polygon") == 0)) { + classId = CID_MARKER_POLYGON; + } else if ((c == 'i') && (strcmp(string, "image") == 0)) { + classId = CID_MARKER_IMAGE; + } else if ((c == 'b') && (strcmp(string, "bitmap") == 0)) { + classId = CID_MARKER_BITMAP; + } else if ((c == 'w') && (strcmp(string, "window") == 0)) { + classId = CID_MARKER_WINDOW; + } else { + Tcl_AppendResult(interp, "unknown marker type \"", string, + "\": should be \"text\", \"line\", \"polygon\", \"bitmap\", \"image\", or \ +\"window\"", (char *)NULL); + return TCL_ERROR; + } + /* Scan for "-name" option. We need it for the component name */ + name = NULL; + for (i = 4; i < objc; i += 2) { + int length; + + string = Tcl_GetStringFromObj(objv[i], &length); + if ((length > 1) && (strncmp(string, "-name", length) == 0)) { + name = Tcl_GetString(objv[i + 1]); + break; + } + } + /* If no name was given for the marker, make up one. */ + if (name == NULL) { + sprintf_s(ident, 200, "marker%d", graphPtr->nextMarkerId++); + name = ident; + } else if (name[0] == '-') { + Tcl_AppendResult(interp, "name of marker \"", name, + "\" can't start with a '-'", (char *)NULL); + return TCL_ERROR; + } + markerPtr = CreateMarker(graphPtr, name, classId); + if (Blt_ConfigureComponentFromObj(interp, graphPtr->tkwin, name, + markerPtr->obj.className, markerPtr->classPtr->configSpecs, + objc - 4, objv + 4, (char *)markerPtr, 0) != TCL_OK) { + DestroyMarker(markerPtr); + return TCL_ERROR; + } + if ((*markerPtr->classPtr->configProc) (markerPtr) != TCL_OK) { + DestroyMarker(markerPtr); + return TCL_ERROR; + } + hPtr = Blt_CreateHashEntry(&graphPtr->markers.table, name, &isNew); + if (!isNew) { + Marker *oldPtr; + /* + * Marker by the same name already exists. Delete the old marker and + * it's list entry. But save the hash entry. + */ + oldPtr = Blt_GetHashValue(hPtr); + oldPtr->hashPtr = NULL; + DestroyMarker(oldPtr); + } + Blt_SetHashValue(hPtr, markerPtr); + markerPtr->hashPtr = hPtr; + /* Unlike elements, new markers are drawn on top of old markers. */ + markerPtr->link = Blt_Chain_Prepend(graphPtr->markers.displayList,markerPtr); + if (markerPtr->drawUnder) { + graphPtr->flags |= CACHE_DIRTY; + } + Blt_EventuallyRedrawGraph(graphPtr); + Tcl_SetStringObj(Tcl_GetObjResult(interp), name, -1); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DeleteOp -- + * + * Deletes the marker given by markerId. + * + * Results: + * The return value is a standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new display list. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +DeleteOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int i; + + for (i = 3; i < objc; i++) { + Marker *markerPtr; + + if (GetMarkerFromObj(NULL, graphPtr, objv[i], &markerPtr) == TCL_OK) { + markerPtr->flags |= DELETE_PENDING; + Tcl_EventuallyFree(markerPtr, FreeMarker); + } + } + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * GetOp -- + * + * Find the legend entry from the given argument. The argument can be + * either a screen position "@x,y" or the name of an element. + * + * I don't know how useful it is to test with the name of an element. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new legend attributes. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +GetOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Marker *markerPtr; + const char *string; + + string = Tcl_GetString(objv[3]); + if ((string[0] == 'c') && (strcmp(string, "current") == 0)) { + markerPtr = (Marker *)Blt_GetCurrentItem(graphPtr->bindTable); + if (markerPtr == NULL) { + return TCL_OK; /* Report only on markers. */ + + } + if ((markerPtr->obj.classId >= CID_MARKER_BITMAP) && + (markerPtr->obj.classId <= CID_MARKER_WINDOW)) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), + markerPtr->obj.name, -1); + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * RelinkOp -- + * + * Reorders the marker (given by the first name) before/after the another + * marker (given by the second name) in the marker display list. If no + * second name is given, the marker is placed at the beginning/end of the + * list. + * + * Results: + * A standard TCL result. + * + * Side Effects: + * Graph will be redrawn to reflect the new display list. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +RelinkOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Blt_ChainLink link, place; + Marker *markerPtr; + const char *string; + + /* Find the marker to be raised or lowered. */ + if (GetMarkerFromObj(interp, graphPtr, objv[3], &markerPtr) != TCL_OK) { + return TCL_ERROR; + } + /* Right now it's assumed that all markers are always in the display + list. */ + link = markerPtr->link; + Blt_Chain_UnlinkLink(graphPtr->markers.displayList, markerPtr->link); + + place = NULL; + if (objc == 5) { + if (GetMarkerFromObj(interp, graphPtr, objv[4], &markerPtr) != TCL_OK) { + return TCL_ERROR; + } + place = markerPtr->link; + } + + /* Link the marker at its new position. */ + string = Tcl_GetString(objv[2]); + if (string[0] == 'l') { + Blt_Chain_LinkAfter(graphPtr->markers.displayList, link, place); + } else { + Blt_Chain_LinkBefore(graphPtr->markers.displayList, link, place); + } + if (markerPtr->drawUnder) { + graphPtr->flags |= CACHE_DIRTY; + } + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * FindOp -- + * + * Returns if marker by a given ID currently exists. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +FindOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Blt_ChainLink link; + Region2d extents; + const char *string; + int enclosed; + int left, right, top, bottom; + int mode; + +#define FIND_ENCLOSED (1<<0) +#define FIND_OVERLAPPING (1<<1) + string = Tcl_GetString(objv[3]); + if (strcmp(string, "enclosed") == 0) { + mode = FIND_ENCLOSED; + } else if (strcmp(string, "overlapping") == 0) { + mode = FIND_OVERLAPPING; + } else { + Tcl_AppendResult(interp, "bad search type \"", string, + ": should be \"enclosed\", or \"overlapping\"", (char *)NULL); + return TCL_ERROR; + } + + if ((Tcl_GetIntFromObj(interp, objv[4], &left) != TCL_OK) || + (Tcl_GetIntFromObj(interp, objv[5], &top) != TCL_OK) || + (Tcl_GetIntFromObj(interp, objv[6], &right) != TCL_OK) || + (Tcl_GetIntFromObj(interp, objv[7], &bottom) != TCL_OK)) { + return TCL_ERROR; + } + if (left < right) { + extents.left = (double)left; + extents.right = (double)right; + } else { + extents.left = (double)right; + extents.right = (double)left; + } + if (top < bottom) { + extents.top = (double)top; + extents.bottom = (double)bottom; + } else { + extents.top = (double)bottom; + extents.bottom = (double)top; + } + enclosed = (mode == FIND_ENCLOSED); + for (link = Blt_Chain_FirstLink(graphPtr->markers.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Marker *markerPtr; + + markerPtr = Blt_Chain_GetValue(link); + if (markerPtr->flags & (HIDE|DELETE_PENDING)) { + continue; + } + if ((markerPtr->elemName != NULL) && (IsElementHidden(markerPtr))) { + continue; + } + if ((*markerPtr->classPtr->regionProc)(markerPtr, &extents, enclosed)) { + Tcl_Obj *objPtr; + + objPtr = Tcl_GetObjResult(interp); + Tcl_SetStringObj(objPtr, markerPtr->obj.name, -1); + return TCL_OK; + } + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), "", -1); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ExistsOp -- + * + * Returns if marker by a given ID currently exists. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ExistsOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Blt_HashEntry *hPtr; + + hPtr = Blt_FindHashEntry(&graphPtr->markers.table, Tcl_GetString(objv[3])); + Tcl_SetBooleanObj(Tcl_GetObjResult(interp), (hPtr != NULL)); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * TypeOp -- + * + * Returns a symbolic name for the type of the marker whose ID is given. + * + * Results: + * A standard TCL result. interp->result will contain the symbolic type + * of the marker. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +TypeOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Marker *markerPtr; + const char *type; + + if (GetMarkerFromObj(interp, graphPtr, objv[3], &markerPtr) != TCL_OK) { + return TCL_ERROR; + } + switch (markerPtr->obj.classId) { + case CID_MARKER_BITMAP: type = "bitmap"; break; + case CID_MARKER_IMAGE: type = "image"; break; + case CID_MARKER_LINE: type = "line"; break; + case CID_MARKER_POLYGON: type = "polygon"; break; + case CID_MARKER_TEXT: type = "text"; break; + case CID_MARKER_WINDOW: type = "window"; break; + default: type = "???"; break; + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), type, -1); + return TCL_OK; +} + +/* Public routines */ + +/* + *--------------------------------------------------------------------------- + * + * Blt_MarkerOp -- + * + * This procedure is invoked to process the TCL command that corresponds + * to a widget managed by this module. See the user documentation for + * details on what it does. + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ + +static Blt_OpSpec markerOps[] = +{ + {"bind", 1, BindOp, 3, 6, "marker sequence command",}, + {"cget", 2, CgetOp, 5, 5, "marker option",}, + {"configure", 2, ConfigureOp, 4, 0,"marker ?marker?... ?option value?...",}, + {"create", 2, CreateOp, 4, 0, "type ?option value?...",}, + {"delete", 1, DeleteOp, 3, 0, "?marker?...",}, + {"exists", 1, ExistsOp, 4, 4, "marker",}, + {"find", 1, FindOp, 8, 8, "enclosed|overlapping x1 y1 x2 y2",}, + {"get", 1, GetOp, 4, 4, "name",}, + {"lower", 1, RelinkOp, 4, 5, "marker ?afterMarker?",}, + {"names", 1, NamesOp, 3, 0, "?pattern?...",}, + {"raise", 1, RelinkOp, 4, 5, "marker ?beforeMarker?",}, + {"type", 1, TypeOp, 4, 4, "marker",}, +}; +static int nMarkerOps = sizeof(markerOps) / sizeof(Blt_OpSpec); + +/*ARGSUSED*/ +int +Blt_MarkerOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + GraphMarkerProc *proc; + int result; + + proc = Blt_GetOpFromObj(interp, nMarkerOps, markerOps, BLT_OP_ARG2, + objc, objv,0); + if (proc == NULL) { + return TCL_ERROR; + } + result = (*proc) (graphPtr, interp, objc, objv); + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_MarkersToPostScript -- + * + *--------------------------------------------------------------------------- + */ +void +Blt_MarkersToPostScript(Graph *graphPtr, Blt_Ps ps, int under) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_LastLink(graphPtr->markers.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + Marker *markerPtr; + + markerPtr = Blt_Chain_GetValue(link); + if ((markerPtr->classPtr->postscriptProc == NULL) || + (markerPtr->nWorldPts == 0)) { + continue; + } + if (markerPtr->drawUnder != under) { + continue; + } + if (markerPtr->flags & (HIDE|DELETE_PENDING)) { + continue; + } + if ((markerPtr->elemName != NULL) && (IsElementHidden(markerPtr))) { + continue; + } + Blt_Ps_VarAppend(ps, "\n% Marker \"", markerPtr->obj.name, + "\" is a ", markerPtr->obj.className, ".\n", (char *)NULL); + (*markerPtr->classPtr->postscriptProc) (markerPtr, ps); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DrawMarkers -- + * + * Calls the individual drawing routines (based on marker type) for each + * marker in the display list. + * + * A marker will not be drawn if + * + * 1) An element linked to the marker (indicated by elemName) is + * currently hidden. + * + * 2) No coordinates have been specified for the marker. + * + * 3) The marker is requesting to be drawn at a different level + * (above/below the elements) from the current mode. + * + * 4) The marker is configured as hidden (-hide option). + * + * 5) The marker isn't visible in the current viewport (i.e. clipped). + * + * Results: + * None + * + * Side Effects: + * Markers are drawn into the drawable (pixmap) which will eventually + * be displayed in the graph window. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DrawMarkers(Graph *graphPtr, Drawable drawable, int under) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_LastLink(graphPtr->markers.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + Marker *markerPtr; + + markerPtr = Blt_Chain_GetValue(link); + + if ((markerPtr->nWorldPts == 0) || + (markerPtr->drawUnder != under) || + (markerPtr->clipped) || + (markerPtr->flags & (DELETE_PENDING|HIDE))) { + continue; + } + if ((markerPtr->elemName != NULL) && (IsElementHidden(markerPtr))) { + continue; + } + (*markerPtr->classPtr->drawProc) (markerPtr, drawable); + } +} + +void +Blt_ConfigureMarkers(Graph *graphPtr) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(graphPtr->markers.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Marker *markerPtr; + + markerPtr = Blt_Chain_GetValue(link); + (*markerPtr->classPtr->configProc) (markerPtr); + } +} + +void +Blt_MapMarkers(Graph *graphPtr) +{ + Blt_ChainLink link; + + for (link = Blt_Chain_FirstLink(graphPtr->markers.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Marker *markerPtr; + + markerPtr = Blt_Chain_GetValue(link); + if (markerPtr->nWorldPts == 0) { + continue; + } + if (markerPtr->flags & (HIDE|DELETE_PENDING)) { + continue; + } + if ((graphPtr->flags & MAP_ALL) || (markerPtr->flags & MAP_ITEM)) { + (*markerPtr->classPtr->mapProc) (markerPtr); + markerPtr->flags &= ~MAP_ITEM; + } + } +} + +void +Blt_DestroyMarkers(Graph *graphPtr) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->markers.table, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + Marker *markerPtr; + + markerPtr = Blt_GetHashValue(hPtr); + /* + * Dereferencing the pointer to the hash table prevents the hash table + * entry from being automatically deleted. + */ + markerPtr->hashPtr = NULL; + DestroyMarker(markerPtr); + } + Blt_DeleteHashTable(&graphPtr->markers.table); + Blt_DeleteHashTable(&graphPtr->markers.tagTable); + Blt_Chain_Destroy(graphPtr->markers.displayList); +} + +Marker * +Blt_NearestMarker( + Graph *graphPtr, + int x, int y, /* Screen coordinates */ + int under) +{ + Blt_ChainLink link; + Point2d point; + + point.x = (double)x; + point.y = (double)y; + for (link = Blt_Chain_FirstLink(graphPtr->markers.displayList); + link != NULL; link = Blt_Chain_NextLink(link)) { + Marker *markerPtr; + + markerPtr = Blt_Chain_GetValue(link); + if ((markerPtr->nWorldPts == 0) || + (markerPtr->flags & (HIDE|DELETE_PENDING|MAP_ITEM))) { + continue; /* Don't consider markers that are + * pending to be mapped. Even if the + * marker has already been mapped, the + * coordinates could be invalid now. + * Better to pick no marker than the + * wrong marker. */ + + } + if ((markerPtr->elemName != NULL) && (IsElementHidden(markerPtr))) { + continue; + } + if ((markerPtr->drawUnder == under) && + (markerPtr->state == STATE_NORMAL)) { + if ((*markerPtr->classPtr->pointProc) (markerPtr, &point)) { + return markerPtr; + } + } + } + return NULL; +} + +ClientData +Blt_MakeMarkerTag(Graph *graphPtr, const char *tagName) +{ + Blt_HashEntry *hPtr; + int isNew; + + assert(tagName != NULL); + hPtr = Blt_CreateHashEntry(&graphPtr->markers.tagTable, tagName, &isNew); + return Blt_GetHashKey(&graphPtr->markers.tagTable, hPtr); +} + + +#ifdef notdef +/* + *--------------------------------------------------------------------------- + * + * ConfigureArrows -- + * + * If arrowheads have been requested for a line, this procedure makes + * arrangements for the arrowheads. + * + * Results: + * Always returns TCL_OK. + * + * Side effects: + * Information in linePtr is set up for one or two arrowheads. the + * firstArrowPtr and lastArrowPtr polygons are allocated and initialized, + * if need be, and the end points of the line are adjusted so that a + * thick line doesn't stick out past the arrowheads. + * + *--------------------------------------------------------------------------- + */ + + /* ARGSUSED */ +static int +ConfigureArrows(canvas, linePtr) + Tk_Canvas canvas; /* Canvas in which arrows will be + * displayed (interp and tkwin fields + * are needed). */ + LineItem *linePtr; /* Item to configure for arrows. */ +{ + double *poly, *coordPtr; + double dx, dy, length, sinTheta, cosTheta, temp; + double fracHeight; /* Line width as fraction of arrowhead + * width. */ + double backup; /* Distance to backup end points so + * the line ends in the middle of the + * arrowhead. */ + double vertX, vertY; /* Position of arrowhead vertex. */ + double shapeA, shapeB, shapeC; /* Adjusted coordinates (see + * explanation below). */ + double width; + Tk_State state = linePtr->header.state; + + if (linePtr->numPoints <2) { + return TCL_OK; + } + + if(state == TK_STATE_NULL) { + state = ((TkCanvas *)canvas)->canvas_state; + } + + width = linePtr->outline.width; + if (((TkCanvas *)canvas)->currentItemPtr == (Tk_Item *)linePtr) { + if (linePtr->outline.activeWidth>width) { + width = linePtr->outline.activeWidth; + } + } else if (state==TK_STATE_DISABLED) { + if (linePtr->outline.disabledWidth>0) { + width = linePtr->outline.disabledWidth; + } + } + + /* + * The code below makes a tiny increase in the shape parameters for the + * line. This is a bit of a hack, but it seems to result in displays that + * more closely approximate the specified parameters. Without the + * adjustment, the arrows come out smaller than expected. + */ + + shapeA = linePtr->arrowShapeA + 0.001; + shapeB = linePtr->arrowShapeB + 0.001; + shapeC = linePtr->arrowShapeC + width/2.0 + 0.001; + + /* + * If there's an arrowhead on the first point of the line, compute its + * polygon and adjust the first point of the line so that the line doesn't + * stick out past the leading edge of the arrowhead. + */ + + fracHeight = (width/2.0)/shapeC; + backup = fracHeight*shapeB + shapeA*(1.0 - fracHeight)/2.0; + if (linePtr->arrow != ARROWS_LAST) { + poly = linePtr->firstArrowPtr; + if (poly == NULL) { + poly = (double *) ckalloc((unsigned) + (2*PTS_IN_ARROW*sizeof(double))); + poly[0] = poly[10] = linePtr->coordPtr[0]; + poly[1] = poly[11] = linePtr->coordPtr[1]; + linePtr->firstArrowPtr = poly; + } + dx = poly[0] - linePtr->coordPtr[2]; + dy = poly[1] - linePtr->coordPtr[3]; + length = hypot(dx, dy); + if (length == 0) { + sinTheta = cosTheta = 0.0; + } else { + sinTheta = dy/length; + cosTheta = dx/length; + } + vertX = poly[0] - shapeA*cosTheta; + vertY = poly[1] - shapeA*sinTheta; + temp = shapeC*sinTheta; + poly[2] = poly[0] - shapeB*cosTheta + temp; + poly[8] = poly[2] - 2*temp; + temp = shapeC*cosTheta; + poly[3] = poly[1] - shapeB*sinTheta - temp; + poly[9] = poly[3] + 2*temp; + poly[4] = poly[2]*fracHeight + vertX*(1.0-fracHeight); + poly[5] = poly[3]*fracHeight + vertY*(1.0-fracHeight); + poly[6] = poly[8]*fracHeight + vertX*(1.0-fracHeight); + poly[7] = poly[9]*fracHeight + vertY*(1.0-fracHeight); + + /* + * Polygon done. Now move the first point towards the second so that + * the corners at the end of the line are inside the arrowhead. + */ + + linePtr->coordPtr[0] = poly[0] - backup*cosTheta; + linePtr->coordPtr[1] = poly[1] - backup*sinTheta; + } + + /* + * Similar arrowhead calculation for the last point of the line. + */ + + if (linePtr->arrow != ARROWS_FIRST) { + coordPtr = linePtr->coordPtr + 2*(linePtr->numPoints-2); + poly = linePtr->lastArrowPtr; + if (poly == NULL) { + poly = (double *) ckalloc((unsigned) + (2*PTS_IN_ARROW*sizeof(double))); + poly[0] = poly[10] = coordPtr[2]; + poly[1] = poly[11] = coordPtr[3]; + linePtr->lastArrowPtr = poly; + } + dx = poly[0] - coordPtr[0]; + dy = poly[1] - coordPtr[1]; + length = hypot(dx, dy); + if (length == 0) { + sinTheta = cosTheta = 0.0; + } else { + sinTheta = dy/length; + cosTheta = dx/length; + } + vertX = poly[0] - shapeA*cosTheta; + vertY = poly[1] - shapeA*sinTheta; + temp = shapeC*sinTheta; + poly[2] = poly[0] - shapeB*cosTheta + temp; + poly[8] = poly[2] - 2*temp; + temp = shapeC*cosTheta; + poly[3] = poly[1] - shapeB*sinTheta - temp; + poly[9] = poly[3] + 2*temp; + poly[4] = poly[2]*fracHeight + vertX*(1.0-fracHeight); + poly[5] = poly[3]*fracHeight + vertY*(1.0-fracHeight); + poly[6] = poly[8]*fracHeight + vertX*(1.0-fracHeight); + poly[7] = poly[9]*fracHeight + vertY*(1.0-fracHeight); + coordPtr[2] = poly[0] - backup*cosTheta; + coordPtr[3] = poly[1] - backup*sinTheta; + } + + return TCL_OK; +} +#endif diff --git a/src/bltGrMisc.C b/src/bltGrMisc.C new file mode 100644 index 0000000..101273e --- /dev/null +++ b/src/bltGrMisc.C @@ -0,0 +1,2024 @@ + + +/* + * bltGrMisc.c -- + * + * This module implements miscellaneous routines for the BLT graph widget. + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include <X11/Xutil.h> +#include <bltAlloc.h> +#include <bltOp.h> +#include <stdarg.h> + +static Blt_OptionParseProc ObjToPoint; +static Blt_OptionPrintProc PointToObj; +Blt_CustomOption bltPointOption = +{ + ObjToPoint, PointToObj, NULL, (ClientData)0 +}; + +static Blt_OptionParseProc ObjToLimitsProc; +static Blt_OptionPrintProc LimitsToObjProc; +Blt_CustomOption bltLimitsOption = +{ + ObjToLimitsProc, LimitsToObjProc, NULL, (ClientData)0 +}; + + +/* + *--------------------------------------------------------------------------- + * Custom option parse and print procedures + *--------------------------------------------------------------------------- + */ + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetXY -- + * + * Converts a string in the form "@x,y" into an XPoint structure of the x + * and y coordinates. + * + * Results: + * A standard TCL result. If the string represents a valid position + * *pointPtr* will contain the converted x and y coordinates and TCL_OK + * is returned. Otherwise, TCL_ERROR is returned and interp->result will + * contain an error message. + * + *--------------------------------------------------------------------------- + */ +int +Blt_GetXY(Tcl_Interp *interp, Tk_Window tkwin, const char *string, + int *xPtr, int *yPtr) +{ + char *comma; + int result; + int x, y; + + if ((string == NULL) || (*string == '\0')) { + *xPtr = *yPtr = -SHRT_MAX; + return TCL_OK; + } + if (*string != '@') { + goto badFormat; + } + comma = strchr(string + 1, ','); + if (comma == NULL) { + goto badFormat; + } + *comma = '\0'; + result = ((Tk_GetPixels(interp, tkwin, string + 1, &x) == TCL_OK) && + (Tk_GetPixels(interp, tkwin, comma + 1, &y) == TCL_OK)); + *comma = ','; + if (!result) { + Tcl_AppendResult(interp, ": can't parse position \"", string, "\"", + (char *)NULL); + return TCL_ERROR; + } + *xPtr = x, *yPtr = y; + return TCL_OK; + + badFormat: + Tcl_AppendResult(interp, "bad position \"", string, + "\": should be \"@x,y\"", (char *)NULL); + return TCL_ERROR; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToPoint -- + * + * Convert the string representation of a legend XY position into window + * coordinates. The form of the string must be "@x,y" or none. + * + * Results: + * A standard TCL result. The symbol type is written into the + * widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToPoint( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* New legend position string */ + char *widgRec, /* Widget record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + XPoint *pointPtr = (XPoint *)(widgRec + offset); + int x, y; + + if (Blt_GetXY(interp, tkwin, Tcl_GetString(objPtr), &x, &y) != TCL_OK) { + return TCL_ERROR; + } + pointPtr->x = x, pointPtr->y = y; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * PointToObj -- + * + * Convert the window coordinates into a string. + * + * Results: + * The string representing the coordinate position is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +PointToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Widget record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + XPoint *pointPtr = (XPoint *)(widgRec + offset); + Tcl_Obj *objPtr; + + if ((pointPtr->x != -SHRT_MAX) && (pointPtr->y != -SHRT_MAX)) { + char string[200]; + + sprintf_s(string, 200, "@%d,%d", pointPtr->x, pointPtr->y); + objPtr = Tcl_NewStringObj(string, -1); + } else { + objPtr = Tcl_NewStringObj("", -1); + } + return objPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToLimitsProc -- + * + * Converts the list of elements into zero or more pixel values which + * determine the range of pixel values possible. An element can be in any + * form accepted by Tk_GetPixels. The list has a different meaning based + * upon the number of elements. + * + * # of elements: + * + * 0 - the limits are reset to the defaults. + * 1 - the minimum and maximum values are set to this + * value, freezing the range at a single value. + * 2 - first element is the minimum, the second is the + * maximum. + * 3 - first element is the minimum, the second is the + * maximum, and the third is the nominal value. + * + * Any element may be the empty string which indicates the default. + * + * Results: + * The return value is a standard TCL result. The min and max fields + * of the range are set. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToLimitsProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back + * to */ + Tk_Window tkwin, /* Widget of paneset */ + Tcl_Obj *objPtr, /* New width list */ + char *widgRec, /* Widget record */ + int offset, /* Offset to field in structure */ + int flags) +{ + Blt_Limits *limitsPtr = (Blt_Limits *)(widgRec + offset); + + if (Blt_GetLimitsFromObj(interp, tkwin, objPtr, limitsPtr) != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * LimitsToObjProc -- + * + * Convert the limits of the pixel values allowed into a list. + * + * Results: + * The string representation of the limits is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +LimitsToObjProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Row/column structure record */ + int offset, /* Offset to field in structure */ + int flags) +{ + Blt_Limits *limitsPtr = (Blt_Limits *)(widgRec + offset); + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (limitsPtr->flags & LIMITS_MIN_SET) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(limitsPtr->min)); + } else { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("", -1)); + } + if (limitsPtr->flags & LIMITS_MAX_SET) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(limitsPtr->max)); + } else { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("", -1)); + } + if (limitsPtr->flags & LIMITS_NOM_SET) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(limitsPtr->nom)); + } else { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewStringObj("", -1)); + } + return listObjPtr; +} + +int +Blt_PointInSegments( + Point2d *samplePtr, + Segment2d *segments, + int nSegments, + double halo) +{ + Segment2d *sp, *send; + double minDist; + + minDist = DBL_MAX; + for (sp = segments, send = sp + nSegments; sp < send; sp++) { + double dist; + double left, right, top, bottom; + Point2d p, t; + + t = Blt_GetProjection((int)samplePtr->x, (int)samplePtr->y, + &sp->p, &sp->q); + if (sp->p.x > sp->q.x) { + right = sp->p.x, left = sp->q.x; + } else { + right = sp->q.x, left = sp->p.x; + } + if (sp->p.y > sp->q.y) { + bottom = sp->p.y, top = sp->q.y; + } else { + bottom = sp->q.y, top = sp->p.y; + } + p.x = BOUND(t.x, left, right); + p.y = BOUND(t.y, top, bottom); + dist = hypot(p.x - samplePtr->x, p.y - samplePtr->y); + if (dist < minDist) { + minDist = dist; + } + } + return (minDist < halo); +} + +int +Blt_PointInPolygon( + Point2d *s, /* Sample point. */ + Point2d *points, /* Points representing the polygon. */ + int nPoints) /* # of points in above array. */ +{ + Point2d *p, *q, *qend; + int count; + + count = 0; + for (p = points, q = p + 1, qend = p + nPoints; q < qend; p++, q++) { + if (((p->y <= s->y) && (s->y < q->y)) || + ((q->y <= s->y) && (s->y < p->y))) { + double b; + + b = (q->x - p->x) * (s->y - p->y) / (q->y - p->y) + p->x; + if (s->x < b) { + count++; /* Count the number of intersections. */ + } + } + } + return (count & 0x01); +} + +int +Blt_RegionInPolygon( + Region2d *regionPtr, + Point2d *points, + int nPoints, + int enclosed) +{ + Point2d *pp, *pend; + + if (enclosed) { + /* + * All points of the polygon must be inside the rectangle. + */ + for (pp = points, pend = pp + nPoints; pp < pend; pp++) { + if ((pp->x < regionPtr->left) || (pp->x > regionPtr->right) || + (pp->y < regionPtr->top) || (pp->y > regionPtr->bottom)) { + return FALSE; /* One point is exterior. */ + } + } + return TRUE; + } else { + Point2d r; + /* + * If any segment of the polygon clips the bounding region, the + * polygon overlaps the rectangle. + */ + points[nPoints] = points[0]; + for (pp = points, pend = pp + nPoints; pp < pend; pp++) { + Point2d p, q; + + p = *pp; + q = *(pp + 1); + if (Blt_LineRectClip(regionPtr, &p, &q)) { + return TRUE; + } + } + /* + * Otherwise the polygon and rectangle are either disjoint or + * enclosed. Check if one corner of the rectangle is inside the + * polygon. + */ + r.x = regionPtr->left; + r.y = regionPtr->top; + return Blt_PointInPolygon(&r, points, nPoints); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GraphExtents -- + * + * Generates a bounding box representing the plotting area of the + * graph. This data structure is used to clip the points and line + * segments of the line element. + * + * The clip region is the plotting area plus such arbitrary extra space. + * The reason we clip with a bounding box larger than the plot area is so + * that symbols will be drawn even if their center point isn't in the + * plotting area. + * + * Results: + * None. + * + * Side Effects: + * The bounding box is filled with the dimensions of the plotting area. + * + *--------------------------------------------------------------------------- + */ +void +Blt_GraphExtents(Graph *graphPtr, Region2d *regionPtr) +{ + regionPtr->left = (double)(graphPtr->hOffset - graphPtr->xPad.side1); + regionPtr->top = (double)(graphPtr->vOffset - graphPtr->yPad.side1); + regionPtr->right = (double)(graphPtr->hOffset + graphPtr->hRange + + graphPtr->xPad.side2); + regionPtr->bottom = (double)(graphPtr->vOffset + graphPtr->vRange + + graphPtr->yPad.side2); +} + +static int +ClipTest (double ds, double dr, double *t1, double *t2) +{ + double t; + + if (ds < 0.0) { + t = dr / ds; + if (t > *t2) { + return FALSE; + } + if (t > *t1) { + *t1 = t; + } + } else if (ds > 0.0) { + t = dr / ds; + if (t < *t1) { + return FALSE; + } + if (t < *t2) { + *t2 = t; + } + } else { + /* d = 0, so line is parallel to this clipping edge */ + if (dr < 0.0) { /* Line is outside clipping edge */ + return FALSE; + } + } + return TRUE; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_LineRectClip -- + * + * Clips the given line segment to a rectangular region. The coordinates + * of the clipped line segment are returned. The original coordinates + * are overwritten. + * + * Reference: + * Liang, Y-D., and B. Barsky, A new concept and method for + * Line Clipping, ACM, TOG,3(1), 1984, pp.1-22. + * + * Results: + * Returns if line segment is visible within the region. The coordinates + * of the original line segment are overwritten by the clipped + * coordinates. + * + *--------------------------------------------------------------------------- + */ +int +Blt_LineRectClip( + Region2d *regionPtr, /* Rectangular region to clip. */ + Point2d *p, Point2d *q) /* (in/out) Coordinates of original and + * clipped line segment. */ +{ + double t1, t2; + double dx, dy; + + t1 = 0.0, t2 = 1.0; + dx = q->x - p->x; + if ((ClipTest (-dx, p->x - regionPtr->left, &t1, &t2)) && + (ClipTest (dx, regionPtr->right - p->x, &t1, &t2))) { + dy = q->y - p->y; + if ((ClipTest (-dy, p->y - regionPtr->top, &t1, &t2)) && + (ClipTest (dy, regionPtr->bottom - p->y, &t1, &t2))) { + if (t2 < 1.0) { + q->x = p->x + t2 * dx; + q->y = p->y + t2 * dy; + } + if (t1 > 0.0) { + p->x += t1 * dx; + p->y += t1 * dy; + } + return TRUE; + } + } + return FALSE; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_PolyRectClip -- + * + * Clips the given polygon to a rectangular region. The resulting + * polygon is returned. Note that the resulting polyon may be complex, + * connected by zero width/height segments. The drawing routine (such as + * XFillPolygon) will not draw a connecting segment. + * + * Reference: + * Liang Y. D. and Brian A. Barsky, "Analysis and Algorithm for + * Polygon Clipping", Communications of ACM, Vol. 26, + * p.868-877, 1983 + * + * Results: + * Returns the number of points in the clipped polygon. The points of the + * clipped polygon are stored in *outputPts*. + * + *--------------------------------------------------------------------------- + */ +#define EPSILON FLT_EPSILON +#define AddVertex(vx, vy) r->x=(vx), r->y=(vy), r++, count++ +#define LastVertex(vx, vy) r->x=(vx), r->y=(vy), count++ + +int +Blt_PolyRectClip( + Region2d *regionPtr, /* Rectangular region clipping the polygon. */ + Point2d *points, /* Points of polygon to be clipped. */ + int nPoints, /* # of points in polygon. */ + Point2d *clipPts) /* (out) Points of clipped polygon. */ +{ + Point2d *p; /* First vertex of input polygon edge. */ + Point2d *pend; + Point2d *q; /* Last vertex of input polygon edge. */ + Point2d *r; + int count; + + r = clipPts; + count = 0; /* Counts # of vertices in output polygon. */ + + points[nPoints] = points[0]; + for (p = points, q = p + 1, pend = p + nPoints; p < pend; p++, q++) { + double dx, dy; + double tin1, tin2, tinx, tiny; + double xin, yin, xout, yout; + + dx = q->x - p->x; /* X-direction */ + dy = q->y - p->y; /* Y-direction */ + + if (FABS(dx) < EPSILON) { + dx = (p->x > regionPtr->left) ? -EPSILON : EPSILON ; + } + if (FABS(dy) < EPSILON) { + dy = (p->y > regionPtr->top) ? -EPSILON : EPSILON ; + } + + if (dx > 0.0) { /* Left */ + xin = regionPtr->left; + xout = regionPtr->right + 1.0; + } else { /* Right */ + xin = regionPtr->right + 1.0; + xout = regionPtr->left; + } + if (dy > 0.0) { /* Top */ + yin = regionPtr->top; + yout = regionPtr->bottom + 1.0; + } else { /* Bottom */ + yin = regionPtr->bottom + 1.0; + yout = regionPtr->top; + } + + tinx = (xin - p->x) / dx; + tiny = (yin - p->y) / dy; + + if (tinx < tiny) { /* Hits x first */ + tin1 = tinx; + tin2 = tiny; + } else { /* Hits y first */ + tin1 = tiny; + tin2 = tinx; + } + + if (tin1 <= 1.0) { + if (tin1 > 0.0) { + AddVertex(xin, yin); + } + if (tin2 <= 1.0) { + double toutx, touty, tout1; + + toutx = (xout - p->x) / dx; + touty = (yout - p->y) / dy; + tout1 = MIN(toutx, touty); + + if ((tin2 > 0.0) || (tout1 > 0.0)) { + if (tin2 <= tout1) { + if (tin2 > 0.0) { + if (tinx > tiny) { + AddVertex(xin, p->y + tinx * dy); + } else { + AddVertex(p->x + tiny * dx, yin); + } + } + if (tout1 < 1.0) { + if (toutx < touty) { + AddVertex(xout, p->y + toutx * dy); + } else { + AddVertex(p->x + touty * dx, yout); + } + } else { + AddVertex(q->x, q->y); + } + } else { + if (tinx > tiny) { + AddVertex(xin, yout); + } else { + AddVertex(xout, yin); + } + + } + } + } + } + } + if (count > 0) { + LastVertex(clipPts[0].x, clipPts[0].y); + } + return count; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetProjection -- + * + * Computes the projection of a point on a line. The line (given by two + * points), is assumed the be infinite. + * + * Compute the slope (angle) of the line and rotate it 90 degrees. Using + * the slope-intercept method (we know the second line from the sample + * test point and the computed slope), then find the intersection of both + * lines. This will be the projection of the sample point on the first + * line. + * + * Results: + * Returns the coordinates of the projection on the line. + * + *--------------------------------------------------------------------------- + */ +Point2d +Blt_GetProjection( + int x, int y, /* Screen coordinates of the sample point. */ + Point2d *p, Point2d *q) /* Line segment to project point onto */ +{ + double dx, dy; + Point2d t; + + dx = p->x - q->x; + dy = p->y - q->y; + + /* Test for horizontal and vertical lines */ + if (FABS(dx) < DBL_EPSILON) { + t.x = p->x, t.y = (double)y; + } else if (FABS(dy) < DBL_EPSILON) { + t.x = (double)x, t.y = p->y; + } else { + double m1, m2; /* Slope of both lines */ + double b1, b2; /* y-intercepts */ + double midX, midY; /* Midpoint of line segment. */ + double ax, ay, bx, by; + + /* Compute the slope and intercept of PQ. */ + m1 = (dy / dx); + b1 = p->y - (p->x * m1); + + /* + * Compute the slope and intercept of a second line segment: one that + * intersects through sample X-Y coordinate with a slope perpendicular + * to original line. + */ + + /* Find midpoint of PQ. */ + midX = (p->x + q->x) * 0.5; + midY = (p->y + q->y) * 0.5; + + /* Rotate the line 90 degrees */ + ax = midX - (0.5 * dy); + ay = midY - (0.5 * -dx); + bx = midX + (0.5 * dy); + by = midY + (0.5 * -dx); + + m2 = (ay - by) / (ax - bx); + b2 = y - (x * m2); + + /* + * Given the equations of two lines which contain the same point, + * + * y = m1 * x + b1 + * y = m2 * x + b2 + * + * solve for the intersection. + * + * x = (b2 - b1) / (m1 - m2) + * y = m1 * x + b1 + * + */ + + t.x = (b2 - b1) / (m1 - m2); + t.y = m1 * t.x + b1; + } + return t; +} + +typedef struct { + double hue, sat, val; +} HSV; + +#define SetColor(c,r,g,b) ((c)->red = (int)((r) * 65535.0), \ + (c)->green = (int)((g) * 65535.0), \ + (c)->blue = (int)((b) * 65535.0)) + +#ifdef notdef +void +Blt_XColorToHSV(XColor *colorPtr, HSV *hsvPtr) +{ + unsigned short max, min; + double range; + unsigned short *colorValues; + + /* Find the minimum and maximum RGB intensities */ + colorValues = (unsigned short *)&colorPtr->red; + max = MAX3(colorValues[0], colorValues[1], colorValues[2]); + min = MIN3(colorValues[0], colorValues[1], colorValues[2]); + + hsvPtr->val = (double)max / 65535.0; + hsvPtr->hue = hsvPtr->sat = 0.0; + + range = (double)(max - min); + if (max != min) { + hsvPtr->sat = range / (double)max; + } + if (hsvPtr->sat > 0.0) { + double red, green, blue; + + /* Normalize the RGB values */ + red = (double)(max - colorPtr->red) / range; + green = (double)(max - colorPtr->green) / range; + blue = (double)(max - colorPtr->blue) / range; + + if (colorPtr->red == max) { + hsvPtr->hue = (blue - green); + } else if (colorPtr->green == max) { + hsvPtr->hue = 2 + (red - blue); + } else if (colorPtr->blue == max) { + hsvPtr->hue = 4 + (green - red); + } + hsvPtr->hue *= 60.0; + } else { + hsvPtr->sat = 0.5; + } + if (hsvPtr->hue < 0.0) { + hsvPtr->hue += 360.0; + } +} + +void +Blt_HSVToXColor(HSV *hsvPtr, XColor *colorPtr) +{ + double hue, p, q, t; + double frac; + int quadrant; + + if (hsvPtr->val < 0.0) { + hsvPtr->val = 0.0; + } else if (hsvPtr->val > 1.0) { + hsvPtr->val = 1.0; + } + if (hsvPtr->sat == 0.0) { + SetColor(colorPtr, hsvPtr->val, hsvPtr->val, hsvPtr->val); + return; + } + hue = FMOD(hsvPtr->hue, 360.0) / 60.0; + quadrant = (int)floor(hue); + frac = hsvPtr->hue - quadrant; + p = hsvPtr->val * (1 - (hsvPtr->sat)); + q = hsvPtr->val * (1 - (hsvPtr->sat * frac)); + t = hsvPtr->val * (1 - (hsvPtr->sat * (1 - frac))); + + switch (quadrant) { + case 0: + SetColor(colorPtr, hsvPtr->val, t, p); + break; + case 1: + SetColor(colorPtr, q, hsvPtr->val, p); + break; + case 2: + SetColor(colorPtr, p, hsvPtr->val, t); + break; + case 3: + SetColor(colorPtr, p, q, hsvPtr->val); + break; + case 4: + SetColor(colorPtr, t, p, hsvPtr->val); + break; + case 5: + SetColor(colorPtr, hsvPtr->val, p, q); + break; + } +} +#endif + +/* + *--------------------------------------------------------------------------- + * + * Blt_AdjustViewport -- + * + * Adjusts the offsets of the viewport according to the scroll mode. + * This is to accommodate both "listbox" and "canvas" style scrolling. + * + * "canvas" The viewport scrolls within the range of world + * coordinates. This way the viewport always displays + * a full page of the world. If the world is smaller + * than the viewport, then (bizarrely) the world and + * viewport are inverted so that the world moves up + * and down within the viewport. + * + * "listbox" The viewport can scroll beyond the range of world + * coordinates. Every entry can be displayed at the + * top of the viewport. This also means that the + * scrollbar thumb weirdly shrinks as the last entry + * is scrolled upward. + * + * Results: + * The corrected offset is returned. + * + *--------------------------------------------------------------------------- + */ +int +Blt_AdjustViewport(int offset, int worldSize, int windowSize, int scrollUnits, + int scrollMode) +{ + switch (scrollMode) { + case BLT_SCROLL_MODE_CANVAS: + + /* + * Canvas-style scrolling allows the world to be scrolled within the + * window. + */ + if (worldSize < windowSize) { + if ((worldSize - offset) > windowSize) { + offset = worldSize - windowSize; + } + if (offset > 0) { + offset = 0; + } + } else { + if ((offset + windowSize) > worldSize) { + offset = worldSize - windowSize; + } + if (offset < 0) { + offset = 0; + } + } + break; + + case BLT_SCROLL_MODE_LISTBOX: + if (offset < 0) { + offset = 0; + } + if (offset >= worldSize) { + offset = worldSize - scrollUnits; + } + break; + + case BLT_SCROLL_MODE_HIERBOX: + + /* + * Hierbox-style scrolling allows the world to be scrolled within the + * window. + */ + if ((offset + windowSize) > worldSize) { + offset = worldSize - windowSize; + } + if (offset < 0) { + offset = 0; + } + break; + } + return offset; +} + +int +Blt_GetScrollInfoFromObj(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, + int *offsetPtr, int worldSize, int windowSize, + int scrollUnits, int scrollMode) +{ + char c; + const char *string; + int length; + int offset; + + offset = *offsetPtr; + string = Tcl_GetStringFromObj(objv[0], &length); + c = string[0]; + if ((c == 's') && (strncmp(string, "scroll", length) == 0)) { + double fract; + int count; + + if (objc != 3) { + return TCL_ERROR; + } + /* Scroll number unit/page */ + if (Tcl_GetIntFromObj(interp, objv[1], &count) != TCL_OK) { + return TCL_ERROR; + } + string = Tcl_GetStringFromObj(objv[2], &length); + c = string[0]; + if ((c == 'u') && (strncmp(string, "units", length) == 0)) { + fract = (double)count *scrollUnits; + } else if ((c == 'p') && (strncmp(string, "pages", length) == 0)) { + /* A page is 90% of the view-able window. */ + fract = (double)count * windowSize * 0.9; + } else { + Tcl_AppendResult(interp, "unknown \"scroll\" units \"", + Tcl_GetString(objv[2]), "\"", (char *)NULL); + return TCL_ERROR; + } + offset += (int)fract; + } else if ((c == 'm') && (strncmp(string, "moveto", length) == 0)) { + double fract; + + if (objc != 2) { + return TCL_ERROR; + } + /* moveto fraction */ + if (Tcl_GetDoubleFromObj(interp, objv[1], &fract) != TCL_OK) { + return TCL_ERROR; + } + offset = (int)(worldSize * fract); + } else { + double fract; + int count; + + /* Treat like "scroll units" */ + if (Tcl_GetIntFromObj(interp, objv[0], &count) != TCL_OK) { + return TCL_ERROR; + } + fract = (double)count *scrollUnits; + offset += (int)fract; + } + *offsetPtr = Blt_AdjustViewport(offset, worldSize, windowSize, scrollUnits, + scrollMode); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_UpdateScrollbar -- + * + * Invoke a TCL command to the scrollbar, defining the new position and + * length of the scroll. See the Tk documentation for further information + * on the scrollbar. It is assumed the scrollbar command prefix is + * valid. + * + * Results: + * None. + * + * Side Effects: + * Scrollbar is commanded to change position and/or size. + * + *--------------------------------------------------------------------------- + */ +void +Blt_UpdateScrollbar( + Tcl_Interp *interp, + Tcl_Obj *scrollCmdObjPtr, /* Scrollbar command prefix. May be + * several words */ + int first, int last, int width) +{ + Tcl_Obj *cmdObjPtr; + double firstFract, lastFract; + + firstFract = 0.0, lastFract = 1.0; + if (width > 0) { + firstFract = (double)first / (double)width; + lastFract = (double)last / (double)width; + } + cmdObjPtr = Tcl_DuplicateObj(scrollCmdObjPtr); + Tcl_ListObjAppendElement(interp, cmdObjPtr, Tcl_NewDoubleObj(firstFract)); + Tcl_ListObjAppendElement(interp, cmdObjPtr, Tcl_NewDoubleObj(lastFract)); + Tcl_IncrRefCount(cmdObjPtr); + if (Tcl_EvalObjEx(interp, cmdObjPtr, TCL_EVAL_GLOBAL) != TCL_OK) { + Tcl_BackgroundError(interp); + } + Tcl_DecrRefCount(cmdObjPtr); + +} + +/* -------------------------------------------------------------------------- */ +/* + *--------------------------------------------------------------------------- + * + * Blt_GetPrivateGCFromDrawable -- + * + * Like Tk_GetGC, but doesn't share the GC with any other widget. This + * is needed because the certain GC parameters (like dashes) can not be + * set via XCreateGC, therefore there is no way for Tk's hashing + * mechanism to recognize that two such GCs differ. + * + * Results: + * A new GC is returned. + * + *--------------------------------------------------------------------------- + */ +GC +Blt_GetPrivateGCFromDrawable( + Display *display, + Drawable drawable, + unsigned long gcMask, + XGCValues *valuePtr) +{ + GC newGC; + +#ifdef WIN32 + newGC = Blt_EmulateXCreateGC(display, drawable, gcMask, valuePtr); +#else + newGC = XCreateGC(display, drawable, gcMask, valuePtr); +#endif + return newGC; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetPrivateGC -- + * + * Like Tk_GetGC, but doesn't share the GC with any other widget. This + * is needed because the certain GC parameters (like dashes) can not be + * set via XCreateGC, therefore there is no way for Tk's hashing + * mechanism to recognize that two such GCs differ. + * + * Results: + * A new GC is returned. + * + *--------------------------------------------------------------------------- + */ +GC +Blt_GetPrivateGC( + Tk_Window tkwin, + unsigned long gcMask, + XGCValues *valuePtr) +{ + GC gc; + Pixmap pixmap; + Drawable drawable; + Display *display; + + pixmap = None; + drawable = Tk_WindowId(tkwin); + display = Tk_Display(tkwin); + if (drawable == None) { + Drawable root; + int depth; + + root = Tk_RootWindow(tkwin); + depth = Tk_Depth(tkwin); + + if (depth == DefaultDepth(display, Tk_ScreenNumber(tkwin))) { + drawable = root; + } else { + pixmap = Tk_GetPixmap(display, root, 1, 1, depth); + drawable = pixmap; + Blt_SetDrawableAttribs(display, drawable, 1, 1, depth, + Tk_Colormap(tkwin), Tk_Visual(tkwin)); + } + } + gc = Blt_GetPrivateGCFromDrawable(display, drawable, gcMask, valuePtr); + if (pixmap != None) { + Tk_FreePixmap(display, pixmap); + } + return gc; +} + +void +Blt_FreePrivateGC(Display *display, GC gc) +{ + Tk_FreeXId(display, (XID) XGContextFromGC(gc)); + XFreeGC(display, gc); +} + +#ifndef WIN32 +void +Blt_SetDashes(Display *display, GC gc, Blt_Dashes *dashesPtr) +{ + XSetDashes(display, gc, dashesPtr->offset, (const char *)dashesPtr->values, + (int)strlen((char *)dashesPtr->values)); +} +#endif + +void +Blt_ScreenDPI(Tk_Window tkwin, unsigned int *xPtr, unsigned int *yPtr) +{ + Screen *screen; + +#define MM_INCH 25.4 + screen = Tk_Screen(tkwin); + *xPtr = (unsigned int)((WidthOfScreen(screen) * MM_INCH) / + WidthMMOfScreen(screen)); + *yPtr = (unsigned int)((HeightOfScreen(screen) * MM_INCH) / + HeightMMOfScreen(screen)); +} + +void +Blt_Draw2DSegments( + Display *display, + Drawable drawable, + GC gc, + Segment2d *segments, + int nSegments) +{ + XSegment *dp, *xsegments; + Segment2d *sp, *send; + + xsegments = Blt_Malloc(nSegments * sizeof(XSegment)); + if (xsegments == NULL) { + return; + } + dp = xsegments; + for (sp = segments, send = sp + nSegments; sp < send; sp++) { + dp->x1 = (short int)sp->p.x; + dp->y1 = (short int)sp->p.y; + dp->x2 = (short int)sp->q.x; + dp->y2 = (short int)sp->q.y; + dp++; + } + XDrawSegments(display, drawable, gc, xsegments, nSegments); + Blt_Free(xsegments); +} + +void +Blt_DrawArrowOld(Display *display, Drawable drawable, GC gc, int x, int y, int w, + int h, int borderWidth, int orientation) +{ + XPoint arrow[4]; + int s2, s; + int ax, ay; + +#define ARROW_IPAD 1 + w -= 2 * (ARROW_IPAD + borderWidth); + h -= 2 * (ARROW_IPAD + borderWidth); + x += ARROW_IPAD + borderWidth; + y += ARROW_IPAD + borderWidth; + + w |= 0x01; + h |= 0x01; + s = MIN(w, h); + s2 = s / 2; + ax = x + w / 2; + ay = y + h / 2; + + switch (orientation) { + case ARROW_UP: + ay -= s2/2 + 1; + arrow[2].x = arrow[0].x = ax; + arrow[2].y = arrow[0].y = ay; + arrow[0].x = ax + s2 + 1; + arrow[1].x = ax - s2; + arrow[0].y = arrow[1].y = ay + s2 + 1; + fprintf(stderr, "up arrow %d,%d %d,%d %d,%d\n", + arrow[0].x, arrow[0].y, + arrow[1].x, arrow[1].y, + arrow[2].x, arrow[2].y); + break; + case ARROW_DOWN: + ay -= s2/2; + arrow[3].x = arrow[0].x = ax; + arrow[3].y = arrow[0].y = ay + s2 + 1; + arrow[1].x = ax + s2 + 1; + arrow[2].x = ax - s2; + arrow[2].y = arrow[1].y = ay; + fprintf(stderr, "down arrow %d,%d %d,%d %d,%d\n", + arrow[0].x, arrow[0].y, + arrow[1].x, arrow[1].y, + arrow[2].x, arrow[2].y); + break; + case ARROW_LEFT: + ax -= s2 / 2; + arrow[3].x = arrow[0].x = ax; + arrow[3].y = arrow[0].y = ay; + arrow[1].y = ay - s2; + arrow[2].y = ay + s2 + 1; + arrow[2].x = arrow[1].x = ax + s2 + 1; + break; + case ARROW_RIGHT: + ax -= s2 / 2; + arrow[3].x = arrow[0].x = ax + s2 + 1; + arrow[3].y = arrow[0].y = ay; + arrow[1].y = ay - s2; + arrow[2].y = ay + s2; + arrow[2].x = arrow[1].x = ax; + break; + } + XFillPolygon(display, drawable, gc, arrow, 3, Convex, CoordModeOrigin); +} + +void +Blt_DrawArrow(Display *display, Drawable drawable, XColor *color, int x, int y, + int w, int h, int borderWidth, int orientation) +{ + int s; + int s2; + int ax, ay; + int dx, dy; + GC gc; + +#define ARROW_IPAD 1 + w -= 2 * (ARROW_IPAD + borderWidth); + h -= 2 * (ARROW_IPAD + borderWidth); + x += ARROW_IPAD + borderWidth; + y += ARROW_IPAD + borderWidth; + + s = MIN(w, h); + s2 = (s / 2) + 1; + ax = x + w / 2; + ay = y + h / 2; + + gc = Tk_GCForColor(color, drawable); + switch (orientation) { + case ARROW_UP: + ay -= s2 / 2; + for (dx = 0; dx < s2; dx++, ay++) { + XDrawLine(display, drawable, gc, ax - dx, ay, ax + dx, ay); + } + break; + case ARROW_DOWN: + ay += s2 / 2; + for (dx = 0; dx < s2; dx++, ay--) { + XDrawLine(display, drawable, gc, ax - dx, ay, ax + dx, ay); + } + break; + case ARROW_LEFT: + ax -= s2 / 2; + for (dy = 0; dy < s2; dy++, ax++) { + XDrawLine(display, drawable, gc, ax, ay - dy, ax, ay + dy); + } + break; + case ARROW_RIGHT: + ax += s2 / 2; + for (dy = 0; dy < s2; dy++, ax--) { + XDrawLine(display, drawable, gc, ax, ay - dy, ax, ay + dy); + } + break; + } +} + +long +Blt_MaxRequestSize(Display *display, size_t elemSize) +{ + static long maxSizeBytes = 0L; + + if (maxSizeBytes == 0L) { + long size; +#ifndef WIN32 + size = XExtendedMaxRequestSize(display); + if (size == 0) { + size = XMaxRequestSize(display); + } +#else + size = XMaxRequestSize(display); +#endif + size -= (4 * elemSize); + /* maxSizeBytes = (size * 4); */ + maxSizeBytes = size; + } + return (maxSizeBytes / elemSize); +} + +void +Blt_GetLineExtents(size_t nPoints, Point2d *points, Region2d *r) +{ + Point2d *p, *pend; + r->top = r->left = DBL_MAX; + r->bottom = r->right = -DBL_MAX; + for (p = points, pend = p + nPoints; p < pend; p++) { + if (r->top > p->y) { + r->top = p->y; + } + if (r->bottom < p->y) { + r->bottom = p->y; + } + if (r->left > p->x) { + r->left = p->x; + } + if (r->right < p->x) { + r->right = p->x; + } + } +} + +#undef Blt_Fill3DRectangle +void +Blt_Fill3DRectangle( + Tk_Window tkwin, /* Window for which border was allocated. */ + Drawable drawable, /* X window or pixmap in which to draw. */ + Tk_3DBorder border, /* Token for border to draw. */ + int x, int y, + int width, int height, /* Outside area of rectangular region. */ + int borderWidth, /* Desired width for border, in pixels. Border + * will be *inside* region. */ + int relief) /* Indicates 3D effect: TK_RELIEF_FLAT, + * TK_RELIEF_RAISED, or TK_RELIEF_SUNKEN. */ +{ +#ifndef notdef + if ((borderWidth > 1) && (width > 2) && (height > 2) && + ((relief == TK_RELIEF_SUNKEN) || (relief == TK_RELIEF_RAISED))) { + GC lightGC, darkGC; + int x2, y2; + + x2 = x + width - 1; + y2 = y + height - 1; +#define TK_3D_LIGHT2_GC TK_3D_DARK_GC+1 +#define TK_3D_DARK2_GC TK_3D_DARK_GC+2 + if (relief == TK_RELIEF_RAISED) { + lightGC = Tk_3DBorderGC(tkwin, border, TK_3D_FLAT_GC); + darkGC = Tk_3DBorderGC(tkwin, border, TK_3D_DARK_GC); +#ifdef notdef + darkGC = DefaultGC(Tk_Display(tkwin), Tk_ScreenNumber(tkwin)); +#endif + } else { + + lightGC = Tk_3DBorderGC(tkwin, border, TK_3D_LIGHT_GC); +#ifdef notdef + lightGC = DefaultGC(Tk_Display(tkwin), Tk_ScreenNumber(tkwin)); +#endif + darkGC = Tk_3DBorderGC(tkwin, border, TK_3D_FLAT_GC); + } + XDrawLine(Tk_Display(tkwin), drawable, lightGC, x, y, x2, y); + XDrawLine(Tk_Display(tkwin), drawable, darkGC, x2, y2, x2, y); + XDrawLine(Tk_Display(tkwin), drawable, darkGC, x2, y2, x, y2); + XDrawLine(Tk_Display(tkwin), drawable, lightGC, x, y, x, y2); + x++, y++, width -= 2, height -= 2, borderWidth--; + } +#endif + Tk_Fill3DRectangle(tkwin, drawable, border, x, y, width, height, + borderWidth, relief); +} + + +#undef Blt_Draw3DRectangle +void +Blt_Draw3DRectangle( + Tk_Window tkwin, /* Window for which border was allocated. */ + Drawable drawable, /* X window or pixmap in which to draw. */ + Tk_3DBorder border, /* Token for border to draw. */ + int x, int y, + int width, int height, /* Outside area of rectangular region. */ + int borderWidth, /* Desired width for border, in pixels. Border + * will be *inside* region. */ + int relief) /* Indicates 3D effect: TK_RELIEF_FLAT, + * TK_RELIEF_RAISED, or TK_RELIEF_SUNKEN. */ +{ +#ifndef notdef + if ((borderWidth > 1) && (width > 2) && (height > 2) && + ((relief == TK_RELIEF_SUNKEN) || (relief == TK_RELIEF_RAISED))) { + GC lightGC, darkGC; + int x2, y2; + + x2 = x + width - 1; + y2 = y + height - 1; + if (relief == TK_RELIEF_RAISED) { + lightGC = Tk_3DBorderGC(tkwin, border, TK_3D_FLAT_GC); + darkGC = Tk_3DBorderGC(tkwin, border, TK_3D_DARK_GC); +#ifdef notdef + darkGC = DefaultGC(Tk_Display(tkwin), Tk_ScreenNumber(tkwin)); +#endif + } else { + lightGC = Tk_3DBorderGC(tkwin, border, TK_3D_LIGHT_GC); +#ifdef notdef + lightGC = DefaultGC(Tk_Display(tkwin), Tk_ScreenNumber(tkwin)); +#endif + darkGC = Tk_3DBorderGC(tkwin, border, TK_3D_FLAT_GC); + } + XDrawLine(Tk_Display(tkwin), drawable, darkGC, x2, y2, x2, y); + XDrawLine(Tk_Display(tkwin), drawable, lightGC, x, y, x2, y); + XDrawLine(Tk_Display(tkwin), drawable, darkGC, x2, y2, x, y2); + XDrawLine(Tk_Display(tkwin), drawable, lightGC, x, y, x, y2); + x++, y++, width -= 2, height -= 2, borderWidth--; + } +#endif + Tk_Draw3DRectangle(tkwin, drawable, border, x, y, width, height, + borderWidth, relief); +} + +#ifdef notdef +typedef struct { + Screen *screen; + Visual *visual; + Colormap colormap; + Tk_Uid nameUid; +} BorderKey; + +typedef struct { + Screen *screen; /* Screen on which the border will be used. */ + Visual *visual; /* Visual for all windows and pixmaps using + * the border. */ + int depth; /* Number of bits per pixel of drawables where + * the border will be used. */ + Colormap colormap; /* Colormap out of which pixels are + * allocated. */ + int refCount; /* Number of active uses of this color (each + * active use corresponds to a call to + * Blt_Get3DBorder). If this count is 0, then + * this structure is no longer valid and it + * isn't present in borderTable: it is being + * kept around only because there are objects + * referring to it. The structure is freed + * when refCount is 0. */ + + XColor *bgColorPtr; /* Color of face. */ + XColor *shadows[4]; + + Pixmap darkStipple; /* Stipple pattern to use for drawing shadows + * areas. Used for displays with <= 64 colors + * or where colormap has filled up. */ + Pixmap lightStipple; /* Stipple pattern to use for drawing shadows + * areas. Used for displays with <= 64 colors + * or where colormap has filled up. */ + GC bgGC; /* Used (if necessary) to draw areas in the + * background color. */ + GC lightGC, darkGC; + Tcl_HashEntry *hashPtr; /* Entry in borderTable (needed in order to + * delete structure). */ + + struct _Blt_3DBorder *nextPtr; +} Border, *Blt_3DBorder; + + +void +Blt_Draw3DRectangle(tkwin, drawable, border, x, y, width, + height, borderWidth, relief) + Tk_Window tkwin; /* Window for which border was allocated. */ + Drawable drawable; /* X window or pixmap in which to draw. */ + Blt_3DBorder *borderPtr; /* Border to draw. */ + int x, y, width, height; /* Outside area of rectangular region. */ + int borderWidth; /* Desired width for border, in + * pixels. Border will be *inside* region. */ + int relief; /* Indicates 3D effect: TK_RELIEF_FLAT, + * TK_RELIEF_RAISED, or TK_RELIEF_SUNKEN. */ +{ + if ((width > (2 * borderWidth)) && (height > (2 * borderWidth))) { + int x2, y2; + int i; + + x2 = x + width - 1; + y2 = y + height - 1; + + XSetForeground(borderPtr->lightGC, borderPtr->shadows[0]); + XSetForeground(borderPtr->darkGC, borderPtr->shadows[3]); + XDrawLine(Tk_Display(tkwin), drawable, borderPtr->lightGC, + x, y, x2, y); + XDrawLine(Tk_Display(tkwin), drawable, borderPtr->lightGC, + x, y, x, y2); + XDrawLine(Tk_Display(tkwin), drawable, borderPtr->darkGC, + x2, y, x2, y2); + XDrawLine(Tk_Display(tkwin), drawable, borderPtr->darkGC, + x2, y2, x, y2); + XSetForeground(borderPtr->lightGC, borderPtr->shadows[1]); + XSetForeground(borderPtr->darkGC, borderPtr->shadows[2]); + for (i = 1; i < (borderWidth - 1); i++) { + + /* + * +---------- + * |+------- + * ||+----- + * ||| + * ||| + * || + * | + */ + x++, y++, x2--, y2--; + XDrawLine(Tk_Display(tkwin), drawable, borderPtr->lightGC, + x, y, x2, y); + XDrawLine(Tk_Display(tkwin), drawable, borderPtr->lightGC, + x, y, x, y2); + XDrawLine(Tk_Display(tkwin), drawable, borderPtr->darkGC, + x2, y, x2, y2); + XDrawLine(Tk_Display(tkwin), drawable, borderPtr->darkGC, + x2, y2, x, y2); + } + } +} + +void +Blt_Fill3DRectangle(tkwin, drawable, border, x, y, width, height, borderWidth, + relief) + Tk_Window tkwin; /* Window for which border was allocated. */ + Drawable drawable; /* X window or pixmap in which to draw. */ + Tk_3DBorder border; /* Token for border to draw. */ + int x, y, width, height; /* Outside area of rectangular region. */ + int borderWidth; /* Desired width for border, in + * pixels. Border will be *inside* region. */ + int relief; /* Indicates 3D effect: TK_RELIEF_FLAT, + * TK_RELIEF_RAISED, or TK_RELIEF_SUNKEN. */ +{ + Blt_3DBorder *borderPtr; + + XFillRectangle(Tk_Display(tkwin), drawable, borderPtr->bgGC, x, y, width, + height); + if ((borderWidth > 0) && (relief != BLT_RELIEF_FLAT)) { + Blt_Draw3DRectangle(tkwin, drawable, borderPtr, x, y, width, height, + borderWidth, relief); + } +} + + +void +FreeBorder(display, borderPtr) + Display *display; + Border *borderPtr; +{ + int i; + + if (borderPtr->bgColorPtr != NULL) { + Tk_FreeColor(display, borderPtr->bgColorPtr); + } + for (i = 0; i < 4; i++) { + Tk_FreeColor(display, borderPtr->shadows[i]); + } + if (borderPtr->darkGC != NULL) { + Blt_FreePrivateGC(display, borderPtr->darkGC); + } + if (borderPtr->lightGC != NULL) { + Blt_FreePrivateGC(tkwin, borderPtr->lightGC); + } + if (borderPtr->bgGC != NULL) { + Blt_FreePrivateGC(tkwin, borderPtr->bgGC); + } + Blt_Free(borderPtr); +} + +void +Blt_Free3DBorder(display, border) + Display *display; + Blt_3DBorder border; +{ + Border *borderPtr = (Border *)border; + + borderPtr->refCount--; + if (borderPtr->refCount >= 0) { + /* Search for the border in the bucket. Start at the head. */ + headPtr = Blt_GetHashValue(borderPtr->hashPtr); + lastPtr = NULL; + while ((headPtr != borderPtr) && (headPtr != NULL)) { + lastPtr = headPtr; + headPtr = headPtr->next; + } + if (headPtr == NULL) { + return; /* This can't happen. It means that we could + * not find the border. */ + } + if (lastPtr != NULL) { + lastPtr->next = borderPtr->next; + } else { + Tcl_DeleteHashEntry(borderPtr->hashPtr); + } + FreeBorder(display, borderPtr); + } +} + +Blt_3DBorder * +Blt_Get3DBorder(Tcl_Interp *interp, Tk_Window tkwin, const char *borderName) +{ + Blt_3DBorder *borderPtr, *lastBorderPtr; + Blt_HashEntry *hPtr; + XColor *bgColorPtr; + char **argv; + const char *colorName; + int argc; + int isNew; + + lastBorderPtr = NULL; + hPtr = Tcl_CreateHashEntry(&dataPtr->borderTable, borderName, &isNew); + if (!isNew) { + borderPtr = lastBorderPtr = Blt_GetHashValue(hPtr); + while (borderPtr != NULL) { + if ((Tk_Screen(tkwin) == borderPtr->screen) && + (Tk_Colormap(tkwin) == borderPtr->colormap)) { + borderPtr->refCount++; + return borderPtr; + } + borderPtr = borderPtr->nextPtr; + } + } + /* Create a new border. */ + argv = NULL; + bgColorPtr = NULL; + + if (Tcl_SplitList(interp, borderName, &argc, &argv) != TCL_OK) { + goto error; + } + colorName = borderName; + bgColorPtr = Tk_GetColor(interp, tkwin, colorName); + if (bgColorPtr == NULL) { + goto error; + } + + /* Create a new border */ + borderPtr = Blt_AssertCalloc(1, sizeof(Blt_3DBorder)); + borderPtr->screen = Tk_Screen(tkwin); + borderPtr->visual = Tk_Visual(tkwin); + borderPtr->depth = Tk_Depth(tkwin); + borderPtr->colormap = Tk_Colormap(tkwin); + borderPtr->refCount = 1; + borderPtr->bgColorPtr = bgColorPtr; + borderPtr->darkGC = Blt_GetPrivateGC(tkwin, 0, NULL); + borderPtr->lightGC = Blt_GetPrivateGC(tkwin, 0, NULL); + borderPtr->hashPtr = lastBorderPtr->hashPtr; + lastBorderPtr->nextPtr = lastBorderPtr; + { + HSV hsv; + XColor color; + double sat, sat0, diff, step, hstep; + int count; + + /* Convert the face (background) color to HSV */ + Blt_XColorToHSV(borderPtr->bgColorPtr, &hsv); + + /* Using the color as the baseline intensity, pick a set of colors + * around the intensity. */ +#define UFLOOR(x,u) (floor((x)*(u))/(u)) + diff = hsv.sat - UFLOOR(hsv.sat, 0.2); + sat = 0.1 + (diff - 0.1); + sat0 = hsv.sat; + count = 0; + for (sat = 0.1 + (diff - 0.1); sat <= 1.0; sat += 0.2) { + if (FABS(sat0 - sat) >= 0.1) { + hsv.sat = sat; + Blt_HSVToXColor(&hsv, &color); + borderPtr->shadows[count] = Tk_GetColorByValue(tkwin, &color); + count++; + } + } + } + Blt_SetHashValue(hPtr, borderPtr); + if (argv != NULL) { + Blt_Free(argv); + } + return TCL_OK; + + error: + if (argv != NULL) { + Blt_Free(argv); + } + if (bgColorPtr != NULL) { + Tk_FreeColor(bgColorPtr); + } + if (isNew) { + Blt_DeleteHashEntry(&borderTable, hPtr); + } + return NULL; +} + + +#endif + +typedef struct { + float x, y, z; +} Vector3f; + +typedef struct { + float x, y, z, w; +} Vector4f; + +typedef Vector4f Quaternion; + +typedef float Matrix3x3f[3][3]; + +typedef struct _ArcBall { + Vector3f click; + Vector3f drag; + float xScale; + float yScale; +} ArcBall; + +/* + * Arcball sphere constants: + * Diameter is 2.0f + * Radius is 1.0f + * Radius squared is 1.0f + */ + +/* assuming IEEE-754 (float), which i believe has max precision of 7 bits */ +#define EPSILON FLT_EPSILON +static INLINE float +LengthVector3f(Vector3f *a) +{ + return sqrtf((a->x * a->x) + (a->y * a->y) + (a->z * a->z)); +} + +static INLINE float DotProductVector3f(Vector3f *a, Vector3f *b) +{ + return (a->x * b->x) + (a->y * b->y) + (a->z * b->z); +} + +/** + * Calculate the cross product of two 3D vectors: c = a x b. + * "c" must not refer to the same memory location as "a" or "b". + */ +static INLINE void +CrossProductVector3f(Vector3f *a, Vector3f *b, Vector3f *c) +{ + c->x = (a->y * b->z) - (b->y * a->z); + c->y = (a->z * b->x) - (b->z * a->x); + c->z = (a->x * b->y) - (b->x * a->y); +} + +static void +PointOnSphere (ArcBall *arcPtr, float x, float y, Vector3f *outPtr) +{ + float sx, sy; + float d; + + /* Adjust point coords and scale down to range of [-1 ... 1] */ + sx = (x * arcPtr->xScale) - 1.0f; + sy = 1.0f - (y * arcPtr->yScale); + + /* Compute the square of the length of the vector to the point from the + * center. */ + d = (sx * sx) + (sy * sy); + + /* If the point is mapped outside of the sphere ... + * (length > radius squared) + */ + if (d > 1.0f) { + float scale; + + /* Compute a normalizing factor (radius / sqrt(length)) */ + scale = 1.0f / sqrt (d); + + /* Return the "normalized" vector, a point on the sphere */ + outPtr->x = sx * scale; + outPtr->y = sy * scale; + outPtr->z = 0.0f; + } else { /* else it's on the inside */ + /* Return a vector to a point mapped inside the sphere + * sqrt(radius squared - length) */ + outPtr->x = sx; + outPtr->y = sy; + outPtr->z = sqrtf(1.0f - d); + } +} + +static void +SetArcBallBounds(ArcBall *arcPtr, float w, float h) +{ + if (w <= 1.0f ) { + w = 2.0f; + } + if (h <= 1.0f ) { + h = 2.0f; + } + /* Set adjustment factor for width/height */ + arcPtr->xScale = 1.0f / ((w - 1.0f) * 0.5f); + arcPtr->yScale = 1.0f / ((h - 1.0f) * 0.5f); +} + +static ArcBall * +CreateArcBall (float w, float h) +{ + ArcBall *arcPtr; + + arcPtr = Blt_AssertCalloc(1, sizeof(ArcBall)); + SetArcBallBounds (arcPtr, w, h); + return arcPtr; +} + +static void +DestroyArcBall(ArcBall *arcPtr) +{ + if (arcPtr != NULL) { + Blt_Free(arcPtr); + } +} + +/* Mouse down: Supply mouse position in x and y */ +static void +ArcBallOnClick(ArcBall *arcPtr, float x, float y) +{ + PointOnSphere (arcPtr, x, y, &arcPtr->click); +} + +/* Mouse drag, calculate rotation: Supply mouse position in x and y */ +static void +ArcBallOnDrag(ArcBall *arcPtr, float x, float y, Quaternion *outPtr) +{ + /* Map the point to the sphere */ + PointOnSphere(arcPtr, x, y, &arcPtr->drag); + + /* Return the quaternion equivalent to the rotation */ + if (outPtr != NULL) { + Vector3f perp; + + /* Compute the vector perpendicular to the begin and end vectors */ + CrossProductVector3f(&arcPtr->drag, &arcPtr->click, &perp); + + /* Compute the length of the perpendicular vector */ + if (LengthVector3f(&perp) > FLT_EPSILON) { + /* If its non-zero, we're ok, so return the perpendicular + * vector as the transform after all + */ + outPtr->x = perp.x; + outPtr->y = perp.y; + outPtr->z = perp.z; + /* In the quaternion values, w is cosine (theta / 2), + * where theta is rotation angle + */ + outPtr->w = DotProductVector3f(&arcPtr->click, &arcPtr->drag); + } else { + /* If it is zero, the begin and end vectors coincide, + * so return an identity transform + */ + outPtr->x = outPtr->y = outPtr->z = outPtr->z = 0.0f; + } + } +} + + +static INLINE void +SetRotationMatrix(const Quaternion* q, Matrix3x3f mat) +{ + float n, s; + float xs, ys, zs; + float wx, wy, wz; + float xx, xy, xz; + float yy, yz, zz; + + assert(mat && q); + + n = (q->x * q->x) + (q->y * q->y) + (q->z * q->z) + (q->w * q->w); + + s = (n > 0.0f) ? (2.0f / n) : 0.0f; + + xs = q->x * s; + ys = q->y * s; + zs = q->z * s; + wx = q->w * xs; + wy = q->w * ys; + wz = q->w * zs; + xx = q->x * xs; + xy = q->x * ys; + xz = q->x * zs; + yy = q->y * ys; + yz = q->y * zs; + zz = q->z * zs; + + mat[0][0] = 1.0f - (yy + zz); + mat[0][1] = xy - wz; + mat[0][2] = xz + wy; + mat[1][0] = xy + wz; + mat[1][1] = 1.0f - (xx + zz); + mat[1][2] = yz - wx; + mat[2][0] = xz - wy; + mat[2][1] = yz + wx; + mat[2][2] = 1.0f - (xx + yy); +} + +/* Return quaternion product qL * qR. Note: order is important! + * To combine rotations, use the product Mul(Second, First), + * which gives the effect of rotating by First then Second. */ +static INLINE void +CombineRotations(Quaternion *a, Quaternion *b, Quaternion *result) +{ + result->w = (a->w * b->w) - (a->x * b->x) - (a->y * b->y) - (a->z * b->z); + result->x = (a->w * b->x) + (a->x * b->w) + (a->y * b->z) - (a->z * b->y); + result->y = (a->w * b->y) + (a->y * b->w) + (a->z * b->x) - (a->x * b->z); + result->z = (a->w * b->z) + (a->z * b->w) + (a->x * b->y) - (a->y * b->x); +} + + +static int +GetQuaternionFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, Quaternion *q) +{ + Tcl_Obj **objv; + int objc; + double x, y, z, w; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if (objc != 4) { + Tcl_AppendResult(interp, "wrong number of elements in quaternion \"", + Tcl_GetString(objPtr), "\"", (char *)NULL); + return TCL_ERROR; + } + if ((Tcl_GetDoubleFromObj(interp, objv[0], &x) != TCL_OK) || + (Tcl_GetDoubleFromObj(interp, objv[1], &y) != TCL_OK) || + (Tcl_GetDoubleFromObj(interp, objv[2], &z) != TCL_OK) || + (Tcl_GetDoubleFromObj(interp, objv[3], &w) != TCL_OK)) { + return TCL_ERROR; + } + q->x = x, q->y = y, q->z = z, q->w = w; + return TCL_OK; +} + +static int +ArcBallCombineOp(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Tcl_Obj *listObjPtr; + Quaternion q1, q2, r; + + if (GetQuaternionFromObj(interp, objv[2], &q1) != TCL_OK) { + return TCL_ERROR; + } + if (GetQuaternionFromObj(interp, objv[3], &q2) != TCL_OK) { + return TCL_ERROR; + } + CombineRotations(&q2, &q1, &r); + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(r.x)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(r.y)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(r.w)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(r.z)); + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +static int +ArcBallRotateOp(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + ArcBall *arcPtr; + Tcl_Obj *listObjPtr; + Quaternion q; + double x1, y1, x2, y2; + int w, h; + + if ((Tcl_GetIntFromObj(interp, objv[2], &w) != TCL_OK) || + (Tcl_GetIntFromObj(interp, objv[3], &h) != TCL_OK)) { + return TCL_ERROR; + } + if ((Tcl_GetDoubleFromObj(interp, objv[4], &x1) != TCL_OK) || + (Tcl_GetDoubleFromObj(interp, objv[5], &y1) != TCL_OK) || + (Tcl_GetDoubleFromObj(interp, objv[6], &x2) != TCL_OK) || + (Tcl_GetDoubleFromObj(interp, objv[7], &y2) != TCL_OK)) { + return TCL_ERROR; + } + arcPtr = CreateArcBall((float)w, (float)h); + ArcBallOnClick(arcPtr, x1, y1); + ArcBallOnDrag(arcPtr, x2, y2, &q); + DestroyArcBall(arcPtr); + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(q.x)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(q.y)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(q.w)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(q.z)); + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +static int +ArcBallMatrixOp(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Matrix3x3f rot; + Tcl_Obj *listObjPtr; + Quaternion q; + + if (GetQuaternionFromObj(interp, objv[2], &q) != TCL_OK) { + return TCL_ERROR; + } + SetRotationMatrix(&q, rot); + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[0][0])); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[0][1])); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[0][2])); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[1][0])); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[1][1])); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[1][2])); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[2][0])); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[2][1])); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(rot[2][2])); + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +static Blt_OpSpec arcBallOps[] = +{ + {"combine", 1, ArcBallCombineOp, 4, 4, "quat1 quat2",}, + {"matrix", 1, ArcBallMatrixOp, 3, 3, "quat",}, + {"rotate", 1, ArcBallRotateOp, 8, 8, "w h x1 y1 x2 y2",}, +}; +static int nArcBallOps = sizeof(arcBallOps) / sizeof(Blt_OpSpec); + +static int +ArcBallCmd(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + Tcl_ObjCmdProc *proc; + + proc = Blt_GetOpFromObj(interp, nArcBallOps, arcBallOps, BLT_OP_ARG1, + objc, objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + return (*proc) (clientData, interp, objc, objv); +} + +#undef Tk_GetPixmap +Pixmap +Blt_GetPixmap(Display *display, Drawable drawable, int w, int h, int depth, + int lineNum, const char *fileName) +{ + if (w <= 0) { + fprintf(stderr, "line %d of %s: width is %d\n", + lineNum, fileName, w); + abort(); + } + if (h <= 0) { + fprintf(stderr, "line %d of %s: height is %d\n", + lineNum, fileName, h); + abort(); + } + return Tk_GetPixmap(display, drawable, w, h, depth); +} diff --git a/src/bltGrPSOutput.C b/src/bltGrPSOutput.C new file mode 100644 index 0000000..44cfdb8 --- /dev/null +++ b/src/bltGrPSOutput.C @@ -0,0 +1,1697 @@ + +/* + * bltPs.c -- + * + * This module implements general PostScript conversion routines. + * + * Copyright 1991-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + */ + +#include "bltInt.h" +#include <stdarg.h> +#include <X11/Xutil.h> +#include <X11/Xatom.h> +#include "tkIntBorder.h" +#include "bltDBuffer.h" +#include "bltPicture.h" +#include "bltPsInt.h" +#include "tkDisplay.h" +#include "tkFont.h" + +#define PS_MAXPATH 1500 /* Maximum number of components in a + * PostScript (level 1) path. */ + +#define PICA_MM 2.83464566929 +#define PICA_INCH 72.0 +#define PICA_CM 28.3464566929 + +static Tcl_Interp *psInterp = NULL; + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_GetPica -- + * + * Given a string, returns the number of pica corresponding to that + * string. + * + * Results: + * The return value is a standard TCL return result. If TCL_OK is + * returned, then everything went well and the pixel distance is stored + * at *doublePtr; otherwise TCL_ERROR is returned and an error message is + * left in interp->result. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Ps_GetPicaFromObj( + Tcl_Interp *interp, /* Use this for error reporting. */ + Tcl_Obj *objPtr, /* String describing a number of + * pixels. */ + int *picaPtr) /* Place to store converted result. */ +{ + char *p; + double pica; + const char *string; + + string = Tcl_GetString(objPtr); + pica = strtod((char *)string, &p); + if (p == string) { + goto error; + } + if (pica < 0.0) { + goto error; + } + while ((*p != '\0') && isspace(UCHAR(*p))) { + p++; + } + switch (*p) { + case '\0': break; + case 'c': pica *= PICA_CM; p++; break; + case 'i': pica *= PICA_INCH; p++; break; + case 'm': pica *= PICA_MM; p++; break; + case 'p': p++; break; + default: goto error; + } + while ((*p != '\0') && isspace(UCHAR(*p))) { + p++; + } + if (*p == '\0') { + *picaPtr = ROUND(pica); + return TCL_OK; + } + error: + Tcl_AppendResult(interp, "bad screen distance \"", string, "\"", + (char *) NULL); + return TCL_ERROR; +} + +int +Blt_Ps_GetPadFromObj( + Tcl_Interp *interp, /* Interpreter to send results back + * to */ + Tcl_Obj *objPtr, /* Pixel value string */ + Blt_Pad *padPtr) +{ + int side1, side2; + int objc; + Tcl_Obj **objv; + + if (Tcl_ListObjGetElements(interp, objPtr, &objc, &objv) != TCL_OK) { + return TCL_ERROR; + } + if ((objc < 1) || (objc > 2)) { + Tcl_AppendResult(interp, "wrong # elements in padding list", + (char *)NULL); + return TCL_ERROR; + } + if (Blt_Ps_GetPicaFromObj(interp, objv[0], &side1) != TCL_OK) { + return TCL_ERROR; + } + side2 = side1; + if ((objc > 1) && + (Blt_Ps_GetPicaFromObj(interp, objv[1], &side2) != TCL_OK)) { + return TCL_ERROR; + } + /* Don't update the pad structure until we know both values are okay. */ + padPtr->side1 = side1; + padPtr->side2 = side2; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_ComputeBoundingBox -- + * + * Computes the bounding box for the PostScript plot. First get the size + * of the plot (by default, it's the size of graph's X window). If the + * plot plus the page border is bigger than the designated paper size, or + * if the "-maxpect" option is turned on, scale the plot to the page. + * + * Note: All coordinates/sizes are in screen coordinates, not PostScript + * coordinates. This includes the computed bounding box and paper + * size. They will be scaled to printer points later. + * + * Results: + * Returns the height of the paper in screen coordinates. + * + * Side Effects: + * The graph dimensions (width and height) are changed to the requested + * PostScript plot size. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Ps_ComputeBoundingBox(PageSetup *setupPtr, int width, int height) +{ + int paperWidth, paperHeight; + int x, y, hSize, vSize, hBorder, vBorder; + float hScale, vScale, scale; + + x = setupPtr->padLeft; + y = setupPtr->padTop; + + hBorder = PADDING(setupPtr->xPad); + vBorder = PADDING(setupPtr->yPad); + + if (setupPtr->flags & PS_LANDSCAPE) { + hSize = height; + vSize = width; + } else { + hSize = width; + vSize = height; + } + /* + * If the paper size wasn't specified, set it to the graph size plus the + * paper border. + */ + paperWidth = (setupPtr->reqPaperWidth > 0) ? setupPtr->reqPaperWidth : + hSize + hBorder; + paperHeight = (setupPtr->reqPaperHeight > 0) ? setupPtr->reqPaperHeight : + vSize + vBorder; + + /* + * Scale the plot size (the graph itself doesn't change size) if it's + * bigger than the paper or if -maxpect was set. + */ + hScale = vScale = 1.0f; + if ((setupPtr->flags & PS_MAXPECT) || ((hSize + hBorder) > paperWidth)) { + hScale = (float)(paperWidth - hBorder) / (float)hSize; + } + if ((setupPtr->flags & PS_MAXPECT) || ((vSize + vBorder) > paperHeight)) { + vScale = (float)(paperHeight - vBorder) / (float)vSize; + } + scale = MIN(hScale, vScale); + if (scale != 1.0f) { + hSize = (int)((hSize * scale) + 0.5f); + vSize = (int)((vSize * scale) + 0.5f); + } + setupPtr->scale = scale; + if (setupPtr->flags & PS_CENTER) { + if (paperWidth > hSize) { + x = (paperWidth - hSize) / 2; + } + if (paperHeight > vSize) { + y = (paperHeight - vSize) / 2; + } + } + setupPtr->left = x; + setupPtr->bottom = y; + setupPtr->right = x + hSize - 1; + setupPtr->top = y + vSize - 1; + setupPtr->paperHeight = paperHeight; + setupPtr->paperWidth = paperWidth; + return paperHeight; +} + +PostScript * +Blt_Ps_Create(Tcl_Interp *interp, PageSetup *setupPtr) +{ + PostScript *psPtr; + + psPtr = Blt_AssertMalloc(sizeof(PostScript)); + psPtr->setupPtr = setupPtr; + psPtr->interp = interp; + Tcl_DStringInit(&psPtr->dString); + return psPtr; +} + +void +Blt_Ps_SetPrinting(PostScript *psPtr, int state) +{ + psInterp = ((state) && (psPtr != NULL)) ? psPtr->interp : NULL; +} + +int +Blt_Ps_IsPrinting(void) +{ + return (psInterp != NULL); +} + +void +Blt_Ps_Free(PostScript *psPtr) +{ + Tcl_DStringFree(&psPtr->dString); + Blt_Free(psPtr); +} + +const char * +Blt_Ps_GetValue(PostScript *psPtr, int *lengthPtr) +{ + *lengthPtr = strlen(Tcl_DStringValue(&psPtr->dString)); + return Tcl_DStringValue(&psPtr->dString); +} + +void +Blt_Ps_SetInterp(PostScript *psPtr, Tcl_Interp *interp) +{ + Tcl_DStringResult(interp, &psPtr->dString); +} + +char * +Blt_Ps_GetScratchBuffer(PostScript *psPtr) +{ + return psPtr->scratchArr; +} + +Tcl_Interp * +Blt_Ps_GetInterp(PostScript *psPtr) +{ + return psPtr->interp; +} + +Tcl_DString * +Blt_Ps_GetDString(PostScript *psPtr) +{ + return &psPtr->dString; +} + +int +Blt_Ps_SaveFile(Tcl_Interp *interp, PostScript *psPtr, const char *fileName) +{ + Tcl_Channel channel; + int nWritten, nBytes; + char *bytes; + + channel = Tcl_OpenFileChannel(interp, fileName, "w", 0660); + if (channel == NULL) { + return TCL_ERROR; + } + nBytes = Tcl_DStringLength(&psPtr->dString); + bytes = Tcl_DStringValue(&psPtr->dString); + nWritten = Tcl_Write(channel, bytes, nBytes); + Tcl_Close(interp, channel); + if (nWritten != nBytes) { + Tcl_AppendResult(interp, "short file \"", fileName, (char *)NULL); + Tcl_AppendResult(interp, "\" : wrote ", Blt_Itoa(nWritten), " of ", + (char *)NULL); + Tcl_AppendResult(interp, Blt_Itoa(nBytes), " bytes.", (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +void +Blt_Ps_VarAppend +TCL_VARARGS_DEF(PostScript *, arg1) +{ + va_list argList; + PostScript *psPtr; + const char *string; + + psPtr = TCL_VARARGS_START(PostScript, arg1, argList); + for (;;) { + string = va_arg(argList, char *); + if (string == NULL) { + break; + } + Tcl_DStringAppend(&psPtr->dString, string, -1); + } +} + +void +Blt_Ps_AppendBytes(PostScript *psPtr, const char *bytes, int length) +{ + Tcl_DStringAppend(&psPtr->dString, bytes, length); +} + +void +Blt_Ps_Append(PostScript *psPtr, const char *string) +{ + Tcl_DStringAppend(&psPtr->dString, string, -1); +} + +void +Blt_Ps_Format +TCL_VARARGS_DEF(PostScript *, arg1) +{ + va_list argList; + PostScript *psPtr; + char *fmt; + + psPtr = TCL_VARARGS_START(PostScript, arg1, argList); + fmt = va_arg(argList, char *); + vsnprintf(psPtr->scratchArr, POSTSCRIPT_BUFSIZ, fmt, argList); + va_end(argList); + Tcl_DStringAppend(&psPtr->dString, psPtr->scratchArr, -1); +} + +int +Blt_Ps_IncludeFile(Tcl_Interp *interp, Blt_Ps ps, const char *fileName) +{ + Tcl_Channel channel; + Tcl_DString dString; + char *buf; + char *libDir; + int nBytes; + + buf = Blt_Ps_GetScratchBuffer(ps); + + /* + * Read in a standard prolog file from file and append it to the + * PostScript output stored in the Tcl_DString in psPtr. + */ + + libDir = (char *)Tcl_GetVar(interp, "blt_library", TCL_GLOBAL_ONLY); + if (libDir == NULL) { + Tcl_AppendResult(interp, "couldn't find BLT script library:", + "global variable \"blt_library\" doesn't exist", (char *)NULL); + return TCL_ERROR; + } + Tcl_DStringInit(&dString); + Tcl_DStringAppend(&dString, libDir, -1); + Tcl_DStringAppend(&dString, "/", -1); + Tcl_DStringAppend(&dString, fileName, -1); + fileName = Tcl_DStringValue(&dString); + Blt_Ps_VarAppend(ps, "\n% including file \"", fileName, "\"\n\n", + (char *)NULL); + channel = Tcl_OpenFileChannel(interp, fileName, "r", 0); + if (channel == NULL) { + Tcl_AppendResult(interp, "couldn't open prologue file \"", fileName, + "\": ", Tcl_PosixError(interp), (char *)NULL); + return TCL_ERROR; + } + for(;;) { + nBytes = Tcl_Read(channel, buf, POSTSCRIPT_BUFSIZ); + if (nBytes < 0) { + Tcl_AppendResult(interp, "error reading prologue file \"", + fileName, "\": ", Tcl_PosixError(interp), + (char *)NULL); + Tcl_Close(interp, channel); + Tcl_DStringFree(&dString); + return TCL_ERROR; + } + if (nBytes == 0) { + break; + } + buf[nBytes] = '\0'; + Blt_Ps_Append(ps, buf); + } + Tcl_DStringFree(&dString); + Tcl_Close(interp, channel); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * XColorToPostScript -- + * + * Convert the a XColor (from its RGB values) to a PostScript command. + * If a Tk color map variable exists, it will be consulted for a + * PostScript translation based upon the color name. + * + * Maps an X color intensity (0 to 2^16-1) to a floating point value + * [0..1]. Many versions of Tk don't properly handle the the lower 8 + * bits of the color intensity, so we can only consider the upper 8 bits. + * + * Results: + * The string representing the color mode is returned. + * + *--------------------------------------------------------------------------- + */ +static void +XColorToPostScript(Blt_Ps ps, XColor *colorPtr) +{ + /* + * Shift off the lower byte before dividing because some versions of Tk + * don't fill the lower byte correctly. + */ + Blt_Ps_Format(ps, "%g %g %g", + ((double)(colorPtr->red >> 8) / 255.0), + ((double)(colorPtr->green >> 8) / 255.0), + ((double)(colorPtr->blue >> 8) / 255.0)); +} + +void +Blt_Ps_XSetBackground(PostScript *psPtr, XColor *colorPtr) +{ + /* If the color name exists in TCL array variable, use that translation */ + if ((psPtr->setupPtr != NULL) && (psPtr->setupPtr->colorVarName != NULL)) { + const char *psColor; + + psColor = Tcl_GetVar2(psPtr->interp, psPtr->setupPtr->colorVarName, + Tk_NameOfColor(colorPtr), 0); + if (psColor != NULL) { + Blt_Ps_VarAppend(psPtr, " ", psColor, "\n", (char *)NULL); + return; + } + } + XColorToPostScript(psPtr, colorPtr); + Blt_Ps_Append(psPtr, " setrgbcolor\n"); + if (psPtr->setupPtr->flags & PS_GREYSCALE) { + Blt_Ps_Append(psPtr, " currentgray setgray\n"); + } +} + +void +Blt_Ps_XSetForeground(PostScript *psPtr, XColor *colorPtr) +{ + /* If the color name exists in TCL array variable, use that translation */ + if ((psPtr->setupPtr != NULL) && (psPtr->setupPtr->colorVarName != NULL)) { + const char *psColor; + + psColor = Tcl_GetVar2(psPtr->interp, psPtr->setupPtr->colorVarName, + Tk_NameOfColor(colorPtr), 0); + if (psColor != NULL) { + Blt_Ps_VarAppend(psPtr, " ", psColor, "\n", (char *)NULL); + return; + } + } + XColorToPostScript(psPtr, colorPtr); + Blt_Ps_Append(psPtr, " setrgbcolor\n"); + if (psPtr->setupPtr->flags & PS_GREYSCALE) { + Blt_Ps_Append(psPtr, " currentgray setgray\n"); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ReverseBits -- + * + * Convert a byte from a X image into PostScript image order. This + * requires not only the nybbles to be reversed but also their bit + * values. + * + * Results: + * The converted byte is returned. + * + *--------------------------------------------------------------------------- + */ +INLINE static unsigned char +ReverseBits(unsigned char byte) +{ + byte = ((byte >> 1) & 0x55) | ((byte << 1) & 0xaa); + byte = ((byte >> 2) & 0x33) | ((byte << 2) & 0xcc); + byte = ((byte >> 4) & 0x0f) | ((byte << 4) & 0xf0); + return byte; +} + +/* + *--------------------------------------------------------------------------- + * + * ByteToHex -- + * + * Convert a byte to its ASCII hexidecimal equivalent. + * + * Results: + * The converted 2 ASCII character string is returned. + * + *--------------------------------------------------------------------------- + */ +INLINE static void +ByteToHex(unsigned char byte, char *string) +{ + static char hexDigits[] = "0123456789ABCDEF"; + + string[0] = hexDigits[byte >> 4]; + string[1] = hexDigits[byte & 0x0F]; +} + +#ifdef WIN32 +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_XSetBitmapData -- + * + * Output a PostScript image string of the given bitmap image. It is + * assumed the image is one bit deep and a zero value indicates an + * off-pixel. To convert to PostScript, the bits need to be reversed + * from the X11 image order. + * + * Results: + * None. + * + * Side Effects: + * The PostScript image string is appended. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ps_XSetBitmapData( + PostScript *psPtr, + Display *display, + Pixmap bitmap, + int width, int height) +{ + unsigned char byte; + int x, y, bitPos; + unsigned long pixel; + int byteCount; + char string[10]; + unsigned char *srcBits, *srcPtr; + int bytesPerRow; + + srcBits = Blt_GetBitmapData(display, bitmap, width, height, &bytesPerRow); + if (srcBits == NULL) { + OutputDebugString("Can't get bitmap data"); + return; + } + Blt_Ps_Append(psPtr, "\t<"); + byteCount = bitPos = 0; /* Suppress compiler warning */ + for (y = height - 1; y >= 0; y--) { + srcPtr = srcBits + (bytesPerRow * y); + byte = 0; + for (x = 0; x < width; x++) { + bitPos = x % 8; + pixel = (*srcPtr & (0x80 >> bitPos)); + if (pixel) { + byte |= (unsigned char)(1 << bitPos); + } + if (bitPos == 7) { + byte = ReverseBits(byte); + ByteToHex(byte, string); + string[2] = '\0'; + byteCount++; + srcPtr++; + byte = 0; + if (byteCount >= 30) { + string[2] = '\n'; + string[3] = '\t'; + string[4] = '\0'; + byteCount = 0; + } + Blt_Ps_Append(psPtr, string); + } + } /* x */ + if (bitPos != 7) { + byte = ReverseBits(byte); + ByteToHex(byte, string); + string[2] = '\0'; + Blt_Ps_Append(psPtr, string); + byteCount++; + } + } /* y */ + Blt_Free(srcBits); + Blt_Ps_Append(psPtr, ">\n"); +} + +#else + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_XSetBitmapData -- + * + * Output a PostScript image string of the given bitmap image. It is + * assumed the image is one bit deep and a zero value indicates an + * off-pixel. To convert to PostScript, the bits need to be reversed + * from the X11 image order. + * + * Results: + * None. + * + * Side Effects: + * The PostScript image string is appended to interp->result. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ps_XSetBitmapData(Blt_Ps ps, Display *display, Pixmap bitmap, int w, int h) +{ + XImage *imagePtr; + int byteCount; + int y, bitPos; + + imagePtr = XGetImage(display, bitmap, 0, 0, w, h, 1, ZPixmap); + Blt_Ps_Append(ps, "\t<"); + byteCount = bitPos = 0; /* Suppress compiler warning */ + for (y = 0; y < h; y++) { + unsigned char byte; + char string[10]; + int x; + + byte = 0; + for (x = 0; x < w; x++) { + unsigned long pixel; + + pixel = XGetPixel(imagePtr, x, y); + bitPos = x % 8; + byte |= (unsigned char)(pixel << bitPos); + if (bitPos == 7) { + byte = ReverseBits(byte); + ByteToHex(byte, string); + string[2] = '\0'; + byteCount++; + byte = 0; + if (byteCount >= 30) { + string[2] = '\n'; + string[3] = '\t'; + string[4] = '\0'; + byteCount = 0; + } + Blt_Ps_Append(ps, string); + } + } /* x */ + if (bitPos != 7) { + byte = ReverseBits(byte); + ByteToHex(byte, string); + string[2] = '\0'; + Blt_Ps_Append(ps, string); + byteCount++; + } + } /* y */ + Blt_Ps_Append(ps, ">\n"); + XDestroyImage(imagePtr); +} + +#endif /* WIN32 */ + +typedef struct { + const char *alias; + const char *fontName; +} FamilyMap; + +static FamilyMap familyMap[] = +{ + { "Arial", "Helvetica" }, + { "AvantGarde", "AvantGarde" }, + { "Bookman", "Bookman" }, + { "Courier New", "Courier" }, + { "Courier", "Courier" }, + { "Geneva", "Helvetica" }, + { "Helvetica", "Helvetica" }, + { "Mathematica1", "Helvetica" }, + { "Monaco", "Courier" }, + { "New Century Schoolbook", "NewCenturySchlbk" }, + { "New York", "Times" }, + { "Nimbus Roman No9 L" "Times" }, + { "Nimbus Sans L Condensed","Helvetica" }, + { "Nimbus Sans L", "Helvetica" }, + { "Palatino", "Palatino" }, + { "Standard Symbols L", "Symbol" }, + { "Swiss 721", "Helvetica" }, + { "Symbol", "Symbol" }, + { "Times New Roman", "Times" }, + { "Times Roman", "Times" }, + { "Times", "Times" }, + { "ZapfChancery", "ZapfChancery" }, + { "ZapfDingbats", "ZapfDingbats" } +}; + +static int nFamilyNames = (sizeof(familyMap) / sizeof(FamilyMap)); + +static const char * +FamilyToPsFamily(const char *family) +{ + FamilyMap *fp, *fend; + + if (strncasecmp(family, "itc ", 4) == 0) { + family += 4; + } + for (fp = familyMap, fend = fp + nFamilyNames; fp < fend; fp++) { + if (strcasecmp(fp->alias, family) == 0) { + return fp->fontName; + } + } + return NULL; +} + +/* + *--------------------------------------------------------------------------- + * Routines to convert X drawing functions to PostScript commands. + *--------------------------------------------------------------------------- + */ +void +Blt_Ps_SetClearBackground(Blt_Ps ps) +{ + Blt_Ps_Append(ps, "1 1 1 setrgbcolor\n"); +} + +void +Blt_Ps_XSetCapStyle(Blt_Ps ps, int capStyle) +{ + /* + * X11:not last = 0, butt = 1, round = 2, projecting = 3 + * PS: butt = 0, round = 1, projecting = 2 + */ + if (capStyle > 0) { + capStyle--; + } + Blt_Ps_Format(ps, "%d setlinecap\n", capStyle); +} + +void +Blt_Ps_XSetJoinStyle(Blt_Ps ps, int joinStyle) +{ + /* + * miter = 0, round = 1, bevel = 2 + */ + Blt_Ps_Format(ps, "%d setlinejoin\n", joinStyle); +} + +void +Blt_Ps_XSetLineWidth(Blt_Ps ps, int lineWidth) +{ + if (lineWidth < 1) { + lineWidth = 1; + } + Blt_Ps_Format(ps, "%d setlinewidth\n", lineWidth); +} + +void +Blt_Ps_XSetDashes(Blt_Ps ps, Blt_Dashes *dashesPtr) +{ + + Blt_Ps_Append(ps, "[ "); + if (dashesPtr != NULL) { + unsigned char *vp; + + for (vp = dashesPtr->values; *vp != 0; vp++) { + Blt_Ps_Format(ps, " %d", *vp); + } + } + Blt_Ps_Append(ps, "] 0 setdash\n"); +} + +void +Blt_Ps_XSetLineAttributes( + Blt_Ps ps, + XColor *colorPtr, + int lineWidth, + Blt_Dashes *dashesPtr, + int capStyle, + int joinStyle) +{ + Blt_Ps_XSetJoinStyle(ps, joinStyle); + Blt_Ps_XSetCapStyle(ps, capStyle); + Blt_Ps_XSetForeground(ps, colorPtr); + Blt_Ps_XSetLineWidth(ps, lineWidth); + Blt_Ps_XSetDashes(ps, dashesPtr); + Blt_Ps_Append(ps, "/DashesProc {} def\n"); +} + +void +Blt_Ps_Rectangle(Blt_Ps ps, int x, int y, int width, int height) +{ + Blt_Ps_Append(ps, "newpath\n"); + Blt_Ps_Format(ps, " %d %d moveto\n", x, y); + Blt_Ps_Format(ps, " %d %d rlineto\n", width, 0); + Blt_Ps_Format(ps, " %d %d rlineto\n", 0, height); + Blt_Ps_Format(ps, " %d %d rlineto\n", -width, 0); + Blt_Ps_Append(ps, "closepath\n"); +} + +void +Blt_Ps_XFillRectangle(Blt_Ps ps, double x, double y, int width, int height) +{ + Blt_Ps_Rectangle(ps, (int)x, (int)y, width, height); + Blt_Ps_Append(ps, "fill\n"); +} + +void +Blt_Ps_PolylineFromXPoints(Blt_Ps ps, XPoint *points, int n) +{ + XPoint *pp, *pend; + + pp = points; + Blt_Ps_Append(ps, "newpath\n"); + Blt_Ps_Format(ps, " %d %d moveto\n", pp->x, pp->y); + pp++; + for (pend = points + n; pp < pend; pp++) { + Blt_Ps_Format(ps, " %d %d lineto\n", pp->x, pp->y); + } +} + +void +Blt_Ps_Polyline(Blt_Ps ps, Point2d *screenPts, int nScreenPts) +{ + Point2d *pp, *pend; + + pp = screenPts; + Blt_Ps_Append(ps, "newpath\n"); + Blt_Ps_Format(ps, " %g %g moveto\n", pp->x, pp->y); + for (pp++, pend = screenPts + nScreenPts; pp < pend; pp++) { + Blt_Ps_Format(ps, " %g %g lineto\n", pp->x, pp->y); + } +} + +void +Blt_Ps_Polygon(Blt_Ps ps, Point2d *screenPts, int nScreenPts) +{ + Point2d *pp, *pend; + + pp = screenPts; + Blt_Ps_Append(ps, "newpath\n"); + Blt_Ps_Format(ps, " %g %g moveto\n", pp->x, pp->y); + for (pp++, pend = screenPts + nScreenPts; pp < pend; pp++) { + Blt_Ps_Format(ps, " %g %g lineto\n", pp->x, pp->y); + } + Blt_Ps_Format(ps, " %g %g lineto\n", screenPts[0].x, screenPts[0].y); + Blt_Ps_Append(ps, "closepath\n"); +} + +void +Blt_Ps_XFillPolygon(Blt_Ps ps, Point2d *screenPts, int nScreenPts) +{ + Blt_Ps_Polygon(ps, screenPts, nScreenPts); + Blt_Ps_Append(ps, "fill\n"); +} + +void +Blt_Ps_XDrawSegments(Blt_Ps ps, XSegment *segments, int nSegments) +{ + XSegment *sp, *send; + + for (sp = segments, send = sp + nSegments; sp < send; sp++) { + Blt_Ps_Format(ps, "%d %d moveto %d %d lineto\n", sp->x1, sp->y1, + sp->x2, sp->y2); + Blt_Ps_Append(ps, "DashesProc stroke\n"); + } +} + + +void +Blt_Ps_XFillRectangles(Blt_Ps ps, XRectangle *rectangles, int nRectangles) +{ + XRectangle *rp, *rend; + + for (rp = rectangles, rend = rp + nRectangles; rp < rend; rp++) { + Blt_Ps_XFillRectangle(ps, (double)rp->x, (double)rp->y, + (int)rp->width, (int)rp->height); + } +} + +#ifndef TK_RELIEF_SOLID +#define TK_RELIEF_SOLID -1 /* Set the an impossible value. */ +#endif /* TK_RELIEF_SOLID */ + +void +Blt_Ps_Draw3DRectangle( + Blt_Ps ps, + Tk_3DBorder border, /* Token for border to draw. */ + double x, double y, /* Coordinates of rectangle */ + int width, int height, /* Region to be drawn. */ + int borderWidth, /* Desired width for border, in pixels. */ + int relief) /* Should be either TK_RELIEF_RAISED or + * TK_RELIEF_SUNKEN; indicates position of + * interior of window relative to exterior. */ +{ + Point2d points[7]; + TkBorder *borderPtr = (TkBorder *) border; + XColor *lightPtr, *darkPtr; + XColor *topPtr, *bottomPtr; + XColor light, dark; + int twiceWidth = (borderWidth * 2); + + if ((width < twiceWidth) || (height < twiceWidth)) { + return; + } + if ((relief == TK_RELIEF_SOLID) || + (borderPtr->lightColor == NULL) || (borderPtr->darkColor == NULL)) { + if (relief == TK_RELIEF_SOLID) { + dark.red = dark.blue = dark.green = 0x00; + light.red = light.blue = light.green = 0x00; + relief = TK_RELIEF_SUNKEN; + } else { + light = *borderPtr->bgColor; + dark.red = dark.blue = dark.green = 0xFF; + } + lightPtr = &light; + darkPtr = &dark; + } else { + lightPtr = borderPtr->lightColor; + darkPtr = borderPtr->darkColor; + } + + + /* Handle grooves and ridges with recursive calls. */ + + if ((relief == TK_RELIEF_GROOVE) || (relief == TK_RELIEF_RIDGE)) { + int halfWidth, insideOffset; + + halfWidth = borderWidth / 2; + insideOffset = borderWidth - halfWidth; + Blt_Ps_Draw3DRectangle(ps, border, (double)x, (double)y, + width, height, halfWidth, + (relief == TK_RELIEF_GROOVE) ? TK_RELIEF_SUNKEN : TK_RELIEF_RAISED); + Blt_Ps_Draw3DRectangle(ps, border, + (double)(x + insideOffset), (double)(y + insideOffset), + width - insideOffset * 2, height - insideOffset * 2, halfWidth, + (relief == TK_RELIEF_GROOVE) ? TK_RELIEF_RAISED : TK_RELIEF_SUNKEN); + return; + } + if (relief == TK_RELIEF_RAISED) { + topPtr = lightPtr; + bottomPtr = darkPtr; + } else if (relief == TK_RELIEF_SUNKEN) { + topPtr = darkPtr; + bottomPtr = lightPtr; + } else { + topPtr = bottomPtr = borderPtr->bgColor; + } + Blt_Ps_XSetBackground(ps, bottomPtr); + Blt_Ps_XFillRectangle(ps, x, y + height - borderWidth, width, borderWidth); + Blt_Ps_XFillRectangle(ps, x + width - borderWidth, y, borderWidth, height); + points[0].x = points[1].x = points[6].x = x; + points[0].y = points[6].y = y + height; + points[1].y = points[2].y = y; + points[2].x = x + width; + points[3].x = x + width - borderWidth; + points[3].y = points[4].y = y + borderWidth; + points[4].x = points[5].x = x + borderWidth; + points[5].y = y + height - borderWidth; + if (relief != TK_RELIEF_FLAT) { + Blt_Ps_XSetBackground(ps, topPtr); + } + Blt_Ps_XFillPolygon(ps, points, 7); +} + +void +Blt_Ps_Fill3DRectangle( + Blt_Ps ps, + Tk_3DBorder border, /* Token for border to draw. */ + double x, double y, /* Coordinates of top-left of border area */ + int width, int height, /* Dimension of border to be drawn. */ + int borderWidth, /* Desired width for border, in pixels. */ + int relief) /* Should be either TK_RELIEF_RAISED or + * TK_RELIEF_SUNKEN; indicates position of + * interior of window relative to exterior. */ +{ + TkBorder *borderPtr = (TkBorder *) border; + + Blt_Ps_XSetBackground(ps, borderPtr->bgColor); + Blt_Ps_XFillRectangle(ps, x, y, width, height); + Blt_Ps_Draw3DRectangle(ps, border, x, y, width, height, borderWidth, + relief); +} + +void +Blt_Ps_XSetStipple(Blt_Ps ps, Display *display, Pixmap bitmap) +{ + int width, height; + + Tk_SizeOfBitmap(display, bitmap, &width, &height); + Blt_Ps_Format(ps, + "gsave\n" + " clip\n" + " %d %d\n", + width, height); + Blt_Ps_XSetBitmapData(ps, display, bitmap, width, height); + Blt_Ps_VarAppend(ps, + " StippleFill\n" + "grestore\n", (char *)NULL); +} + +static void +Base85Encode(Blt_DBuffer dBuffer, Tcl_DString *resultPtr) +{ + char *dp; + int count; + int length, nBytes, oldLength; + int n; + unsigned char *sp, *send; + + oldLength = Tcl_DStringLength(resultPtr); + nBytes = Blt_DBuffer_Length(dBuffer); + + /* + * Compute worst-case length of buffer needed for encoding. + * That is 5 characters per 4 bytes. There are newlines every + * 65 characters. The actual size can be smaller, depending upon + * the number of 0 tuples ('z' bytes). + */ + length = oldLength + nBytes; + length += ((nBytes + 3)/4) * 5; /* 5 characters per 4 bytes. */ + length += (nBytes+64) / 65; /* # of newlines. */ + Tcl_DStringSetLength(resultPtr, length); + + + n = count = 0; + dp = Tcl_DStringValue(resultPtr) + oldLength; + for (sp = Blt_DBuffer_Bytes(dBuffer), send = sp + nBytes; sp < send; + sp += 4) { + unsigned int tuple; + + tuple = 0; +#ifdef WORDS_BIGENDIAN + tuple |= (sp[3] << 24); + tuple |= (sp[2] << 16); + tuple |= (sp[1] << 8); + tuple |= sp[0]; +#else + tuple |= (sp[0] << 24); + tuple |= (sp[1] << 16); + tuple |= (sp[2] << 8); + tuple |= sp[3]; +#endif + if (tuple == 0) { + *dp++ = 'z'; + count++; + n++; + } else { + dp[4] = '!' + (tuple % 85); + tuple /= 85; + dp[3] = '!' + (tuple % 85); + tuple /= 85; + dp[2] = '!' + (tuple % 85); + tuple /= 85; + dp[1] = '!' + (tuple % 85); + tuple /= 85; + dp[0] = '!' + (tuple % 85); + dp += 5; + n += 5; + count += 5; + } + if (count > 64) { + *dp++ = '\n'; + n++; + count = 0; + } + } + + { + unsigned int tuple; + + /* Handle remaining bytes (0-3). */ + nBytes = (nBytes & 0x3); + sp -= nBytes; + tuple = 0; + switch (nBytes) { +#ifdef WORDS_BIGENDIAN + case 3: + tuple |= (sp[2] << 8); + case 2: + tuple |= (sp[1] << 16); + case 1: + tuple |= (sp[0] << 24); +#else + case 3: + tuple |= (sp[2] << 24); + case 2: + tuple |= (sp[1] << 16); + case 1: + tuple |= (sp[0] << 8); +#endif + default: + break; + } + if (nBytes > 0) { + tuple /= 85; + if (nBytes > 2) { + dp[3] = '!' + (tuple % 85); + n++; + } + tuple /= 85; + if (nBytes > 1) { + dp[2] = '!' + (tuple % 85); + n++; + } + tuple /= 85; + dp[1] = '!' + (tuple % 85); + tuple /= 85; + dp[0] = '!' + (tuple % 85); + *dp++ = '\n'; + n += 3; + } + Tcl_DStringSetLength(resultPtr, n); + } +} + +static void +AsciiHexEncode(Blt_DBuffer dBuffer, Tcl_DString *resultPtr) +{ + static char hexDigits[] = "0123456789ABCDEF"; + int length, oldLength; + int nBytes; + + /* + * Compute the length of the buffer needed for the encoding. That is 2 + * characters per byte. There are newlines every 64 characters. + */ + length = oldLength = Tcl_DStringLength(resultPtr); + nBytes = Blt_DBuffer_Length(dBuffer) * 2; /* Two characters per byte */ + length += nBytes; + length += (nBytes+63)/64; /* Number of newlines required. */ + Tcl_DStringSetLength(resultPtr, length); + { + unsigned char *sp, *send; + char *bytes, *dp; + int count, n; + + count = n = 0; + dp = bytes = Tcl_DStringValue(resultPtr) + oldLength; + for (sp = Blt_DBuffer_Bytes(dBuffer), + send = sp + Blt_DBuffer_Length(dBuffer); + sp < send; sp++) { + dp[0] = hexDigits[*sp >> 4]; + dp[1] = hexDigits[*sp & 0x0F]; + dp += 2; + n += 2; + count++; + if ((count & 0x1F) == 0) { + *dp++ = '\n'; + n++; + } + } + *dp++ = '\0'; +#ifdef notdef + Tcl_DStringSetLength(resultPtr, n + oldLength); +#endif + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_DrawPicture -- + * + * Translates a picture into 3 component RGB PostScript output. Uses PS + * Language Level 2 operator "colorimage". + * + * Results: + * The dynamic string will contain the PostScript output. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ps_DrawPicture(PostScript *psPtr, Blt_Picture picture, double x, double y) +{ + PageSetup *setupPtr = psPtr->setupPtr; + int w, h; + Blt_DBuffer dBuffer; + + w = Blt_PictureWidth(picture); + h = Blt_PictureHeight(picture); + Blt_Ps_Format(psPtr, + "gsave\n" + "/DeviceRGB setcolorspace\n" + "%g %g translate\n" + "%d %d scale\n", x, y, w, h); + if ((setupPtr->flags & PS_GREYSCALE) || (setupPtr->level == 1)) { + int strSize; + + strSize = (setupPtr->flags & PS_GREYSCALE) ? w : w * 3; + Blt_Ps_Format(psPtr, + "/picstr %d string def\n" + "%d %d 8\n" + "[%d 0 0 %d 0 %d]\n" + "{\n" + " currentfile picstr readhexstring pop\n" + "}\n", strSize, w, h, w, -h, h); + if (setupPtr->flags & PS_GREYSCALE) { + Blt_Picture greyscale; + + Blt_Ps_Append(psPtr, "image\n"); + greyscale = Blt_GreyscalePicture(picture); + dBuffer = Blt_PictureToDBuffer(picture, 1); + Blt_FreePicture(greyscale); + } else { + Blt_Ps_Append(psPtr, "false 3 colorimage\n"); + dBuffer = Blt_PictureToDBuffer(picture, 3); + } + AsciiHexEncode(dBuffer, &psPtr->dString); + Blt_DBuffer_Free(dBuffer); + } else { + Blt_Ps_Format(psPtr, + "<<\n" + "/ImageType 1\n" + "/Width %d\n" + "/Height %d\n" + "/BitsPerComponent 8\n" + "/Decode [0 1 0 1 0 1]\n" + "/ImageMatrix [%d 0 0 %d 0 %d]\n" + "/Interpolate true\n" + "/DataSource currentfile /ASCII85Decode filter\n" + ">>\n" + "image\n", w, h, w, -h, h); + dBuffer = Blt_PictureToDBuffer(picture, 3); + Base85Encode(dBuffer, &psPtr->dString); + Blt_DBuffer_Free(dBuffer); + } + Blt_Ps_Append(psPtr, "\ngrestore\n\n"); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_XDrawWindow -- + * + * Converts a Tk window to PostScript. If the window could not be + * "snapped", then a grey rectangle is drawn in its place. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ps_XDrawWindow(Blt_Ps ps, Tk_Window tkwin, double x, double y) +{ + Blt_Picture picture; + + picture = Blt_DrawableToPicture(tkwin, Tk_WindowId(tkwin), 0, 0, + Tk_Width(tkwin), Tk_Height(tkwin), GAMMA); + if (picture == NULL) { + /* Can't grab window image so paint the window area grey */ + Blt_Ps_VarAppend(ps, "% Can't grab window \"", Tk_PathName(tkwin), + "\"\n", (char *)NULL); + Blt_Ps_Append(ps, "0.5 0.5 0.5 setrgbcolor\n"); + Blt_Ps_XFillRectangle(ps, x, y, Tk_Width(tkwin), Tk_Height(tkwin)); + return; + } + Blt_Ps_DrawPicture(ps, picture, x, y); + Blt_FreePicture(picture); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_DrawPhoto -- + * + * Output a PostScript image string of the given photo image. The photo + * is first converted into a picture and then translated into PostScript. + * + * Results: + * None. + * + * Side Effects: + * The PostScript output representing the photo is appended to the + * psPtr's dynamic string. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ps_DrawPhoto(Blt_Ps ps, Tk_PhotoHandle photo, double x, double y) +{ + Blt_Picture picture; + + picture = Blt_PhotoToPicture(photo); + Blt_Ps_DrawPicture(ps, picture, x, y); + Blt_FreePicture(picture); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_XSetFont -- + * + * Map the Tk font to a PostScript font and point size. + * + * If a TCL array variable was specified, each element should be indexed + * by the X11 font name and contain a list of 1-2 elements; the + * PostScript font name and the desired point size. The point size may + * be omitted and the X font point size will be used. + * + * Otherwise, if the foundry is "Adobe", we try to do a plausible mapping + * looking at the full name of the font and building a string in the form + * of "Family-TypeFace". + * + * Returns: + * None. + * + * Side Effects: + * PostScript commands are output to change the type and the point size + * of the current font. + * + *--------------------------------------------------------------------------- + */ + +void +Blt_Ps_XSetFont(PostScript *psPtr, Blt_Font font) +{ + Tcl_Interp *interp = psPtr->interp; + const char *family; + + /* Use the font variable information if it exists. */ + if ((psPtr->setupPtr != NULL) && (psPtr->setupPtr->fontVarName != NULL)) { + char *value; + + value = (char *)Tcl_GetVar2(interp, psPtr->setupPtr->fontVarName, + Blt_NameOfFont(font), 0); + if (value != NULL) { + const char **argv = NULL; + int argc; + int newSize; + double pointSize; + const char *fontName; + + if (Tcl_SplitList(NULL, value, &argc, &argv) != TCL_OK) { + return; + } + fontName = argv[0]; + if ((argc != 2) || + (Tcl_GetInt(interp, argv[1], &newSize) != TCL_OK)) { + Blt_Free(argv); + return; + } + pointSize = (double)newSize; + Blt_Ps_Format(psPtr, "%g /%s SetFont\n", pointSize, + fontName); + Blt_Free(argv); + return; + } + /*FallThru*/ + } + + /* + * Check to see if it's a PostScript font. Tk_PostScriptFontName silently + * generates a bogus PostScript font name, so we have to check to see if + * this is really a PostScript font first before we call it. + */ + family = FamilyToPsFamily(Blt_FamilyOfFont(font)); + if (family != NULL) { + Tcl_DString dString; + double pointSize; + + Tcl_DStringInit(&dString); + pointSize = (double)Blt_PostscriptFontName(font, &dString); + Blt_Ps_Format(psPtr, "%g /%s SetFont\n", pointSize, + Tcl_DStringValue(&dString)); + Tcl_DStringFree(&dString); + return; + } + Blt_Ps_Append(psPtr, "12.0 /Helvetica-Bold SetFont\n"); +} + +static void +TextLayoutToPostScript(Blt_Ps ps, int x, int y, TextLayout *textPtr) +{ + char *bp, *dst; + int count; /* Counts the # of bytes written to the + * intermediate scratch buffer. */ + const char *src, *end; + TextFragment *fragPtr; + int i; + unsigned char c; +#if HAVE_UTF + Tcl_UniChar ch; +#endif + int limit; + + limit = POSTSCRIPT_BUFSIZ - 4; /* High water mark for scratch buffer. */ + fragPtr = textPtr->fragments; + for (i = 0; i < textPtr->nFrags; i++, fragPtr++) { + if (fragPtr->count < 1) { + continue; + } + Blt_Ps_Append(ps, "("); + count = 0; + dst = Blt_Ps_GetScratchBuffer(ps); + src = fragPtr->text; + end = fragPtr->text + fragPtr->count; + while (src < end) { + if (count > limit) { + /* Don't let the scatch buffer overflow */ + dst = Blt_Ps_GetScratchBuffer(ps); + dst[count] = '\0'; + Blt_Ps_Append(ps, dst); + count = 0; + } +#if HAVE_UTF + /* + * INTL: For now we just treat the characters as binary data and + * display the lower byte. Eventually this should be revised to + * handle international postscript fonts. + */ + src += Tcl_UtfToUniChar(src, &ch); + c = (unsigned char)(ch & 0xff); +#else + c = *src++; +#endif + + if ((c == '\\') || (c == '(') || (c == ')')) { + /* + * If special PostScript characters characters "\", "(", and + * ")" are contained in the text string, prepend backslashes + * to them. + */ + *dst++ = '\\'; + *dst++ = c; + count += 2; + } else if ((c < ' ') || (c > '~')) { + /* Convert non-printable characters into octal. */ + sprintf_s(dst, 5, "\\%03o", c); + dst += 4; + count += 4; + } else { + *dst++ = c; + count++; + } + } + bp = Blt_Ps_GetScratchBuffer(ps); + bp[count] = '\0'; + Blt_Ps_Append(ps, bp); + Blt_Ps_Format(ps, ") %d %d %d DrawAdjText\n", + fragPtr->width, x + fragPtr->x, y + fragPtr->y); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ps_DrawText -- + * + * Output PostScript commands to print a text string. The string may be + * rotated at any arbitrary angle, and placed according the anchor type + * given. The anchor indicates how to interpret the window coordinates as + * an anchor for the text bounding box. + * + * Results: + * None. + * + * Side Effects: + * Text string is drawn using the given font and GC on the graph window + * at the given coordinates, anchor, and rotation + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ps_DrawText( + Blt_Ps ps, + const char *string, /* String to convert to PostScript */ + TextStyle *tsPtr, /* Text attribute information */ + double x, double y) /* Window coordinates where to print text */ +{ + TextLayout *textPtr; + Point2d t; + + if ((string == NULL) || (*string == '\0')) { /* Empty string, do nothing */ + return; + } + textPtr = Blt_Ts_CreateLayout(string, -1, tsPtr); + { + float angle; + double rw, rh; + + angle = FMOD(tsPtr->angle, (double)360.0); + Blt_GetBoundingBox(textPtr->width, textPtr->height, angle, &rw, &rh, + (Point2d *)NULL); + /* + * Find the center of the bounding box + */ + t = Blt_AnchorPoint(x, y, rw, rh, tsPtr->anchor); + t.x += rw * 0.5; + t.y += rh * 0.5; + } + + /* Initialize text (sets translation and rotation) */ + Blt_Ps_Format(ps, "%d %d %g %g %g BeginText\n", textPtr->width, + textPtr->height, tsPtr->angle, t.x, t.y); + + Blt_Ps_XSetFont(ps, tsPtr->font); + + Blt_Ps_XSetForeground(ps, tsPtr->color); + TextLayoutToPostScript(ps, 0, 0, textPtr); + Blt_Free(textPtr); + Blt_Ps_Append(ps, "EndText\n"); +} + +void +Blt_Ps_XDrawLines(Blt_Ps ps, XPoint *points, int n) +{ + int nLeft; + + if (n <= 0) { + return; + } + for (nLeft = n; nLeft > 0; nLeft -= PS_MAXPATH) { + int length; + + length = MIN(PS_MAXPATH, nLeft); + Blt_Ps_PolylineFromXPoints(ps, points, length); + Blt_Ps_Append(ps, "DashesProc stroke\n"); + points += length; + } +} + +void +Blt_Ps_DrawPolyline(Blt_Ps ps, Point2d *points, int nPoints) +{ + int nLeft; + + if (nPoints <= 0) { + return; + } + for (nLeft = nPoints; nLeft > 0; nLeft -= PS_MAXPATH) { + int length; + + length = MIN(PS_MAXPATH, nLeft); + Blt_Ps_Polyline(ps, points, length); + Blt_Ps_Append(ps, "DashesProc stroke\n"); + points += length; + } +} + +void +Blt_Ps_DrawBitmap( + Blt_Ps ps, + Display *display, + Pixmap bitmap, /* Bitmap to be converted to PostScript */ + double xScale, double yScale) +{ + int width, height; + double sw, sh; + + Tk_SizeOfBitmap(display, bitmap, &width, &height); + sw = (double)width * xScale; + sh = (double)height * yScale; + Blt_Ps_Append(ps, " gsave\n"); + Blt_Ps_Format(ps, " %g %g translate\n", sw * -0.5, sh * 0.5); + Blt_Ps_Format(ps, " %g %g scale\n", sw, -sh); + Blt_Ps_Format(ps, " %d %d true [%d 0 0 %d 0 %d] {", + width, height, width, -height, height); + Blt_Ps_XSetBitmapData(ps, display, bitmap, width, height); + Blt_Ps_Append(ps, " } imagemask\n grestore\n"); +} + +void +Blt_Ps_Draw2DSegments(Blt_Ps ps, Segment2d *segments, int nSegments) +{ + Segment2d *sp, *send; + + Blt_Ps_Append(ps, "newpath\n"); + for (sp = segments, send = sp + nSegments; sp < send; sp++) { + Blt_Ps_Format(ps, " %g %g moveto %g %g lineto\n", + sp->p.x, sp->p.y, sp->q.x, sp->q.y); + Blt_Ps_Append(ps, "DashesProc stroke\n"); + } +} + +void +Blt_Ps_FontName(const char *family, int flags, Tcl_DString *resultPtr) +{ + const char *familyName, *weightName, *slantName; + int len; + + len = Tcl_DStringLength(resultPtr); + + familyName = FamilyToPsFamily(family); + if (familyName == NULL) { + Tcl_UniChar ch; + char *src, *dest; + int upper; + + /* + * Inline, capitalize the first letter of each word, lowercase the + * rest of the letters in each word, and then take out the spaces + * between the words. This may make the DString shorter, which is + * safe to do. + */ + Tcl_DStringAppend(resultPtr, family, -1); + src = dest = Tcl_DStringValue(resultPtr) + len; + upper = TRUE; + while (*src != '\0') { + while (isspace(*src)) { /* INTL: ISO space */ + src++; + upper = TRUE; + } + src += Tcl_UtfToUniChar(src, &ch); + if (upper) { + ch = Tcl_UniCharToUpper(ch); + upper = FALSE; + } else { + ch = Tcl_UniCharToLower(ch); + } + dest += Tcl_UniCharToUtf(ch, dest); + } + *dest = '\0'; + Tcl_DStringSetLength(resultPtr, dest - Tcl_DStringValue(resultPtr)); + familyName = Tcl_DStringValue(resultPtr) + len; + } + if (familyName != Tcl_DStringValue(resultPtr) + len) { + Tcl_DStringAppend(resultPtr, familyName, -1); + familyName = Tcl_DStringValue(resultPtr) + len; + } + if (strcasecmp(familyName, "NewCenturySchoolbook") == 0) { + Tcl_DStringSetLength(resultPtr, len); + Tcl_DStringAppend(resultPtr, "NewCenturySchlbk", -1); + familyName = Tcl_DStringValue(resultPtr) + len; + } + + /* Get the string to use for the weight. */ + weightName = NULL; + if (flags & FONT_BOLD) { + if ((strcmp(familyName, "Bookman") == 0) || + (strcmp(familyName, "AvantGarde") == 0)) { + weightName = "Demi"; + } else { + weightName = "Bold"; + } + } else { + if (strcmp(familyName, "Bookman") == 0) { + weightName = "Light"; + } else if (strcmp(familyName, "AvantGarde") == 0) { + weightName = "Book"; + } else if (strcmp(familyName, "ZapfChancery") == 0) { + weightName = "Medium"; + } + } + + /* Get the string to use for the slant. */ + slantName = NULL; + if (flags & FONT_ITALIC) { + if ((strcmp(familyName, "Helvetica") == 0) || + (strcmp(familyName, "Courier") == 0) || + (strcmp(familyName, "AvantGarde") == 0)) { + slantName = "Oblique"; + } else { + slantName = "Italic"; + } + } + + /* + * The string "Roman" needs to be added to some fonts that are not bold + * and not italic. + */ + if ((slantName == NULL) && (weightName == NULL)) { + if ((strcmp(familyName, "Times") == 0) || + (strcmp(familyName, "NewCenturySchlbk") == 0) || + (strcmp(familyName, "Palatino") == 0)) { + Tcl_DStringAppend(resultPtr, "-Roman", -1); + } + } else { + Tcl_DStringAppend(resultPtr, "-", -1); + if (weightName != NULL) { + Tcl_DStringAppend(resultPtr, weightName, -1); + } + if (slantName != NULL) { + Tcl_DStringAppend(resultPtr, slantName, -1); + } + } +} diff --git a/src/bltGrPSOutput.h b/src/bltGrPSOutput.h new file mode 100644 index 0000000..944faf8 --- /dev/null +++ b/src/bltGrPSOutput.h @@ -0,0 +1,215 @@ + +/* + * bltPs.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_PS_H +#define _BLT_PS_H + +#include "bltPicture.h" + +/* + * PageSetup -- + * + * Structure contains information specific to the layout of the page for + * printing the graph. + * + */ +typedef struct { + /* User configurable fields */ + + int reqWidth, reqHeight; /* If greater than zero, represents the + * requested dimensions of the printed graph */ + int reqPaperWidth; + int reqPaperHeight; /* Requested dimensions for the PostScript + * page. Can constrain the size of the graph + * if the graph (plus padding) is larger than + * the size of the page. */ + Blt_Pad xPad, yPad; /* Requested padding on the exterior of the + * graph. This forms the bounding box for + * the page. */ + const char *colorVarName; /* If non-NULL, is the name of a TCL array + * variable containing X to output device color + * translations */ + const char *fontVarName; /* If non-NULL, is the name of a TCL array + * variable containing X to output device font + * translations */ + int level; /* PostScript Language level 1-3 */ + unsigned int flags; + + const char **comments; /* User supplied comments to be added. */ + + /* Computed fields */ + + short int left, bottom; /* Bounding box of the plot in the page. */ + short int right, top; + + float scale; /* Scale of page. Set if "-maxpect" option + * is set, otherwise 1.0. */ + + int paperHeight; + int paperWidth; + +} PageSetup; + +#define PS_GREYSCALE (1<<0) +#define PS_LANDSCAPE (1<<2) +#define PS_CENTER (1<<3) +#define PS_MAXPECT (1<<4) +#define PS_DECORATIONS (1<<5) +#define PS_FOOTER (1<<6) +#define PS_FMT_NONE 0 +#define PS_FMT_MASK (PS_FMT_WMF|PS_FMT_EPSI|PS_FMT_TIFF) +#define PS_FMT_WMF (1<<8) +#define PS_FMT_EPSI (1<<9) +#define PS_FMT_TIFF (1<<10) + +typedef struct _Blt_Ps *Blt_Ps; + +BLT_EXTERN Blt_Ps Blt_Ps_Create(Tcl_Interp *interp, PageSetup *setupPtr); + +BLT_EXTERN void Blt_Ps_Free(Blt_Ps ps); + +BLT_EXTERN const char *Blt_Ps_GetValue(Blt_Ps ps, int *lengthPtr); + +BLT_EXTERN Tcl_Interp *Blt_Ps_GetInterp(Blt_Ps ps); + +BLT_EXTERN Tcl_DString *Blt_Ps_GetDString(Blt_Ps ps); + +BLT_EXTERN char *Blt_Ps_GetScratchBuffer(Blt_Ps ps); + +BLT_EXTERN void Blt_Ps_SetInterp(Blt_Ps ps, Tcl_Interp *interp); + +BLT_EXTERN void Blt_Ps_Append(Blt_Ps ps, const char *string); + +BLT_EXTERN void Blt_Ps_AppendBytes(Blt_Ps ps, const char *string, int nBytes); + +BLT_EXTERN void Blt_Ps_VarAppend TCL_VARARGS(Blt_Ps, ps); + +BLT_EXTERN void Blt_Ps_Format TCL_VARARGS(Blt_Ps, ps); + +BLT_EXTERN void Blt_Ps_SetClearBackground(Blt_Ps ps); + +BLT_EXTERN int Blt_Ps_IncludeFile(Tcl_Interp *interp, Blt_Ps ps, + const char *fileName); + +BLT_EXTERN int Blt_Ps_GetPicaFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + int *picaPtr); + +BLT_EXTERN int Blt_Ps_GetPadFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + Blt_Pad *padPtr); + +BLT_EXTERN int Blt_Ps_ComputeBoundingBox(PageSetup *setupPtr, int w, int h); + +BLT_EXTERN void Blt_Ps_DrawPicture(Blt_Ps ps, Blt_Picture picture, + double x, double y); + +BLT_EXTERN void Blt_Ps_Rectangle(Blt_Ps ps, int x, int y, int w, int h); + + +BLT_EXTERN int Blt_Ps_SaveFile(Tcl_Interp *interp, Blt_Ps ps, + const char *fileName); + +#ifdef _TK + +#include "bltFont.h" +#include "bltText.h" + +BLT_EXTERN void Blt_Ps_XSetLineWidth(Blt_Ps ps, int lineWidth); + +BLT_EXTERN void Blt_Ps_XSetBackground(Blt_Ps ps, XColor *colorPtr); + +BLT_EXTERN void Blt_Ps_XSetBitmapData(Blt_Ps ps, Display *display, + Pixmap bitmap, int width, int height); + +BLT_EXTERN void Blt_Ps_XSetForeground(Blt_Ps ps, XColor *colorPtr); + +BLT_EXTERN void Blt_Ps_XSetFont(Blt_Ps ps, Blt_Font font); + +BLT_EXTERN void Blt_Ps_XSetDashes(Blt_Ps ps, Blt_Dashes *dashesPtr); + +BLT_EXTERN void Blt_Ps_XSetLineAttributes(Blt_Ps ps, XColor *colorPtr, + int lineWidth, Blt_Dashes *dashesPtr, int capStyle, int joinStyle); + +BLT_EXTERN void Blt_Ps_XSetStipple(Blt_Ps ps, Display *display, Pixmap bitmap); + +BLT_EXTERN void Blt_Ps_Polyline(Blt_Ps ps, Point2d *screenPts, int nScreenPts); + +BLT_EXTERN void Blt_Ps_XDrawLines(Blt_Ps ps, XPoint *points, int n); + +BLT_EXTERN void Blt_Ps_XDrawSegments(Blt_Ps ps, XSegment *segments, + int nSegments); + +BLT_EXTERN void Blt_Ps_DrawPolyline(Blt_Ps ps, Point2d *points, int n); + +BLT_EXTERN void Blt_Ps_Draw2DSegments(Blt_Ps ps, Segment2d *segments, + int nSegments); + +BLT_EXTERN void Blt_Ps_Draw3DRectangle(Blt_Ps ps, Tk_3DBorder border, + double x, double y, int width, int height, int borderWidth, int relief); + +BLT_EXTERN void Blt_Ps_Fill3DRectangle(Blt_Ps ps, Tk_3DBorder border, double x, + double y, int width, int height, int borderWidth, int relief); + +BLT_EXTERN void Blt_Ps_XFillRectangle(Blt_Ps ps, double x, double y, + int width, int height); + +BLT_EXTERN void Blt_Ps_XFillRectangles(Blt_Ps ps, XRectangle *rects, int n); + +BLT_EXTERN void Blt_Ps_XFillPolygon(Blt_Ps ps, Point2d *screenPts, + int nScreenPts); + +BLT_EXTERN void Blt_Ps_DrawPhoto(Blt_Ps ps, Tk_PhotoHandle photoToken, + double x, double y); + +BLT_EXTERN void Blt_Ps_XDrawWindow(Blt_Ps ps, Tk_Window tkwin, + double x, double y); + +BLT_EXTERN void Blt_Ps_DrawText(Blt_Ps ps, const char *string, + TextStyle *attrPtr, double x, double y); + +BLT_EXTERN void Blt_Ps_DrawBitmap(Blt_Ps ps, Display *display, Pixmap bitmap, + double scaleX, double scaleY); + +BLT_EXTERN void Blt_Ps_XSetCapStyle(Blt_Ps ps, int capStyle); + +BLT_EXTERN void Blt_Ps_XSetJoinStyle(Blt_Ps ps, int joinStyle); + +BLT_EXTERN void Blt_Ps_PolylineFromXPoints(Blt_Ps ps, XPoint *points, int n); + +BLT_EXTERN void Blt_Ps_Polygon(Blt_Ps ps, Point2d *screenPts, int nScreenPts); + +BLT_EXTERN void Blt_Ps_SetPrinting(Blt_Ps ps, int value); +BLT_EXTERN int Blt_Ps_IsPrinting(void); + +BLT_EXTERN int Blt_Ps_TextWidth(Blt_Font font, const char *string, int nBytes); + +BLT_EXTERN int Blt_Ps_GetFontMetrics(Blt_Font font, Blt_FontMetrics *fmPtr); + +BLT_EXTERN void Blt_Ps_FontName(const char *family, int flags, + Tcl_DString *resultPtr); + +#endif /* _TK */ + +#endif /* BLT_PS_H */ diff --git a/src/bltGrPenOp.C b/src/bltGrPenOp.C new file mode 100644 index 0000000..2e13b3a --- /dev/null +++ b/src/bltGrPenOp.C @@ -0,0 +1,765 @@ + +/* + * bltGrPen.c -- + * + * This module implements pens for the BLT graph widget. + * + * Copyright 1996-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltGraph.h" +#include "bltOp.h" +#include <X11/Xutil.h> + +typedef int (GraphPenProc)(Tcl_Interp *interp, Graph *graphPtr, int objc, + Tcl_Obj *const *objv); + +static Blt_OptionFreeProc FreeColor; +static Blt_OptionParseProc ObjToColor; +static Blt_OptionPrintProc ColorToObj; +Blt_CustomOption bltColorOption = { + ObjToColor, ColorToObj, FreeColor, (ClientData)0 +}; + +static Blt_OptionFreeProc FreePen; +static Blt_OptionParseProc ObjToPen; +static Blt_OptionPrintProc PenToObj; +Blt_CustomOption bltBarPenOption = { + ObjToPen, PenToObj, FreePen, (ClientData)CID_ELEM_BAR +}; +Blt_CustomOption bltLinePenOption = { + ObjToPen, PenToObj, FreePen, (ClientData)CID_ELEM_LINE +}; + +/*ARGSUSED*/ +static void +FreeColor( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + XColor *colorPtr = *(XColor **)(widgRec + offset); + + if ((colorPtr != NULL) && (colorPtr != COLOR_DEFAULT)) { + Tk_FreeColor(colorPtr); + } +} + +/* + *--------------------------------------------------------------------------- + + * ObjToColor -- + * + * Convert the string representation of a color into a XColor pointer. + * + * Results: + * The return value is a standard TCL result. The color pointer is + * written into the widget record. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToColor( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing color */ + char *widgRec, /* Widget record */ + int offset, /* Offset to field in structure */ + int flags) +{ + XColor **colorPtrPtr = (XColor **)(widgRec + offset); + XColor *colorPtr; + const char *string; + char c; + int length; + + string = Tcl_GetStringFromObj(objPtr, &length); + c = string[0]; + + if ((c == '\0') && (flags & BLT_CONFIG_NULL_OK)) { + if ((*colorPtrPtr != NULL) && (*colorPtrPtr != COLOR_DEFAULT)) { + Tk_FreeColor(*colorPtrPtr); + } + *colorPtrPtr = NULL; + return TCL_OK; + } + if ((c == 'd') && (strncmp(string, "defcolor", length) == 0)) { + if ((*colorPtrPtr != NULL) && (*colorPtrPtr != COLOR_DEFAULT)) { + Tk_FreeColor(*colorPtrPtr); + } + *colorPtrPtr = COLOR_DEFAULT; + return TCL_OK; + } + colorPtr = Tk_AllocColorFromObj(interp, tkwin, objPtr); + if (colorPtr == NULL) { + return TCL_ERROR; + } + if ((*colorPtrPtr != NULL) && (*colorPtrPtr != COLOR_DEFAULT)) { + Tk_FreeColor(*colorPtrPtr); + } + *colorPtrPtr = colorPtr; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ColorToObj -- + * + * Convert the color value into a string. + * + * Results: + * The string representing the symbol color is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +ColorToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Widget information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + XColor *colorPtr = *(XColor **)(widgRec + offset); + Tcl_Obj *objPtr; + + if (colorPtr == NULL) { + objPtr = Tcl_NewStringObj("", -1); + } else if (colorPtr == COLOR_DEFAULT) { + objPtr = Tcl_NewStringObj("defcolor", -1); + } else { + objPtr = Tcl_NewStringObj(Tk_NameOfColor(colorPtr), -1); + } + return objPtr; +} + +/*ARGSUSED*/ +static void +FreePen( + ClientData clientData, /* Not used. */ + Display *display, /* Not used. */ + char *widgRec, + int offset) +{ + Pen **penPtrPtr = (Pen **)(widgRec + offset); + + if (*penPtrPtr != NULL) { + Blt_FreePen(*penPtrPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToPen -- + * + * Convert the color value into a string. + * + * Results: + * The string representing the symbol color is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToPen( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + Tk_Window tkwin, /* Not used. */ + Tcl_Obj *objPtr, /* String representing pen */ + char *widgRec, /* Widget record */ + int offset, /* Offset to field in structure */ + int flags) +{ + Pen **penPtrPtr = (Pen **)(widgRec + offset); + const char *string; + + string = Tcl_GetString(objPtr); + if ((string[0] == '\0') && (flags & BLT_CONFIG_NULL_OK)) { + Blt_FreePen(*penPtrPtr); + *penPtrPtr = NULL; + } else { + Pen *penPtr; + Graph *graphPtr; + ClassId classId = (ClassId)clientData; /* Element type. */ + + graphPtr = Blt_GetGraphFromWindowData(tkwin); + assert(graphPtr); + + if (classId == CID_NONE) { + classId = graphPtr->classId; + } + if (Blt_GetPenFromObj(interp, graphPtr, objPtr, classId, &penPtr) + != TCL_OK) { + return TCL_ERROR; + } + Blt_FreePen(*penPtrPtr); + *penPtrPtr = penPtr; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * PenToObj -- + * + * Parse the name of the name. + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static Tcl_Obj * +PenToObj( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tk_Window tkwin, /* Not used. */ + char *widgRec, /* Widget information record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Pen *penPtr = *(Pen **)(widgRec + offset); + + if (penPtr == NULL) { + return Tcl_NewStringObj("", -1); + } else { + return Tcl_NewStringObj(penPtr->name, -1); + } +} + +/* + *--------------------------------------------------------------------------- + * + * GetPenFromObj -- + * + * Find and return the pen style from a given name. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +static int +GetPenFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, + Pen **penPtrPtr) +{ + Blt_HashEntry *hPtr; + Pen *penPtr; + const char *name; + + penPtr = NULL; + name = Tcl_GetString(objPtr); + hPtr = Blt_FindHashEntry(&graphPtr->penTable, name); + if (hPtr != NULL) { + penPtr = Blt_GetHashValue(hPtr); + if (penPtr->flags & DELETE_PENDING) { + penPtr = NULL; + } + } + if (penPtr == NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "can't find pen \"", name, "\" in \"", + Tk_PathName(graphPtr->tkwin), "\"", (char *)NULL); + } + return TCL_ERROR; + } + *penPtrPtr = penPtr; + return TCL_OK; +} + +static void +DestroyPen(Pen *penPtr) +{ + Graph *graphPtr = penPtr->graphPtr; + + Blt_FreeOptions(penPtr->configSpecs, (char *)penPtr, graphPtr->display, 0); + (*penPtr->destroyProc) (graphPtr, penPtr); + if ((penPtr->name != NULL) && (penPtr->name[0] != '\0')) { + Blt_Free(penPtr->name); + } + if (penPtr->hashPtr != NULL) { + Blt_DeleteHashEntry(&graphPtr->penTable, penPtr->hashPtr); + } + Blt_Free(penPtr); +} + +void +Blt_FreePen(Pen *penPtr) +{ + if (penPtr != NULL) { + penPtr->refCount--; + if ((penPtr->refCount == 0) && (penPtr->flags & DELETE_PENDING)) { + DestroyPen(penPtr); + } + } +} + +Pen * +Blt_CreatePen(Graph *graphPtr, const char *penName, ClassId classId, + int objc, Tcl_Obj *const *objv) +{ + Pen *penPtr; + Blt_HashEntry *hPtr; + unsigned int configFlags; + int isNew; + int i; + + /* + * Scan the option list for a "-type" entry. This will indicate what type + * of pen we are creating. Otherwise we'll default to the suggested type. + * Last -type option wins. + */ + for (i = 0; i < objc; i += 2) { + char *string; + int length; + + string = Tcl_GetStringFromObj(objv[i], &length); + if ((length > 2) && (strncmp(string, "-type", length) == 0)) { + char *arg; + + arg = Tcl_GetString(objv[i + 1]); + if (strcmp(arg, "bar") == 0) { + classId = CID_ELEM_BAR; + } else if (strcmp(arg, "line") == 0) { + classId = CID_ELEM_LINE; + } else if (strcmp(arg, "strip") == 0) { + classId = CID_ELEM_LINE; + } else if (strcmp(arg, "contour") == 0) { + classId = CID_ELEM_CONTOUR; + } else { + Tcl_AppendResult(graphPtr->interp, "unknown pen type \"", + arg, "\" specified", (char *)NULL); + return NULL; + } + } + } + if (classId == CID_ELEM_STRIP) { + classId = CID_ELEM_LINE; + } + hPtr = Blt_CreateHashEntry(&graphPtr->penTable, penName, &isNew); + if (!isNew) { + penPtr = Blt_GetHashValue(hPtr); + if ((penPtr->flags & DELETE_PENDING) == 0) { + Tcl_AppendResult(graphPtr->interp, "pen \"", penName, + "\" already exists in \"", Tk_PathName(graphPtr->tkwin), "\"", + (char *)NULL); + return NULL; + } + if (penPtr->classId != classId) { + Tcl_AppendResult(graphPtr->interp, "pen \"", penName, + "\" in-use: can't change pen type from \"", + Blt_GraphClassName(penPtr->classId), "\" to \"", + Blt_GraphClassName(classId), "\"", (char *)NULL); + return NULL; + } + penPtr->flags &= ~DELETE_PENDING; /* Undelete the pen. */ + } else { + if (classId == CID_ELEM_BAR) { + penPtr = Blt_BarPen(penName); + } else { + penPtr = Blt_LinePen(penName); + } + penPtr->classId = classId; + penPtr->hashPtr = hPtr; + penPtr->graphPtr = graphPtr; + Blt_SetHashValue(hPtr, penPtr); + } + configFlags = (penPtr->flags & (ACTIVE_PEN | NORMAL_PEN)); + if (Blt_ConfigureComponentFromObj(graphPtr->interp, graphPtr->tkwin, + penPtr->name, "Pen", penPtr->configSpecs, objc, objv, + (char *)penPtr, configFlags) != TCL_OK) { + if (isNew) { + DestroyPen(penPtr); + } + return NULL; + } + (*penPtr->configProc) (graphPtr, penPtr); + return penPtr; +} + +int +Blt_GetPenFromObj(Tcl_Interp *interp, Graph *graphPtr, Tcl_Obj *objPtr, + ClassId classId, Pen **penPtrPtr) +{ + Blt_HashEntry *hPtr; + Pen *penPtr; + const char *name; + + penPtr = NULL; + name = Tcl_GetString(objPtr); + hPtr = Blt_FindHashEntry(&graphPtr->penTable, name); + if (hPtr != NULL) { + penPtr = Blt_GetHashValue(hPtr); + if (penPtr->flags & DELETE_PENDING) { + penPtr = NULL; + } + } + if (penPtr == NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "can't find pen \"", name, "\" in \"", + Tk_PathName(graphPtr->tkwin), "\"", (char *)NULL); + } + return TCL_ERROR; + } + if (classId == CID_ELEM_STRIP) { + classId = CID_ELEM_LINE; + } + if (penPtr->classId != classId) { + if (interp != NULL) { + Tcl_AppendResult(interp, "pen \"", name, + "\" is the wrong type (is \"", + Blt_GraphClassName(penPtr->classId), "\"", ", wanted \"", + Blt_GraphClassName(classId), "\")", (char *)NULL); + } + return TCL_ERROR; + } + penPtr->refCount++; + *penPtrPtr = penPtr; + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_DestroyPens -- + * + * Release memory and resources allocated for the style. + * + * Results: + * None. + * + * Side effects: + * Everything associated with the pen style is freed up. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DestroyPens(Graph *graphPtr) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->penTable, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + Pen *penPtr; + + penPtr = Blt_GetHashValue(hPtr); + penPtr->hashPtr = NULL; + DestroyPen(penPtr); + } + Blt_DeleteHashTable(&graphPtr->penTable); +} + +/* + *--------------------------------------------------------------------------- + * + * CgetOp -- + * + * Queries axis attributes (font, line width, label, etc). + * + * Results: + * A standard TCL result. If querying configuration values, + * interp->result will contain the results. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static int +CgetOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Pen *penPtr; + unsigned int configFlags; + + if (GetPenFromObj(interp, graphPtr, objv[3], &penPtr) != TCL_OK) { + return TCL_ERROR; + } + configFlags = (penPtr->flags & (ACTIVE_PEN | NORMAL_PEN)); + return Blt_ConfigureValueFromObj(interp, graphPtr->tkwin, + penPtr->configSpecs, (char *)penPtr, objv[4], configFlags); +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureOp -- + * + * Queries or resets pen attributes (font, line width, color, etc). + * + * Results: + * A standard TCL result. If querying configuration values, + * interp->result will contain the results. + * + * Side Effects: + * Pen resources are possibly allocated (GC, font). + * + *--------------------------------------------------------------------------- + */ +static int +ConfigureOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Pen *penPtr; + int nNames, nOpts; + int redraw; + Tcl_Obj *const *options; + int i; + + /* Figure out where the option value pairs begin */ + objc -= 3; + objv += 3; + for (i = 0; i < objc; i++) { + char *string; + + string = Tcl_GetString(objv[i]); + if (string[0] == '-') { + break; + } + if (GetPenFromObj(interp, graphPtr, objv[i], &penPtr) != TCL_OK) { + return TCL_ERROR; + } + } + nNames = i; /* Number of pen names specified */ + nOpts = objc - i; /* Number of options specified */ + options = objv + i; /* Start of options in objv */ + + redraw = 0; + for (i = 0; i < nNames; i++) { + int flags; + + if (GetPenFromObj(interp, graphPtr, objv[i], &penPtr) != TCL_OK) { + return TCL_ERROR; + } + flags = BLT_CONFIG_OBJV_ONLY | (penPtr->flags&(ACTIVE_PEN|NORMAL_PEN)); + if (nOpts == 0) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, + penPtr->configSpecs, (char *)penPtr, (Tcl_Obj *)NULL, flags); + } else if (nOpts == 1) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, + penPtr->configSpecs, (char *)penPtr, options[0], flags); + } + if (Blt_ConfigureWidgetFromObj(interp, graphPtr->tkwin, + penPtr->configSpecs, nOpts, options, (char *)penPtr, flags) + != TCL_OK) { + break; + } + (*penPtr->configProc) (graphPtr, penPtr); + if (penPtr->refCount > 0) { + redraw++; + } + } + if (redraw) { + graphPtr->flags |= CACHE_DIRTY; + Blt_EventuallyRedrawGraph(graphPtr); + } + if (i < nNames) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * CreateOp -- + * + * Adds a new penstyle to the graph. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +static int +CreateOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Pen *penPtr; + + penPtr = Blt_CreatePen(graphPtr, Tcl_GetString(objv[3]), graphPtr->classId, + objc - 4, objv + 4); + if (penPtr == NULL) { + return TCL_ERROR; + } + Tcl_SetObjResult(interp, objv[3]); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DeleteOp -- + * + * Delete the given pen. + * + * Results: + * Always returns TCL_OK. The interp->result field is a list of the + * graph axis limits. + * + *--------------------------------------------------------------------------- + */ + +/*ARGSUSED*/ +static int +DeleteOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + int i; + + for (i = 3; i < objc; i++) { + Pen *penPtr; + + if (GetPenFromObj(interp, graphPtr, objv[i], &penPtr) != TCL_OK) { + return TCL_ERROR; + } + if (penPtr->flags & DELETE_PENDING) { + Tcl_AppendResult(interp, "can't find pen \"", + Tcl_GetString(objv[i]), "\" in \"", + Tk_PathName(graphPtr->tkwin), "\"", (char *)NULL); + return TCL_ERROR; + } + penPtr->flags |= DELETE_PENDING; + if (penPtr->refCount == 0) { + DestroyPen(penPtr); + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NamesOp -- + * + * Return a list of the names of all the axes. + * + * Results: + * Returns a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +NamesOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (objc == 3) { + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->penTable, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + Pen *penPtr; + + penPtr = Blt_GetHashValue(hPtr); + if ((penPtr->flags & DELETE_PENDING) == 0) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(penPtr->name, -1)); + } + } + } else { + Blt_HashEntry *hPtr; + Blt_HashSearch iter; + + for (hPtr = Blt_FirstHashEntry(&graphPtr->penTable, &iter); + hPtr != NULL; hPtr = Blt_NextHashEntry(&iter)) { + Pen *penPtr; + + penPtr = Blt_GetHashValue(hPtr); + if ((penPtr->flags & DELETE_PENDING) == 0) { + int i; + + for (i = 3; i < objc; i++) { + char *pattern; + + pattern = Tcl_GetString(objv[i]); + if (Tcl_StringMatch(penPtr->name, pattern)) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(penPtr->name, -1)); + break; + } + } + } + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * TypeOp -- + * + * Return the type of pen. + * + * Results: + * Returns a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +TypeOp(Tcl_Interp *interp, Graph *graphPtr, int objc, Tcl_Obj *const *objv) +{ + Pen *penPtr; + + if (GetPenFromObj(interp, graphPtr, objv[3], &penPtr) != TCL_OK) { + return TCL_ERROR; + } + Tcl_SetStringObj(Tcl_GetObjResult(interp), + Blt_GraphClassName(penPtr->classId), -1); + return TCL_OK; +} + +static Blt_OpSpec penOps[] = +{ + {"cget", 2, CgetOp, 5, 5, "penName option",}, + {"configure", 2, ConfigureOp, 4, 0, + "penName ?penName?... ?option value?...",}, + {"create", 2, CreateOp, 4, 0, "penName ?option value?...",}, + {"delete", 2, DeleteOp, 3, 0, "?penName?...",}, + {"names", 1, NamesOp, 3, 0, "?pattern?...",}, + {"type", 1, TypeOp, 4, 4, "penName",}, +}; +static int nPenOps = sizeof(penOps) / sizeof(Blt_OpSpec); + +int +Blt_PenOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + GraphPenProc *proc; + + proc = Blt_GetOpFromObj(interp, nPenOps, penOps, BLT_OP_ARG2, + objc, objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + return (*proc) (interp, graphPtr, objc, objv); +} diff --git a/src/bltGrText.C b/src/bltGrText.C new file mode 100644 index 0000000..d9cb33b --- /dev/null +++ b/src/bltGrText.C @@ -0,0 +1,2018 @@ + +/* + * bltText.c -- + * + * This module implements multi-line, rotate-able text for the BLT toolkit. + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltInt.h" +#include <bltHash.h> +#include <X11/Xutil.h> +#include "tkIntBorder.h" +#include "tkDisplay.h" +#include "bltImage.h" +#include "bltBitmap.h" +#include "bltFont.h" +#include "bltText.h" +#include "bltBgStyle.h" + +#define WINDEBUG 0 + +static Blt_HashTable bitmapGCTable; +static int initialized; + +GC +Blt_GetBitmapGC(Tk_Window tkwin) +{ + int isNew; + GC gc; + Display *display; + Blt_HashEntry *hPtr; + + if (!initialized) { + Blt_InitHashTable(&bitmapGCTable, BLT_ONE_WORD_KEYS); + initialized = TRUE; + } + display = Tk_Display(tkwin); + hPtr = Blt_CreateHashEntry(&bitmapGCTable, (char *)display, &isNew); + if (isNew) { + Pixmap bitmap; + XGCValues gcValues; + unsigned long gcMask; + Window root; + + root = Tk_RootWindow(tkwin); + bitmap = Tk_GetPixmap(display, root, 1, 1, 1); + gcValues.foreground = gcValues.background = 0; + gcMask = (GCForeground | GCBackground); + gc = Blt_GetPrivateGCFromDrawable(display, bitmap, gcMask, &gcValues); + Tk_FreePixmap(display, bitmap); + Blt_SetHashValue(hPtr, gc); + } else { + gc = (GC)Blt_GetHashValue(hPtr); + } + return gc; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetTextExtents -- + * + * Get the extents of a possibly multiple-lined text string. + * + * Results: + * Returns via *widthPtr* and *heightPtr* the dimensions of the text + * string. + * + *--------------------------------------------------------------------------- + */ +void +Blt_GetTextExtents( + Blt_Font font, + int leader, + const char *text, /* Text string to be measured. */ + int textLen, /* Length of the text. If -1, indicates that + * text is an ASCIZ string that the length + * should be computed with strlen. */ + unsigned int *widthPtr, + unsigned int *heightPtr) +{ + unsigned int lineHeight; + + if (text == NULL) { + return; /* NULL string? */ + } + { + Blt_FontMetrics fm; + + Blt_GetFontMetrics(font, &fm); + lineHeight = fm.linespace; + } + if (textLen < 0) { + textLen = strlen(text); + } + { + unsigned int lineLen; /* # of characters on each line */ + const char *p, *pend; + const char *line; + unsigned int maxWidth, maxHeight; + + maxWidth = maxHeight = 0; + lineLen = 0; + for (p = line = text, pend = text + textLen; p < pend; p++) { + if (*p == '\n') { + if (lineLen > 0) { + unsigned int lineWidth; + + lineWidth = Blt_TextWidth(font, line, lineLen); + if (lineWidth > maxWidth) { + maxWidth = lineWidth; + } + } + maxHeight += lineHeight; + line = p + 1; /* Point to the start of the next line. */ + lineLen = 0; /* Reset counter to indicate the start of a + * new line. */ + continue; + } + lineLen++; + } + if ((lineLen > 0) && (*(p - 1) != '\n')) { + unsigned int lineWidth; + + maxHeight += lineHeight; + lineWidth = Blt_TextWidth(font, line, lineLen); + if (lineWidth > maxWidth) { + maxWidth = lineWidth; + } + } + *widthPtr = maxWidth; + *heightPtr = maxHeight; + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ts_GetExtents -- + * + * Get the extents of a possibly multiple-lined text string. + * + * Results: + * Returns via *widthPtr* and *heightPtr* the dimensions of + * the text string. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ts_GetExtents(TextStyle *tsPtr, const char *text, unsigned int *widthPtr, + unsigned int *heightPtr) +{ + + if (text == NULL) { + *widthPtr = *heightPtr = 0; + } else { + unsigned int w, h; + + Blt_GetTextExtents(tsPtr->font, tsPtr->leader, text, -1, &w, &h); + *widthPtr = w + PADDING(tsPtr->xPad); + *heightPtr = h + PADDING(tsPtr->yPad); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetBoundingBox + * + * Computes the dimensions of the bounding box surrounding a rectangle + * rotated about its center. If pointArr isn't NULL, the coordinates of + * the rotated rectangle are also returned. + * + * The dimensions are determined by rotating the rectangle, and doubling + * the maximum x-coordinate and y-coordinate. + * + * w = 2 * maxX, h = 2 * maxY + * + * Since the rectangle is centered at 0,0, the coordinates of the + * bounding box are (-w/2,-h/2 w/2,-h/2, w/2,h/2 -w/2,h/2). + * + * 0 ------- 1 + * | | + * | x | + * | | + * 3 ------- 2 + * + * Results: + * The width and height of the bounding box containing the rotated + * rectangle are returned. + * + *--------------------------------------------------------------------------- + */ +void +Blt_GetBoundingBox( + int width, int height, /* Unrotated region */ + float angle, /* Rotation of box */ + double *rotWidthPtr, + double *rotHeightPtr, /* (out) Bounding box region */ + Point2d *bbox) /* (out) Points of the rotated box */ +{ + int i; + double sinTheta, cosTheta; + double radians; + double xMax, yMax; + double x, y; + Point2d corner[4]; + + angle = FMOD(angle, 360.0); + if (FMOD(angle, (double)90.0) == 0.0) { + int ll, ur, ul, lr; + double rotWidth, rotHeight; + int quadrant; + + /* Handle right-angle rotations specially. */ + + quadrant = (int)(angle / 90.0); + switch (quadrant) { + case ROTATE_270: /* 270 degrees */ + ul = 3, ur = 0, lr = 1, ll = 2; + rotWidth = (double)height; + rotHeight = (double)width; + break; + case ROTATE_90: /* 90 degrees */ + ul = 1, ur = 2, lr = 3, ll = 0; + rotWidth = (double)height; + rotHeight = (double)width; + break; + case ROTATE_180: /* 180 degrees */ + ul = 2, ur = 3, lr = 0, ll = 1; + rotWidth = (double)width; + rotHeight = (double)height; + break; + default: + case ROTATE_0: /* 0 degrees */ + ul = 0, ur = 1, lr = 2, ll = 3; + rotWidth = (double)width; + rotHeight = (double)height; + break; + } + if (bbox != NULL) { + x = rotWidth * 0.5; + y = rotHeight * 0.5; + bbox[ll].x = bbox[ul].x = -x; + bbox[ur].y = bbox[ul].y = -y; + bbox[lr].x = bbox[ur].x = x; + bbox[ll].y = bbox[lr].y = y; + } + *rotWidthPtr = rotWidth; + *rotHeightPtr = rotHeight; + return; + } + /* Set the four corners of the rectangle whose center is the origin. */ + corner[1].x = corner[2].x = (double)width * 0.5; + corner[0].x = corner[3].x = -corner[1].x; + corner[2].y = corner[3].y = (double)height * 0.5; + corner[0].y = corner[1].y = -corner[2].y; + + radians = (-angle / 180.0) * M_PI; + sinTheta = sin(radians), cosTheta = cos(radians); + xMax = yMax = 0.0; + + /* Rotate the four corners and find the maximum X and Y coordinates */ + + for (i = 0; i < 4; i++) { + x = (corner[i].x * cosTheta) - (corner[i].y * sinTheta); + y = (corner[i].x * sinTheta) + (corner[i].y * cosTheta); + if (x > xMax) { + xMax = x; + } + if (y > yMax) { + yMax = y; + } + if (bbox != NULL) { + bbox[i].x = x; + bbox[i].y = y; + } + } + + /* + * By symmetry, the width and height of the bounding box are twice the + * maximum x and y coordinates. + */ + *rotWidthPtr = xMax + xMax; + *rotHeightPtr = yMax + yMax; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_TranslateAnchor -- + * + * Translate the coordinates of a given bounding box based upon the + * anchor specified. The anchor indicates where the given x-y position + * is in relation to the bounding box. + * + * nw --- n --- ne + * | | + * w center e + * | | + * sw --- s --- se + * + * The coordinates returned are translated to the origin of the bounding + * box (suitable for giving to XCopyArea, XCopyPlane, etc.) + * + * Results: + * The translated coordinates of the bounding box are returned. + * + *--------------------------------------------------------------------------- + */ +void +Blt_TranslateAnchor( + int x, int y, /* Window coordinates of anchor */ + int w, int h, /* Extents of the bounding box */ + Tk_Anchor anchor, /* Direction of the anchor */ + int *xPtr, int *yPtr) +{ + switch (anchor) { + case TK_ANCHOR_NW: /* Upper left corner */ + break; + case TK_ANCHOR_W: /* Left center */ + y -= (h / 2); + break; + case TK_ANCHOR_SW: /* Lower left corner */ + y -= h; + break; + case TK_ANCHOR_N: /* Top center */ + x -= (w / 2); + break; + case TK_ANCHOR_CENTER: /* Center */ + x -= (w / 2); + y -= (h / 2); + break; + case TK_ANCHOR_S: /* Bottom center */ + x -= (w / 2); + y -= h; + break; + case TK_ANCHOR_NE: /* Upper right corner */ + x -= w; + break; + case TK_ANCHOR_E: /* Right center */ + x -= w; + y -= (h / 2); + break; + case TK_ANCHOR_SE: /* Lower right corner */ + x -= w; + y -= h; + break; + } + *xPtr = x; + *yPtr = y; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_AnchorPoint -- + * + * Translates a position, using both the dimensions of the bounding box, + * and the anchor direction, returning the coordinates of the upper-left + * corner of the box. The anchor indicates where the given x-y position + * is in relation to the bounding box. + * + * nw --- n --- ne + * | | + * w center e + * | | + * sw --- s --- se + * + * The coordinates returned are translated to the origin of the bounding + * box (suitable for giving to XCopyArea, XCopyPlane, etc.) + * + * Results: + * The translated coordinates of the bounding box are returned. + * + *--------------------------------------------------------------------------- + */ +Point2d +Blt_AnchorPoint( + double x, double y, /* Coordinates of anchor. */ + double w, double h, /* Extents of the bounding box */ + Tk_Anchor anchor) /* Direction of the anchor */ +{ + Point2d t; + + switch (anchor) { + case TK_ANCHOR_NW: /* Upper left corner */ + break; + case TK_ANCHOR_W: /* Left center */ + y -= (h * 0.5); + break; + case TK_ANCHOR_SW: /* Lower left corner */ + y -= h; + break; + case TK_ANCHOR_N: /* Top center */ + x -= (w * 0.5); + break; + case TK_ANCHOR_CENTER: /* Center */ + x -= (w * 0.5); + y -= (h * 0.5); + break; + case TK_ANCHOR_S: /* Bottom center */ + x -= (w * 0.5); + y -= h; + break; + case TK_ANCHOR_NE: /* Upper right corner */ + x -= w; + break; + case TK_ANCHOR_E: /* Right center */ + x -= w; + y -= (h * 0.5); + break; + case TK_ANCHOR_SE: /* Lower right corner */ + x -= w; + y -= h; + break; + } + t.x = x; + t.y = y; + return t; +} + +static INLINE int +SizeOfUtfChar(const char *s) /* Buffer in which the UTF-8 representation of + * the Tcl_UniChar is stored. Buffer must be + * large enough to hold the UTF-8 character + * (at most TCL_UTF_MAX bytes). */ +{ + int byte; + + byte = *((unsigned char *)s); + if (byte < 0xC0) { + return 1; + } else if ((byte < 0xE0) && ((s[1] & 0xC0) == 0x80)) { + return 2; + } else if ((byte < 0xF0) && + ((s[1] & 0xC0) == 0x80) && ((s[2] & 0xC0) == 0x80)) { + return 3; + } + return 1; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_MeasureText -- + * + * Draw a string of characters on the screen. Blt_DrawChars() + * expands control characters that occur in the string to + * \xNN sequences. + * + * Results: + * None. + * + * Side effects: + * Information gets drawn on the screen. + * + *--------------------------------------------------------------------------- + */ +int +Blt_MeasureText( + Blt_Font font, /* Font in which characters will be drawn; + * must be the same as font used in GC. */ + const char *text, /* UTF-8 string to be displayed. Need not be + * '\0' terminated. All Tk meta-characters + * (tabs, control characters, and newlines) + * should be stripped out of the string that + * is passed to this function. If they are + * not stripped out, they will be displayed as + * regular printing characters. */ + int textLen, /* # of bytes to draw in text string. */ + int maxLength, + int *countPtr) +{ + int elWidth; + const char *s, *send; + int accum, count, threshold; + int nBytes; + + if (maxLength < 0) { + if (countPtr != NULL) { + nBytes = textLen; + } + return Blt_TextWidth(font, text, textLen); + } + elWidth = Blt_TextWidth(font, "...", 3); + threshold = maxLength - elWidth; + if (threshold <= 0) { + return 0; + } +#if !HAVE_UTF + nBytes = 1; +#endif /* !HAVE_UTF */ + count = accum = 0; + for (s = text, send = s + textLen; s < send; s += nBytes) { +#if HAVE_UTF + Tcl_UniChar ch; +#endif /* HAVE_UTF */ + int w; +#if HAVE_UTF + nBytes = Tcl_UtfToUniChar (s, &ch); +#endif /* HAVE_UTF */ + w = Blt_TextWidth(font, s, nBytes); + if ((accum + w) > threshold) { + if (countPtr != NULL) { + *countPtr = count; + } + return accum + elWidth; + } + accum += w; + count += nBytes; + } + if (countPtr != NULL) { + *countPtr = count; + } + return accum; +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ts_CreateLayout -- + * + * Get the extents of a possibly multiple-lined text string. + * + * Results: + * Returns via *widthPtr* and *heightPtr* the dimensions of the text + * string. + * + *--------------------------------------------------------------------------- + */ +TextLayout * +Blt_Ts_CreateLayout(const char *text, int textLen, TextStyle *tsPtr) +{ + TextFragment *fp; + TextLayout *layoutPtr; + Blt_FontMetrics fm; + int count; /* Count # of characters on each line */ + int lineHeight; + size_t maxHeight, maxWidth; + size_t nFrags; + int width; /* Running dimensions of the text */ + const char *p, *endp, *start; + int i; + size_t size; + + nFrags = 0; + endp = text + ((textLen < 0) ? strlen(text) : textLen); + for (p = text; p < endp; p++) { + if (*p == '\n') { + nFrags++; + } + } + if ((p != text) && (*(p - 1) != '\n')) { + nFrags++; + } + size = sizeof(TextLayout) + (sizeof(TextFragment) * (nFrags - 1)); + + layoutPtr = Blt_AssertCalloc(1, size); + layoutPtr->nFrags = nFrags; + + nFrags = count = 0; + width = maxWidth = 0; + maxHeight = tsPtr->padTop; + Blt_GetFontMetrics(tsPtr->font, &fm); + lineHeight = fm.linespace + tsPtr->leader; + + fp = layoutPtr->fragments; + for (p = start = text; p < endp; p++) { + if (*p == '\n') { + if (count > 0) { + width = Blt_TextWidth(tsPtr->font, start, count); + if (width > maxWidth) { + maxWidth = width; + } + } else { + width = 0; + } + fp->width = width; + fp->count = count; + fp->sy = fp->y = maxHeight + fm.ascent; + fp->text = start; + maxHeight += lineHeight; + fp++; + nFrags++; + start = p + 1; /* Start the text on the next line */ + count = 0; /* Reset to indicate the start of a new + * line */ + continue; + } + count++; + } + + if (nFrags < layoutPtr->nFrags) { + width = Blt_TextWidth(tsPtr->font, start, count); + if (width > maxWidth) { + maxWidth = width; + } + fp->width = width; + fp->count = count; + fp->sy = fp->y = maxHeight + fm.ascent; + fp->text = start; + maxHeight += lineHeight; + nFrags++; + } + maxHeight += tsPtr->padBottom; + maxWidth += PADDING(tsPtr->xPad); + fp = layoutPtr->fragments; + for (i = 0; i < nFrags; i++, fp++) { + switch (tsPtr->justify) { + default: + case TK_JUSTIFY_LEFT: + /* No offset for left justified text strings */ + fp->x = fp->sx = tsPtr->padLeft; + break; + case TK_JUSTIFY_RIGHT: + fp->x = fp->sx = (maxWidth - fp->width) - tsPtr->padRight; + break; + case TK_JUSTIFY_CENTER: + fp->x = fp->sx = (maxWidth - fp->width) / 2; + break; + } + } + if (tsPtr->underline >= 0) { + fp = layoutPtr->fragments; + for (i = 0; i < nFrags; i++, fp++) { + int first, last; + + first = fp->text - text; + last = first + fp->count; + if ((tsPtr->underline >= first) && (tsPtr->underline < last)) { + layoutPtr->underlinePtr = fp; + layoutPtr->underline = tsPtr->underline - first; + break; + } + } + } + layoutPtr->width = maxWidth; + layoutPtr->height = maxHeight - tsPtr->leader; + return layoutPtr; +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_DrawCharsWithEllipsis -- + * + * Draw a string of characters on the screen. Blt_DrawChars() + * expands control characters that occur in the string to + * \xNN sequences. + * + * Results: + * None. + * + * Side effects: + * Information gets drawn on the screen. + * + *--------------------------------------------------------------------------- + */ +void +Blt_DrawCharsWithEllipsis( + Tk_Window tkwin, /* Display on which to draw. */ + Drawable drawable, /* Window or pixmap in which to draw. */ + GC gc, /* Graphics context for drawing characters. */ + Blt_Font font, /* Font in which characters will be drawn; + * must be the same as font used in GC. */ + int depth, + float angle, + const char *text, /* UTF-8 string to be displayed. Need not be + * '\0' terminated. All Tk meta-characters + * (tabs, control characters, and newlines) + * should be stripped out of the string that + * is passed to this function. If they are + * not stripped out, they will be displayed as + * regular printing characters. */ + int textLen, /* # of bytes to draw in text string. */ + int x, int y, /* Coordinates at which to place origin of + * string when drawing. */ + int maxLength) +{ + int elWidth; + const char *s, *send; + Tcl_DString dString; + int nBytes; + int accum, threshold; + +#if HAVE_UTF + Tcl_UniChar ch; +#endif /* HAVE_UTF */ + accum = 0; + elWidth = Blt_TextWidth(font, "...", 3); + if (maxLength < elWidth) { + return; + } + threshold = maxLength - elWidth; + Tcl_DStringInit(&dString); +#if !HAVE_UTF + nBytes = 1; +#endif /* !HAVE_UTF */ + for (s = text, send = s + textLen; s < send; s += nBytes) { +#if HAVE_UTF + nBytes = Tcl_UtfToUniChar (s, &ch); +#endif /* HAVE_UTF */ + accum += Blt_TextWidth(font, s, nBytes); + if (accum > threshold) { + break; + } + Tcl_DStringAppend(&dString, s, nBytes); + } + if (s < send) { + Tcl_DStringAppend(&dString, "...", 3); + } + Blt_DrawChars(Tk_Display(tkwin), drawable, gc, font, depth, angle, + Tcl_DStringValue(&dString), Tcl_DStringLength(&dString), x, y); + Tcl_DStringFree(&dString); +} + +void +Blt_DrawLayout(Tk_Window tkwin, Drawable drawable, GC gc, Blt_Font font, + int depth, float angle, int x, int y, TextLayout *layoutPtr, + int maxLength) +{ + TextFragment *fp, *fend; + Blt_FontMetrics fm; + + Blt_GetFontMetrics(font, &fm); + for (fp = layoutPtr->fragments, fend = fp + layoutPtr->nFrags; + fp < fend; fp++) { + int sx, sy; + + sx = x + fp->sx, sy = y + fp->sy; + if ((maxLength > 0) && ((fp->width + fp->x) > maxLength)) { + Blt_DrawCharsWithEllipsis(tkwin, drawable, gc, font, depth, angle, + fp->text, fp->count, sx, sy, maxLength - fp->x); + } else { + Blt_DrawChars(Tk_Display(tkwin), drawable, gc, font, depth, angle, + fp->text, fp->count, sx, sy); + } + } + if (layoutPtr->underlinePtr != NULL) { + fp = layoutPtr->underlinePtr; + Blt_UnderlineChars(Tk_Display(tkwin), drawable, gc, font, fp->text, + fp->count, x + fp->sx, y + fp->sy, layoutPtr->underline, + layoutPtr->underline + 1, maxLength); + } +} + + +#ifdef WIN32 +/* + *--------------------------------------------------------------------------- + * + * Blt_Ts_Bitmap -- + * + * Draw a bitmap, using the the given window coordinates as an anchor for + * the text bounding box. + * + * Results: + * Returns the bitmap representing the text string. + * + * Side Effects: + * Bitmap is drawn using the given font and GC in the drawable at the + * given coordinates, anchor, and rotation. + * + *--------------------------------------------------------------------------- + */ +Pixmap +Blt_Ts_Bitmap( + Tk_Window tkwin, + TextLayout *layoutPtr, /* Text string to draw */ + TextStyle *stylePtr, /* Text attributes: rotation, color, + * font, linespacing, justification, + * etc. */ + int *bmWidthPtr, + int *bmHeightPtr) /* Extents of rotated text string */ +{ + Pixmap bitmap; + Window root; + GC gc; + HDC hDC; + TkWinDCState state; + + /* Create a temporary bitmap to contain the text string */ + root = Tk_RootWindow(tkwin); + bitmap = Tk_GetPixmap(Tk_Display(tkwin), root, layoutPtr->width, + layoutPtr->height, 1); + assert(bitmap != None); + if (bitmap == None) { + return None; /* Can't allocate pixmap. */ + } + gc = Blt_GetBitmapGC(tkwin); + + /* Clear the pixmap and draw the text string into it */ + hDC = TkWinGetDrawableDC(Tk_Display(tkwin), bitmap, &state); + PatBlt(hDC, 0, 0, layoutPtr->width, layoutPtr->height, WHITENESS); + TkWinReleaseDrawableDC(bitmap, hDC, &state); + + XSetFont(Tk_Display(tkwin), gc, Blt_FontId(stylePtr->font)); + XSetForeground(Tk_Display(tkwin), gc, 1); + Blt_DrawLayout(tkwin, bitmap, gc, stylePtr->font, 1, 0.0f, 0, 0, layoutPtr, + stylePtr->maxLength); + + /* + * Under Win32, 1 is off and 0 is on. That's why we're inverting the + * bitmap here. + */ + hDC = TkWinGetDrawableDC(Tk_Display(tkwin), bitmap, &state); + PatBlt(hDC, 0, 0, layoutPtr->width, layoutPtr->height, DSTINVERT); + TkWinReleaseDrawableDC(bitmap, hDC, &state); + + *bmWidthPtr = layoutPtr->width, *bmHeightPtr = layoutPtr->height; + return bitmap; +} +#else +/* + *--------------------------------------------------------------------------- + * + * Blt_Ts_Bitmap -- + * + * Draw a bitmap, using the the given window coordinates as an anchor for + * the text bounding box. + * + * Results: + * Returns the bitmap representing the text string. + * + * Side Effects: + * Bitmap is drawn using the given font and GC in the drawable at the + * given coordinates, anchor, and rotation. + * + *--------------------------------------------------------------------------- + */ +Pixmap +Blt_Ts_Bitmap( + Tk_Window tkwin, + TextLayout *layoutPtr, /* Text string to draw */ + TextStyle *stylePtr, /* Text attributes: rotation, color, + * font, linespacing, justification, + * etc. */ + int *bmWidthPtr, + int *bmHeightPtr) /* Extents of rotated text string */ +{ + Pixmap bitmap; + GC gc; + + /* Create a bitmap big enough to contain the text. */ + bitmap = Tk_GetPixmap(Tk_Display(tkwin), Tk_RootWindow(tkwin), + layoutPtr->width, layoutPtr->height, 1); + assert(bitmap != None); + if (bitmap == None) { + return None; /* Can't allocate pixmap. */ + } + gc = Blt_GetBitmapGC(tkwin); + + /* Clear the bitmap. Background is 0. */ + XSetForeground(Tk_Display(tkwin), gc, 0); + XFillRectangle(Tk_Display(tkwin), bitmap, gc, 0, 0, layoutPtr->width, + layoutPtr->height); + + /* Draw the text into the bitmap. Foreground is 1. */ + XSetFont(Tk_Display(tkwin), gc, Blt_FontId(stylePtr->font)); + XSetForeground(Tk_Display(tkwin), gc, 1); + Blt_DrawLayout(tkwin, bitmap, gc, stylePtr->font, 1, 0.0f, 0, 0, layoutPtr, + stylePtr->maxLength); + *bmWidthPtr = layoutPtr->width, *bmHeightPtr = layoutPtr->height; + return bitmap; +} +#endif /* WIN32 */ + +void +Blt_Ts_SetDrawStyle( + TextStyle *stylePtr, + Blt_Font font, + GC gc, + XColor *normalColor, + float angle, + Tk_Anchor anchor, + Tk_Justify justify, + int leader) +{ + stylePtr->xPad.side1 = stylePtr->xPad.side2 = 0; + stylePtr->yPad.side1 = stylePtr->yPad.side2 = 0; + stylePtr->state = 0; + stylePtr->anchor = anchor; + stylePtr->color = normalColor; + stylePtr->font = font; + stylePtr->gc = gc; + stylePtr->justify = justify; + stylePtr->leader = leader; + stylePtr->angle = (float)angle; +} + +static void +DrawStandardLayout(Tk_Window tkwin, Drawable drawable, TextStyle *stylePtr, + TextLayout *layoutPtr, int x, int y) +{ + int w, h; + /* + * This is the easy case of no rotation. Simply draw the text + * using the standard drawing routines. Handle offset printing + * for engraved (disabled) text. + */ + w = layoutPtr->width; + h = layoutPtr->height; + if ((stylePtr->maxLength > 0) && (stylePtr->maxLength < w)) { + w = stylePtr->maxLength; + } + Blt_TranslateAnchor(x, y, w, h, stylePtr->anchor, &x, &y); + if (stylePtr->state & (STATE_DISABLED | STATE_EMPHASIS)) { + TkBorder *borderPtr = (TkBorder *) Blt_BackgroundBorder(stylePtr->bg); + XColor *color1, *color2; + + color1 = borderPtr->lightColor, color2 = borderPtr->darkColor; + if (stylePtr->state & STATE_EMPHASIS) { + XColor *hold; + + hold = color1, color1 = color2, color2 = hold; + } + if (color1 != NULL) { + XSetForeground(Tk_Display(tkwin), stylePtr->gc, color1->pixel); + } + Blt_DrawLayout(tkwin, drawable, stylePtr->gc, stylePtr->font, + Tk_Depth(tkwin), 0.0f, x+1, y+1, layoutPtr,stylePtr->maxLength); + if (color2 != NULL) { + XSetForeground(Tk_Display(tkwin), stylePtr->gc, color2->pixel); + } + Blt_DrawLayout(tkwin, drawable, stylePtr->gc, stylePtr->font, + Tk_Depth(tkwin), 0.0f, x, y, layoutPtr, stylePtr->maxLength); + + /* Reset the foreground color back to its original setting, so not to + * invalidate the GC cache. */ + XSetForeground(Tk_Display(tkwin), stylePtr->gc, stylePtr->color->pixel); + + return; /* Done */ + } + Blt_DrawLayout(tkwin, drawable, stylePtr->gc, stylePtr->font, + Tk_Depth(tkwin), 0.0f, x, y, layoutPtr, stylePtr->maxLength); +} + + +static void +RotateStartingTextPositions(TextLayout *lPtr, int w, int h, float angle) +{ + Point2d off1, off2; + TextFragment *fp, *fend; + double radians; + double rw, rh; + double sinTheta, cosTheta; + + Blt_GetBoundingBox(w, h, angle, &rw, &rh, (Point2d *)NULL); + off1.x = (double)w * 0.5; + off1.y = (double)h * 0.5; + off2.x = rw * 0.5; + off2.y = rh * 0.5; + radians = (-angle / 180.0) * M_PI; + + sinTheta = sin(radians), cosTheta = cos(radians); + for (fp = lPtr->fragments, fend = fp + lPtr->nFrags; fp < fend; fp++) { + Point2d p, q; + + p.x = fp->x - off1.x; + p.y = fp->y - off1.y; + q.x = (p.x * cosTheta) - (p.y * sinTheta); + q.y = (p.x * sinTheta) + (p.y * cosTheta); + q.x += off2.x; + q.y += off2.y; + fp->sx = ROUND(q.x); + fp->sy = ROUND(q.y); + } +} + +void +Blt_RotateStartingTextPositions(TextLayout *lPtr, float angle) +{ + RotateStartingTextPositions(lPtr, lPtr->width, lPtr->height, angle); +} + +int +Blt_DrawTextWithRotatedFont(Tk_Window tkwin, Drawable drawable, float angle, + TextStyle *stylePtr, TextLayout *layoutPtr, + int x, int y) +{ + double rw, rh; + int w, h; + + w = layoutPtr->width; + h = layoutPtr->height; + if ((stylePtr->maxLength > 0) && (stylePtr->maxLength < w)) { + w = stylePtr->maxLength; + } + RotateStartingTextPositions(layoutPtr, w, h, angle); + Blt_GetBoundingBox(w, h, angle, &rw, &rh, (Point2d *)NULL); + Blt_TranslateAnchor(x, y, (int)rw, (int)rh, stylePtr->anchor, &x, &y); + if (stylePtr->state & (STATE_DISABLED | STATE_EMPHASIS)) { + TkBorder *borderPtr = (TkBorder *)Blt_BackgroundBorder(stylePtr->bg); + XColor *color1, *color2; + + color1 = borderPtr->lightColor, color2 = borderPtr->darkColor; + if (stylePtr->state & STATE_EMPHASIS) { + XColor *hold; + + hold = color1, color1 = color2, color2 = hold; + } + if (color1 != NULL) { + XSetForeground(Tk_Display(tkwin), stylePtr->gc, color1->pixel); + Blt_DrawLayout(tkwin, drawable, stylePtr->gc, stylePtr->font, + Tk_Depth(tkwin), angle, x, y, layoutPtr, stylePtr->maxLength); + } + if (color2 != NULL) { + XSetForeground(Tk_Display(tkwin), stylePtr->gc, color2->pixel); + Blt_DrawLayout(tkwin, drawable, stylePtr->gc, stylePtr->font, + Tk_Depth(tkwin), angle, x, y, layoutPtr, stylePtr->maxLength); + } + XSetForeground(Tk_Display(tkwin), stylePtr->gc, stylePtr->color->pixel); + return TRUE; + } + XSetForeground(Tk_Display(tkwin), stylePtr->gc, stylePtr->color->pixel); + Blt_DrawLayout(tkwin, drawable, stylePtr->gc, stylePtr->font, + Tk_Depth(tkwin), angle, x, y, layoutPtr, stylePtr->maxLength); + return TRUE; +} + +static void +Blt_DrawTextWithRotatedBitmap( + Tk_Window tkwin, + Drawable drawable, + float angle, + TextStyle *stylePtr, /* Text attribute information */ + TextLayout *layoutPtr, + int x, int y) /* Window coordinates to draw text */ +{ + int width, height; + Display *display; + Pixmap bitmap; + + display = Tk_Display(tkwin); + /* + * Rotate the text by writing the text into a bitmap and rotating the + * bitmap. Set the clip mask and origin in the GC first. And make sure + * we restore the GC because it may be shared. + */ + stylePtr->angle = angle; + + bitmap = Blt_Ts_Bitmap(tkwin, layoutPtr, stylePtr, &width, &height); + if (bitmap == None) { + return; + } + if ((bitmap != None) && (stylePtr->angle != 0.0)) { + Pixmap rotated; + + rotated = Blt_RotateBitmap(tkwin, bitmap, width, height, + stylePtr->angle, &width, &height); + Tk_FreePixmap(display, bitmap); + bitmap = rotated; + } + Blt_TranslateAnchor(x, y, width, height, stylePtr->anchor, &x, &y); + XSetClipMask(display, stylePtr->gc, bitmap); + + if (stylePtr->state & (STATE_DISABLED | STATE_EMPHASIS)) { + TkBorder *borderPtr = (TkBorder *) Blt_BackgroundBorder(stylePtr->bg); + XColor *color1, *color2; + + color1 = borderPtr->lightColor, color2 = borderPtr->darkColor; + if (stylePtr->state & STATE_EMPHASIS) { + XColor *hold; + + hold = color1, color1 = color2, color2 = hold; + } + if (color1 != NULL) { + XSetForeground(display, stylePtr->gc, color1->pixel); + } + XSetClipOrigin(display, stylePtr->gc, x + 1, y + 1); + XCopyPlane(display, bitmap, drawable, stylePtr->gc, 0, 0, width, + height, x + 1, y + 1, 1); + if (color2 != NULL) { + XSetForeground(display, stylePtr->gc, color2->pixel); + } + XSetClipOrigin(display, stylePtr->gc, x, y); + XCopyPlane(display, bitmap, drawable, stylePtr->gc, 0, 0, width, + height, x, y, 1); + XSetForeground(display, stylePtr->gc, stylePtr->color->pixel); + } else { + XSetForeground(display, stylePtr->gc, stylePtr->color->pixel); + XSetClipOrigin(display, stylePtr->gc, x, y); + XCopyPlane(display, bitmap, drawable, stylePtr->gc, 0, 0, width, height, + x, y, 1); + } + XSetClipMask(display, stylePtr->gc, None); + Tk_FreePixmap(display, bitmap); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ts_DrawLayout -- + * + * Draw a text string, possibly rotated, using the the given window + * coordinates as an anchor for the text bounding box. If the text is + * not rotated, simply use the X text drawing routines. Otherwise, + * generate a bitmap of the rotated text. + * + * Results: + * Returns the x-coordinate to the right of the text. + * + * Side Effects: + * Text string is drawn using the given font and GC at the the given + * window coordinates. + * + * The Stipple, FillStyle, and TSOrigin fields of the GC are modified for + * rotated text. This assumes the GC is private, *not* shared (via + * Tk_GetGC) + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ts_DrawLayout( + Tk_Window tkwin, + Drawable drawable, + TextLayout *layoutPtr, + TextStyle *stylePtr, /* Text attribute information */ + int x, int y) /* Window coordinates to draw text */ +{ + float angle; + + if ((stylePtr->gc == NULL) || (stylePtr->flags & UPDATE_GC)) { + Blt_Ts_ResetStyle(tkwin, stylePtr); + } + angle = (float)FMOD(stylePtr->angle, 360.0); + if (angle < 0.0) { + angle += 360.0; + } + if (angle == 0.0) { + /* + * This is the easy case of no rotation. Simply draw the text using + * the standard drawing routines. Handle offset printing for engraved + * (disabled) text. + */ + DrawStandardLayout(tkwin, drawable, stylePtr, layoutPtr, x, y); + return; + } + if (Blt_CanRotateFont(stylePtr->font, angle)) { + if (Blt_DrawTextWithRotatedFont(tkwin, drawable, angle, stylePtr, + layoutPtr, x, y)) { + return; /* Success. */ + } + } + /*Fallthru*/ + stylePtr->angle = (float)angle; + Blt_DrawTextWithRotatedBitmap(tkwin, drawable, angle, stylePtr, layoutPtr, + x, y); +} + +void +Blt_Ts_UnderlineLayout( + Tk_Window tkwin, + Drawable drawable, + TextLayout *layoutPtr, + TextStyle *stylePtr, /* Text attribute information */ + int x, int y) /* Window coordinates to draw text */ +{ + float angle; + + if ((stylePtr->gc == NULL) || (stylePtr->flags & UPDATE_GC)) { + Blt_Ts_ResetStyle(tkwin, stylePtr); + } + angle = (float)FMOD(stylePtr->angle, 360.0); + if (angle < 0.0) { + angle += 360.0; + } + if (angle == 0.0) { + TextFragment *fp, *fend; + + for (fp = layoutPtr->fragments, fend = fp + layoutPtr->nFrags; + fp < fend; fp++) { + int sx, sy; + + sx = x + fp->sx, sy = y + fp->sy; + Blt_UnderlineChars(Tk_Display(tkwin), drawable, stylePtr->gc, + stylePtr->font, fp->text, fp->count, sx, sy, 0, fp->count, + stylePtr->maxLength); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Ts_DrawLayout -- + * + * Draw a text string, possibly rotated, using the the given window + * coordinates as an anchor for the text bounding box. If the text is + * not rotated, simply use the X text drawing routines. Otherwise, + * generate a bitmap of the rotated text. + * + * Results: + * Returns the x-coordinate to the right of the text. + * + * Side Effects: + * Text string is drawn using the given font and GC at the the given + * window coordinates. + * + * The Stipple, FillStyle, and TSOrigin fields of the GC are modified for + * rotated text. This assumes the GC is private, *not* shared (via + * Tk_GetGC) + * + *--------------------------------------------------------------------------- + */ +void +Blt_Ts_DrawText( + Tk_Window tkwin, + Drawable drawable, + const char *text, + int textLen, + TextStyle *stylePtr, /* Text attribute information */ + int x, int y) /* Window coordinates to draw text */ +{ + TextLayout *layoutPtr; + + layoutPtr = Blt_Ts_CreateLayout(text, textLen, stylePtr); + Blt_Ts_DrawLayout(tkwin, drawable, layoutPtr, stylePtr, x, y); + Blt_Free(layoutPtr); +} + +void +Blt_DrawText2( + Tk_Window tkwin, + Drawable drawable, + const char *string, + TextStyle *stylePtr, /* Text attribute information */ + int x, int y, /* Window coordinates to draw text */ + Dim2D *areaPtr) +{ + TextLayout *layoutPtr; + int width, height; + float angle; + + if ((string == NULL) || (*string == '\0')) { + return; /* Empty string, do nothing */ + } + layoutPtr = Blt_Ts_CreateLayout(string, -1, stylePtr); + Blt_Ts_DrawLayout(tkwin, drawable, layoutPtr, stylePtr, x, y); + angle = FMOD(stylePtr->angle, 360.0); + if (angle < 0.0) { + angle += 360.0; + } + width = layoutPtr->width; + height = layoutPtr->height; + if (angle != 0.0) { + double rotWidth, rotHeight; + + Blt_GetBoundingBox(width, height, angle, &rotWidth, &rotHeight, + (Point2d *)NULL); + width = ROUND(rotWidth); + height = ROUND(rotHeight); + } + areaPtr->width = width; + areaPtr->height = height; + Blt_Free(layoutPtr); +} + +void +Blt_DrawText( + Tk_Window tkwin, + Drawable drawable, + const char *string, + TextStyle *stylePtr, /* Text attribute information */ + int x, int y) /* Window coordinates to draw text */ +{ + TextLayout *layoutPtr; + + if ((string == NULL) || (*string == '\0')) { + return; /* Empty string, do nothing */ + } + layoutPtr = Blt_Ts_CreateLayout(string, -1, stylePtr); + Blt_Ts_DrawLayout(tkwin, drawable, layoutPtr, stylePtr, x, y); + Blt_Free(layoutPtr); +} + +void +Blt_Ts_ResetStyle(Tk_Window tkwin, TextStyle *stylePtr) +{ + GC newGC; + XGCValues gcValues; + unsigned long gcMask; + + gcMask = GCFont; + gcValues.font = Blt_FontId(stylePtr->font); + if (stylePtr->color != NULL) { + gcMask |= GCForeground; + gcValues.foreground = stylePtr->color->pixel; + } + newGC = Tk_GetGC(tkwin, gcMask, &gcValues); + if (stylePtr->gc != NULL) { + Tk_FreeGC(Tk_Display(tkwin), stylePtr->gc); + } + stylePtr->gc = newGC; + stylePtr->flags &= ~UPDATE_GC; +} + +void +Blt_Ts_FreeStyle(Display *display, TextStyle *stylePtr) +{ + if (stylePtr->gc != NULL) { + Tk_FreeGC(display, stylePtr->gc); + } +} + +/* + * The following two structures are used to keep track of string + * measurement information when using the text layout facilities. + * + * A LayoutChunk represents a contiguous range of text that can be measured + * and displayed by low-level text calls. In general, chunks will be + * delimited by newlines and tabs. Low-level, platform-specific things + * like kerning and non-integer character widths may occur between the + * characters in a single chunk, but not between characters in different + * chunks. + * + * A TextLayout is a collection of LayoutChunks. It can be displayed with + * respect to any origin. It is the implementation of the Tk_TextLayout + * opaque token. + */ + +typedef struct LayoutChunk { + const char *start; /* Pointer to simple string to be displayed. + * This is a pointer into the TkTextLayout's + * string. */ + int numBytes; /* The number of bytes in this chunk. */ + int numChars; /* The number of characters in this chunk. */ + int numDisplayChars; /* The number of characters to display when + * this chunk is displayed. Can be less than + * numChars if extra space characters were + * absorbed by the end of the chunk. This + * will be < 0 if this is a chunk that is + * holding a tab or newline. */ + int x, y; /* The origin of the first character in this + * chunk with respect to the upper-left hand + * corner of the TextLayout. */ + int totalWidth; /* Width in pixels of this chunk. Used + * when hit testing the invisible spaces at + * the end of a chunk. */ + int displayWidth; /* Width in pixels of the displayable + * characters in this chunk. Can be less than + * width if extra space characters were + * absorbed by the end of the chunk. */ +} LayoutChunk; + +typedef struct TkTextLayout { + Blt_Font font; /* The font used when laying out the text. */ + const char *string; /* The string that was layed out. */ + int width; /* The maximum width of all lines in the + * text layout. */ + int numChunks; /* Number of chunks actually used in + * following array. */ + LayoutChunk chunks[1]; /* Array of chunks. The actual size will + * be maxChunks. THIS FIELD MUST BE THE LAST + * IN THE STRUCTURE. */ +} TkTextLayout; + + +/* + *--------------------------------------------------------------------------- + * + * Blt_FreeTextLayout -- + * + * This procedure is called to release the storage associated with + * a Tk_TextLayout when it is no longer needed. + * + * Results: + * None. + * + * Side effects: + * Memory is freed. + * + *--------------------------------------------------------------------------- + */ + +void +Blt_FreeTextLayout(Tk_TextLayout textLayout) +{ + TkTextLayout *layoutPtr = (TkTextLayout *) textLayout; + + if (layoutPtr != NULL) { + Blt_Free(layoutPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * NewChunk -- + * + * Helper function for Blt_ComputeTextLayout(). Encapsulates a + * measured set of characters in a chunk that can be quickly + * drawn. + * + * Results: + * A pointer to the new chunk in the text layout. + * + * Side effects: + * The text layout is reallocated to hold more chunks as necessary. + * + * Currently, Tk_ComputeTextLayout() stores contiguous ranges of + * "normal" characters in a chunk, along with individual tab + * and newline chars in their own chunks. All characters in the + * text layout are accounted for. + * + *--------------------------------------------------------------------------- + */ +static LayoutChunk * +NewChunk(TkTextLayout **layoutPtrPtr, int *maxPtr, const char *start, + int numBytes, int curX, int newX, int y) +{ + TkTextLayout *layoutPtr; + LayoutChunk *chunkPtr; + int maxChunks, numChars; + size_t s; + + layoutPtr = *layoutPtrPtr; + maxChunks = *maxPtr; + if (layoutPtr->numChunks == maxChunks) { + maxChunks *= 2; + s = sizeof(TkTextLayout) + ((maxChunks - 1) * sizeof(LayoutChunk)); + layoutPtr = Blt_Realloc(layoutPtr, s); + *layoutPtrPtr = layoutPtr; + *maxPtr = maxChunks; + } + numChars = Tcl_NumUtfChars(start, numBytes); + chunkPtr = &layoutPtr->chunks[layoutPtr->numChunks]; + chunkPtr->start = start; + chunkPtr->numBytes = numBytes; + chunkPtr->numChars = numChars; + chunkPtr->numDisplayChars = numChars; + chunkPtr->x = curX; + chunkPtr->y = y; + chunkPtr->totalWidth = newX - curX; + chunkPtr->displayWidth = newX - curX; + layoutPtr->numChunks++; + + return chunkPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ComputeTextLayout -- + * + * Computes the amount of screen space needed to display a multi-line, + * justified string of text. Records all the measurements that were done + * to determine to size and positioning of the individual lines of text; + * this information can be used by the Tk_DrawTextLayout() procedure to + * display the text quickly (without remeasuring it). + * + * This procedure is useful for simple widgets that want to display + * single-font, multi-line text and want Tk to handle the details. + * + * Results: + * The return value is a Tk_TextLayout token that holds the measurement + * information for the given string. The token is only valid for the + * given string. If the string is freed, the token is no longer valid + * and must also be freed. To free the token, call Tk_FreeTextLayout(). + * + * The dimensions of the screen area needed to display the text are + * stored in *widthPtr and *heightPtr. + * + * Side effects: + * Memory is allocated to hold the measurement information. + * + *--------------------------------------------------------------------------- + */ + +Tk_TextLayout +Blt_ComputeTextLayout( + Blt_Font font, /* Font that will be used to display text. */ + const char *string, /* String whose dimensions are to be + * computed. */ + int numChars, /* Number of characters to consider from + * string, or < 0 for strlen(). */ + int wrapLength, /* Longest permissible line length, in + * pixels. <= 0 means no automatic wrapping: + * just let lines get as long as needed. */ + Tk_Justify justify, /* How to justify lines. */ + int flags, /* Flag bits OR-ed together. + * TK_IGNORE_TABS means that tab characters + * should not be expanded. TK_IGNORE_NEWLINES + * means that newline characters should not + * cause a line break. */ + int *widthPtr, /* Filled with width of string. */ + int *heightPtr) /* Filled with height of string. */ +{ + const char *start, *end, *special; + int n, y, bytesThisChunk, maxChunks; + int baseline, height, curX, newX, maxWidth; + TkTextLayout *layoutPtr; + LayoutChunk *chunkPtr; + Blt_FontMetrics fm; + Tcl_DString lineBuffer; + int *lineLengths; + int curLine, layoutHeight; + + Tcl_DStringInit(&lineBuffer); + + if ((font == NULL) || (string == NULL)) { + if (widthPtr != NULL) { + *widthPtr = 0; + } + if (heightPtr != NULL) { + *heightPtr = 0; + } + return NULL; + } + + Blt_GetFontMetrics(font, &fm); + height = fm.ascent + fm.descent; + + if (numChars < 0) { + numChars = Tcl_NumUtfChars(string, -1); + } + if (wrapLength == 0) { + wrapLength = -1; + } + + maxChunks = 1; + + layoutPtr = Blt_AssertMalloc(sizeof(TkTextLayout) + (maxChunks - 1) * + sizeof(LayoutChunk)); + layoutPtr->font = font; + layoutPtr->string = string; + layoutPtr->numChunks = 0; + + baseline = fm.ascent; + maxWidth = 0; + + /* + * Divide the string up into simple strings and measure each string. + */ + + curX = 0; + + end = Tcl_UtfAtIndex(string, numChars); + special = string; + + flags &= TK_IGNORE_TABS | TK_IGNORE_NEWLINES; + flags |= TK_WHOLE_WORDS | TK_AT_LEAST_ONE; + for (start = string; start < end; ) { + if (start >= special) { + /* + * Find the next special character in the string. + * + * INTL: Note that it is safe to increment by byte, because we are + * looking for 7-bit characters that will appear unchanged in + * UTF-8. At some point we may need to support the full Unicode + * whitespace set. + */ + + for (special = start; special < end; special++) { + if (!(flags & TK_IGNORE_NEWLINES)) { + if ((*special == '\n') || (*special == '\r')) { + break; + } + } + if (!(flags & TK_IGNORE_TABS)) { + if (*special == '\t') { + break; + } + } + } + } + + /* + * Special points at the next special character (or the end of the + * string). Process characters between start and special. + */ + + chunkPtr = NULL; + if (start < special) { + bytesThisChunk = Blt_MeasureChars(font, start, special - start, + wrapLength - curX, flags, &newX); + newX += curX; + flags &= ~TK_AT_LEAST_ONE; + if (bytesThisChunk > 0) { + chunkPtr = NewChunk(&layoutPtr, &maxChunks, start, + bytesThisChunk, curX, newX, baseline); + + start += bytesThisChunk; + curX = newX; + } + } + + if ((start == special) && (special < end)) { + /* + * Handle the special character. + * + * INTL: Special will be pointing at a 7-bit character so we + * can safely treat it as a single byte. + */ + + chunkPtr = NULL; + if (*special == '\t') { + newX = curX + fm.tabWidth; + newX -= newX % fm.tabWidth; + NewChunk(&layoutPtr, &maxChunks, start, 1, curX, newX, + baseline)->numDisplayChars = -1; + start++; + if ((start < end) && + ((wrapLength <= 0) || (newX <= wrapLength))) { + /* + * More chars can still fit on this line. + */ + + curX = newX; + flags &= ~TK_AT_LEAST_ONE; + continue; + } + } else { + NewChunk(&layoutPtr, &maxChunks, start, 1, curX, curX, + baseline)->numDisplayChars = -1; + start++; + goto wrapLine; + } + } + + /* + * No more characters are going to go on this line, either because + * no more characters can fit or there are no more characters left. + * Consume all extra spaces at end of line. + */ + + while ((start < end) && isspace(UCHAR(*start))) { /* INTL: ISO space */ + if (!(flags & TK_IGNORE_NEWLINES)) { + if ((*start == '\n') || (*start == '\r')) { + break; + } + } + if (!(flags & TK_IGNORE_TABS)) { + if (*start == '\t') { + break; + } + } + start++; + } + if (chunkPtr != NULL) { + const char *end; + + /* + * Append all the extra spaces on this line to the end of the + * last text chunk. This is a little tricky because we are + * switching back and forth between characters and bytes. + */ + + end = chunkPtr->start + chunkPtr->numBytes; + bytesThisChunk = start - end; + if (bytesThisChunk > 0) { + bytesThisChunk = Blt_MeasureChars(font, end, bytesThisChunk, + -1, 0, &chunkPtr->totalWidth); + chunkPtr->numBytes += bytesThisChunk; + chunkPtr->numChars += Tcl_NumUtfChars(end, bytesThisChunk); + chunkPtr->totalWidth += curX; + } + } + + wrapLine: + flags |= TK_AT_LEAST_ONE; + + /* + * Save current line length, then move current position to start of + * next line. + */ + + if (curX > maxWidth) { + maxWidth = curX; + } + + /* + * Remember width of this line, so that all chunks on this line + * can be centered or right justified, if necessary. + */ + + Tcl_DStringAppend(&lineBuffer, (char *) &curX, sizeof(curX)); + + curX = 0; + baseline += height; + } + + /* + * If last line ends with a newline, then we need to make a 0 width + * chunk on the next line. Otherwise "Hello" and "Hello\n" are the + * same height. + */ + + if ((layoutPtr->numChunks > 0) && ((flags & TK_IGNORE_NEWLINES) == 0)) { + if (layoutPtr->chunks[layoutPtr->numChunks - 1].start[0] == '\n') { + chunkPtr = NewChunk(&layoutPtr, &maxChunks, start, 0, curX, + curX, baseline); + chunkPtr->numDisplayChars = -1; + Tcl_DStringAppend(&lineBuffer, (char *) &curX, sizeof(curX)); + baseline += height; + } + } + + layoutPtr->width = maxWidth; + layoutHeight = baseline - fm.ascent; + if (layoutPtr->numChunks == 0) { + layoutHeight = height; + + /* + * This fake chunk is used by the other procedures so that they can + * pretend that there is a chunk with no chars in it, which makes + * the coding simpler. + */ + + layoutPtr->numChunks = 1; + layoutPtr->chunks[0].start = string; + layoutPtr->chunks[0].numBytes = 0; + layoutPtr->chunks[0].numChars = 0; + layoutPtr->chunks[0].numDisplayChars = -1; + layoutPtr->chunks[0].x = 0; + layoutPtr->chunks[0].y = fm.ascent; + layoutPtr->chunks[0].totalWidth = 0; + layoutPtr->chunks[0].displayWidth = 0; + } else { + /* + * Using maximum line length, shift all the chunks so that the lines + * are all justified correctly. + */ + + curLine = 0; + chunkPtr = layoutPtr->chunks; + y = chunkPtr->y; + lineLengths = (int *) Tcl_DStringValue(&lineBuffer); + for (n = 0; n < layoutPtr->numChunks; n++) { + int extra; + + if (chunkPtr->y != y) { + curLine++; + y = chunkPtr->y; + } + extra = maxWidth - lineLengths[curLine]; + if (justify == TK_JUSTIFY_CENTER) { + chunkPtr->x += extra / 2; + } else if (justify == TK_JUSTIFY_RIGHT) { + chunkPtr->x += extra; + } + chunkPtr++; + } + } + + if (widthPtr != NULL) { + *widthPtr = layoutPtr->width; + } + if (heightPtr != NULL) { + *heightPtr = layoutHeight; + } + Tcl_DStringFree(&lineBuffer); + + return (Tk_TextLayout) layoutPtr; +} + +void +Blt_DrawTextLayout( + Display *display, /* Display on which to draw. */ + Drawable drawable, /* Window or pixmap in which to draw. */ + GC gc, /* Graphics context to use for drawing text. */ + Tk_TextLayout layout, /* Layout information, from a previous call + * to Blt_ComputeTextLayout(). */ + int x, int y, /* Upper-left hand corner of rectangle in + * which to draw (pixels). */ + int firstChar, /* The index of the first character to draw + * from the given text item. 0 specfies the + * beginning. */ + int lastChar) /* The index just after the last character + * to draw from the given text item. A number + * < 0 means to draw all characters. */ +{ + TkTextLayout *layoutPtr; + int i, numDisplayChars, drawX; + const char *firstByte; + const char *lastByte; + LayoutChunk *chunkPtr; + int depth = 24; + + layoutPtr = (TkTextLayout *) layout; + if (layoutPtr == NULL) { + return; + } + + if (lastChar < 0) { + lastChar = 100000000; + } + chunkPtr = layoutPtr->chunks; + for (i = 0; i < layoutPtr->numChunks; i++) { + numDisplayChars = chunkPtr->numDisplayChars; + if ((numDisplayChars > 0) && (firstChar < numDisplayChars)) { + if (firstChar <= 0) { + drawX = 0; + firstChar = 0; + firstByte = chunkPtr->start; + } else { + firstByte = Tcl_UtfAtIndex(chunkPtr->start, firstChar); + Blt_MeasureChars(layoutPtr->font, chunkPtr->start, + firstByte - chunkPtr->start, -1, 0, &drawX); + } + if (lastChar < numDisplayChars) { + numDisplayChars = lastChar; + } + lastByte = Tcl_UtfAtIndex(chunkPtr->start, numDisplayChars); + Blt_DrawChars(display, drawable, gc, layoutPtr->font, depth, 0.0f, + firstByte, lastByte - firstByte, + x + chunkPtr->x + drawX, y + chunkPtr->y); + } + firstChar -= chunkPtr->numChars; + lastChar -= chunkPtr->numChars; + if (lastChar <= 0) { + break; + } + chunkPtr++; + } +} + +/* + *--------------------------------------------------------------------------- + * + * Tk_CharBbox -- + * + * Use the information in the Tk_TextLayout token to return the + * bounding box for the character specified by index. + * + * The width of the bounding box is the advance width of the + * character, and does not include and left- or right-bearing. + * Any character that extends partially outside of the + * text layout is considered to be truncated at the edge. Any + * character which is located completely outside of the text + * layout is considered to be zero-width and pegged against + * the edge. + * + * The height of the bounding box is the line height for this font, + * extending from the top of the ascent to the bottom of the + * descent. Information about the actual height of the individual + * letter is not available. + * + * A text layout that contains no characters is considered to + * contain a single zero-width placeholder character. + * + * Results: + * The return value is 0 if the index did not specify a character + * in the text layout, or non-zero otherwise. In that case, + * *bbox is filled with the bounding box of the character. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +int +Blt_CharBbox( + Tk_TextLayout layout, /* Layout information, from a previous call to + * Tk_ComputeTextLayout(). */ + int index, /* The index of the character whose bbox is + * desired. */ + int *xPtr, int *yPtr, /* Filled with the upper-left hand corner, in + * pixels, of the bounding box for the character + * specified by index, if non-NULL. */ + int *widthPtr, + int *heightPtr) /* Filled with the width and height of the + * bounding box for the character specified by + * index, if non-NULL. */ +{ + TkTextLayout *layoutPtr; + LayoutChunk *chunkPtr; + int i, x, w; + Blt_Font font; + const char *end; + Blt_FontMetrics fm; + + if (index < 0) { + return 0; + } + + layoutPtr = (TkTextLayout *) layout; + chunkPtr = layoutPtr->chunks; + font = layoutPtr->font; + + Blt_GetFontMetrics(font, &fm); + for (i = 0; i < layoutPtr->numChunks; i++) { + if (chunkPtr->numDisplayChars < 0) { + if (index == 0) { + x = chunkPtr->x; + w = chunkPtr->totalWidth; + goto check; + } + } else if (index < chunkPtr->numChars) { + end = Tcl_UtfAtIndex(chunkPtr->start, index); + if (xPtr != NULL) { + Blt_MeasureChars(font, chunkPtr->start, + end - chunkPtr->start, -1, 0, &x); + x += chunkPtr->x; + } + if (widthPtr != NULL) { + Blt_MeasureChars(font, end, Tcl_UtfNext(end) - end, -1, 0, &w); + } + goto check; + } + index -= chunkPtr->numChars; + chunkPtr++; + } + if (index == 0) { + /* + * Special case to get location just past last char in layout. + */ + + chunkPtr--; + x = chunkPtr->x + chunkPtr->totalWidth; + w = 0; + } else { + return 0; + } + + /* + * Ensure that the bbox lies within the text layout. This forces all + * chars that extend off the right edge of the text layout to have + * truncated widths, and all chars that are completely off the right + * edge of the text layout to peg to the edge and have 0 width. + */ + check: + if (yPtr != NULL) { + *yPtr = chunkPtr->y - fm.ascent; + } + if (heightPtr != NULL) { + *heightPtr = fm.ascent + fm.descent; + } + + if (x > layoutPtr->width) { + x = layoutPtr->width; + } + if (xPtr != NULL) { + *xPtr = x; + } + if (widthPtr != NULL) { + if (x + w > layoutPtr->width) { + w = layoutPtr->width - x; + } + *widthPtr = w; + } + + return 1; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_UnderlineTextLayout -- + * + * Use the information in the Tk_TextLayout token to display an + * underline below an individual character. This procedure does + * not draw the text, just the underline. + * + * This procedure is useful for simple widgets that need to + * display single-font, multi-line text with an individual + * character underlined and want Tk to handle the details. + * To display larger amounts of underlined text, construct + * and use an underlined font. + * + * Results: + * None. + * + * Side effects: + * Underline drawn on the screen. + * + *--------------------------------------------------------------------------- + */ + +void +Blt_UnderlineTextLayout( + Display *display, /* Display on which to draw. */ + Drawable drawable, /* Window or pixmap in which to draw. */ + GC gc, /* Graphics context to use for drawing text. */ + Tk_TextLayout layout, /* Layout information, from a previous call + * to Tk_ComputeTextLayout(). */ + int x, int y, /* Upper-left hand corner of rectangle in + * which to draw (pixels). */ + int underline) /* Index of the single character to + * underline, or -1 for no underline. */ +{ + TkTextLayout *layoutPtr; + int xx, yy, width, height; + + if ((Blt_CharBbox(layout, underline, &xx, &yy, &width, &height) != 0) + && (width != 0)) { + Blt_FontMetrics fm; + layoutPtr = (TkTextLayout *) layout; + Blt_GetFontMetrics(layoutPtr->font, &fm); + XFillRectangle(display, drawable, gc, x + xx, + y + yy + fm.ascent + fm.underlinePos, + (unsigned int) width, fm.underlineHeight); + } +} diff --git a/src/bltGrText.h b/src/bltGrText.h new file mode 100644 index 0000000..7d4ef3d --- /dev/null +++ b/src/bltGrText.h @@ -0,0 +1,265 @@ + +/* + * bltText.h -- + * + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_TEXT_H +#define _BLT_TEXT_H + +#include "bltBgStyle.h" + +#define DEF_TEXT_FLAGS (TK_PARTIAL_OK | TK_IGNORE_NEWLINES) +#define UPDATE_GC 1 + +/* + * TextFragment -- + */ +typedef struct { + const char *text; /* Text string to be displayed */ + + size_t count; /* Number of bytes in text. The actual + * character count may differ because of + * multi-byte UTF encodings. */ + + short x, y; /* X-Y offset of the baseline from the + * upper-left corner of the bbox. */ + + short sx, sy; /* Starting offset of text using rotated + * font. */ + + int width; /* Width of segment in pixels. This + * information is used to draw + * PostScript strings the same width + * as X. */ +} TextFragment; + + +/* + * TextItem -- + * + * Parsed form for markup string. Each item is a scrap of text + * describes the font, position, and characters to be displayed. + * + * subscript x_y very small subset of latex markup. + * superscript x^y + * grouping a^{x+y} a_{i,j} + * supersuper a^{10^8} + * \hat{a} \bar{b} \vec{c} + * \overline{} \underline{} + * \frac \tfrac + * \Alpha \Beta ... + * \mathbf{} \mathit{} \mathrm{} \boldsymbol{} + * \angstrom \degree + * + * -mathtext instead of -text + * + * Can use TextItem where you don't directly edit the text: + * label, treeview, graph, barchart... + * + * Font selector (bold, italic, size adjust) from base font. + * Global font table reference counted. + * + */ +typedef struct { + const char *text; /* Text string to be displayed */ + + size_t count; /* Number of bytes in text. The actual + * character count may differ because of + * multi-byte UTF encodings. */ + + short int x, y; /* X-Y offset of the baseline from the + * upper-left corner of the bbox. */ + + short int sx, sy; /* Starting offset of text using rotated + * font. */ + + Blt_Font font; /* Allocated font for this chunk. + * If NULL, use the global font. */ + + int underline; /* Text is underlined */ + + int width; /* Width of segment in pixels. This + * information is used to draw + * PostScript strings the same width + * as X. (deprecated) */ +} TextItem; + +/* + * TextLayout -- + */ +typedef struct { + TextFragment *underlinePtr; + int underline; + size_t width, height; /* Dimensions of text bounding box */ + size_t nFrags; /* # fragments of text */ + TextFragment fragments[1]; /* Information about each fragment of text */ +} TextLayout; + +/* + * TextStyle -- + * + * A somewhat convenient structure to hold text attributes that determine + * how a text string is to be displayed on the screen or drawn with + * PostScript commands. The alternative is to pass lots of parameters to + * the drawing and printing routines. This seems like a more efficient + * and less cumbersome way of passing parameters. + */ +typedef struct { + unsigned int state; /* If non-zero, indicates to draw text + * in the active color */ + XColor *color; /* Color to draw the text. */ + Blt_Font font; /* Font to use to draw text */ + Blt_Background bg; /* Background color of text. This is + * also used for drawing disabled + * text. */ + float angle; /* Rotation of text in degrees. */ + Tk_Justify justify; /* Justification of the text + * string. This only matters if the + * text is composed of multiple + * lines. */ + Tk_Anchor anchor; /* Indicates how the text is anchored + * around its x,y coordinates. */ + Blt_Pad xPad, yPad; /* # pixels padding of around text + * region. */ + unsigned short int leader; /* # pixels spacing between lines of + * text. */ + short int underline; /* Index of character to be underlined, + * -1 if no underline. */ + int maxLength; /* Maximum length in pixels of text */ + /* Private fields. */ + unsigned short flags; + GC gc; /* GC used to draw the text */ +} TextStyle; + +BLT_EXTERN TextLayout *Blt_Ts_CreateLayout(const char *string, int length, + TextStyle *tsPtr); + +BLT_EXTERN void Blt_Ts_DrawLayout(Tk_Window tkwin, Drawable drawable, + TextLayout *textPtr, TextStyle *tsPtr, int x, int y); + +BLT_EXTERN void Blt_Ts_GetExtents(TextStyle *tsPtr, const char *text, + unsigned int *widthPtr, unsigned int *heightPtr); + +BLT_EXTERN void Blt_Ts_ResetStyle(Tk_Window tkwin, TextStyle *tsPtr); + +BLT_EXTERN void Blt_Ts_FreeStyle(Display *display, TextStyle *tsPtr); + +BLT_EXTERN void Blt_Ts_SetDrawStyle (TextStyle *tsPtr, Blt_Font font, GC gc, + XColor *fgColor, float angle, Tk_Anchor anchor, Tk_Justify justify, + int leader); + +BLT_EXTERN void Blt_Ts_SetPrintStyle(TextStyle *tsPtr, Blt_Font font, + XColor *fgColor, XColor *bgColor, float angle, Tk_Anchor anchor, + Tk_Justify justify, int leader); + +BLT_EXTERN void Blt_DrawText(Tk_Window tkwin, Drawable drawable, + const char *string, TextStyle *tsPtr, int x, int y); + +BLT_EXTERN void Blt_DrawText2(Tk_Window tkwin, Drawable drawable, + const char *string, TextStyle *tsPtr, int x, int y, Dim2D * dimPtr); + +BLT_EXTERN Pixmap Blt_Ts_Bitmap(Tk_Window tkwin, TextLayout *textPtr, + TextStyle *tsPtr, int *widthPtr, int *heightPtr); + +BLT_EXTERN int Blt_DrawTextWithRotatedFont(Tk_Window tkwin, Drawable drawable, + float angle, TextStyle *tsPtr, TextLayout *textPtr, int x, int y); + +BLT_EXTERN void Blt_DrawLayout(Tk_Window tkwin, Drawable drawable, GC gc, + Blt_Font font, int depth, float angle, int x, int y, + TextLayout *layoutPtr, int maxLength); + +BLT_EXTERN void Blt_GetTextExtents(Blt_Font font, int leader, const char *text, + int textLen, unsigned int *widthPtr, unsigned int *heightPtr); + +BLT_EXTERN void Blt_RotateStartingTextPositions(TextLayout *textPtr, + float angle); + +BLT_EXTERN Tk_TextLayout Blt_ComputeTextLayout(Blt_Font font, + const char *string, int numChars, int wrapLength, Tk_Justify justify, + int flags, int *widthPtr, int *heightPtr); + +BLT_EXTERN void Blt_DrawTextLayout(Display *display, Drawable drawable, GC gc, + Tk_TextLayout layout, int x, int y, int firstChar, int lastChar); + +BLT_EXTERN int Blt_CharBbox(Tk_TextLayout layout, int index, int *xPtr, + int *yPtr, int *widthPtr, int *heightPtr); + +BLT_EXTERN void Blt_UnderlineTextLayout(Display *display, Drawable drawable, + GC gc, Tk_TextLayout layout, int x, int y, int underline); + +BLT_EXTERN void Blt_Ts_UnderlineLayout(Tk_Window tkwin, Drawable drawable, + TextLayout *layoutPtr, TextStyle *tsPtr, int x, int y); + +BLT_EXTERN void Blt_Ts_DrawText(Tk_Window tkwin, Drawable drawable, + const char *text, int textLen, TextStyle *tsPtr, int x, int y); + +BLT_EXTERN int Blt_MeasureText(Blt_Font font, const char *text, int textLen, + int maxLength, int *nBytesPtr); + +BLT_EXTERN void Blt_FreeTextLayout(Tk_TextLayout layout); + +#define Blt_Ts_GetAnchor(ts) ((ts).anchor) +#define Blt_Ts_GetAngle(ts) ((ts).angle) +#define Blt_Ts_GetBackground(ts) ((ts).bg) +#define Blt_Ts_GetFont(ts) ((ts).font) +#define Blt_Ts_GetForeground(ts) ((ts).color) +#define Blt_Ts_GetJustify(ts) ((ts).justify) +#define Blt_Ts_GetLeader(ts) ((ts).leader) + +#define Blt_Ts_SetAnchor(ts, a) ((ts).anchor = (a)) +#define Blt_Ts_SetAngle(ts, r) ((ts).angle = (float)(r)) +#define Blt_Ts_SetBackground(ts, b) ((ts).bg = (b)) +#define Blt_Ts_SetFont(ts, f) \ + (((ts).font != (f)) ? ((ts).font = (f), (ts).flags |= UPDATE_GC) : 0) +#define Blt_Ts_SetForeground(ts, c) \ + (((ts).color != (c)) ? ((ts).color = (c), (ts).flags |= UPDATE_GC) : 0) +#define Blt_Ts_SetGC(ts, g) ((ts).gc = (g)) +#define Blt_Ts_SetJustify(ts, j) ((ts).justify = (j)) +#define Blt_Ts_SetLeader(ts, l) ((ts).leader = (l)) +#define Blt_Ts_SetMaxLength(ts, l) ((ts).maxLength = (l)) +#define Blt_Ts_SetPadding(ts, l, r, t, b) \ + ((ts).xPad.side1 = (l), \ + (ts).xPad.side2 = (r), \ + (ts).yPad.side1 = (t), \ + (ts).yPad.side2 = (b)) +#define Blt_Ts_SetState(ts, s) ((ts).state = (s)) +#define Blt_Ts_SetUnderline(ts, ul) ((ts).underline = (ul)) + +#define Blt_Ts_InitStyle(ts) \ + ((ts).anchor = TK_ANCHOR_NW, \ + (ts).color = (XColor *)NULL, \ + (ts).font = NULL, \ + (ts).justify = TK_JUSTIFY_LEFT, \ + (ts).leader = 0, \ + (ts).underline = -1, \ + (ts).xPad.side1 = (ts).xPad.side2 = 0, \ + (ts).yPad.side1 = (ts).yPad.side2 = 0, \ + (ts).state = 0, \ + (ts).flags = 0, \ + (ts).gc = NULL, \ + (ts).maxLength = -1, \ + (ts).angle = 0.0) + +#endif /* _BLT_TEXT_H */ diff --git a/src/bltGraph.C b/src/bltGraph.C new file mode 100644 index 0000000..de768f1 --- /dev/null +++ b/src/bltGraph.C @@ -0,0 +1,2381 @@ + +/* + * bltGraph.c -- + * + * This module implements a graph widget for the BLT toolkit. + * + * The graph widget was created by Sani Nassif and George Howlett. + * + * Copyright 1991-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * To do: + * + * 2) Update manual pages. + * + * 3) Update comments. + * + * 5) Surface, contour, and flow graphs + * + * 7) Arrows for line markers + * + */ + +#include "bltGraph.h" +#include "bltOp.h" +#include "bltBind.h" +#include "bltGrElem.h" +#include "bltGrLegd.h" +#include "bltSwitch.h" +#include <X11/Xutil.h> +#include "tkDisplay.h" +#include "bltPicture.h" + +typedef int (GraphCmdProc)(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +/* + * Objects in the graph have their own class names. These class names are + * used for the resource database and bindings. Example. + * + * option add *X.title "X Axis Title" widgetDefault + * .g marker bind BitmapMarker <Enter> { ... } + * + * The option database trick is performed by creating a temporary window when + * an object is initially configured. The class name of the temporary window + * will be from the list below. + */ +static const char *objectClassNames[] = { + "unknown", + "XAxis", + "YAxis", + "BarElement", + "ContourElement", + "LineElement", + "StripElement", + "BitmapMarker", + "ImageMarker", + "LineMarker", + "PolygonMarker", + "TextMarker", + "WindowMarker", +}; + +BLT_EXTERN Blt_CustomOption bltLinePenOption; +BLT_EXTERN Blt_CustomOption bltBarPenOption; +BLT_EXTERN Blt_CustomOption bltBarModeOption; + +#define DEF_GRAPH_ASPECT_RATIO "0.0" +#define DEF_GRAPH_BAR_BASELINE "0.0" +#define DEF_GRAPH_BAR_MODE "normal" +#define DEF_GRAPH_BAR_WIDTH "0.9" +#define DEF_GRAPH_BACKGROUND STD_NORMAL_BACKGROUND +#define DEF_GRAPH_BORDERWIDTH STD_BORDERWIDTH +#define DEF_GRAPH_BUFFER_ELEMENTS "yes" +#define DEF_GRAPH_BUFFER_GRAPH "1" +#define DEF_GRAPH_CURSOR "crosshair" +#define DEF_GRAPH_FONT "{Sans Serif} 12" +#define DEF_GRAPH_HALO "2m" +#define DEF_GRAPH_HALO_BAR "0.1i" +#define DEF_GRAPH_HEIGHT "4i" +#define DEF_GRAPH_HIGHLIGHT_BACKGROUND STD_NORMAL_BACKGROUND +#define DEF_GRAPH_HIGHLIGHT_COLOR RGB_BLACK +#define DEF_GRAPH_HIGHLIGHT_WIDTH "2" +#define DEF_GRAPH_INVERT_XY "0" +#define DEF_GRAPH_JUSTIFY "center" +#define DEF_GRAPH_MARGIN "0" +#define DEF_GRAPH_MARGIN_VAR (char *)NULL +#define DEF_GRAPH_PLOT_BACKGROUND RGB_WHITE +#define DEF_GRAPH_PLOT_BORDERWIDTH "1" +#define DEF_GRAPH_PLOT_PADX "0" +#define DEF_GRAPH_PLOT_PADY "0" +#define DEF_GRAPH_PLOT_RELIEF "solid" +#define DEF_GRAPH_RELIEF "flat" +#define DEF_GRAPH_SHOW_VALUES "no" +#define DEF_GRAPH_STACK_AXES "no" +#define DEF_GRAPH_TAKE_FOCUS "" +#define DEF_GRAPH_TITLE (char *)NULL +#define DEF_GRAPH_TITLE_COLOR STD_NORMAL_FOREGROUND +#define DEF_GRAPH_WIDTH "5i" +#define DEF_GRAPH_DATA (char *)NULL +#define DEF_GRAPH_DATA_COMMAND (char *)NULL +#define DEF_GRAPH_UNMAP_HIDDEN_ELEMENTS "0" + +static Blt_ConfigSpec configSpecs[] = +{ + {BLT_CONFIG_FLOAT, "-aspect", "aspect", "Aspect", DEF_GRAPH_ASPECT_RATIO, + Blt_Offset(Graph, aspect), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BACKGROUND, "-background", "background", "Background", + DEF_GRAPH_BACKGROUND, Blt_Offset(Graph, normalBg), 0}, + {BLT_CONFIG_CUSTOM, "-barmode", "barMode", "BarMode", DEF_GRAPH_BAR_MODE, + Blt_Offset(Graph, mode), BLT_CONFIG_DONT_SET_DEFAULT, + &bltBarModeOption}, + {BLT_CONFIG_FLOAT, "-barwidth", "barWidth", "BarWidth", + DEF_GRAPH_BAR_WIDTH, Blt_Offset(Graph, barWidth), 0}, + {BLT_CONFIG_FLOAT, "-baseline", "baseline", "Baseline", + DEF_GRAPH_BAR_BASELINE, Blt_Offset(Graph, baseline), 0}, + {BLT_CONFIG_SYNONYM, "-bd", "borderWidth", (char *)NULL, (char *)NULL,0, 0}, + {BLT_CONFIG_SYNONYM, "-bg", "background", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_SYNONYM, "-bm", "bottomMargin", (char *)NULL, (char *)NULL, + 0, 0}, + {BLT_CONFIG_PIXELS_NNEG, "-borderwidth", "borderWidth", "BorderWidth", + DEF_GRAPH_BORDERWIDTH, Blt_Offset(Graph, borderWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-bottommargin", "bottomMargin", "Margin", + DEF_GRAPH_MARGIN, Blt_Offset(Graph, bottomMargin.reqSize), 0}, + {BLT_CONFIG_STRING, "-bottomvariable", "bottomVariable", "BottomVariable", + DEF_GRAPH_MARGIN_VAR, Blt_Offset(Graph, bottomMargin.varName), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_BOOLEAN, "-bufferelements", "bufferElements", "BufferElements", + DEF_GRAPH_BUFFER_ELEMENTS, Blt_Offset(Graph, backingStore), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BOOLEAN, "-buffergraph", "bufferGraph", "BufferGraph", + DEF_GRAPH_BUFFER_GRAPH, Blt_Offset(Graph, doubleBuffer), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_ACTIVE_CURSOR, "-cursor", "cursor", "Cursor", + DEF_GRAPH_CURSOR, Blt_Offset(Graph, cursor), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STRING, "-data", "data", "Data", + (char *)NULL, Blt_Offset(Graph, data), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-datacommand", "dataCommand", "DataCommand", + (char *)NULL, Blt_Offset(Graph, dataCmd), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_SYNONYM, "-fg", "foreground", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_FONT, "-font", "font", "Font", + DEF_GRAPH_FONT, Blt_Offset(Graph, titleTextStyle.font), 0}, + {BLT_CONFIG_COLOR, "-foreground", "foreground", "Foreground", + DEF_GRAPH_TITLE_COLOR, Blt_Offset(Graph, titleTextStyle.color), 0}, + {BLT_CONFIG_PIXELS_NNEG, "-halo", "halo", "Halo", DEF_GRAPH_HALO, + Blt_Offset(Graph, halo), 0}, + {BLT_CONFIG_PIXELS_NNEG, "-height", "height", "Height", DEF_GRAPH_HEIGHT, + Blt_Offset(Graph, reqHeight), 0}, + {BLT_CONFIG_COLOR, "-highlightbackground", "highlightBackground", + "HighlightBackground", DEF_GRAPH_HIGHLIGHT_BACKGROUND, + Blt_Offset(Graph, highlightBgColor), 0}, + {BLT_CONFIG_COLOR, "-highlightcolor", "highlightColor", "HighlightColor", + DEF_GRAPH_HIGHLIGHT_COLOR, Blt_Offset(Graph, highlightColor), 0}, + {BLT_CONFIG_PIXELS_NNEG, "-highlightthickness", "highlightThickness", + "HighlightThickness", DEF_GRAPH_HIGHLIGHT_WIDTH, + Blt_Offset(Graph, highlightWidth), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_BITMASK, "-unmaphiddenelements", "unmapHiddenElements", + "UnmapHiddenElements", DEF_GRAPH_UNMAP_HIDDEN_ELEMENTS, + Blt_Offset(Graph, flags), ALL_GRAPHS | BLT_CONFIG_DONT_SET_DEFAULT, + (Blt_CustomOption *)UNMAP_HIDDEN}, + {BLT_CONFIG_BOOLEAN, "-invertxy", "invertXY", "InvertXY", + DEF_GRAPH_INVERT_XY, Blt_Offset(Graph, inverted), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_JUSTIFY, "-justify", "justify", "Justify", DEF_GRAPH_JUSTIFY, + Blt_Offset(Graph, titleTextStyle.justify), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-leftmargin", "leftMargin", "Margin", + DEF_GRAPH_MARGIN, Blt_Offset(Graph, leftMargin.reqSize), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-leftvariable", "leftVariable", "LeftVariable", + DEF_GRAPH_MARGIN_VAR, Blt_Offset(Graph, leftMargin.varName), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-lm", "leftMargin", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_BACKGROUND, "-plotbackground", "plotBackground", "Background", + DEF_GRAPH_PLOT_BACKGROUND, Blt_Offset(Graph, plotBg), 0}, + {BLT_CONFIG_PIXELS_NNEG, "-plotborderwidth", "plotBorderWidth", + "PlotBorderWidth", DEF_GRAPH_PLOT_BORDERWIDTH, + Blt_Offset(Graph, plotBW), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PAD, "-plotpadx", "plotPadX", "PlotPad", DEF_GRAPH_PLOT_PADX, + Blt_Offset(Graph, xPad), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PAD, "-plotpady", "plotPadY", "PlotPad", DEF_GRAPH_PLOT_PADY, + Blt_Offset(Graph, yPad), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_RELIEF, "-plotrelief", "plotRelief", "Relief", + DEF_GRAPH_PLOT_RELIEF, Blt_Offset(Graph, plotRelief), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_RELIEF, "-relief", "relief", "Relief", DEF_GRAPH_RELIEF, + Blt_Offset(Graph, relief), BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-rightmargin", "rightMargin", "Margin", + DEF_GRAPH_MARGIN, Blt_Offset(Graph, rightMargin.reqSize), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-rightvariable", "rightVariable", "RightVariable", + DEF_GRAPH_MARGIN_VAR, Blt_Offset(Graph, rightMargin.varName), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-rm", "rightMargin", (char *)NULL, (char *)NULL, 0,0}, + {BLT_CONFIG_BOOLEAN, "-stackaxes", "stackAxes", "StackAxes", + DEF_GRAPH_STACK_AXES, Blt_Offset(Graph, stackAxes), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-takefocus", "takeFocus", "TakeFocus", + DEF_GRAPH_TAKE_FOCUS, Blt_Offset(Graph, takeFocus), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_STRING, "-title", "title", "Title", DEF_GRAPH_TITLE, + Blt_Offset(Graph, title), BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_SYNONYM, "-tm", "topMargin", (char *)NULL, (char *)NULL, 0, 0}, + {BLT_CONFIG_PIXELS_NNEG, "-topmargin", "topMargin", "Margin", + DEF_GRAPH_MARGIN, Blt_Offset(Graph, topMargin.reqSize), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_STRING, "-topvariable", "topVariable", "TopVariable", + DEF_GRAPH_MARGIN_VAR, Blt_Offset(Graph, topMargin.varName), + BLT_CONFIG_NULL_OK}, + {BLT_CONFIG_PIXELS_NNEG, "-width", "width", "Width", DEF_GRAPH_WIDTH, + Blt_Offset(Graph, reqWidth), 0}, + {BLT_CONFIG_PIXELS_NNEG, "-plotwidth", "plotWidth", "PlotWidth", + (char *)NULL, Blt_Offset(Graph, reqPlotWidth), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_PIXELS_NNEG, "-plotheight", "plotHeight", "PlotHeight", + (char *)NULL, Blt_Offset(Graph, reqPlotHeight), + BLT_CONFIG_DONT_SET_DEFAULT}, + {BLT_CONFIG_END, NULL, NULL, NULL, NULL, 0, 0} +}; + +static Blt_SwitchParseProc ObjToFormat; +static Blt_SwitchCustom formatSwitch = +{ + ObjToFormat, NULL, (ClientData)0, +}; + +typedef struct { + const char *name; + int width, height; + int format; +} SnapSwitches; + +enum SnapFormats { FORMAT_PICTURE, FORMAT_PHOTO, FORMAT_EMF, FORMAT_WMF }; + +static Blt_SwitchSpec snapSwitches[] = +{ + {BLT_SWITCH_INT_POS, "-width", "width", + Blt_Offset(SnapSwitches, width), 0}, + {BLT_SWITCH_INT_POS, "-height", "height", + Blt_Offset(SnapSwitches, height), 0}, + {BLT_SWITCH_CUSTOM, "-format", "format", + Blt_Offset(SnapSwitches, format), 0, 0, &formatSwitch}, + {BLT_SWITCH_END} +}; + +static Tcl_IdleProc DisplayGraph; +static Tcl_FreeProc DestroyGraph; +static Tk_EventProc GraphEventProc; +Tcl_ObjCmdProc Blt_GraphInstCmdProc; + +static Blt_BindPickProc PickEntry; +static Tcl_ObjCmdProc StripchartCmd; +static Tcl_ObjCmdProc BarchartCmd; +static Tcl_ObjCmdProc GraphCmd; +static Tcl_CmdDeleteProc GraphInstCmdDeleteProc; + +/* + *--------------------------------------------------------------------------- + * + * Blt_UpdateGraph -- + * + * Tells the Tk dispatcher to call the graph display routine at the next + * idle point. This request is made only if the window is displayed and + * no other redraw request is pending. + * + * Results: None. + * + * Side effects: + * The window is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +void +Blt_UpdateGraph(ClientData clientData) +{ + Graph *graphPtr = clientData; + + graphPtr->flags |= REDRAW_WORLD; + if ((graphPtr->tkwin != NULL) && !(graphPtr->flags & REDRAW_PENDING)) { + Tcl_DoWhenIdle(DisplayGraph, graphPtr); + graphPtr->flags |= REDRAW_PENDING; + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_EventuallyRedrawGraph -- + * + * Tells the Tk dispatcher to call the graph display routine at the next + * idle point. This request is made only if the window is displayed and + * no other redraw request is pending. + * + * Results: None. + * + * Side effects: + * The window is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +void +Blt_EventuallyRedrawGraph(Graph *graphPtr) +{ + if ((graphPtr->tkwin != NULL) && !(graphPtr->flags & REDRAW_PENDING)) { + Tcl_DoWhenIdle(DisplayGraph, graphPtr); + graphPtr->flags |= REDRAW_PENDING; + } +} + +const char * +Blt_GraphClassName(ClassId classId) +{ + if ((classId >= CID_NONE) && (classId <= CID_MARKER_WINDOW)) { + return objectClassNames[classId]; + } + return NULL; +} + +void +Blt_GraphSetObjectClass(GraphObj *graphObjPtr, ClassId classId) +{ + graphObjPtr->classId = classId; + graphObjPtr->className = Blt_GraphClassName(classId); +} + +/* + *--------------------------------------------------------------------------- + * + * GraphEventProc -- + * + * This procedure is invoked by the Tk dispatcher for various events on + * graphs. + * + * Results: + * None. + * + * Side effects: + * When the window gets deleted, internal structures get cleaned up. + * When it gets exposed, the graph is eventually redisplayed. + * + *--------------------------------------------------------------------------- + */ +static void +GraphEventProc(ClientData clientData, XEvent *eventPtr) +{ + Graph *graphPtr = clientData; + + if (eventPtr->type == Expose) { + if (eventPtr->xexpose.count == 0) { + graphPtr->flags |= REDRAW_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + } + } else if ((eventPtr->type == FocusIn) || (eventPtr->type == FocusOut)) { + if (eventPtr->xfocus.detail != NotifyInferior) { + if (eventPtr->type == FocusIn) { + graphPtr->flags |= FOCUS; + } else { + graphPtr->flags &= ~FOCUS; + } + graphPtr->flags |= REDRAW_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + } + } else if (eventPtr->type == DestroyNotify) { + if (graphPtr->tkwin != NULL) { + Blt_DeleteWindowInstanceData(graphPtr->tkwin); + graphPtr->tkwin = NULL; + Tcl_DeleteCommandFromToken(graphPtr->interp, graphPtr->cmdToken); + } + if (graphPtr->flags & REDRAW_PENDING) { + Tcl_CancelIdleCall(DisplayGraph, graphPtr); + } + Tcl_EventuallyFree(graphPtr, DestroyGraph); + } else if (eventPtr->type == ConfigureNotify) { + graphPtr->flags |= (MAP_WORLD | REDRAW_WORLD); + Blt_EventuallyRedrawGraph(graphPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * GraphInstCmdDeleteProc -- + * + * This procedure is invoked when a widget command is deleted. If the + * widget isn't already in the process of being destroyed, this command + * destroys it. + * + * Results: + * None. + * + * Side effects: + * The widget is destroyed. + * + *--------------------------------------------------------------------------- + */ +static void +GraphInstCmdDeleteProc(ClientData clientData) /* Pointer to widget record. */ +{ + Graph *graphPtr = clientData; + + if (graphPtr->tkwin != NULL) { /* NULL indicates window has already + * been destroyed. */ + Tk_Window tkwin; + + tkwin = graphPtr->tkwin; + graphPtr->tkwin = NULL; + Blt_DeleteWindowInstanceData(tkwin); + Tk_DestroyWindow(tkwin); + } +} + +/* + *--------------------------------------------------------------------------- + * + * AdjustAxisPointers -- + * + * Sets the axis pointers according to whether the axis is inverted on + * not. The axis sites are also reset. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +AdjustAxisPointers(Graph *graphPtr) +{ + if (graphPtr->inverted) { + graphPtr->leftMargin.axes = graphPtr->axisChain[0]; + graphPtr->bottomMargin.axes = graphPtr->axisChain[1]; + graphPtr->rightMargin.axes = graphPtr->axisChain[2]; + graphPtr->topMargin.axes = graphPtr->axisChain[3]; + } else { + graphPtr->leftMargin.axes = graphPtr->axisChain[1]; + graphPtr->bottomMargin.axes = graphPtr->axisChain[0]; + graphPtr->rightMargin.axes = graphPtr->axisChain[3]; + graphPtr->topMargin.axes = graphPtr->axisChain[2]; + } +} + +static int +InitPens(Graph *graphPtr) +{ + Blt_InitHashTable(&graphPtr->penTable, BLT_STRING_KEYS); + if (Blt_CreatePen(graphPtr, "activeLine", CID_ELEM_LINE, 0, NULL) == NULL) { + return TCL_ERROR; + } + if (Blt_CreatePen(graphPtr, "activeBar", CID_ELEM_BAR, 0, NULL) == NULL) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GraphTags -- + * + * Sets the binding tags for a graph obj. This routine is called by Tk + * when an event occurs in the graph. It fills an array of pointers with + * bind tag addresses. + * + * The object addresses are strings hashed in one of two tag tables: one + * for elements and the another for markers. Note that there's only one + * binding table for elements and markers. [We don't want to trigger + * both a marker and element bind command for the same event.] But we + * don't want a marker and element with the same tag name to activate the + * others bindings. A tag "all" for markers should mean all markers, not + * all markers and elements. As a result, element and marker tags are + * stored in separate hash tables, which means we can't generate the same + * tag address for both an elements and marker, even if they have the + * same name. + * + * Results: + * None. + * + * Side effects: + * This information will be used by the binding code in bltUtil.c to + * determine what graph objects match the current event. The tags are + * placed in tagArr and *nTagsPtr is set with the number of tags found. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +void +Blt_GraphTags( + Blt_BindTable table, + ClientData object, + ClientData context, /* Not used. */ + Blt_List list) +{ + GraphObj *graphObjPtr; + MakeTagProc *tagProc; + Graph *graphPtr; + + graphPtr = (Graph *)Blt_GetBindingData(table); + + /* + * All graph objects (markers, elements, axes, etc) have the same starting + * fields in their structures, such as "classId", "name", "className", and + * "tags". + */ + graphObjPtr = (GraphObj *)object; + + switch (graphObjPtr->classId) { + case CID_ELEM_BAR: + case CID_ELEM_CONTOUR: + case CID_ELEM_LINE: + case CID_ELEM_STRIP: + tagProc = Blt_MakeElementTag; + break; + case CID_AXIS_X: + case CID_AXIS_Y: + tagProc = Blt_MakeAxisTag; + break; + case CID_MARKER_BITMAP: + case CID_MARKER_IMAGE: + case CID_MARKER_LINE: + case CID_MARKER_POLYGON: + case CID_MARKER_TEXT: + case CID_MARKER_WINDOW: + tagProc = Blt_MakeMarkerTag; + break; + case CID_NONE: + panic("unknown object type"); + tagProc = NULL; + break; + default: + panic("bogus object type"); + tagProc = NULL; + break; + } + assert(graphObjPtr->name != NULL); + + /* Always add the name of the object to the tag array. */ + Blt_List_Append(list, (*tagProc)(graphPtr, graphObjPtr->name), 0); + Blt_List_Append(list, (*tagProc)(graphPtr, graphObjPtr->className), 0); + if (graphObjPtr->tags != NULL) { + const char **p; + + for (p = graphObjPtr->tags; *p != NULL; p++) { + Blt_List_Append(list, (*tagProc) (graphPtr, *p), 0); + } + } +} + +/* + * Find the closest point from the set of displayed elements, searching + * the display list from back to front. That way, if the points from + * two different elements overlay each other exactly, the one that's on + * top (visible) is picked. + */ +/*ARGSUSED*/ +static ClientData +PickEntry(ClientData clientData, int x, int y, ClientData *contextPtr) +{ + Graph *graphPtr = clientData; + Blt_ChainLink link; + Element *elemPtr; + Marker *markerPtr; + Region2d exts; + + if (graphPtr->flags & MAP_ALL) { + return NULL; /* Don't pick anything until the next + * redraw occurs. */ + } + Blt_GraphExtents(graphPtr, &exts); + + if ((x >= exts.right) || (x < exts.left) || + (y >= exts.bottom) || (y < exts.top)) { + /* + * Sample coordinate is in one of the graph margins. Can only pick an + * axis. + */ + return Blt_NearestAxis(graphPtr, x, y); + } + /* + * From top-to-bottom check: + * 1. markers drawn on top (-under false). + * 2. elements using its display list back to front. + * 3. markers drawn under element (-under true). + */ + markerPtr = Blt_NearestMarker(graphPtr, x, y, FALSE); + if (markerPtr != NULL) { + return markerPtr; /* Found a marker (-under false). */ + } + { + ClosestSearch search; + + search.along = SEARCH_BOTH; + search.halo = graphPtr->halo; + search.index = -1; + search.x = x; + search.y = y; + search.dist = (double)(search.halo + 1); + search.mode = SEARCH_AUTO; + + for (link = Blt_Chain_LastLink(graphPtr->elements.displayList); + link != NULL; link = Blt_Chain_PrevLink(link)) { + elemPtr = Blt_Chain_GetValue(link); + if (elemPtr->flags & (HIDE|MAP_ITEM)) { + continue; + } + if (elemPtr->state == STATE_NORMAL) { + (*elemPtr->procsPtr->closestProc) (graphPtr, elemPtr, &search); + } + } + if (search.dist <= (double)search.halo) { + return search.elemPtr; /* Found an element within the minimum + * halo distance. */ + } + } + markerPtr = Blt_NearestMarker(graphPtr, x, y, TRUE); + if (markerPtr != NULL) { + return markerPtr; /* Found a marker (-under true) */ + } + return NULL; /* Nothing found. */ +} + +/* + *--------------------------------------------------------------------------- + * + * ConfigureGraph -- + * + * Allocates resources for the graph. + * + * Results: + * None. + * + * Side effects: + * Configuration information, such as text string, colors, font, etc. get + * set for graphPtr; old resources get freed, if there were any. The + * graph is redisplayed. + * + *--------------------------------------------------------------------------- + */ +static void +ConfigureGraph(Graph *graphPtr) +{ + XColor *colorPtr; + GC newGC; + XGCValues gcValues; + unsigned long gcMask; + + /* Don't allow negative bar widths. Reset to an arbitrary value (0.1) */ + if (graphPtr->barWidth <= 0.0f) { + graphPtr->barWidth = 0.8f; + } + graphPtr->inset = graphPtr->borderWidth + graphPtr->highlightWidth; + if ((graphPtr->reqHeight != Tk_ReqHeight(graphPtr->tkwin)) || + (graphPtr->reqWidth != Tk_ReqWidth(graphPtr->tkwin))) { + Tk_GeometryRequest(graphPtr->tkwin, graphPtr->reqWidth, + graphPtr->reqHeight); + } + Tk_SetInternalBorder(graphPtr->tkwin, graphPtr->borderWidth); + colorPtr = Blt_BackgroundBorderColor(graphPtr->normalBg); + + graphPtr->titleWidth = graphPtr->titleHeight = 0; + if (graphPtr->title != NULL) { + unsigned int w, h; + + Blt_Ts_GetExtents(&graphPtr->titleTextStyle, graphPtr->title, &w, &h); + graphPtr->titleHeight = h; + } + + /* + * Create GCs for interior and exterior regions, and a background GC for + * clearing the margins with XFillRectangle + */ + + /* Margin GC */ + + gcValues.foreground = + Blt_Ts_GetForeground(graphPtr->titleTextStyle)->pixel; + gcValues.background = colorPtr->pixel; + gcMask = (GCForeground | GCBackground); + newGC = Tk_GetGC(graphPtr->tkwin, gcMask, &gcValues); + if (graphPtr->drawGC != NULL) { + Tk_FreeGC(graphPtr->display, graphPtr->drawGC); + } + graphPtr->drawGC = newGC; + + if (graphPtr->plotBg != NULL) { + Blt_SetBackgroundChangedProc(graphPtr->plotBg, Blt_UpdateGraph, + graphPtr); + } + if (graphPtr->normalBg != NULL) { + Blt_SetBackgroundChangedProc(graphPtr->normalBg, Blt_UpdateGraph, + graphPtr); + } + if (Blt_ConfigModified(configSpecs, "-invertxy", (char *)NULL)) { + + /* + * If the -inverted option changed, we need to readjust the pointers + * to the axes and recompute the their scales. + */ + + AdjustAxisPointers(graphPtr); + graphPtr->flags |= RESET_AXES; + } + if ((!graphPtr->backingStore) && (graphPtr->cache != None)) { + /* + * Free the pixmap if we're not buffering the display of elements + * anymore. + */ + Tk_FreePixmap(graphPtr->display, graphPtr->cache); + graphPtr->cache = None; + } + /* + * Reconfigure the crosshairs, just in case the background color of the + * plotarea has been changed. + */ + Blt_ConfigureCrosshairs(graphPtr); + + /* + * Update the layout of the graph (and redraw the elements) if any of the + * following graph options which affect the size of * the plotting area + * has changed. + * + * -aspect + * -borderwidth, -plotborderwidth + * -font, -title + * -width, -height + * -invertxy + * -bottommargin, -leftmargin, -rightmargin, -topmargin, + * -barmode, -barwidth + */ + if (Blt_ConfigModified(configSpecs, "-invertxy", "-title", "-font", + "-*margin", "-*width", "-height", "-barmode", "-*pad*", + "-aspect", "-*borderwidth", "-plot*", "-*width", "-*height", + "-unmaphiddenelements", (char *)NULL)) { + graphPtr->flags |= RESET_WORLD | CACHE_DIRTY; + } + if (Blt_ConfigModified(configSpecs, "-plot*", "-*background", + (char *)NULL)) { + graphPtr->flags |= CACHE_DIRTY; + } + graphPtr->flags |= REDRAW_WORLD; +} + +/* + *--------------------------------------------------------------------------- + * + * DestroyGraph -- + * + * This procedure is invoked by Tcl_EventuallyFree or Tcl_Release to + * clean up the internal structure of a graph at a safe time (when no-one + * is using it anymore). + * + * Results: + * None. + * + * Side effects: + * Everything associated with the widget is freed up. + * + *--------------------------------------------------------------------------- + */ +static void +DestroyGraph(DestroyData dataPtr) +{ + Graph *graphPtr = (Graph *)dataPtr; + + Blt_FreeOptions(configSpecs, (char *)graphPtr, graphPtr->display, 0); + /* + * Destroy the individual components of the graph: elements, markers, + * axes, legend, display lists etc. Be careful to remove them in + * order. For example, axes are used by elements and markers, so they have + * to be removed after the markers and elements. Same it true with the + * legend and pens (they use elements), so can't be removed until the + * elements are destroyed. + */ + Blt_DestroyMarkers(graphPtr); + Blt_DestroyElements(graphPtr); + Blt_DestroyLegend(graphPtr); + Blt_DestroyAxes(graphPtr); + Blt_DestroyPens(graphPtr); + Blt_DestroyCrosshairs(graphPtr); + Blt_DestroyPageSetup(graphPtr); + Blt_DestroyBarSets(graphPtr); + /* Destroy table clients after elements are destroyed. */ + Blt_DestroyTableClients(graphPtr); + if (graphPtr->bindTable != NULL) { + Blt_DestroyBindingTable(graphPtr->bindTable); + } + + /* Release allocated X resources and memory. */ + if (graphPtr->drawGC != NULL) { + Tk_FreeGC(graphPtr->display, graphPtr->drawGC); + } + Blt_Ts_FreeStyle(graphPtr->display, &graphPtr->titleTextStyle); + if (graphPtr->cache != None) { + Tk_FreePixmap(graphPtr->display, graphPtr->cache); + } + Blt_Free(graphPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * CreateGraph -- + * + * This procedure creates and initializes a new widget. + * + * Results: + * The return value is a pointer to a structure describing the new + * widget. If an error occurred, then the return value is NULL and an + * error message is left in interp->result. + * + * Side effects: + * Memory is allocated, a Tk_Window is created, etc. + * + *--------------------------------------------------------------------------- + */ + +static Graph * +CreateGraph(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, ClassId classId) +{ + Graph *graphPtr; + Tk_Window tkwin; + + tkwin = Tk_CreateWindowFromPath(interp, Tk_MainWindow(interp), + Tcl_GetString(objv[1]), (char *)NULL); + if (tkwin == NULL) { + return NULL; + } + graphPtr = Blt_AssertCalloc(1, sizeof(Graph)); + + /* Initialize the graph data structure. */ + + graphPtr->tkwin = tkwin; + graphPtr->display = Tk_Display(tkwin); + graphPtr->interp = interp; + graphPtr->classId = classId; + graphPtr->backingStore = TRUE; + graphPtr->doubleBuffer = TRUE; + graphPtr->borderWidth = 2; + graphPtr->plotBW = 1; + graphPtr->highlightWidth = 2; + graphPtr->plotRelief = TK_RELIEF_SOLID; + graphPtr->relief = TK_RELIEF_FLAT; + graphPtr->flags = RESET_WORLD; + graphPtr->nextMarkerId = 1; + graphPtr->padLeft = graphPtr->padRight = 0; + graphPtr->padTop = graphPtr->padBottom = 0; + graphPtr->bottomMargin.site = MARGIN_BOTTOM; + graphPtr->leftMargin.site = MARGIN_LEFT; + graphPtr->topMargin.site = MARGIN_TOP; + graphPtr->rightMargin.site = MARGIN_RIGHT; + Blt_Ts_InitStyle(graphPtr->titleTextStyle); + Blt_Ts_SetAnchor(graphPtr->titleTextStyle, TK_ANCHOR_N); + + Blt_InitHashTable(&graphPtr->axes.table, BLT_STRING_KEYS); + Blt_InitHashTable(&graphPtr->axes.tagTable, BLT_STRING_KEYS); + Blt_InitHashTable(&graphPtr->elements.table, BLT_STRING_KEYS); + Blt_InitHashTable(&graphPtr->elements.tagTable, BLT_STRING_KEYS); + Blt_InitHashTable(&graphPtr->markers.table, BLT_STRING_KEYS); + Blt_InitHashTable(&graphPtr->markers.tagTable, BLT_STRING_KEYS); + Blt_InitHashTable(&graphPtr->dataTables, BLT_STRING_KEYS); + graphPtr->elements.displayList = Blt_Chain_Create(); + graphPtr->markers.displayList = Blt_Chain_Create(); + graphPtr->axes.displayList = Blt_Chain_Create(); + + switch (classId) { + case CID_ELEM_LINE: + Tk_SetClass(tkwin, "Graph"); + break; + case CID_ELEM_BAR: + Tk_SetClass(tkwin, "Barchart"); + break; + case CID_ELEM_STRIP: + Tk_SetClass(tkwin, "Stripchart"); + default: + Tk_SetClass(tkwin, "???"); + break; + } + Blt_SetWindowInstanceData(tkwin, graphPtr); + + if (InitPens(graphPtr) != TCL_OK) { + goto error; + } + if (Blt_ConfigureWidgetFromObj(interp, tkwin, configSpecs, objc - 2, + objv + 2, (char *)graphPtr, 0) != TCL_OK) { + goto error; + } + if (Blt_DefaultAxes(graphPtr) != TCL_OK) { + goto error; + } + AdjustAxisPointers(graphPtr); + + if (Blt_CreatePageSetup(graphPtr) != TCL_OK) { + goto error; + } + if (Blt_CreateCrosshairs(graphPtr) != TCL_OK) { + goto error; + } + if (Blt_CreateLegend(graphPtr) != TCL_OK) { + goto error; + } + Tk_CreateEventHandler(graphPtr->tkwin, + ExposureMask | StructureNotifyMask | FocusChangeMask, GraphEventProc, + graphPtr); + + graphPtr->cmdToken = Tcl_CreateObjCommand(interp, Tcl_GetString(objv[1]), + Blt_GraphInstCmdProc, graphPtr, GraphInstCmdDeleteProc); + ConfigureGraph(graphPtr); + graphPtr->bindTable = Blt_CreateBindingTable(interp, tkwin, graphPtr, + PickEntry, Blt_GraphTags); + + Tcl_SetObjResult(interp, objv[1]); + return graphPtr; + + error: + DestroyGraph((DestroyData)graphPtr); + return NULL; +} + +/* Widget sub-commands */ + +/*ARGSUSED*/ +static int +XAxisOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int margin; + + margin = (graphPtr->inverted) ? MARGIN_LEFT : MARGIN_BOTTOM; + return Blt_AxisOp(interp, graphPtr, margin, objc, objv); +} + +static int +X2AxisOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int margin; + + margin = (graphPtr->inverted) ? MARGIN_RIGHT : MARGIN_TOP; + return Blt_AxisOp(interp, graphPtr, margin, objc, objv); +} + +static int +YAxisOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int margin; + + margin = (graphPtr->inverted) ? MARGIN_BOTTOM : MARGIN_LEFT; + return Blt_AxisOp(interp, graphPtr, margin, objc, objv); +} + +static int +Y2AxisOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int margin; + + margin = (graphPtr->inverted) ? MARGIN_TOP : MARGIN_RIGHT; + return Blt_AxisOp(interp, graphPtr, margin, objc, objv); +} + +static int +BarOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + return Blt_ElementOp(graphPtr, interp, objc, objv, CID_ELEM_BAR); +} + +/*ARGSUSED*/ +static int +LineOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + return Blt_ElementOp(graphPtr, interp, objc, objv, CID_ELEM_LINE); +} + +static int +ElementOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + return Blt_ElementOp(graphPtr, interp, objc, objv, graphPtr->classId); +} + +static int +ConfigureOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int flags; + + flags = BLT_CONFIG_OBJV_ONLY; + if (objc == 2) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)graphPtr, (Tcl_Obj *)NULL, flags); + } else if (objc == 3) { + return Blt_ConfigureInfoFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)graphPtr, objv[2], flags); + } else { + if (Blt_ConfigureWidgetFromObj(interp, graphPtr->tkwin, configSpecs, + objc - 2, objv + 2, (char *)graphPtr, flags) != TCL_OK) { + return TCL_ERROR; + } + ConfigureGraph(graphPtr); + Blt_EventuallyRedrawGraph(graphPtr); + return TCL_OK; + } +} + +/* ARGSUSED*/ +static int +CgetOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + return Blt_ConfigureValueFromObj(interp, graphPtr->tkwin, configSpecs, + (char *)graphPtr, objv[2], 0); +} + +/* + *--------------------------------------------------------------------------- + * + * ExtentsOp -- + * + * Reports the size of one of several items within the graph. The + * following are valid items: + * + * "bottommargin" Height of the bottom margin + * "leftmargin" Width of the left margin + * "legend" x y w h of the legend + * "plotarea" x y w h of the plotarea + * "plotheight" Height of the plot area + * "rightmargin" Width of the right margin + * "topmargin" Height of the top margin + * "plotwidth" Width of the plot area + * + * Results: + * Always returns TCL_OK. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED*/ +static int +ExtentsOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + const char *string; + char c; + int length; + + string = Tcl_GetStringFromObj(objv[2], &length); + c = string[0]; + if ((c == 'p') && (length > 4) && + (strncmp("plotheight", string, length) == 0)) { + int height; + + height = graphPtr->bottom - graphPtr->top + 1; + Tcl_SetIntObj(Tcl_GetObjResult(interp), height); + } else if ((c == 'p') && (length > 4) && + (strncmp("plotwidth", string, length) == 0)) { + int width; + + width = graphPtr->right - graphPtr->left + 1; + Tcl_SetIntObj(Tcl_GetObjResult(interp), width); + } else if ((c == 'p') && (length > 4) && + (strncmp("plotarea", string, length) == 0)) { + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(graphPtr->left)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(graphPtr->top)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(graphPtr->right - graphPtr->left + 1)); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(graphPtr->bottom - graphPtr->top + 1)); + Tcl_SetObjResult(interp, listObjPtr); + } else if ((c == 'l') && (length > 2) && + (strncmp("legend", string, length) == 0)) { + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(Blt_Legend_X(graphPtr))); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(Blt_Legend_Y(graphPtr))); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(Blt_Legend_Width(graphPtr))); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(Blt_Legend_Height(graphPtr))); + Tcl_SetObjResult(interp, listObjPtr); + } else if ((c == 'l') && (length > 2) && + (strncmp("leftmargin", string, length) == 0)) { + Tcl_SetIntObj(Tcl_GetObjResult(interp), graphPtr->leftMargin.width); + } else if ((c == 'r') && (length > 1) && + (strncmp("rightmargin", string, length) == 0)) { + Tcl_SetIntObj(Tcl_GetObjResult(interp), graphPtr->rightMargin.width); + } else if ((c == 't') && (length > 1) && + (strncmp("topmargin", string, length) == 0)) { + Tcl_SetIntObj(Tcl_GetObjResult(interp), graphPtr->topMargin.height); + } else if ((c == 'b') && (length > 1) && + (strncmp("bottommargin", string, length) == 0)) { + Tcl_SetIntObj(Tcl_GetObjResult(interp), graphPtr->bottomMargin.height); + } else { + Tcl_AppendResult(interp, "bad extent item \"", objv[2], + "\": should be plotheight, plotwidth, leftmargin, rightmargin, \ +topmargin, bottommargin, plotarea, or legend", (char *)NULL); + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * InsideOp -- + * + * Returns true of false whether the given point is inside the plotting + * area (defined by left,bottom right, top). + * + * Results: + * Always returns TCL_OK. interp->result will contain the boolean string + * representation. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED*/ +static int +InsideOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int x, y; + Region2d exts; + int result; + + if (Tcl_GetIntFromObj(interp, objv[2], &x) != TCL_OK) { + return TCL_ERROR; + } + if (Tcl_GetIntFromObj(interp, objv[3], &y) != TCL_OK) { + return TCL_ERROR; + } + Blt_GraphExtents(graphPtr, &exts); + result = PointInRegion(&exts, x, y); + Tcl_SetBooleanObj(Tcl_GetObjResult(interp), result); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * InvtransformOp -- + * + * This procedure returns a list of the graph coordinate values + * corresponding with the given window X and Y coordinate positions. + * + * Results: + * Returns a standard TCL result. If an error occurred while parsing the + * window positions, TCL_ERROR is returned, and interp->result will + * contain the error message. Otherwise interp->result will contain a + * Tcl list of the x and y coordinates. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +InvtransformOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + double x, y; + Point2d point; + Axis2d axes; + Tcl_Obj *listObjPtr; + + if ((Blt_ExprDoubleFromObj(interp, objv[2], &x) != TCL_OK) || + (Blt_ExprDoubleFromObj(interp, objv[3], &y) != TCL_OK)) { + return TCL_ERROR; + } + if (graphPtr->flags & RESET_AXES) { + Blt_ResetAxes(graphPtr); + } + /* Perform the reverse transformation, converting from window coordinates + * to graph data coordinates. Note that the point is always mapped to the + * bottom and left axes (which may not be what the user wants). */ + + /* Pick the first pair of axes */ + axes.x = Blt_GetFirstAxis(graphPtr->axisChain[0]); + axes.y = Blt_GetFirstAxis(graphPtr->axisChain[1]); + point = Blt_InvMap2D(graphPtr, x, y, &axes); + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(point.x)); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(point.y)); + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * TransformOp -- + * + * This procedure returns a list of the window coordinates corresponding + * with the given graph x and y coordinates. + * + * Results: + * Returns a standard TCL result. interp->result contains the list of + * the graph coordinates. If an error occurred while parsing the window + * positions, TCL_ERROR is returned, then interp->result will contain an + * error message. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +TransformOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + double x, y; + Point2d point; + Axis2d axes; + Tcl_Obj *listObjPtr; + + if ((Blt_ExprDoubleFromObj(interp, objv[2], &x) != TCL_OK) || + (Blt_ExprDoubleFromObj(interp, objv[3], &y) != TCL_OK)) { + return TCL_ERROR; + } + if (graphPtr->flags & RESET_AXES) { + Blt_ResetAxes(graphPtr); + } + /* + * Perform the transformation from window to graph coordinates. Note that + * the points are always mapped onto the bottom and left axes (which may + * not be the what the user wants). + */ + axes.x = Blt_GetFirstAxis(graphPtr->axisChain[0]); + axes.y = Blt_GetFirstAxis(graphPtr->axisChain[1]); + + point = Blt_Map2D(graphPtr, x, y, &axes); + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewIntObj(ROUND(point.x))); + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewIntObj(ROUND(point.y))); + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +#ifndef NO_PRINTER + +/* + *--------------------------------------------------------------------------- + * + * Print1Op -- + * + * Prints the equivalent of a screen snapshot of the graph to the + * designated printer. + * + * Results: + * Returns a standard TCL result. If an error occurred TCL_ERROR is + * returned and interp->result will contain an error message. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +Print1Op(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + BITMAPINFO info; + void *data; + TkWinDCState state; + TkWinBitmap bd; + DIBSECTION ds; + Drawable drawable; + HBITMAP hBitmap; + HDC hDC; + DOCINFO di; + double pageWidth, pageHeight; + int result; + double scale, sx, sy; + int jobId; + + graphPtr->width = Tk_Width(graphPtr->tkwin); + graphPtr->height = Tk_Height(graphPtr->tkwin); + if ((graphPtr->width < 2) && (graphPtr->reqWidth > 0)) { + graphPtr->width = graphPtr->reqWidth; + } + if ((graphPtr->height < 2) && (graphPtr->reqHeight > 0)) { + graphPtr->height = graphPtr->reqHeight; + } + if (objc == 2) { + result = Blt_PrintDialog(interp, &drawable); + if (result == TCL_ERROR) { + return TCL_ERROR; + } + if (result == TCL_RETURN) { + return TCL_OK; + } + } else { + if (Blt_GetOpenPrinter(interp, Tcl_GetString(objv[2]), &drawable) + != TCL_OK) { + return TCL_ERROR; + } + } + /* + * This is a taken from Blt_SnapPhoto. The difference is that here we're + * using the DIBSection directly, without converting the section into a + * Picture. + */ + ZeroMemory(&info, sizeof(info)); + info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + info.bmiHeader.biWidth = graphPtr->width; + info.bmiHeader.biHeight = graphPtr->height; + info.bmiHeader.biPlanes = 1; + info.bmiHeader.biBitCount = 32; + info.bmiHeader.biCompression = BI_RGB; + hDC = TkWinGetDrawableDC(graphPtr->display, Tk_WindowId(graphPtr->tkwin), + &state); + hBitmap = CreateDIBSection(hDC, &info, DIB_RGB_COLORS, &data, NULL, 0); + TkWinReleaseDrawableDC(Tk_WindowId(graphPtr->tkwin), hDC, &state); + + /* + * Create our own drawable by hand using the DIB we just created. We'll + * then draw into it using the standard drawing functions. + */ + bd.type = TWD_BITMAP; + bd.handle = hBitmap; + bd.colormap = DefaultColormap(graphPtr->display, + DefaultScreen(graphPtr->display)); + bd.depth = Tk_Depth(graphPtr->tkwin); + + graphPtr->flags |= RESET_WORLD; + Blt_DrawGraph(graphPtr, (Drawable)&bd); + + /* + * Now that the DIB contains the image of the graph, get the the data bits + * and write them to the printer device, stretching the image to the fit + * the printer's resolution. + */ + result = TCL_ERROR; + if (GetObject(hBitmap, sizeof(DIBSECTION), &ds) == 0) { + Tcl_AppendResult(interp, "can't get object: ", Blt_LastError(), + (char *)NULL); + goto done; + } + hDC = ((TkWinDC *) drawable)->hdc; + /* Get the resolution of the printer device. */ + sx = (double)GetDeviceCaps(hDC, HORZRES) / (double)graphPtr->width; + sy = (double)GetDeviceCaps(hDC, VERTRES) / (double)graphPtr->height; + scale = MIN(sx, sy); + pageWidth = scale * graphPtr->width; + pageHeight = scale * graphPtr->height; + + ZeroMemory(&di, sizeof(di)); + di.cbSize = sizeof(di); + di.lpszDocName = "Graph Contents"; + jobId = StartDoc(hDC, &di); + if (jobId <= 0) { + Tcl_AppendResult(interp, "can't start document: ", Blt_LastError(), + (char *)NULL); + goto done; + } + if (StartPage(hDC) <= 0) { + Tcl_AppendResult(interp, "error starting page: ", Blt_LastError(), + (char *)NULL); + goto done; + } + StretchDIBits(hDC, 0, 0, ROUND(pageWidth), ROUND(pageHeight), 0, 0, + graphPtr->width, graphPtr->height, ds.dsBm.bmBits, + (LPBITMAPINFO)&ds.dsBmih, DIB_RGB_COLORS, SRCCOPY); + EndPage(hDC); + EndDoc(hDC); + result = TCL_OK; + done: + DeleteBitmap(hBitmap); + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * Print2Op -- + * + * Prints directly to the designated printer device. + * + * Results: + * Returns a standard TCL result. If an error occurred, TCL_ERROR is + * returned and interp->result will contain an error message. + * + *--------------------------------------------------------------------------- + */ +static int +Print2Op(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Drawable drawable; + int result; + + graphPtr->width = Tk_Width(graphPtr->tkwin); + graphPtr->height = Tk_Height(graphPtr->tkwin); + if ((graphPtr->width < 2) && (graphPtr->reqWidth > 0)) { + graphPtr->width = graphPtr->reqWidth; + } + if ((graphPtr->height < 2) && (graphPtr->reqHeight > 0)) { + graphPtr->height = graphPtr->reqHeight; + } + if (objc == 2) { + result = Blt_PrintDialog(interp, &drawable); + if (result == TCL_ERROR) { + return TCL_ERROR; + } + if (result == TCL_RETURN) { + return TCL_OK; + } + } else { + result = Blt_GetOpenPrinter(interp, Tcl_GetString(objv[2]), &drawable); + } + if (result == TCL_OK) { + int oldMode; + HDC hDC; + double xRatio, yRatio; + TkWinDC *drawPtr; + int w, h; + + drawPtr = (TkWinDC *) drawable; + hDC = drawPtr->hdc; + Blt_GetPrinterScale(hDC, &xRatio, &yRatio); + oldMode = SetMapMode(hDC, MM_ISOTROPIC); + if (oldMode == 0) { + Tcl_AppendResult(interp, "can't set mode for printer DC: ", + Blt_LastError(), (char *)NULL); + return TCL_ERROR; + } + w = (int)round(graphPtr->width * xRatio); + h = (int)round(graphPtr->height * yRatio); + SetViewportExtEx(hDC, w, h, NULL); + SetWindowExtEx(hDC, graphPtr->width, graphPtr->height, NULL); + + Blt_StartPrintJob(interp, drawable); + graphPtr->flags |= RESET_WORLD; + Blt_DrawGraph(graphPtr, drawable); + Blt_EndPrintJob(interp, drawable); + } + return result; +} + +#endif /* NO_PRINTER */ + +/* + *--------------------------------------------------------------------------- + * + * ObjToFormat -- + * + * Convert a string represent a node number into its integer value. + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToFormat( + ClientData clientData, /* Not used.*/ + Tcl_Interp *interp, /* Interpreter to send results back to */ + const char *switchName, /* Not used. */ + Tcl_Obj *objPtr, /* String representation */ + char *record, /* Structure record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + int *formatPtr = (int *)(record + offset); + char c; + const char *string; + + string = Tcl_GetString(objPtr); + c = string[0]; + if ((c == 'p') && (strcmp(string, "picture") == 0)) { + *formatPtr = FORMAT_PHOTO; + } else if ((c == 'p') && (strcmp(string, "photo") == 0)) { + *formatPtr = FORMAT_PHOTO; +#ifdef WIN32 + } else if ((c == 'e') && (strcmp(string, "emf") == 0)) { + *formatPtr = FORMAT_EMF; + } else if ((c == 'w') && (strcmp(string, "wmf") == 0)) { + *formatPtr = FORMAT_WMF; +#endif /* WIN32 */ + } else { +#ifdef WIN32 + Tcl_AppendResult(interp, "bad format \"", string, + "\": should be picture, photo, emf, or wmf.", (char *)NULL); +#else + Tcl_AppendResult(interp, "bad format \"", string, + "\": should be picture or photo.", (char *)NULL); +#endif /* WIN32 */ + return TCL_ERROR; + } + return TCL_OK; +} + +#ifdef WIN32 +static int InitMetaFileHeader( + Tk_Window tkwin, + int width, int height, + APMHEADER *mfhPtr) +{ + unsigned int *p; + unsigned int sum; +#define MM_INCH 25.4 + int xdpi, ydpi; + + mfhPtr->key = 0x9ac6cdd7L; + mfhPtr->hmf = 0; + mfhPtr->inch = 1440; + + Blt_ScreenDPI(tkwin, &xdpi, &ydpi); + mfhPtr->bbox.Left = mfhPtr->bbox.Top = 0; + mfhPtr->bbox.Bottom = (SHORT)((width * 1440)/ (float)xdpi); + mfhPtr->bbox.Right = (SHORT)((height * 1440) / (float)ydpi); + mfhPtr->reserved = 0; + sum = 0; + for (p = (unsigned int *)mfhPtr; + p < (unsigned int *)&(mfhPtr->checksum); p++) { + sum ^= *p; + } + mfhPtr->checksum = sum; + return TCL_OK; +} + +static int +CreateAPMetaFile(Tcl_Interp *interp, HANDLE hMetaFile, HDC hDC, + APMHEADER *mfhPtr, const char *fileName) +{ + HANDLE hFile; + HANDLE hMem; + LPVOID buffer; + int result; + DWORD count, nBytes; + + result = TCL_ERROR; + hMem = NULL; + hFile = CreateFile( + fileName, /* File path */ + GENERIC_WRITE, /* Access mode */ + 0, /* No sharing. */ + NULL, /* Security attributes */ + CREATE_ALWAYS, /* Overwrite any existing file */ + FILE_ATTRIBUTE_NORMAL, + NULL); /* No template file */ + if (hFile == INVALID_HANDLE_VALUE) { + Tcl_AppendResult(interp, "can't create metafile \"", fileName, + "\":", Blt_LastError(), (char *)NULL); + return TCL_ERROR; + } + if ((!WriteFile(hFile, (LPVOID)mfhPtr, sizeof(APMHEADER), &count, + NULL)) || (count != sizeof(APMHEADER))) { + Tcl_AppendResult(interp, "can't create metafile header to \"", + fileName, "\":", Blt_LastError(), (char *)NULL); + goto error; + } + nBytes = GetWinMetaFileBits(hMetaFile, 0, NULL, MM_ANISOTROPIC, hDC); + hMem = GlobalAlloc(GHND, nBytes); + if (hMem == NULL) { + Tcl_AppendResult(interp, "can't create allocate global memory:", + Blt_LastError(), (char *)NULL); + goto error; + } + buffer = (LPVOID)GlobalLock(hMem); + if (!GetWinMetaFileBits(hMetaFile, nBytes, buffer, MM_ANISOTROPIC, hDC)) { + Tcl_AppendResult(interp, "can't get metafile bits:", + Blt_LastError(), (char *)NULL); + goto error; + } + if ((!WriteFile(hFile, buffer, nBytes, &count, NULL)) || + (count != nBytes)) { + Tcl_AppendResult(interp, "can't write metafile bits:", + Blt_LastError(), (char *)NULL); + goto error; + } + result = TCL_OK; + error: + CloseHandle(hFile); + if (hMem != NULL) { + GlobalUnlock(hMem); + GlobalFree(hMem); + } + return result; +} +#endif /*WIN32*/ + +/* + *--------------------------------------------------------------------------- + * + * SnapOp -- + * + * Snaps a picture of the graph and stores it in the specified image. + * + * Results: + * Returns a standard TCL result. interp->result contains + * the list of the graph coordinates. If an error occurred + * while parsing the window positions, TCL_ERROR is returned, + * then interp->result will contain an error message. + * + *--------------------------------------------------------------------------- + */ +static int +SnapOp(Graph *graphPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int result; + Pixmap drawable; + int i; + SnapSwitches switches; + + /* .g snap ?switches? name */ + switches.height = Tk_Height(graphPtr->tkwin); + if ((switches.height < 2) && (graphPtr->reqHeight > 0)) { + switches.height = graphPtr->reqHeight; + } + switches.width = Tk_Width(graphPtr->tkwin); + if ((switches.width < 2) && (graphPtr->reqWidth > 0)) { + switches.width = graphPtr->reqWidth; + } + switches.format = FORMAT_PICTURE; + /* Process switches */ + i = Blt_ParseSwitches(interp, snapSwitches, objc - 2, objv + 2, &switches, + BLT_SWITCH_OBJV_PARTIAL); + if (i < 0) { + return TCL_ERROR; + } + i += 2; + if (i >= objc) { + Tcl_AppendResult(interp, "missing name argument: should be \"", + Tcl_GetString(objv[0]), "snap ?switches? name\"", (char *)NULL); + return TCL_ERROR; + } + switches.name = Tcl_GetString(objv[i]); + if (switches.width < 2) { + switches.width = Tk_ReqWidth(graphPtr->tkwin); + } + if (switches.height < 2) { + switches.width = Tk_ReqHeight(graphPtr->tkwin); + } + /* Always re-compute the layout of the graph before snapping the picture. */ + graphPtr->width = switches.width; + graphPtr->height = switches.height; + Blt_MapGraph(graphPtr); + + drawable = Tk_WindowId(graphPtr->tkwin); + switch (switches.format) { + case FORMAT_PICTURE: + case FORMAT_PHOTO: + drawable = Tk_GetPixmap(graphPtr->display, drawable, graphPtr->width, + graphPtr->height, Tk_Depth(graphPtr->tkwin)); +#ifdef WIN32 + assert(drawable != None); +#endif + graphPtr->flags |= RESET_WORLD; + Blt_DrawGraph(graphPtr, drawable); + if (switches.format == FORMAT_PICTURE) { + result = Blt_SnapPicture(interp, graphPtr->tkwin, drawable, 0, 0, + switches.width, switches.height, switches.width, + switches.height, switches.name, 1.0); + } else { + result = Blt_SnapPhoto(interp, graphPtr->tkwin, drawable, 0, 0, + switches.width, switches.height, switches.width, + switches.height, switches.name, 1.0); + } + Tk_FreePixmap(graphPtr->display, drawable); + break; + +#ifdef WIN32 + case FORMAT_WMF: + case FORMAT_EMF: + { + TkWinDC drawableDC; + TkWinDCState state; + HDC hRefDC, hDC; + HENHMETAFILE hMetaFile; + Tcl_DString dString; + const char *title; + + hRefDC = TkWinGetDrawableDC(graphPtr->display, drawable, &state); + + Tcl_DStringInit(&dString); + Tcl_DStringAppend(&dString, "BLT Graph ", -1); + Tcl_DStringAppend(&dString, BLT_VERSION, -1); + Tcl_DStringAppend(&dString, "\0", -1); + Tcl_DStringAppend(&dString, Tk_PathName(graphPtr->tkwin), -1); + Tcl_DStringAppend(&dString, "\0", -1); + title = Tcl_DStringValue(&dString); + hDC = CreateEnhMetaFile(hRefDC, NULL, NULL, title); + Tcl_DStringFree(&dString); + + if (hDC == NULL) { + Tcl_AppendResult(interp, "can't create metafile: ", + Blt_LastError(), (char *)NULL); + return TCL_ERROR; + } + + drawableDC.hdc = hDC; + drawableDC.type = TWD_WINDC; + + graphPtr->width = switches.width; + graphPtr->height = switches.height; + Blt_MapGraph(graphPtr); + graphPtr->flags |= RESET_WORLD; + Blt_DrawGraph(graphPtr, (Drawable)&drawableDC); + hMetaFile = CloseEnhMetaFile(hDC); + if (strcmp(switches.name, "CLIPBOARD") == 0) { + HWND hWnd; + + hWnd = Tk_GetHWND(drawable); + OpenClipboard(hWnd); + EmptyClipboard(); + SetClipboardData(CF_ENHMETAFILE, hMetaFile); + CloseClipboard(); + result = TCL_OK; + } else { + result = TCL_ERROR; + if (switches.format == FORMAT_WMF) { + APMHEADER mfh; + + assert(sizeof(mfh) == 22); + InitMetaFileHeader(graphPtr->tkwin, switches.width, + switches.height, &mfh); + result = CreateAPMetaFile(interp, hMetaFile, hRefDC, &mfh, + switches.name); + } else { + HENHMETAFILE hMetaFile2; + + hMetaFile2 = CopyEnhMetaFile(hMetaFile, switches.name); + if (hMetaFile2 != NULL) { + result = TCL_OK; + DeleteEnhMetaFile(hMetaFile2); + } + } + DeleteEnhMetaFile(hMetaFile); + } + TkWinReleaseDrawableDC(drawable, hRefDC, &state); + } + break; +#endif /*WIN32*/ + default: + Tcl_AppendResult(interp, "bad snapshot format", (char *)NULL); + return TCL_ERROR; + } + graphPtr->flags |= MAP_WORLD; + Blt_EventuallyRedrawGraph(graphPtr); + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * GraphWidgetCmd -- + * + * This procedure is invoked to process the TCL command that + * corresponds to a widget managed by this module. See the user + * documentation for details on what it does. + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ +static Blt_OpSpec graphOps[] = +{ + {"axis", 1, Blt_VirtualAxisOp, 2, 0, "oper ?args?",}, + {"bar", 2, BarOp, 2, 0, "oper ?args?",}, + {"cget", 2, CgetOp, 3, 3, "option",}, + {"configure", 2, ConfigureOp, 2, 0, "?option value?...",}, + {"crosshairs", 2, Blt_CrosshairsOp, 2, 0, "oper ?args?",}, + {"element", 2, ElementOp, 2, 0, "oper ?args?",}, + {"extents", 2, ExtentsOp, 3, 3, "item",}, + {"inside", 3, InsideOp, 4, 4, "winX winY",}, + {"invtransform", 3, InvtransformOp, 4, 4, "winX winY",}, + {"legend", 2, Blt_LegendOp, 2, 0, "oper ?args?",}, + {"line", 2, LineOp, 2, 0, "oper ?args?",}, + {"marker", 2, Blt_MarkerOp, 2, 0, "oper ?args?",}, + {"pen", 2, Blt_PenOp, 2, 0, "oper ?args?",}, + {"postscript", 2, Blt_PostScriptOp, 2, 0, "oper ?args?",}, +#ifndef NO_PRINTER + {"print1", 2, Print1Op, 2, 3, "?printerName?",}, + {"print2", 2, Print2Op, 2, 3, "?printerName?",}, +#endif /*NO_PRINTER*/ + {"snap", 1, SnapOp, 3, 0, "?switches? name",}, + {"transform", 1, TransformOp, 4, 4, "x y",}, + {"x2axis", 2, X2AxisOp, 2, 0, "oper ?args?",}, + {"xaxis", 2, XAxisOp, 2, 0, "oper ?args?",}, + {"y2axis", 2, Y2AxisOp, 2, 0, "oper ?args?",}, + {"yaxis", 2, YAxisOp, 2, 0, "oper ?args?",}, +}; +static int nGraphOps = sizeof(graphOps) / sizeof(Blt_OpSpec); + +int +Blt_GraphInstCmdProc(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + GraphCmdProc *proc; + int result; + Graph *graphPtr = clientData; + + proc = Blt_GetOpFromObj(interp, nGraphOps, graphOps, BLT_OP_ARG1, + objc, objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + Tcl_Preserve(graphPtr); + result = (*proc) (graphPtr, interp, objc, objv); + Tcl_Release(graphPtr); + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * NewGraph -- + * + * Creates a new window and TCL command representing an instance of a + * graph widget. + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ +static int +NewGraph(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv, ClassId classId) +{ + Graph *graphPtr; + + if (objc < 2) { + Tcl_AppendResult(interp, "wrong # args: should be \"", + Tcl_GetString(objv[0]), " pathName ?option value?...\"", + (char *)NULL); + return TCL_ERROR; + } + graphPtr = CreateGraph(interp, objc, objv, classId); + if (graphPtr == NULL) { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * GraphCmd -- + * + * Creates a new window and TCL command representing an instance of a + * graph widget. + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +GraphCmd(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + return NewGraph(interp, objc, objv, CID_ELEM_LINE); +} + +/* + *--------------------------------------------------------------------------- + * + * BarchartCmd -- + * + * Creates a new window and TCL command representing an instance of a + * barchart widget. + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +BarchartCmd(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + return NewGraph(interp, objc, objv, CID_ELEM_BAR); +} + +/* + *--------------------------------------------------------------------------- + * + * StripchartCmd -- + * + * Creates a new window and TCL command representing an instance of a + * barchart widget. + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +StripchartCmd(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + return NewGraph(interp, objc, objv, CID_ELEM_STRIP); +} + +/* + *--------------------------------------------------------------------------- + * + * DrawMargins -- + * + * Draws the exterior region of the graph (axes, ticks, titles, etc) + * onto a pixmap. The interior region is defined by the given rectangle + * structure. + * + * --------------------------------- + * | | + * | rectArr[0] | + * | | + * --------------------------------- + * | |top right| | + * | | | | + * | | | | + * | [1] | | [2] | + * | | | | + * | | | | + * | | | | + * | | | | + * | | | | + * | |left bottom| | + * --------------------------------- + * | | + * | rectArr[3] | + * | | + * --------------------------------- + * + * X coordinate axis + * Y coordinate axis + * legend + * interior border + * exterior border + * titles (X and Y axis, graph) + * + * Returns: + * None. + * + * Side Effects: + * Exterior of graph is displayed in its window. + * + *--------------------------------------------------------------------------- + */ +static void +DrawMargins(Graph *graphPtr, Drawable drawable) +{ + XRectangle rects[4]; + int site; + + /* + * Draw the four outer rectangles which encompass the plotting + * surface. This clears the surrounding area and clips the plot. + */ + rects[0].x = rects[0].y = rects[3].x = rects[1].x = 0; + rects[0].width = rects[3].width = (short int)graphPtr->width; + rects[0].height = (short int)graphPtr->top; + rects[3].y = graphPtr->bottom; + rects[3].height = graphPtr->height - graphPtr->bottom; + rects[2].y = rects[1].y = graphPtr->top; + rects[1].width = graphPtr->left; + rects[2].height = rects[1].height = graphPtr->bottom - graphPtr->top; + rects[2].x = graphPtr->right; + rects[2].width = graphPtr->width - graphPtr->right; + + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, graphPtr->normalBg, + rects[0].x, rects[0].y, rects[0].width, rects[0].height, + 0, TK_RELIEF_FLAT); + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, graphPtr->normalBg, + rects[1].x, rects[1].y, rects[1].width, rects[1].height, + 0, TK_RELIEF_FLAT); + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, graphPtr->normalBg, + rects[2].x, rects[2].y, rects[2].width, rects[2].height, + 0, TK_RELIEF_FLAT); + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, graphPtr->normalBg, + rects[3].x, rects[3].y, rects[3].width, rects[3].height, + 0, TK_RELIEF_FLAT); + + /* Draw 3D border around the plotting area */ + + if (graphPtr->plotBW > 0) { + int x, y, w, h; + + x = graphPtr->left - graphPtr->plotBW; + y = graphPtr->top - graphPtr->plotBW; + w = (graphPtr->right - graphPtr->left) + (2*graphPtr->plotBW); + h = (graphPtr->bottom - graphPtr->top) + (2*graphPtr->plotBW); + Blt_DrawBackgroundRectangle(graphPtr->tkwin, drawable, + graphPtr->normalBg, x, y, w, h, graphPtr->plotBW, + graphPtr->plotRelief); + } + site = Blt_Legend_Site(graphPtr); + if (site & LEGEND_MARGIN_MASK) { + /* Legend is drawn on one of the graph margins */ + Blt_DrawLegend(graphPtr, drawable); + } else if (site == LEGEND_WINDOW) { + Blt_Legend_EventuallyRedraw(graphPtr); + } + if (graphPtr->title != NULL) { + Blt_DrawText(graphPtr->tkwin, drawable, graphPtr->title, + &graphPtr->titleTextStyle, graphPtr->titleX, graphPtr->titleY); + } + Blt_DrawAxes(graphPtr, drawable); + graphPtr->flags &= ~DRAW_MARGINS; +} + +#ifdef notdef +/* + *--------------------------------------------------------------------------- + * + * DrawPlotRegion -- + * + * Draws the contents of the plotting area. This consists of the + * elements, markers (draw under elements), axis limits, and possibly the + * legend. Typically, the output will be cached into a backing store + * pixmap, so that redraws can occur quickly. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +DrawPlotRegion(Graph *graphPtr, Drawable drawable) +{ + int site; + + /* Clear the background of the plotting area. */ + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, graphPtr->plotBg, + graphPtr->left, graphPtr->top, graphPtr->right - graphPtr->left + 1, + graphPtr->bottom - graphPtr->top + 1, TK_RELIEF_FLAT, 0); + + /* Draw the elements, markers, legend, and axis limits. */ + + Blt_DrawGrids(graphPtr, drawable); + Blt_DrawMarkers(graphPtr, drawable, MARKER_UNDER); + site = Blt_Legend_Site(graphPtr); + if ((site & LEGEND_PLOTAREA_MASK) && + (!Blt_Legend_IsRaised(graphPtr))) { + Blt_DrawLegend(graphPtr, drawable); + } else if (site == LEGEND_WINDOW) { + Blt_Legend_EventuallyRedraw(graphPtr); + } + Blt_DrawAxisLimits(graphPtr, drawable); + DrawMargins(graphPtr, drawable); + Blt_DrawElements(graphPtr, drawable); + Blt_DrawAxes(graphPtr, drawable); +} +#endif + +/* + *--------------------------------------------------------------------------- + * + * DrawPlot -- + * + * Draws the contents of the plotting area. This consists of the + * elements, markers (draw under elements), axis limits, and possibly the + * legend. Typically, the output will be cached into a backing store + * pixmap, so that redraws can occur quickly. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +DrawPlot(Graph *graphPtr, Drawable drawable) +{ + int site; + + DrawMargins(graphPtr, drawable); + + /* Draw the background of the plotting area with 3D border. */ + Blt_FillBackgroundRectangle(graphPtr->tkwin, drawable, graphPtr->plotBg, + graphPtr->left - graphPtr->plotBW, + graphPtr->top - graphPtr->plotBW, + graphPtr->right - graphPtr->left + 1 + 2 * graphPtr->plotBW, + graphPtr->bottom - graphPtr->top + 1 + 2 * graphPtr->plotBW, + graphPtr->plotBW, graphPtr->plotRelief); + + /* Draw the elements, markers, legend, and axis limits. */ + Blt_DrawAxes(graphPtr, drawable); + Blt_DrawGrids(graphPtr, drawable); + Blt_DrawMarkers(graphPtr, drawable, MARKER_UNDER); + + site = Blt_Legend_Site(graphPtr); + if ((site & LEGEND_PLOTAREA_MASK) && (!Blt_Legend_IsRaised(graphPtr))) { + Blt_DrawLegend(graphPtr, drawable); + } else if (site == LEGEND_WINDOW) { + Blt_Legend_EventuallyRedraw(graphPtr); + } + Blt_DrawAxisLimits(graphPtr, drawable); + Blt_DrawElements(graphPtr, drawable); + /* Blt_DrawAxes(graphPtr, drawable); */ +} + +void +Blt_MapGraph(Graph *graphPtr) +{ + if (graphPtr->flags & RESET_AXES) { + Blt_ResetAxes(graphPtr); + } + if (graphPtr->flags & LAYOUT_NEEDED) { + Blt_LayoutGraph(graphPtr); + graphPtr->flags &= ~LAYOUT_NEEDED; + } + /* Compute coordinate transformations for graph components */ + if ((graphPtr->vRange > 1) && (graphPtr->hRange > 1)) { + if (graphPtr->flags & MAP_WORLD) { + Blt_MapAxes(graphPtr); + } + Blt_MapElements(graphPtr); + Blt_MapMarkers(graphPtr); + graphPtr->flags &= ~(MAP_ALL); + } +} + +void +Blt_DrawGraph(Graph *graphPtr, Drawable drawable) +{ + DrawPlot(graphPtr, drawable); + /* Draw markers above elements */ + Blt_DrawMarkers(graphPtr, drawable, MARKER_ABOVE); + Blt_DrawActiveElements(graphPtr, drawable); + + /* Don't draw legend in the plot area. */ + if ((Blt_Legend_Site(graphPtr) & LEGEND_PLOTAREA_MASK) && + (Blt_Legend_IsRaised(graphPtr))) { + Blt_DrawLegend(graphPtr, drawable); + } + /* Draw 3D border just inside of the focus highlight ring. */ + if ((graphPtr->borderWidth > 0) && (graphPtr->relief != TK_RELIEF_FLAT)) { + Blt_DrawBackgroundRectangle(graphPtr->tkwin, drawable, + graphPtr->normalBg, graphPtr->highlightWidth, + graphPtr->highlightWidth, + graphPtr->width - 2 * graphPtr->highlightWidth, + graphPtr->height - 2 * graphPtr->highlightWidth, + graphPtr->borderWidth, graphPtr->relief); + } + /* Draw focus highlight ring. */ + if ((graphPtr->highlightWidth > 0) && (graphPtr->flags & FOCUS)) { + GC gc; + + gc = Tk_GCForColor(graphPtr->highlightColor, drawable); + Tk_DrawFocusHighlight(graphPtr->tkwin, gc, graphPtr->highlightWidth, + drawable); + } +} + +static void +UpdateMarginTraces(Graph *graphPtr) +{ + Margin *marginPtr, *endPtr; + + for (marginPtr = graphPtr->margins, endPtr = marginPtr + 4; + marginPtr < endPtr; marginPtr++) { + if (marginPtr->varName != NULL) { /* Trigger variable traces */ + int size; + + if ((marginPtr->site == MARGIN_LEFT) || + (marginPtr->site == MARGIN_RIGHT)) { + size = marginPtr->width; + } else { + size = marginPtr->height; + } + Tcl_SetVar(graphPtr->interp, marginPtr->varName, Blt_Itoa(size), + TCL_GLOBAL_ONLY); + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * DisplayGraph -- + * + * This procedure is invoked to display a graph widget. + * + * Results: + * None. + * + * Side effects: + * Commands are output to X to display the graph in its current mode. + * + *--------------------------------------------------------------------------- + */ +static void +DisplayGraph(ClientData clientData) +{ + Graph *graphPtr = clientData; + Pixmap drawable; + Tk_Window tkwin; + int site; + + graphPtr->flags &= ~REDRAW_PENDING; + if (graphPtr->tkwin == NULL) { + return; /* Window has been destroyed (we + * should not get here) */ + } + tkwin = graphPtr->tkwin; +#ifdef notdef + fprintf(stderr, "Calling DisplayGraph(%s)\n", Tk_PathName(tkwin)); +#endif + if ((Tk_Width(tkwin) <= 1) || (Tk_Height(tkwin) <= 1)) { + /* Don't bother computing the layout until the size of the window is + * something reasonable. */ + return; + } + graphPtr->width = Tk_Width(tkwin); + graphPtr->height = Tk_Height(tkwin); + Blt_MapGraph(graphPtr); + if (!Tk_IsMapped(tkwin)) { + /* The graph's window isn't displayed, so don't bother drawing + * anything. By getting this far, we've at least computed the + * coordinates of the graph's new layout. */ + return; + } + /* Create a pixmap the size of the window for double buffering. */ + if (graphPtr->doubleBuffer) { + drawable = Tk_GetPixmap(graphPtr->display, Tk_WindowId(tkwin), + graphPtr->width, graphPtr->height, Tk_Depth(tkwin)); + } else { + drawable = Tk_WindowId(tkwin); + } + if (graphPtr->backingStore) { + if ((graphPtr->cache == None) || + (graphPtr->cacheWidth != graphPtr->width) || + (graphPtr->cacheHeight != graphPtr->height)) { + if (graphPtr->cache != None) { + Tk_FreePixmap(graphPtr->display, graphPtr->cache); + } + + + graphPtr->cache = Tk_GetPixmap(graphPtr->display, + Tk_WindowId(tkwin), graphPtr->width, graphPtr->height, + Tk_Depth(tkwin)); + graphPtr->cacheWidth = graphPtr->width; + graphPtr->cacheHeight = graphPtr->height; + graphPtr->flags |= CACHE_DIRTY; + } + } +#ifdef WIN32 + assert(drawable != None); +#endif + if (graphPtr->backingStore) { + if (graphPtr->flags & CACHE_DIRTY) { + /* The backing store is new or out-of-date. */ + DrawPlot(graphPtr, graphPtr->cache); + graphPtr->flags &= ~CACHE_DIRTY; + } + /* Copy the pixmap to the one used for drawing the entire graph. */ + XCopyArea(graphPtr->display, graphPtr->cache, drawable, + graphPtr->drawGC, 0, 0, Tk_Width(graphPtr->tkwin), + Tk_Height(graphPtr->tkwin), 0, 0); + } else { + DrawPlot(graphPtr, drawable); + } + /* Draw markers above elements */ + Blt_DrawMarkers(graphPtr, drawable, MARKER_ABOVE); + Blt_DrawActiveElements(graphPtr, drawable); + /* Don't draw legend in the plot area. */ + site = Blt_Legend_Site(graphPtr); + if ((site & LEGEND_PLOTAREA_MASK) && (Blt_Legend_IsRaised(graphPtr))) { + Blt_DrawLegend(graphPtr, drawable); + } + if (site == LEGEND_WINDOW) { + Blt_Legend_EventuallyRedraw(graphPtr); + } + /* Draw 3D border just inside of the focus highlight ring. */ + if ((graphPtr->borderWidth > 0) && (graphPtr->relief != TK_RELIEF_FLAT)) { + Blt_DrawBackgroundRectangle(graphPtr->tkwin, drawable, + graphPtr->normalBg, graphPtr->highlightWidth, + graphPtr->highlightWidth, + graphPtr->width - 2 * graphPtr->highlightWidth, + graphPtr->height - 2 * graphPtr->highlightWidth, + graphPtr->borderWidth, graphPtr->relief); + } + /* Draw focus highlight ring. */ + if ((graphPtr->highlightWidth > 0) && (graphPtr->flags & FOCUS)) { + GC gc; + + gc = Tk_GCForColor(graphPtr->highlightColor, drawable); + Tk_DrawFocusHighlight(graphPtr->tkwin, gc, graphPtr->highlightWidth, + drawable); + } + /* Disable crosshairs before redisplaying to the screen */ + Blt_DisableCrosshairs(graphPtr); + XCopyArea(graphPtr->display, drawable, Tk_WindowId(tkwin), + graphPtr->drawGC, 0, 0, graphPtr->width, graphPtr->height, 0, 0); + Blt_EnableCrosshairs(graphPtr); + if (graphPtr->doubleBuffer) { + Tk_FreePixmap(graphPtr->display, drawable); + } + graphPtr->flags &= ~RESET_WORLD; + UpdateMarginTraces(graphPtr); +} + +/*LINTLIBRARY*/ +int +Blt_GraphCmdInitProc(Tcl_Interp *interp) +{ + static Blt_InitCmdSpec cmdSpecs[] = { + {"graph", GraphCmd,}, + {"barchart", BarchartCmd,}, + {"stripchart", StripchartCmd,}, + }; + return Blt_InitCmds(interp, "::blt", cmdSpecs, 3); +} + +Graph * +Blt_GetGraphFromWindowData(Tk_Window tkwin) +{ + Graph *graphPtr; + + while (tkwin != NULL) { + graphPtr = (Graph *)Blt_GetWindowInstanceData(tkwin); + if (graphPtr != NULL) { + return graphPtr; + } + tkwin = Tk_Parent(tkwin); + } + return NULL; +} + +int +Blt_GraphType(Graph *graphPtr) +{ + switch (graphPtr->classId) { + case CID_ELEM_LINE: + return GRAPH; + case CID_ELEM_BAR: + return BARCHART; + case CID_ELEM_STRIP: + return STRIPCHART; + default: + return 0; + } + return 0; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ReconfigureGraph -- + * + * Allocates resources for the graph. + * + *--------------------------------------------------------------------------- + */ +void +Blt_ReconfigureGraph(Graph *graphPtr) +{ + ConfigureGraph(graphPtr); + Blt_ConfigureLegend(graphPtr); + Blt_ConfigureElements(graphPtr); + Blt_ConfigureAxes(graphPtr); + Blt_ConfigureMarkers(graphPtr); +} diff --git a/src/bltGraph.h b/src/bltGraph.h new file mode 100644 index 0000000..62ab031 --- /dev/null +++ b/src/bltGraph.h @@ -0,0 +1,699 @@ + +/* + * bltGraph.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_GRAPH_H +#define _BLT_GRAPH_H + +#include "bltInt.h" +#include "bltHash.h" +#include "bltBind.h" +#include "bltChain.h" +#include "bltPs.h" +#include "bltBgStyle.h" + +typedef struct _Graph Graph; +typedef struct _Element Element; +typedef struct _Legend Legend; + +typedef enum { + CID_NONE, + CID_AXIS_X, + CID_AXIS_Y, + CID_ELEM_BAR, + CID_ELEM_CONTOUR, + CID_ELEM_LINE, + CID_ELEM_STRIP, + CID_MARKER_BITMAP, + CID_MARKER_IMAGE, + CID_MARKER_LINE, + CID_MARKER_POLYGON, + CID_MARKER_TEXT, + CID_MARKER_WINDOW, + CID_LEGEND_ENTRY, +} ClassId; + +typedef struct { + /* Generic fields common to all graph objects. */ + ClassId classId; /* Class type of object. */ + const char *name; /* Identifier to refer the object. */ + const char *className; /* Class name of object. */ + + Graph *graphPtr; /* Graph containing of the object. */ + + const char **tags; /* Binding tags for the object. */ +} GraphObj; + +#include "bltGrAxis.h" +#include "bltGrLegd.h" + +#define MARKER_UNDER 1 /* Draw markers designated to lie underneath + * elements, grids, legend, etc. */ +#define MARKER_ABOVE 0 /* Draw markers designated to rest above + * elements, grids, legend, etc. */ + +#define PADX 2 /* Padding between labels/titles */ +#define PADY 2 /* Padding between labels */ + +#define MINIMUM_MARGIN 20 /* Minimum margin size */ + + +#define BOUND(x, lo, hi) \ + (((x) > (hi)) ? (hi) : ((x) < (lo)) ? (lo) : (x)) + +/* + *--------------------------------------------------------------------------- + * + * Graph component structure definitions + * + *--------------------------------------------------------------------------- + */ +#define PointInGraph(g,x,y) \ + (((x) <= (g)->right) && ((x) >= (g)->left) && \ + ((y) <= (g)->bottom) && ((y) >= (g)->top)) + +/* + * Mask values used to selectively enable GRAPH or BARCHART entries in the + * various configuration specs. + */ +#define GRAPH (BLT_CONFIG_USER_BIT << 1) +#define STRIPCHART (BLT_CONFIG_USER_BIT << 2) +#define BARCHART (BLT_CONFIG_USER_BIT << 3) +#define LINE_GRAPHS (GRAPH | STRIPCHART) +#define ALL_GRAPHS (GRAPH | BARCHART | STRIPCHART) + +#define ACTIVE_PEN (BLT_CONFIG_USER_BIT << 16) +#define NORMAL_PEN (BLT_CONFIG_USER_BIT << 17) +#define ALL_PENS (NORMAL_PEN | ACTIVE_PEN) + +typedef struct { + Segment2d *segments; + int length; + int *map; +} GraphSegments; + +typedef struct { + Point2d *points; + int length; + int *map; +} GraphPoints; + + +/* + *--------------------------------------------------------------------------- + * + * BarGroup -- + * + * Represents a sets of bars with the same abscissa. This structure is + * used to track the display of the bars in the group. + * + * Each unique abscissa has at least one group. Groups can be + * defined by the bar element's -group option. Multiple groups are + * needed when you are displaying/comparing similar sets of data (same + * abscissas) but belong to a separate group. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + int nSegments; /* Number of occurrences of + * x-coordinate */ + Axis2d axes; /* The axes associated with this + * group. (mapped to the x-value) */ + float sum; /* Sum of the ordinates (y-coorinate) of + * each duplicate abscissa. Used to + * determine height of stacked bars. */ + int count; /* Current number of bars seen. Used to + * position of the next bar in the + * group. */ + float lastY; /* y-cooridinate position of the + * last bar seen. */ + size_t index; /* Order of group in set (an unique + * abscissa may have more than one + * group). */ +} BarGroup; + +/* + *--------------------------------------------------------------------------- + * + * BarSetKey -- + * + * Key for hash table of set of bars. The bar set is defined by + * coordinates with the same abscissa (x-coordinate). + * + *--------------------------------------------------------------------------- + */ +typedef struct { + float value; /* Duplicated abscissa */ + Axis2d axes; /* Axis mapping of element */ +} BarSetKey; + +/* + * BarModes -- + * + * Bar elements are displayed according to their x-y coordinates. If two + * bars have the same abscissa (x-coordinate), the bar segments will be + * drawn according to one of the following modes: + */ + +typedef enum BarModes { + BARS_INFRONT, /* Each successive bar in a group is + * drawn in front of the previous. */ + BARS_STACKED, /* Each successive bar in a group is + * drawn stacked on top of the previous + * bar. */ + BARS_ALIGNED, /* Each successive bar in a group is + * drawn aligned side-by-side to the + * previous from right-to-left. */ + BARS_OVERLAP /* Like "aligned", each successive bar + * in a group is drawn from + * right-to-left. The bars will overlap + * each other by ~50%. */ +} BarMode; + +typedef struct _Pen Pen; +typedef struct _Marker Marker; + +typedef Pen *(PenCreateProc)(void); +typedef int (PenConfigureProc)(Graph *graphPtr, Pen *penPtr); +typedef void (PenDestroyProc)(Graph *graphPtr, Pen *penPtr); + +struct _Pen { + const char *name; /* Pen style identifier. If NULL pen + * was statically allocated. */ + ClassId classId; /* Type element using this pen. */ + const char *typeId; /* String token identifying the type of + * pen. */ + unsigned int flags; /* Indicates if the pen element is + * active or normal. */ + int refCount; /* Reference count for elements using + * this pen. */ + Blt_HashEntry *hashPtr; + + Blt_ConfigSpec *configSpecs; /* Configuration specifications */ + + PenConfigureProc *configProc; + PenDestroyProc *destroyProc; + Graph *graphPtr; /* Graph that the pen is associated + * with. */ +}; + +/* + *--------------------------------------------------------------------------- + * + * Crosshairs + * + * Contains the line segments positions and graphics context used to + * simulate crosshairs (by XOR-ing) on the graph. + * + *--------------------------------------------------------------------------- + */ +typedef struct _Crosshairs Crosshairs; + +typedef struct { + short int width, height; /* Dimensions of the margin */ + short int axesOffset; + short int axesTitleLength; /* Width of the widest title to be + * shown. Multiple titles are displayed + * in another margin. This is the + * minimum space requirement. */ + short int maxTickWidth; + short int maxTickHeight; + unsigned int nAxes; /* # of axes to be displayed */ + Blt_Chain axes; /* Axes associated with this margin */ + const char *varName; /* If non-NULL, name of variable to be + * updated when the margin size + * changes */ + int reqSize; /* Requested size of margin */ + int site; /* Indicates where margin is located: + * left, right, top, or bottom. */ +} Margin; + +#define MARGIN_NONE -1 +#define MARGIN_BOTTOM 0 /* x */ +#define MARGIN_LEFT 1 /* y */ +#define MARGIN_TOP 2 /* x2 */ +#define MARGIN_RIGHT 3 /* y2 */ + +#define rightMargin margins[MARGIN_RIGHT] +#define leftMargin margins[MARGIN_LEFT] +#define topMargin margins[MARGIN_TOP] +#define bottomMargin margins[MARGIN_BOTTOM] + +/* + *--------------------------------------------------------------------------- + * + * Graph -- + * + * Top level structure containing everything pertaining to the graph. + * + *--------------------------------------------------------------------------- + */ +struct _Graph { + unsigned int flags; /* Flags; see below for definitions. */ + Tcl_Interp *interp; /* Interpreter associated with graph */ + Tk_Window tkwin; /* Window that embodies the graph. + * NULL means that the window has been + * destroyed but the data structures + * haven't yet been cleaned up. */ + Display *display; /* Display containing widget; used to + * release resources after tkwin has + * already gone away. */ + Tcl_Command cmdToken; /* Token for graph's widget command. */ + const char *data; /* This value isn't used in C code. + * It may be used in TCL bindings to + * associate extra data. */ + Tk_Cursor cursor; + int inset; /* Sum of focus highlight and 3-D + * border. Indicates how far to + * offset the graph from outside edge + * of the window. */ + int borderWidth; /* Width of the exterior border */ + int relief; /* Relief of the exterior border. */ + Blt_Background normalBg; /* 3-D border used to delineate the + * plot surface and outer edge of + * window. */ + int highlightWidth; /* Width in pixels of highlight to + * draw around widget when it has the + * focus. <= 0 means don't draw a + * highlight. */ + XColor *highlightBgColor; /* Color for drawing traversal + * highlight area when highlight is + * off. */ + XColor *highlightColor; /* Color for drawing traversal + * highlight. */ + const char *title; /* Graph title */ + short int titleX, titleY; /* Position of title on graph. */ + short int titleWidth, titleHeight; /* Dimensions of title. */ + TextStyle titleTextStyle; /* Title attributes: font, color, + * etc.*/ + + const char *takeFocus; /* Not used in C code, indicates if + * widget should be included in focus + * traversal. */ + Axis *focusPtr; /* The axis that currently has focus. */ + + int reqWidth, reqHeight; /* Requested size of graph window */ + int reqPlotWidth, reqPlotHeight; /* Requested size of plot area. Zero + * means to adjust the dimension + * according to the available space + * left in the window. */ + int width, height; /* Actual size (in pixels) of graph + * window or PostScript page. */ + Blt_HashTable penTable; /* Table of pens */ + struct Component { + Blt_HashTable table; /* Hash table of ids. */ + Blt_Chain displayList; /* Display list. */ + Blt_HashTable tagTable; /* Table of bind tags. */ + } elements, markers, axes; + + Blt_HashTable dataTables; /* Hash table of datatable clients. */ + ClassId classId; /* Default element type */ + Blt_BindTable bindTable; + int nextMarkerId; /* Tracks next marker identifier + * available */ + Blt_Chain axisChain[4]; /* Chain of axes for each of the + * margins. They're separate from the + * margin structures to make it easier + * to invert the X-Y axes by simply + * switching chain pointers. */ + Margin margins[4]; + PageSetup *pageSetup; /* Page layout options: see bltGrPS.c */ + Legend *legend; /* Legend information: see + * bltGrLegd.c */ + Crosshairs *crosshairs; /* Crosshairs information: see + * bltGrHairs.c */ + int halo; /* Maximum distance allowed between + * points when searching for a point */ + int inverted; /* If non-zero, indicates the x and y + * axis positions should be inverted. */ + int stackAxes; /* If non-zero, indicates to stack + * mulitple axes in a margin, rather + * than layering them one on top of + * another. */ + GC drawGC; /* GC for drawing on the margins. This + * includes the axis lines */ + int plotBW; /* Width of interior 3-D border. */ + int plotRelief; /* 3-d effect: TK_RELIEF_RAISED etc. */ + Blt_Background plotBg; /* Color of plotting surface */ + + /* If non-zero, force plot to conform to aspect ratio W/H */ + float aspect; + + short int left, right; /* Coordinates of plot bbox */ + short int top, bottom; + + Blt_Pad xPad; /* Vertical padding for plotarea */ + int vRange, vOffset; /* Vertical axis range and offset from + * the left side of the graph + * window. Used to transform coordinates + * to vertical axes. */ + Blt_Pad yPad; /* Horizontal padding for plotarea */ + int hRange, hOffset; /* Horizontal axis range and offset from + * the top of the graph window. Used to + * transform horizontal axes */ + float vScale, hScale; + + int doubleBuffer; /* If non-zero, draw the graph into a + * pixmap first to reduce flashing. */ + int backingStore; /* If non-zero, cache elements by + * drawing them into a pixmap */ + Pixmap cache; /* Pixmap used to cache elements + * displayed. If *backingStore* is + * non-zero, each element is drawn into + * this pixmap before it is copied onto + * the screen. The pixmap then acts as + * a cache (only the pixmap is + * redisplayed if the none of elements + * have changed). This is done so that + * markers can be redrawn quickly over + * elements without redrawing each + * element. */ + short int cacheWidth, cacheHeight; /* Size of element backing store + * pixmap. */ + + /* + * barchart specific information + */ + float baseline; /* Baseline from bar chart. */ + float barWidth; /* Default width of each bar in graph + * units. The default width is 1.0 + * units. */ + BarMode mode; /* Mode describing how to display bars + * with the same x-coordinates. Mode can + * be "stacked", "aligned", "overlap", + * or "infront" */ + BarGroup *barGroups; /* Contains information about duplicate + * x-values in bar elements (malloc-ed). + * This information can also be accessed + * by the group hash table */ + int nBarGroups; /* # of entries in barGroups array. If + * zero, indicates nothing special + * needs to be * done for "stack" or + * "align" modes */ + Blt_HashTable setTable; /* Table managing sets of bars with + * the same abscissas. The bars in a + * set may be displayed is various + * ways: aligned, overlap, infront, or + * stacked. */ + int maxBarSetSize; + const char *dataCmd; /* New data callback? */ + +}; + +/* + * Bit flags definitions: + * + * All kinds of state information kept here. All these things happen + * when the window is available to draw into (DisplayGraph). Need the + * window width and height before we can calculate graph layout (i.e. the + * screen coordinates of the axes, elements, titles, etc). But we want to + * do this only when we have to, not every time the graph is redrawn. + * + * Same goes for maintaining a pixmap to double buffer graph elements. + * Need to mark when the pixmap needs to updated. + * + * + * MAP_ITEM Indicates that the element/marker/axis + * configuration has changed such that + * its layout of the item (i.e. its + * position in the graph window) needs + * to be recalculated. + * + * MAP_ALL Indicates that the layout of the axes and + * all elements and markers and the graph need + * to be recalculated. Otherwise, the layout + * of only those markers and elements that + * have changed will be reset. + * + * GET_AXIS_GEOMETRY Indicates that the size of the axes needs + * to be recalculated. + * + * RESET_AXES Flag to call to Blt_ResetAxes routine. + * This routine recalculates the scale offset + * (used for mapping coordinates) of each axis. + * If an axis limit has changed, then it sets + * flags to re-layout and redraw the entire + * graph. This needs to happend before the axis + * can compute transformations between graph and + * screen coordinates. + * + * LAYOUT_NEEDED + * + * CACHE_DIRTY If set, redraw all elements into the pixmap + * used for buffering elements. + * + * REDRAW_PENDING Non-zero means a DoWhenIdle handler has + * already been queued to redraw this window. + * + * DRAW_LEGEND Non-zero means redraw the legend. If this is + * the only DRAW_* flag, the legend display + * routine is called instead of the graph + * display routine. + * + * DRAW_MARGINS Indicates that the margins bordering + * the plotting area need to be redrawn. + * The possible reasons are: + * + * 1) an axis configuration changed + * 2) an axis limit changed + * 3) titles have changed + * 4) window was resized. + * + * GRAPH_FOCUS + */ + +#define HIDE (1<<0) /* 0x0001 */ +#define DELETE_PENDING (1<<1) /* 0x0002 */ +#define REDRAW_PENDING (1<<2) /* 0x0004 */ +#define ACTIVE_PENDING (1<<3) /* 0x0008 */ +#define MAP_ITEM (1<<4) /* 0x0010 */ +#define DIRTY (1<<5) /* 0x0020 */ +#define ACTIVE (1<<6) /* 0x0040 */ +#define FOCUS (1<<7) /* 0x0080 */ + +#define MAP_ALL (1<<8) /* 0x0100 */ +#define LAYOUT_NEEDED (1<<9) /* 0x0200 */ +#define RESET_AXES (1<<10)/* 0x0400 */ +#define GET_AXIS_GEOMETRY (1<<11)/* 0x0800 */ + +#define DRAW_LEGEND (1<<12)/* 0x1000 */ +#define DRAW_MARGINS (1<<13)/* 0x2000 */ +#define CACHE_DIRTY (1<<14)/* 0x4000 */ +#define REQ_BACKING_STORE (1<<15)/* 0x8000 */ +#define UNMAP_HIDDEN (1<<16) + +#define MAP_WORLD (MAP_ALL|RESET_AXES|GET_AXIS_GEOMETRY) +#define REDRAW_WORLD (DRAW_LEGEND) +#define RESET_WORLD (REDRAW_WORLD | MAP_WORLD) + +/* + * ---------------------- Forward declarations ------------------------ + */ + +BLT_EXTERN int Blt_CreatePageSetup(Graph *graphPtr); + +BLT_EXTERN int Blt_CreateCrosshairs(Graph *graphPtr); + +BLT_EXTERN double Blt_InvHMap(Axis *axisPtr, double x); + +BLT_EXTERN double Blt_InvVMap(Axis *axisPtr, double x); + +BLT_EXTERN double Blt_HMap(Axis *axisPtr, double x); + +BLT_EXTERN double Blt_VMap(Axis *axisPtr, double y); + +BLT_EXTERN Point2d Blt_InvMap2D(Graph *graphPtr, double x, double y, + Axis2d *pairPtr); + +BLT_EXTERN Point2d Blt_Map2D(Graph *graphPtr, double x, double y, + Axis2d *pairPtr); + +BLT_EXTERN Graph *Blt_GetGraphFromWindowData(Tk_Window tkwin); + +BLT_EXTERN void Blt_AdjustAxisPointers(Graph *graphPtr); + +BLT_EXTERN int Blt_PolyRectClip(Region2d *extsPtr, Point2d *inputPts, + int nInputPts, Point2d *outputPts); + +BLT_EXTERN void Blt_ComputeBarStacks(Graph *graphPtr); + +BLT_EXTERN void Blt_ConfigureCrosshairs(Graph *graphPtr); +BLT_EXTERN void Blt_ConfigureLegend(Graph *graphPtr); +BLT_EXTERN void Blt_ConfigureElements(Graph *graphPtr); +BLT_EXTERN void Blt_ConfigureAxes(Graph *graphPtr); +BLT_EXTERN void Blt_ConfigureMarkers(Graph *graphPtr); +BLT_EXTERN void Blt_ReconfigureGraph(Graph *graphPtr); + +BLT_EXTERN void Blt_DestroyAxes(Graph *graphPtr); + +BLT_EXTERN void Blt_DestroyCrosshairs(Graph *graphPtr); + +BLT_EXTERN void Blt_DestroyElements(Graph *graphPtr); + +BLT_EXTERN void Blt_DestroyMarkers(Graph *graphPtr); + +BLT_EXTERN void Blt_DestroyPageSetup(Graph *graphPtr); + +BLT_EXTERN void Blt_DrawAxes(Graph *graphPtr, Drawable drawable); + +BLT_EXTERN void Blt_DrawAxisLimits(Graph *graphPtr, Drawable drawable); + +BLT_EXTERN void Blt_DrawElements(Graph *graphPtr, Drawable drawable); + +BLT_EXTERN void Blt_DrawActiveElements(Graph *graphPtr, Drawable drawable); + +BLT_EXTERN void Blt_DrawGraph(Graph *graphPtr, Drawable drawable); + +BLT_EXTERN void Blt_DrawMarkers(Graph *graphPtr, Drawable drawable, int under); + +BLT_EXTERN void Blt_Draw2DSegments(Display *display, Drawable drawable, GC gc, + Segment2d *segments, int nSegments); + +BLT_EXTERN int Blt_GetCoordinate(Tcl_Interp *interp, const char *string, + double *valuePtr); + +BLT_EXTERN void Blt_InitBarSetTable(Graph *graphPtr); + +BLT_EXTERN void Blt_LayoutGraph(Graph *graphPtr); + +BLT_EXTERN void Blt_EventuallyRedrawGraph(Graph *graphPtr); + +BLT_EXTERN void Blt_ResetAxes(Graph *graphPtr); + +BLT_EXTERN void Blt_ResetBarGroups(Graph *graphPtr); + +BLT_EXTERN void Blt_GraphExtents(Graph *graphPtr, Region2d *extsPtr); + +BLT_EXTERN void Blt_DisableCrosshairs(Graph *graphPtr); + +BLT_EXTERN void Blt_EnableCrosshairs(Graph *graphPtr); + +BLT_EXTERN void Blt_MapGraph(Graph *graphPtr); + +BLT_EXTERN void Blt_MapAxes(Graph *graphPtr); + +BLT_EXTERN void Blt_MapElements(Graph *graphPtr); + +BLT_EXTERN void Blt_MapMarkers(Graph *graphPtr); + +BLT_EXTERN void Blt_UpdateCrosshairs(Graph *graphPtr); + +BLT_EXTERN void Blt_DestroyPens(Graph *graphPtr); + +BLT_EXTERN int Blt_GetPenFromObj(Tcl_Interp *interp, Graph *graphPtr, + Tcl_Obj *objPtr, ClassId classId, Pen **penPtrPtr); + +BLT_EXTERN Pen *Blt_BarPen(const char *penName); + +BLT_EXTERN Pen *Blt_LinePen(const char *penName); + +BLT_EXTERN Pen *Blt_CreatePen(Graph *graphPtr, const char *penName, + ClassId classId, int objc, Tcl_Obj *const *objv); + +BLT_EXTERN int Blt_InitLinePens(Graph *graphPtr); + +BLT_EXTERN int Blt_InitBarPens(Graph *graphPtr); + +BLT_EXTERN void Blt_FreePen(Pen *penPtr); + +BLT_EXTERN int Blt_VirtualAxisOp(Graph *graphPtr, Tcl_Interp *interp, + int objc, Tcl_Obj *const *objv); + +BLT_EXTERN int Blt_AxisOp(Tcl_Interp *interp, Graph *graphPtr, int margin, + int objc, Tcl_Obj *const *objv); + +BLT_EXTERN int Blt_ElementOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv, ClassId classId); + +BLT_EXTERN int Blt_CrosshairsOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +BLT_EXTERN int Blt_MarkerOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +BLT_EXTERN int Blt_PenOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +BLT_EXTERN int Blt_PointInPolygon(Point2d *samplePtr, Point2d *screenPts, + int nScreenPts); + +BLT_EXTERN int Blt_RegionInPolygon(Region2d *extsPtr, Point2d *points, + int nPoints, int enclosed); + +BLT_EXTERN int Blt_PointInSegments(Point2d *samplePtr, Segment2d *segments, + int nSegments, double halo); + +BLT_EXTERN int Blt_PostScriptOp(Graph *graphPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +BLT_EXTERN int Blt_GraphUpdateNeeded(Graph *graphPtr); + +BLT_EXTERN int Blt_DefaultAxes(Graph *graphPtr); + +BLT_EXTERN Axis *Blt_GetFirstAxis(Blt_Chain chain); + +BLT_EXTERN void Blt_UpdateAxisBackgrounds(Graph *graphPtr); + +BLT_EXTERN Marker *Blt_NearestMarker(Graph *graphPtr, int x, int y, int under); + +BLT_EXTERN Axis *Blt_NearestAxis(Graph *graphPtr, int x, int y); + +typedef ClientData (MakeTagProc)(Graph *graphPtr, const char *tagName); + +BLT_EXTERN MakeTagProc Blt_MakeElementTag; +BLT_EXTERN MakeTagProc Blt_MakeMarkerTag; +BLT_EXTERN MakeTagProc Blt_MakeAxisTag; +BLT_EXTERN Blt_BindTagProc Blt_GraphTags; +BLT_EXTERN Blt_BindTagProc Blt_AxisTags; + +BLT_EXTERN int Blt_GraphType(Graph *graphPtr); + +BLT_EXTERN void Blt_UpdateGraph(ClientData clientData); + +BLT_EXTERN void Blt_GraphSetObjectClass(GraphObj *graphObjPtr,ClassId classId); + +BLT_EXTERN void Blt_MarkersToPostScript(Graph *graphPtr, Blt_Ps ps, int under); +BLT_EXTERN void Blt_ElementsToPostScript(Graph *graphPtr, Blt_Ps ps); +BLT_EXTERN void Blt_ActiveElementsToPostScript(Graph *graphPtr, Blt_Ps ps); +BLT_EXTERN void Blt_LegendToPostScript(Graph *graphPtr, Blt_Ps ps); +BLT_EXTERN void Blt_AxesToPostScript(Graph *graphPtr, Blt_Ps ps); +BLT_EXTERN void Blt_AxisLimitsToPostScript(Graph *graphPtr, Blt_Ps ps); + +BLT_EXTERN Element *Blt_LineElement(Graph *graphPtr, const char *name, + ClassId classId); +BLT_EXTERN Element *Blt_BarElement(Graph *graphPtr, const char *name, + ClassId classId); + +BLT_EXTERN void Blt_DrawGrids(Graph *graphPtr, Drawable drawable); + +BLT_EXTERN void Blt_GridsToPostScript(Graph *graphPtr, Blt_Ps ps); +BLT_EXTERN void Blt_InitBarSetTable(Graph *graphPtr); +BLT_EXTERN void Blt_DestroyBarSets(Graph *graphPtr); + +/* ---------------------- Global declarations ------------------------ */ + +BLT_EXTERN const char *Blt_GraphClassName(ClassId classId); + +#endif /* _BLT_GRAPH_H */ diff --git a/src/bltInt.C b/src/bltInt.C new file mode 100644 index 0000000..ac4640c --- /dev/null +++ b/src/bltInt.C @@ -0,0 +1,375 @@ + +/* + * bltCoreInit.c -- + * + * This module initials the non-Tk command of the BLT toolkit, registering the + * commands with the TCL interpreter. + * + * Copyright 1991-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltInt.h" +#include "bltNsUtil.h" +#include "bltArrayObj.h" +#include "bltMath.h" + +#ifndef BLT_LIBRARY +# ifdef WIN32 +# define BLT_LIBRARY "c:/Program Files/Tcl/lib/blt"##BLT_VERSION +# else +# define BLT_LIBRARY "unknown" +# endif +#endif + +#if (_TCL_VERSION >= _VERSION(8,5,0)) +#define TCL_VERSION_LOADED TCL_PATCH_LEVEL +#else +#define TCL_VERSION_LOADED TCL_VERSION +#endif + +static double bltNaN; + +BLT_EXTERN Tcl_AppInitProc Blt_core_Init; +BLT_EXTERN Tcl_AppInitProc Blt_core_SafeInit; + +static Tcl_MathProc MinMathProc, MaxMathProc; +static char libPath[1024] = +{ + BLT_LIBRARY +}; + +/* + * Script to set the BLT library path in the variable global "blt_library" + * + * Checks the usual locations for a file (bltGraph.pro) from the BLT library. + * The places searched in order are + * + * $BLT_LIBRARY + * $BLT_LIBRARY/blt2.4 + * $BLT_LIBRARY/.. + * $BLT_LIBRARY/../blt2.4 + * $blt_libPath + * $blt_libPath/blt2.4 + * $blt_libPath/.. + * $blt_libPath/../blt2.4 + * $tcl_library + * $tcl_library/blt2.4 + * $tcl_library/.. + * $tcl_library/../blt2.4 + * $env(TCL_LIBRARY) + * $env(TCL_LIBRARY)/blt2.4 + * $env(TCL_LIBRARY)/.. + * $env(TCL_LIBRARY)/../blt2.4 + * + * The TCL variable "blt_library" is set to the discovered path. If the file + * wasn't found, no error is returned. The actual usage of $blt_library is + * purposely deferred so that it can be set from within a script. + */ + +/* FIXME: Change this to a namespace procedure in 3.0 */ + +static char initScript[] = +{"\n\ +global blt_library blt_libPath blt_version tcl_library env\n\ +set blt_library {}\n\ +set path {}\n\ +foreach var { env(BLT_LIBRARY) blt_libPath tcl_library env(TCL_LIBRARY) } { \n\ + if { ![info exists $var] } { \n\ + continue \n\ + } \n\ + set path [set $var] \n\ + if { [file readable [file join $path bltGraph.pro]] } { \n\ + set blt_library $path\n\ + break \n\ + } \n\ + set path [file join $path blt$blt_version ] \n\ + if { [file readable [file join $path bltGraph.pro]] } { \n\ + set blt_library $path\n\ + break \n\ + } \n\ + set path [file dirname [set $var]] \n\ + if { [file readable [file join $path bltGraph.pro]] } { \n\ + set blt_library $path\n\ + break \n\ + } \n\ + set path [file join $path blt$blt_version ] \n\ + if { [file readable [file join $path bltGraph.pro]] } { \n\ + set blt_library $path\n\ + break \n\ + } \n\ +} \n\ +if { $blt_library != \"\" } { \n\ + global auto_path \n\ + lappend auto_path $blt_library \n\ +}\n\ +unset var path\n\ +\n" +}; + + +static Tcl_AppInitProc *cmdProcs[] = +{ +#ifndef NO_BASE64 + Blt_Base64CmdInitProc, +#endif +#ifndef NO_BGEXEC + Blt_BgexecCmdInitProc, +#endif +#ifndef NO_PTYEXEC + Blt_PtyExecCmdInitProc, +#endif +#ifndef NO_CRC32 + Blt_Crc32CmdInitProc, +#endif +#ifndef NO_CSV + Blt_CsvCmdInitProc, +#endif +#ifndef NO_DATATABLE + Blt_TableCmdInitProc, +#endif +#ifndef NO_DDE + Blt_DdeCmdInitProc, +#endif +#ifndef NO_DEBUG + Blt_DebugCmdInitProc, +#endif +#ifndef NO_SPLINE + Blt_SplineCmdInitProc, +#endif +#ifndef NO_TREE + Blt_TreeCmdInitProc, +#endif +#ifndef NO_VECTOR + Blt_VectorCmdInitProc, +#endif +#ifndef NO_WATCH + Blt_WatchCmdInitProc, +#endif + (Tcl_AppInitProc *) NULL +}; + +double +Blt_NaN(void) +{ + return bltNaN; +} + +static double +MakeNaN(void) +{ + union DoubleValue { + unsigned int words[2]; + double value; + } result; + +#ifdef WORDS_BIGENDIAN + result.words[0] = 0x7ff80000; + result.words[1] = 0x00000000; +#else + result.words[0] = 0x00000000; + result.words[1] = 0x7ff80000; +#endif + return result.value; +} + +/* ARGSUSED */ +static int +MinMathProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tcl_Value *argsPtr, + Tcl_Value *resultPtr) +{ + Tcl_Value *op1Ptr, *op2Ptr; + + op1Ptr = argsPtr, op2Ptr = argsPtr + 1; + if ((op1Ptr->type == TCL_INT) && (op2Ptr->type == TCL_INT)) { + resultPtr->intValue = MIN(op1Ptr->intValue, op2Ptr->intValue); + resultPtr->type = TCL_INT; + } else { + double a, b; + + a = (op1Ptr->type == TCL_INT) + ? (double)op1Ptr->intValue : op1Ptr->doubleValue; + b = (op2Ptr->type == TCL_INT) + ? (double)op2Ptr->intValue : op2Ptr->doubleValue; + resultPtr->doubleValue = MIN(a, b); + resultPtr->type = TCL_DOUBLE; + } + return TCL_OK; +} + +/*ARGSUSED*/ +static int +MaxMathProc( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Not used. */ + Tcl_Value *argsPtr, + Tcl_Value *resultPtr) +{ + Tcl_Value *op1Ptr, *op2Ptr; + + op1Ptr = argsPtr, op2Ptr = argsPtr + 1; + if ((op1Ptr->type == TCL_INT) && (op2Ptr->type == TCL_INT)) { + resultPtr->intValue = MAX(op1Ptr->intValue, op2Ptr->intValue); + resultPtr->type = TCL_INT; + } else { + double a, b; + + a = (op1Ptr->type == TCL_INT) + ? (double)op1Ptr->intValue : op1Ptr->doubleValue; + b = (op2Ptr->type == TCL_INT) + ? (double)op2Ptr->intValue : op2Ptr->doubleValue; + resultPtr->doubleValue = MAX(a, b); + resultPtr->type = TCL_DOUBLE; + } + return TCL_OK; +} + +static int +SetLibraryPath(Tcl_Interp *interp) +{ + Tcl_DString dString; + const char *value; + + Tcl_DStringInit(&dString); + Tcl_DStringAppend(&dString, libPath, -1); +#ifdef WIN32 + { + HKEY key; + DWORD result; +# ifndef BLT_REGISTRY_KEY +# define BLT_REGISTRY_KEY "Software\\BLT\\" BLT_VERSION "\\" TCL_VERSION +# endif + result = RegOpenKeyEx( + HKEY_LOCAL_MACHINE, /* Parent key. */ + BLT_REGISTRY_KEY, /* Path to sub-key. */ + 0, /* Reserved. */ + KEY_READ, /* Security access mask. */ + &key); /* Resulting key.*/ + + if (result == ERROR_SUCCESS) { + DWORD size; + + /* Query once to get the size of the string needed */ + result = RegQueryValueEx(key, "BLT_LIBRARY", NULL, NULL, NULL, + &size); + if (result == ERROR_SUCCESS) { + Tcl_DStringSetLength(&dString, size); + /* And again to collect the string. */ + RegQueryValueEx(key, "BLT_LIBRARY", NULL, NULL, + (LPBYTE)Tcl_DStringValue(&dString), &size); + RegCloseKey(key); + } + } + } +#endif /* WIN32 */ + value = Tcl_SetVar(interp, "blt_libPath", Tcl_DStringValue(&dString), + TCL_GLOBAL_ONLY | TCL_LEAVE_ERR_MSG); + Tcl_DStringFree(&dString); + if (value == NULL) { + return TCL_ERROR; + } + return TCL_OK; +} + + +/*LINTLIBRARY*/ +int +Blt_core_Init(Tcl_Interp *interp) /* Interpreter to add extra commands */ +{ + Tcl_AppInitProc **p; + Tcl_Namespace *nsPtr; + Tcl_ValueType args[2]; + const char *result; + const int isExact = 1; + +#ifdef USE_TCL_STUBS + if (Tcl_InitStubs(interp, TCL_VERSION_LOADED, isExact) == NULL) { + return TCL_ERROR; + }; +#endif + Blt_AllocInit(NULL, NULL, NULL); + + /* + * Check that the versions of TCL that have been loaded are the same ones + * that BLT was compiled against. + */ + if (Tcl_PkgRequire(interp, "Tcl", TCL_VERSION_LOADED, isExact) == NULL) { + return TCL_ERROR; + } + + /* Set the "blt_version", "blt_patchLevel", and "blt_libPath" Tcl + * variables. We'll use them in the following script. */ + + result = Tcl_SetVar(interp, "blt_version", BLT_VERSION, TCL_GLOBAL_ONLY); + if (result == NULL) { + return TCL_ERROR; + } + result = Tcl_SetVar(interp, "blt_patchLevel", BLT_PATCH_LEVEL, + TCL_GLOBAL_ONLY); + if (result == NULL) { + return TCL_ERROR; + } + if (SetLibraryPath(interp) != TCL_OK) { + return TCL_ERROR; + } + if (Tcl_Eval(interp, initScript) != TCL_OK) { + return TCL_ERROR; + } + + + nsPtr = Tcl_FindNamespace(interp, "::blt", (Tcl_Namespace *)NULL, 0); + if (nsPtr == NULL) { + nsPtr = Tcl_CreateNamespace(interp, "::blt", NULL, NULL); + if (nsPtr == NULL) { + return TCL_ERROR; + } + } + /* Initialize the BLT commands that only require Tcl. */ + for (p = cmdProcs; *p != NULL; p++) { + if ((**p) (interp) != TCL_OK) { + Tcl_DeleteNamespace(nsPtr); + return TCL_ERROR; + } + } + args[0] = args[1] = TCL_EITHER; + Tcl_CreateMathFunc(interp, "min", 2, args, MinMathProc, (ClientData)0); + Tcl_CreateMathFunc(interp, "max", 2, args, MaxMathProc, (ClientData)0); + Blt_RegisterArrayObj(); + bltNaN = MakeNaN(); + if (Tcl_PkgProvide(interp, "blt_core", BLT_VERSION) != TCL_OK) { + return TCL_ERROR; + } + return TCL_OK; +} + +/*LINTLIBRARY*/ +int +Blt_core_SafeInit(Tcl_Interp *interp) /* Interpreter to add extra commands */ +{ + return Blt_core_Init(interp); +} + +#ifdef USE_DLL +# include "bltWinDll.c" +#endif diff --git a/src/bltNsUtil.C b/src/bltNsUtil.C new file mode 100644 index 0000000..62f727d --- /dev/null +++ b/src/bltNsUtil.C @@ -0,0 +1,174 @@ + +/* + * bltNsUtil.c -- + * + * This module implements utility namespace procedures for the BLT toolkit. + * + * Copyright 1997-2008 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltInt.h" +#include "bltNsUtil.h" + +/* + * A Command structure exists for each command in a namespace. The Tcl_Command + * opaque type actually refers to these structures. + */ + +typedef struct CompileProc CompileProc; +typedef struct ImportRef ImportRef; +typedef struct CommandTrace CommandTrace; + +typedef struct { + Tcl_HashEntry *hPtr; /* Pointer to the hash table entry that refers + * to this command. The hash table is either a + * namespace's command table or an + * interpreter's hidden command table. This + * pointer is used to get a command's name + * from its Tcl_Command handle. NULL means + * that the hash table entry has been removed + * already (this can happen if deleteProc + * causes the command to be deleted or + * recreated). */ + Tcl_Namespace *nsPtr; /* Points to the namespace containing this + * command. */ + int refCount; /* 1 if in command hashtable plus 1 for each + * reference from a CmdName TCL object + * representing a command's name in a ByteCode + * instruction sequence. This structure can be + * freed when refCount becomes zero. */ + int cmdEpoch; /* Incremented to invalidate any references + * that point to this command when it is + * renamed, deleted, hidden, or exposed. */ + CompileProc *compileProc; /* Procedure called to compile command. NULL + * if no compile proc exists for command. */ + Tcl_ObjCmdProc *objProc; /* Object-based command procedure. */ + ClientData objClientData; /* Arbitrary value passed to object proc. */ + Tcl_CmdProc *proc; /* String-based command procedure. */ + ClientData clientData; /* Arbitrary value passed to string proc. */ + Tcl_CmdDeleteProc *deleteProc; + /* Procedure invoked when deleting command + * to, e.g., free all client data. */ + ClientData deleteData; /* Arbitrary value passed to deleteProc. */ + int flags; /* Means that the command is in the process of + * being deleted (its deleteProc is currently + * executing). Other attempts to delete the + * command should be ignored. */ + ImportRef *importRefPtr; /* List of each imported Command created in + * another namespace when this command is + * imported. These imported commands redirect + * invocations back to this command. The list + * is used to remove all those imported + * commands when deleting this "real" + * command. */ + CommandTrace *tracePtr; /* First in list of all traces set for this + * command. */ +} Command; + +/*ARGSUSED*/ +Tcl_Namespace * +Blt_GetCommandNamespace(Tcl_Command cmdToken) +{ + Command *cmdPtr = (Command *)cmdToken; + + return (Tcl_Namespace *)cmdPtr->nsPtr; +} + +Tcl_CallFrame * +Blt_EnterNamespace(Tcl_Interp *interp, Tcl_Namespace *nsPtr) +{ + Tcl_CallFrame *framePtr; + + framePtr = Blt_AssertMalloc(sizeof(Tcl_CallFrame)); + if (Tcl_PushCallFrame(interp, framePtr, (Tcl_Namespace *)nsPtr, 0) + != TCL_OK) { + Blt_Free(framePtr); + return NULL; + } + return framePtr; +} + +void +Blt_LeaveNamespace(Tcl_Interp *interp, Tcl_CallFrame *framePtr) +{ + Tcl_PopCallFrame(interp); + Blt_Free(framePtr); +} + +int +Blt_ParseObjectName(Tcl_Interp *interp, const char *path, + Blt_ObjectName *namePtr, unsigned int flags) +{ + char *last, *colon; + + namePtr->nsPtr = NULL; + namePtr->name = NULL; + colon = NULL; + + /* Find the last namespace separator in the qualified name. */ + last = (char *)(path + strlen(path)); + while (--last > path) { + if ((*last == ':') && (*(last - 1) == ':')) { + last++; /* just after the last "::" */ + colon = last - 2; + break; + } + } + if (colon == NULL) { + namePtr->name = path; + if ((flags & BLT_NO_DEFAULT_NS) == 0) { + namePtr->nsPtr = Tcl_GetCurrentNamespace(interp); + } + return TRUE; /* No namespace designated in name. */ + } + + /* Separate the namespace and the object name. */ + *colon = '\0'; + if (path[0] == '\0') { + namePtr->nsPtr = Tcl_GetGlobalNamespace(interp); + } else { + namePtr->nsPtr = Tcl_FindNamespace(interp, (char *)path, NULL, + (flags & BLT_NO_ERROR_MSG) ? 0 : TCL_LEAVE_ERR_MSG); + } + /* Repair the string. */ *colon = ':'; + + if (namePtr->nsPtr == NULL) { + return FALSE; /* Namespace doesn't exist. */ + } + namePtr->name =last; + return TRUE; +} + +char * +Blt_MakeQualifiedName(Blt_ObjectName *namePtr, Tcl_DString *resultPtr) +{ + Tcl_DStringInit(resultPtr); + if ((namePtr->nsPtr->fullName[0] != ':') || + (namePtr->nsPtr->fullName[1] != ':') || + (namePtr->nsPtr->fullName[2] != '\0')) { + Tcl_DStringAppend(resultPtr, namePtr->nsPtr->fullName, -1); + } + Tcl_DStringAppend(resultPtr, "::", -1); + Tcl_DStringAppend(resultPtr, (char *)namePtr->name, -1); + return Tcl_DStringValue(resultPtr); +} + diff --git a/src/bltNsUtil.h b/src/bltNsUtil.h new file mode 100644 index 0000000..00769f3 --- /dev/null +++ b/src/bltNsUtil.h @@ -0,0 +1,101 @@ +/* + * bltNsUtil.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef BLT_NS_UTIL_H +#define BLT_NS_UTIL_H 1 + +#ifndef TCL_NAMESPACE_ONLY +#define TCL_NAMESPACE_ONLY TCL_GLOBAL_ONLY +#endif + +#define NS_SEARCH_NONE (0) +#define NS_SEARCH_CURRENT (1<<0) +#define NS_SEARCH_GLOBAL (1<<1) +#define NS_SEARCH_BOTH (NS_SEARCH_GLOBAL | NS_SEARCH_CURRENT) + +typedef struct { + const char *name; + Tcl_Namespace *nsPtr; +} Blt_ObjectName; + +#define BLT_NO_DEFAULT_NS (1<<0) +#define BLT_NO_ERROR_MSG (1<<1) + +#ifndef USE_TCL_STUBS + +BLT_EXTERN Tcl_Command Tcl_FindCommand(Tcl_Interp *interp, const char *name, + Tcl_Namespace *nsPtr, int flags); +/* + * Namespace procedures not prototyped defined in Tcl.h + */ +BLT_EXTERN Tcl_Namespace *Tcl_GetCurrentNamespace(Tcl_Interp *interp); + +BLT_EXTERN Tcl_Namespace *Tcl_GetGlobalNamespace(Tcl_Interp *interp); + +BLT_EXTERN Tcl_Namespace *Tcl_CreateNamespace(Tcl_Interp *interp, + const char *name, ClientData clientData, + Tcl_NamespaceDeleteProc *nsDelProc); + +BLT_EXTERN void Tcl_DeleteNamespace(Tcl_Namespace *nsPtr); + +BLT_EXTERN Tcl_Namespace *Tcl_FindNamespace(Tcl_Interp *interp, + const char *name, Tcl_Namespace *context, int flags); + +BLT_EXTERN int Tcl_Export(Tcl_Interp *interp, Tcl_Namespace *nsPtr, + const char *name, int resetFlag); + +BLT_EXTERN Tcl_Var Tcl_FindNamespaceVar(Tcl_Interp *interp, const char *name, + Tcl_Namespace *contextNsPtr, int flags); + +BLT_EXTERN void Tcl_PopCallFrame(Tcl_Interp *interp); + +BLT_EXTERN int Tcl_PushCallFrame(Tcl_Interp *interp, Tcl_CallFrame *framePtr, + Tcl_Namespace *nsPtr, int isProcCallFrame); + +#endif /* USE_TCL_STUBS */ + +/* + * Auxillary procedures + */ +BLT_EXTERN Tcl_Namespace *Blt_GetVariableNamespace(Tcl_Interp *interp, + const char *varName); + +BLT_EXTERN Tcl_Namespace *Blt_GetCommandNamespace(Tcl_Command cmdToken); + +BLT_EXTERN Tcl_CallFrame *Blt_EnterNamespace(Tcl_Interp *interp, + Tcl_Namespace *nsPtr); + +BLT_EXTERN void Blt_LeaveNamespace(Tcl_Interp *interp, Tcl_CallFrame *framePtr); + +BLT_EXTERN int Blt_ParseObjectName(Tcl_Interp *interp, const char *name, + Blt_ObjectName *objNamePtr, unsigned int flags); + +BLT_EXTERN char *Blt_MakeQualifiedName(Blt_ObjectName *objNamePtr, + Tcl_DString *resultPtr); + +#endif /* BLT_NS_UTIL_H */ diff --git a/src/bltOp.h b/src/bltOp.h new file mode 100644 index 0000000..5887a46 --- /dev/null +++ b/src/bltOp.h @@ -0,0 +1,37 @@ + +/* + *--------------------------------------------------------------------------- + * + * Blt_OpSpec -- + * + * Structure to specify a set of operations for a TCL command. + * This is passed to the Blt_GetOp procedure to look + * for a function pointer associated with the operation name. + * + *--------------------------------------------------------------------------- + */ +typedef struct { + const char *name; /* Name of operation */ + int minChars; /* Minimum # characters to disambiguate */ + void *proc; + int minArgs; /* Minimum # args required */ + int maxArgs; /* Maximum # args required */ + const char *usage; /* Usage message */ +} Blt_OpSpec; + +typedef enum { + BLT_OP_ARG0, /* Op is the first argument. */ + BLT_OP_ARG1, /* Op is the second argument. */ + BLT_OP_ARG2, /* Op is the third argument. */ + BLT_OP_ARG3, /* Op is the fourth argument. */ + BLT_OP_ARG4 /* Op is the fifth argument. */ + +} Blt_OpIndex; + +#define BLT_OP_BINARY_SEARCH 0 +#define BLT_OP_LINEAR_SEARCH 1 + +BLT_EXTERN void *Blt_GetOpFromObj(Tcl_Interp *interp, int nSpecs, + Blt_OpSpec *specs, int operPos, int objc, Tcl_Obj *const *objv, + int flags); + diff --git a/src/bltParse.C b/src/bltParse.C new file mode 100644 index 0000000..10703f3 --- /dev/null +++ b/src/bltParse.C @@ -0,0 +1,546 @@ + +/* + * bltParse.c -- + * + * Contains a collection of procedures that are used to parse Tcl + * commands or parts of commands (like quoted strings or nested + * sub-commands). + * + * This file is copied from tclParse.c in the TCL library distribution. + * + * Copyright (c) 1987-1993 The Regents of the University of + * California. + * + * Copyright (c) 1994-1998 Sun Microsystems, Inc. + * + */ + +/* + * Since TCL 8.1.0 these routines have been replaced by ones that + * generate byte-codes. But since these routines are used in vector + * expressions, where no such byte-compilation is necessary, I now + * include them. In fact, the byte-compiled versions would be slower + * since the compiled code typically runs only one time. + */ +#include <bltInt.h> + +#include "bltParse.h" + +/* + * A table used to classify input characters to assist in parsing + * TCL commands. The table should be indexed with a signed character + * using the CHAR_TYPE macro. The character may have a negative + * value. The CHAR_TYPE macro takes a pointer to a signed character + * and a pointer to the last character in the source string. If the + * src pointer is pointing at the terminating null of the string, + * CHAR_TYPE returns TCL_COMMAND_END. + */ + +#define STATIC_STRING_SPACE 150 +#define UCHAR(c) ((unsigned char) (c)) +#define TCL_NORMAL 0x01 +#define TCL_SPACE 0x02 +#define TCL_COMMAND_END 0x04 +#define TCL_QUOTE 0x08 +#define TCL_OPEN_BRACKET 0x10 +#define TCL_OPEN_BRACE 0x20 +#define TCL_CLOSE_BRACE 0x40 +#define TCL_BACKSLASH 0x80 +#define TCL_DOLLAR 0x00 + +/* + * The following table assigns a type to each character. Only types + * meaningful to TCL parsing are represented here. The table is + * designed to be referenced with either signed or unsigned characters, + * so it has 384 entries. The first 128 entries correspond to negative + * character values, the next 256 correspond to positive character + * values. The last 128 entries are identical to the first 128. The + * table is always indexed with a 128-byte offset (the 128th entry + * corresponds to a 0 character value). + */ + +static unsigned char tclTypeTable[] = +{ + /* + * Negative character values, from -128 to -1: + */ + + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + + /* + * Positive character values, from 0-127: + */ + + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_SPACE, TCL_COMMAND_END, TCL_SPACE, + TCL_SPACE, TCL_SPACE, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_SPACE, TCL_NORMAL, TCL_QUOTE, TCL_NORMAL, + TCL_DOLLAR, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_COMMAND_END, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_OPEN_BRACKET, + TCL_BACKSLASH, TCL_COMMAND_END, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_OPEN_BRACE, + TCL_NORMAL, TCL_CLOSE_BRACE, TCL_NORMAL, TCL_NORMAL, + + /* + * Large unsigned character values, from 128-255: + */ + + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, + TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, TCL_NORMAL, +}; + +#define CHAR_TYPE(src,last) \ + (((src)==(last))?TCL_COMMAND_END:(tclTypeTable+128)[(int)*(src)]) + +/* + *--------------------------------------------------------------------------- + * + * Blt_ParseNestedCmd -- + * + * This procedure parses a nested TCL command between + * brackets, returning the result of the command. + * + * Results: + * The return value is a standard TCL result, which is + * TCL_OK unless there was an error while executing the + * nested command. If an error occurs then interp->result + * contains a standard error message. *TermPtr is filled + * in with the address of the character just after the + * last one processed; this is usually the character just + * after the matching close-bracket, or the null character + * at the end of the string if the close-bracket was missing + * (a missing close bracket is an error). The result returned + * by the command is stored in standard fashion in *parsePtr, + * null-terminated, with parsePtr->next pointing to the null + * character. + * + * Side effects: + * The storage space at *parsePtr may be expanded. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ParseNestedCmd( + Tcl_Interp *interp, /* Interpreter to use for nested command + * evaluations and error messages. */ + const char *string, /* Character just after opening bracket. */ + int flags, /* Flags to pass to nested Tcl_Eval. */ + const char **termPtr, /* Store address of terminating character + * here. */ + ParseValue *parsePtr) /* Information about where to place + * result of command. */ +{ + int result, length, shortfall; + Interp *iPtr = (Interp *)interp; + + iPtr->evalFlags = flags | TCL_BRACKET_TERM; + result = Tcl_Eval(interp, string); + *termPtr = (string + iPtr->termOffset); + if (result != TCL_OK) { + /* + * The increment below results in slightly cleaner message in + * the errorInfo variable (the close-bracket will appear). + */ + + if (**termPtr == ']') { + *termPtr += 1; + } + return result; + } + (*termPtr) += 1; + length = (int)strlen(iPtr->result); + shortfall = length + 1 - (parsePtr->end - parsePtr->next); + if (shortfall > 0) { + (*parsePtr->expandProc) (parsePtr, shortfall); + } + strcpy(parsePtr->next, iPtr->result); + parsePtr->next += length; + + Tcl_FreeResult(interp); + iPtr->result = iPtr->resultSpace; + iPtr->resultSpace[0] = '\0'; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ParseBraces -- + * + * This procedure scans the information between matching + * curly braces. + * + * Results: + * The return value is a standard TCL result, which is + * TCL_OK unless there was an error while parsing string. + * If an error occurs then interp->result contains a + * standard error message. *TermPtr is filled + * in with the address of the character just after the + * last one successfully processed; this is usually the + * character just after the matching close-brace. The + * information between curly braces is stored in standard + * fashion in *parsePtr, null-terminated with parsePtr->next + * pointing to the terminating null character. + * + * Side effects: + * The storage space at *parsePtr may be expanded. + * + *--------------------------------------------------------------------------- + */ + +int +Blt_ParseBraces( + Tcl_Interp *interp, /* Interpreter to use for nested command + * evaluations and error messages. */ + const char *string, /* Character just after opening bracket. */ + const char **termPtr, /* Store address of terminating character + * here. */ + ParseValue *parsePtr) /* Information about where to place + * result of command. */ +{ + int level; + const char *src; + char *dest, *end; + char c; + const char *lastChar = string + strlen(string); + + src = string; + dest = parsePtr->next; + end = parsePtr->end; + level = 1; + + /* + * Copy the characters one at a time to the result area, stopping + * when the matching close-brace is found. + */ + + for (;;) { + c = *src; + src++; + + if (dest == end) { + parsePtr->next = dest; + (*parsePtr->expandProc) (parsePtr, 20); + dest = parsePtr->next; + end = parsePtr->end; + } + *dest = c; + dest++; + + if (CHAR_TYPE(src - 1, lastChar) == TCL_NORMAL) { + continue; + } else if (c == '{') { + level++; + } else if (c == '}') { + level--; + if (level == 0) { + dest--; /* Don't copy the last close brace. */ + break; + } + } else if (c == '\\') { + int count; + + /* + * Must always squish out backslash-newlines, even when in + * braces. This is needed so that this sequence can appear + * anywhere in a command, such as the middle of an expression. + */ + + if (*src == '\n') { + dest[-1] = Tcl_Backslash(src - 1, &count); + src += count - 1; + } else { + Tcl_Backslash(src - 1, &count); + while (count > 1) { + if (dest == end) { + parsePtr->next = dest; + (*parsePtr->expandProc) (parsePtr, 20); + dest = parsePtr->next; + end = parsePtr->end; + } + *dest = *src; + dest++; + src++; + count--; + } + } + } else if (c == '\0') { + Tcl_AppendResult(interp, "missing close-brace", (char *)NULL); + *termPtr = string - 1; + return TCL_ERROR; + } + } + + *dest = '\0'; + parsePtr->next = dest; + *termPtr = src; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ExpandParseValue -- + * + * This procedure is commonly used as the value of the + * expandProc in a ParseValue. It uses malloc to allocate + * more space for the result of a parse. + * + * Results: + * The buffer space in *parsePtr is reallocated to something + * larger, and if parsePtr->clientData is non-zero the old + * buffer is freed. Information is copied from the old + * buffer to the new one. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +void +Blt_ExpandParseValue( + ParseValue *parsePtr, /* Information about buffer that + * must be expanded. If the clientData + * in the structure is non-zero, it + * means that the current buffer is + * dynamically allocated. */ + int needed) /* Minimum amount of additional space + * to allocate. */ +{ + int size; + char *buffer; + + /* + * Either double the size of the buffer or add enough new space + * to meet the demand, whichever produces a larger new buffer. + */ + size = (parsePtr->end - parsePtr->buffer) + 1; + if (size < needed) { + size += needed; + } else { + size += size; + } + buffer = Blt_AssertMalloc((unsigned int)size); + + /* + * Copy from old buffer to new, free old buffer if needed, and + * mark new buffer as malloc-ed. + */ + memcpy((VOID *) buffer, (VOID *) parsePtr->buffer, + (size_t) (parsePtr->next - parsePtr->buffer)); + parsePtr->next = buffer + (parsePtr->next - parsePtr->buffer); + if (parsePtr->clientData != 0) { + Blt_Free(parsePtr->buffer); + } + parsePtr->buffer = buffer; + parsePtr->end = buffer + size - 1; + parsePtr->clientData = (ClientData)1; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ParseQuotes -- + * + * This procedure parses a double-quoted string such as a + * quoted TCL command argument or a quoted value in a Tcl + * expression. This procedure is also used to parse array + * element names within parentheses, or anything else that + * needs all the substitutions that happen in quotes. + * + * Results: + * The return value is a standard TCL result, which is + * TCL_OK unless there was an error while parsing the + * quoted string. If an error occurs then interp->result + * contains a standard error message. *TermPtr is filled + * in with the address of the character just after the + * last one successfully processed; this is usually the + * character just after the matching close-quote. The + * fully-substituted contents of the quotes are stored in + * standard fashion in *parsePtr, null-terminated with + * parsePtr->next pointing to the terminating null character. + * + * Side effects: + * The buffer space in parsePtr may be enlarged by calling its + * expandProc. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ParseQuotes( + Tcl_Interp *interp, /* Interpreter to use for nested command + * evaluations and error messages. */ + const char *string, /* Character just after opening double- + * quote. */ + int termChar, /* Character that terminates "quoted" string + * (usually double-quote, but sometimes + * right-paren or something else). */ + int flags, /* Flags to pass to nested Tcl_Eval calls. */ + const char **termPtr, /* Store address of terminating character + * here. */ + ParseValue *parsePtr) /* Information about where to place + * fully-substituted result of parse. */ +{ + const char *src; + char *dest, c; + const char *lastChar = string + strlen(string); + + src = string; + dest = parsePtr->next; + + for (;;) { + if (dest == parsePtr->end) { + /* + * Target buffer space is about to run out. Make more space. + */ + parsePtr->next = dest; + (*parsePtr->expandProc) (parsePtr, 1); + dest = parsePtr->next; + } + c = *src; + src++; + if (c == termChar) { + *dest = '\0'; + parsePtr->next = dest; + *termPtr = src; + return TCL_OK; + } else if (CHAR_TYPE(src - 1, lastChar) == TCL_NORMAL) { + copy: + *dest = c; + dest++; + continue; + } else if (c == '$') { + int length; + const char *value; + + value = Tcl_ParseVar(interp, src - 1, termPtr); + if (value == NULL) { + return TCL_ERROR; + } + src = *termPtr; + length = strlen(value); + if ((parsePtr->end - dest) <= length) { + parsePtr->next = dest; + (*parsePtr->expandProc) (parsePtr, length); + dest = parsePtr->next; + } + strcpy(dest, value); + dest += length; + continue; + } else if (c == '[') { + int result; + + parsePtr->next = dest; + result = Blt_ParseNestedCmd(interp, src, flags, termPtr, parsePtr); + if (result != TCL_OK) { + return result; + } + src = *termPtr; + dest = parsePtr->next; + continue; + } else if (c == '\\') { + int nRead; + + src--; + *dest = Tcl_Backslash(src, &nRead); + dest++; + src += nRead; + continue; + } else if (c == '\0') { + char buf[10]; + + Tcl_ResetResult(interp); + sprintf_s(buf, 10, "missing %c", termChar); + Tcl_SetStringObj(Tcl_GetObjResult(interp), buf, 9); + *termPtr = string - 1; + return TCL_ERROR; + } else { + goto copy; + } + } +} + diff --git a/src/bltParse.h b/src/bltParse.h new file mode 100644 index 0000000..3ff26cb --- /dev/null +++ b/src/bltParse.h @@ -0,0 +1,43 @@ + +/* + * bltParse.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_PARSE_H +#define _BLT_PARSE_H + +#include "tclInterp.h" + +BLT_EXTERN int Blt_ParseBraces(Tcl_Interp *interp, const char *string, + const char **termPtr, ParseValue *pvPtr); + +BLT_EXTERN int Blt_ParseNestedCmd(Tcl_Interp *interp, const char *string, + int flags, const char **termPtr, ParseValue *pvPtr); + +BLT_EXTERN int Blt_ParseQuotes(Tcl_Interp *interp, const char *string, + int termChar, int flags, const char **termPtr, ParseValue * pvPtr); + +BLT_EXTERN void Blt_ExpandParseValue(ParseValue *pvPtr, int needed); + +#endif diff --git a/src/bltSwitch.C b/src/bltSwitch.C new file mode 100644 index 0000000..35228d1 --- /dev/null +++ b/src/bltSwitch.C @@ -0,0 +1,554 @@ + +/* + * bltSwitch.c -- + * + * This module implements command/argument switch parsing procedures for the + * BLT toolkit. + * + * Copyright 1991-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltInt.h" +#include <stdarg.h> + +#include "bltSwitch.h" + +static void +DoHelp(Tcl_Interp *interp, Blt_SwitchSpec *specs) +{ + Tcl_DString ds; + Blt_SwitchSpec *sp; + + Tcl_DStringInit(&ds); + Tcl_DStringAppend(&ds, "following switches are available:", -1); + for (sp = specs; sp->type != BLT_SWITCH_END; sp++) { + Tcl_DStringAppend(&ds, "\n ", 4); + Tcl_DStringAppend(&ds, sp->switchName, -1); + Tcl_DStringAppend(&ds, " ", 1); + Tcl_DStringAppend(&ds, sp->help, -1); + } + Tcl_AppendResult(interp, Tcl_DStringValue(&ds), (char *)NULL); + Tcl_DStringFree(&ds); +} + +/* + *--------------------------------------------------------------------------- + * + * FindSwitchSpec -- + * + * Search through a table of configuration specs, looking for one that + * matches a given argvName. + * + * Results: + * The return value is a pointer to the matching entry, or NULL if + * nothing matched. In that case an error message is left in the + * interp's result. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static Blt_SwitchSpec * +FindSwitchSpec( + Tcl_Interp *interp, /* Used for reporting errors. */ + Blt_SwitchSpec *specs, /* Pointer to table of configuration + * specifications for a widget. */ + const char *name, /* Name identifying a particular switch. */ + int length, /* Length of name. */ + int needFlags, /* Flags that must be present in matching + * entry. */ + int hateFlags) /* Flags that must NOT be present in matching + * entry. */ +{ + Blt_SwitchSpec *sp; + char c; /* First character of current argument. */ + Blt_SwitchSpec *matchPtr; /* Matching spec, or NULL. */ + + c = name[1]; + matchPtr = NULL; + for (sp = specs; sp->type != BLT_SWITCH_END; sp++) { + if (sp->switchName == NULL) { + continue; + } + if (((sp->flags & needFlags) != needFlags) || (sp->flags & hateFlags)) { + continue; + } + if ((sp->switchName[1] != c) || + (strncmp(sp->switchName, name, length) != 0)) { + continue; + } + if (sp->switchName[length] == '\0') { + return sp; /* Stop on a perfect match. */ + } + if (matchPtr != NULL) { + Tcl_AppendResult(interp, "ambiguous switch \"", name, "\"\n", + (char *) NULL); + DoHelp(interp, specs); + return NULL; + } + matchPtr = sp; + } + if (strcmp(name, "-help") == 0) { + DoHelp(interp, specs); + return NULL; + } + if (matchPtr == NULL) { + Tcl_AppendResult(interp, "unknown switch \"", name, "\"\n", + (char *)NULL); + DoHelp(interp, specs); + return NULL; + } + return matchPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * DoSwitch -- + * + * This procedure applies a single configuration switch to a widget + * record. + * + * Results: + * A standard TCL return value. + * + * Side effects: + * WidgRec is modified as indicated by specPtr and value. The old value + * is recycled, if that is appropriate for the value type. + * + *--------------------------------------------------------------------------- + */ +static int +DoSwitch( + Tcl_Interp *interp, /* Interpreter for error reporting. */ + Blt_SwitchSpec *sp, /* Specifier to apply. */ + Tcl_Obj *objPtr, /* Value to use to fill in widgRec. */ + void *record) /* Record whose fields are to be modified. + * Values must be properly initialized. */ +{ + do { + char *ptr; + + ptr = (char *)record + sp->offset; + switch (sp->type) { + case BLT_SWITCH_BOOLEAN: + { + int bool; + + if (Tcl_GetBooleanFromObj(interp, objPtr, &bool) != TCL_OK) { + return TCL_ERROR; + } + if (sp->mask > 0) { + if (bool) { + *((int *)ptr) |= sp->mask; + } else { + *((int *)ptr) &= ~sp->mask; + } + } else { + *((int *)ptr) = bool; + } + } + break; + + case BLT_SWITCH_DOUBLE: + if (Tcl_GetDoubleFromObj(interp, objPtr, (double *)ptr) != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_SWITCH_OBJ: + Tcl_IncrRefCount(objPtr); + *(Tcl_Obj **)ptr = objPtr; + break; + + case BLT_SWITCH_FLOAT: + { + double value; + + if (Tcl_GetDoubleFromObj(interp, objPtr, &value) != TCL_OK) { + return TCL_ERROR; + } + *(float *)ptr = (float)value; + } + break; + + case BLT_SWITCH_INT: + if (Tcl_GetIntFromObj(interp, objPtr, (int *)ptr) != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_SWITCH_INT_NNEG: + { + long value; + + if (Blt_GetCountFromObj(interp, objPtr, COUNT_NNEG, + &value) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = (int)value; + } + break; + + case BLT_SWITCH_INT_POS: + { + long value; + + if (Blt_GetCountFromObj(interp, objPtr, COUNT_POS, + &value) != TCL_OK) { + return TCL_ERROR; + } + *(int *)ptr = (int)value; + } + break; + + case BLT_SWITCH_LIST: + { + int argc; + + if (Tcl_SplitList(interp, Tcl_GetString(objPtr), &argc, + (const char ***)ptr) != TCL_OK) { + return TCL_ERROR; + } + } + break; + + case BLT_SWITCH_LONG: + if (Tcl_GetLongFromObj(interp, objPtr, (long *)ptr) != TCL_OK) { + return TCL_ERROR; + } + break; + + case BLT_SWITCH_LONG_NNEG: + { + long value; + + if (Blt_GetCountFromObj(interp, objPtr, COUNT_NNEG, + &value) != TCL_OK) { + return TCL_ERROR; + } + *(long *)ptr = value; + } + break; + + case BLT_SWITCH_LONG_POS: + { + long value; + + if (Blt_GetCountFromObj(interp, objPtr, COUNT_POS, &value) + != TCL_OK) { + return TCL_ERROR; + } + *(long *)ptr = value; + } + break; + + case BLT_SWITCH_STRING: + { + char *value; + + value = Tcl_GetString(objPtr); + value = (*value == '\0') ? NULL : Blt_AssertStrdup(value); + if (*(char **)ptr != NULL) { + Blt_Free(*(char **)ptr); + } + *(char **)ptr = value; + } +#ifdef notdef + { + char *old, *new, **strPtr; + char *string; + + string = Tcl_GetString(objPtr); + strPtr = (char **)ptr; + new = ((*string == '\0') && (sp->flags & BLT_SWITCH_NULL_OK)) + ? NULL : Blt_AssertStrdup(string); + old = *strPtr; + if (old != NULL) { + Blt_Free(old); + } + *strPtr = new; + } +#endif + break; + + case BLT_SWITCH_CUSTOM: + assert(sp->customPtr != NULL); + if ((*sp->customPtr->parseProc)(sp->customPtr->clientData, interp, + sp->switchName, objPtr, (char *)record, sp->offset, sp->flags) + != TCL_OK) { + return TCL_ERROR; + } + break; + + default: + Tcl_AppendResult(interp, "bad switch table: unknown type \"", + Blt_Itoa(sp->type), "\"", (char *)NULL); + return TCL_ERROR; + } + sp++; + } while ((sp->switchName == NULL) && (sp->type != BLT_SWITCH_END)); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ParseSwitches -- + * + * Process command-line switches to fill in fields of a record with + * resources and other parameters. + * + * Results: + * Returns the number of arguments comsumed by parsing the command line. + * If an error occurred, -1 will be returned and an error messages can be + * found as the interpreter result. + * + * Side effects: + * The fields of widgRec get filled in with information from argc/argv. + * Old information in widgRec's fields gets recycled. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ParseSwitches( + Tcl_Interp *interp, /* Interpreter for error reporting. */ + Blt_SwitchSpec *specs, /* Describes legal switches. */ + int objc, /* Number of elements in argv. */ + Tcl_Obj *const *objv, /* Command-line switches. */ + void *record, /* Record whose fields are to be modified. + * Values must be properly initialized. */ + int flags) /* Used to specify additional flags that must + * be present in switch specs for them to be + * considered. */ +{ + Blt_SwitchSpec *sp; + int count; + int needFlags; /* Specs must contain this set of flags or + * else they are not considered. */ + int hateFlags; /* If a spec contains any bits here, it's not + * considered. */ + + needFlags = flags & ~(BLT_SWITCH_USER_BIT - 1); + hateFlags = 0; + + /* + * Pass 1: Clear the change flags on all the specs so that we + * can check it later. + */ + for (sp = specs; sp->type != BLT_SWITCH_END; sp++) { + sp->flags &= ~BLT_SWITCH_SPECIFIED; + } + /* + * Pass 2: Process the arguments that match entries in the specs. + * It's an error if the argument doesn't match anything. + */ + for (count = 0; count < objc; count++) { + char *arg; + int length; + + arg = Tcl_GetStringFromObj(objv[count], &length); + if (flags & BLT_SWITCH_OBJV_PARTIAL) { + /* + * If the argument doesn't start with a '-' (not a switch) or is + * '--', stop processing and return the number of arguments + * comsumed. + */ + if (arg[0] != '-') { + return count; + } + if ((arg[1] == '-') && (arg[2] == '\0')) { + return count + 1; /* include the "--" in the count. */ + } + } + sp = FindSwitchSpec(interp, specs, arg, length, needFlags, hateFlags); + if (sp == NULL) { + return -1; + } + if (sp->type == BLT_SWITCH_BITMASK) { + char *ptr; + + ptr = (char *)record + sp->offset; + *((int *)ptr) |= sp->mask; + } else if (sp->type == BLT_SWITCH_BITMASK_INVERT) { + char *ptr; + + ptr = (char *)record + sp->offset; + *((int *)ptr) &= ~sp->mask; + } else if (sp->type == BLT_SWITCH_VALUE) { + char *ptr; + + ptr = (char *)record + sp->offset; + *((int *)ptr) = sp->mask; + } else { + count++; + if (count == objc) { + Tcl_AppendResult(interp, "value for \"", arg, "\" missing", + (char *) NULL); + return -1; + } + if (DoSwitch(interp, sp, objv[count], record) != TCL_OK) { + char msg[200]; + + sprintf_s(msg, 200, "\n (processing \"%.40s\" switch)", + sp->switchName); + Tcl_AddErrorInfo(interp, msg); + return -1; + } + } + sp->flags |= BLT_SWITCH_SPECIFIED; + } + return count; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_FreeSwitches -- + * + * Free up all resources associated with switches. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +void +Blt_FreeSwitches( + Blt_SwitchSpec *specs, /* Describes legal switches. */ + void *record, /* Record whose fields contain current values + * for switches. */ + int needFlags) /* Used to specify additional flags that must + * be present in config specs for them to be + * considered. */ +{ + Blt_SwitchSpec *sp; + + for (sp = specs; sp->type != BLT_SWITCH_END; sp++) { + if ((sp->flags & needFlags) == needFlags) { + char *ptr; + + ptr = (char *)record + sp->offset; + switch (sp->type) { + case BLT_SWITCH_STRING: + case BLT_SWITCH_LIST: + if (*((char **) ptr) != NULL) { + Blt_Free(*((char **) ptr)); + *((char **) ptr) = NULL; + } + break; + + case BLT_SWITCH_OBJ: + if (*((Tcl_Obj **) ptr) != NULL) { + Tcl_DecrRefCount(*((Tcl_Obj **)ptr)); + *((Tcl_Obj **) ptr) = NULL; + } + break; + + case BLT_SWITCH_CUSTOM: + assert(sp->customPtr != NULL); + if ((*(char **)ptr != NULL) && + (sp->customPtr->freeProc != NULL)) { + (*sp->customPtr->freeProc)((char *)record, sp->offset, + sp->flags); + } + break; + + default: + break; + } + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_SwitchModified -- + * + * Given the configuration specifications and one or more switch patterns + * (terminated by a NULL), indicate if any of the matching switches has + * been reset. + * + * Results: + * Returns 1 if one of the switches have changed, 0 otherwise. + * + *--------------------------------------------------------------------------- + */ +int +Blt_SwitchChanged TCL_VARARGS_DEF(Blt_SwitchSpec *, arg1) +{ + va_list argList; + Blt_SwitchSpec *specs; + Blt_SwitchSpec *sp; + char *switchName; + + specs = TCL_VARARGS_START(Blt_SwitchSpec *, arg1, argList); + while ((switchName = va_arg(argList, char *)) != NULL) { + for (sp = specs; sp->type != BLT_SWITCH_END; sp++) { + if ((Tcl_StringMatch(sp->switchName, switchName)) && + (sp->flags & BLT_SWITCH_SPECIFIED)) { + va_end(argList); + return 1; + } + } + } + va_end(argList); + return 0; +} + +int +Blt_ExprDoubleFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, double *valuePtr) +{ + /* First try to extract the value as a double precision number. */ + if (Tcl_GetDoubleFromObj((Tcl_Interp *)NULL, objPtr, valuePtr) == TCL_OK) { + return TCL_OK; + } + /* Then try to parse it as an expression. */ + if (Tcl_ExprDouble(interp, Tcl_GetString(objPtr), valuePtr) == TCL_OK) { + return TCL_OK; + } + return TCL_ERROR; +} + +int +Blt_ExprIntFromObj( + Tcl_Interp *interp, + Tcl_Obj *objPtr, + int *valuePtr) +{ + long lvalue; + + /* First try to extract the value as a simple integer. */ + if (Tcl_GetIntFromObj((Tcl_Interp *)NULL, objPtr, valuePtr) == TCL_OK) { + return TCL_OK; + } + /* Otherwise try to parse it as an expression. */ + if (Tcl_ExprLong(interp, Tcl_GetString(objPtr), &lvalue) == TCL_OK) { + *valuePtr = lvalue; + return TCL_OK; + } + return TCL_ERROR; +} + diff --git a/src/bltSwitch.h b/src/bltSwitch.h new file mode 100644 index 0000000..603c73f --- /dev/null +++ b/src/bltSwitch.h @@ -0,0 +1,136 @@ + +/* + * bltSwitch.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef BLT_SWITCH_H +#define BLT_SWITCH_H + +#ifdef HAVE_STDDEF_H +# include <stddef.h> +#endif /* HAVE_STDDEF_H */ + +#ifndef Blt_Offset +#ifdef offsetof +#define Blt_Offset(type, field) ((int) offsetof(type, field)) +#else +#define Blt_Offset(type, field) ((int) ((char *) &((type *) 0)->field)) +#endif +#endif /* Blt_Offset */ + +typedef int (Blt_SwitchParseProc)(ClientData clientData, Tcl_Interp *interp, + const char *switchName, Tcl_Obj *valueObjPtr, char *record, int offset, + int flags); +typedef void (Blt_SwitchFreeProc)(char *record, int offset, int flags); + +typedef struct { + Blt_SwitchParseProc *parseProc; /* Procedure to parse a switch + * value and store it in its * + * converted form in the data * + * record. */ + + Blt_SwitchFreeProc *freeProc; /* Procedure to free a switch. */ + + ClientData clientData; /* Arbitrary one-word value used by + * switch parser, passed to + * parseProc. */ +} Blt_SwitchCustom; + + +/* + * Type values for Blt_SwitchSpec structures. See the user + * documentation for details. + */ +typedef enum { + BLT_SWITCH_BOOLEAN, + BLT_SWITCH_DOUBLE, + BLT_SWITCH_BITMASK, + BLT_SWITCH_BITMASK_INVERT, + BLT_SWITCH_FLOAT, + BLT_SWITCH_INT, + BLT_SWITCH_INT_NNEG, + BLT_SWITCH_INT_POS, + BLT_SWITCH_LIST, + BLT_SWITCH_LONG, + BLT_SWITCH_LONG_NNEG, + BLT_SWITCH_LONG_POS, + BLT_SWITCH_OBJ, + BLT_SWITCH_STRING, + BLT_SWITCH_VALUE, + BLT_SWITCH_CUSTOM, + BLT_SWITCH_END +} Blt_SwitchTypes; + + +typedef struct { + Blt_SwitchTypes type; /* Type of option, such as + * BLT_SWITCH_COLOR; see definitions + * below. Last option in table must + * have type BLT_SWITCH_END. */ + + const char *switchName; /* Switch used to specify option in + * argv. NULL means this spec is part + * of a group. */ + + const char *help; /* Help string. */ + int offset; /* Where in widget record to store + * value; use Blt_Offset macro to + * generate values for this. */ + + int flags; /* Any combination of the values + * defined below. */ + + unsigned int mask; + + Blt_SwitchCustom *customPtr; /* If type is BLT_SWITCH_CUSTOM then + * this is a pointer to info about how + * to parse and print the option. + * Otherwise it is irrelevant. */ +} Blt_SwitchSpec; + +#define BLT_SWITCH_DEFAULTS (0) +#define BLT_SWITCH_ARGV_PARTIAL (1<<1) +#define BLT_SWITCH_OBJV_PARTIAL (1<<1) + +/* + * Possible flag values for Blt_SwitchSpec structures. Any bits at or + * above BLT_SWITCH_USER_BIT may be used by clients for selecting + * certain entries. + */ +#define BLT_SWITCH_NULL_OK (1<<0) +#define BLT_SWITCH_DONT_SET_DEFAULT (1<<3) +#define BLT_SWITCH_SPECIFIED (1<<4) +#define BLT_SWITCH_USER_BIT (1<<8) + +BLT_EXTERN int Blt_ParseSwitches(Tcl_Interp *interp, Blt_SwitchSpec *specPtr, + int objc, Tcl_Obj *const *objv, void *rec, int flags); + +BLT_EXTERN void Blt_FreeSwitches(Blt_SwitchSpec *specs, void *rec, int flags); + +BLT_EXTERN int Blt_SwitchChanged TCL_VARARGS(Blt_SwitchSpec *, specs); + +#endif /* BLT_SWITCH_H */ diff --git a/src/bltVecCmd.C b/src/bltVecCmd.C new file mode 100644 index 0000000..c113347 --- /dev/null +++ b/src/bltVecCmd.C @@ -0,0 +1,2414 @@ + +/* + * bltVecCmd.c -- + * + * This module implements vector data objects. + * + * Copyright 1995-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Code for binary data read operation was donated by Harold Kirsch. + * + */ + +/* + * TODO: + * o Add H. Kirsch's vector binary read operation + * x binread file0 + * x binread -file file0 + * + * o Add ASCII/binary file reader + * x read fileName + * + * o Allow Tcl-based client notifications. + * vector x + * x notify call Display + * x notify delete Display + * x notify reorder #1 #2 + */ + +#include "bltVecInt.h" +#include "bltOp.h" +#include "bltNsUtil.h" +#include "bltSwitch.h" + +typedef int (VectorCmdProc)(Vector *vPtr, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv); + +static Blt_SwitchParseProc ObjToFFTVector; +static Blt_SwitchCustom fftVectorSwitch = { + ObjToFFTVector, NULL, (ClientData)0, +}; + +static Blt_SwitchParseProc ObjToIndex; +static Blt_SwitchCustom indexSwitch = { + ObjToIndex, NULL, (ClientData)0, +}; + +typedef struct { + Tcl_Obj *formatObjPtr; + int from, to; +} PrintSwitches; + +static Blt_SwitchSpec printSwitches[] = +{ + {BLT_SWITCH_OBJ, "-format", "string", + Blt_Offset(PrintSwitches, formatObjPtr), 0}, + {BLT_SWITCH_CUSTOM, "-from", "index", + Blt_Offset(PrintSwitches, from), 0, 0, &indexSwitch}, + {BLT_SWITCH_CUSTOM, "-to", "index", + Blt_Offset(PrintSwitches, to), 0, 0, &indexSwitch}, + {BLT_SWITCH_END} +}; + + +typedef struct { + int flags; +} SortSwitches; + +#define SORT_DECREASING (1<<0) +#define SORT_UNIQUE (1<<1) + +static Blt_SwitchSpec sortSwitches[] = +{ + {BLT_SWITCH_BITMASK, "-decreasing", "", + Blt_Offset(SortSwitches, flags), 0, SORT_DECREASING}, + {BLT_SWITCH_BITMASK, "-reverse", "", + Blt_Offset(SortSwitches, flags), 0, SORT_DECREASING}, + {BLT_SWITCH_BITMASK, "-uniq", "", + Blt_Offset(SortSwitches, flags), 0, SORT_UNIQUE}, + {BLT_SWITCH_END} +}; + +typedef struct { + double delta; + Vector *imagPtr; /* Vector containing imaginary part. */ + Vector *freqPtr; /* Vector containing frequencies. */ + VectorInterpData *dataPtr; + int mask; /* Flags controlling FFT. */ +} FFTData; + + +static Blt_SwitchSpec fftSwitches[] = { + {BLT_SWITCH_CUSTOM, "-imagpart", "vector", + Blt_Offset(FFTData, imagPtr), 0, 0, &fftVectorSwitch}, + {BLT_SWITCH_BITMASK, "-noconstant", "", + Blt_Offset(FFTData, mask), 0, FFT_NO_CONSTANT}, + {BLT_SWITCH_BITMASK, "-spectrum", "", + Blt_Offset(FFTData, mask), 0, FFT_SPECTRUM}, + {BLT_SWITCH_BITMASK, "-bartlett", "", + Blt_Offset(FFTData, mask), 0, FFT_BARTLETT}, + {BLT_SWITCH_DOUBLE, "-delta", "float", + Blt_Offset(FFTData, mask), 0, 0, }, + {BLT_SWITCH_CUSTOM, "-frequencies", "vector", + Blt_Offset(FFTData, freqPtr), 0, 0, &fftVectorSwitch}, + {BLT_SWITCH_END} +}; + +/* + *--------------------------------------------------------------------------- + * + * ObjToFFTVector -- + * + * Convert a string representing a vector into its vector structure. + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToFFTVector( + ClientData clientData, /* Not used. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + const char *switchName, /* Not used. */ + Tcl_Obj *objPtr, /* Name of vector. */ + char *record, /* Structure record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + FFTData *dataPtr = (FFTData *)record; + Vector *vPtr; + Vector **vPtrPtr = (Vector **)(record + offset); + int isNew; /* Not used. */ + char *string; + + string = Tcl_GetString(objPtr); + vPtr = Blt_Vec_Create(dataPtr->dataPtr, string, string, string, &isNew); + if (vPtr == NULL) { + return TCL_ERROR; + } + *vPtrPtr = vPtr; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ObjToIndex -- + * + * Convert a string representing a vector into its vector structure. + * + * Results: + * The return value is a standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ObjToIndex( + ClientData clientData, /* Contains the vector in question to verify + * its length. */ + Tcl_Interp *interp, /* Interpreter to send results back to */ + const char *switchName, /* Not used. */ + Tcl_Obj *objPtr, /* Name of vector. */ + char *record, /* Structure record */ + int offset, /* Offset to field in structure */ + int flags) /* Not used. */ +{ + Vector *vPtr = clientData; + int *indexPtr = (int *)(record + offset); + int index; + + if (Blt_Vec_GetIndex(interp, vPtr, Tcl_GetString(objPtr), &index, + INDEX_CHECK, (Blt_VectorIndexProc **)NULL) != TCL_OK) { + return TCL_ERROR; + } + *indexPtr = index; + return TCL_OK; + +} + +static Tcl_Obj * +GetValues(Vector *vPtr, int first, int last) +{ + Tcl_Obj *listObjPtr; + double *vp, *vend; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (vp = vPtr->valueArr + first, vend = vPtr->valueArr + last; vp <= vend; + vp++) { + Tcl_ListObjAppendElement(vPtr->interp, listObjPtr, + Tcl_NewDoubleObj(*vp)); + } + return listObjPtr; +} + +static void +ReplicateValue(Vector *vPtr, int first, int last, double value) +{ + double *vp, *vend; + + for (vp = vPtr->valueArr + first, vend = vPtr->valueArr + last; + vp <= vend; vp++) { + *vp = value; + } + vPtr->notifyFlags |= UPDATE_RANGE; +} + +static int +CopyList(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int i; + + if (Blt_Vec_SetLength(interp, vPtr, objc) != TCL_OK) { + return TCL_ERROR; + } + for (i = 0; i < objc; i++) { + double value; + + if (Blt_ExprDoubleFromObj(interp, objv[i], &value) != TCL_OK) { + Blt_Vec_SetLength(interp, vPtr, i); + return TCL_ERROR; + } + vPtr->valueArr[i] = value; + } + return TCL_OK; +} + +static int +AppendVector(Vector *destPtr, Vector *srcPtr) +{ + size_t nBytes; + size_t oldSize, newSize; + + oldSize = destPtr->length; + newSize = oldSize + srcPtr->last - srcPtr->first + 1; + if (Blt_Vec_ChangeLength(destPtr->interp, destPtr, newSize) != TCL_OK) { + return TCL_ERROR; + } + nBytes = (newSize - oldSize) * sizeof(double); + memcpy((char *)(destPtr->valueArr + oldSize), + (srcPtr->valueArr + srcPtr->first), nBytes); + destPtr->notifyFlags |= UPDATE_RANGE; + return TCL_OK; +} + +static int +AppendList(Vector *vPtr, int objc, Tcl_Obj *const *objv) +{ + Tcl_Interp *interp = vPtr->interp; + int count; + int i; + double value; + int oldSize; + + oldSize = vPtr->length; + if (Blt_Vec_ChangeLength(interp, vPtr, vPtr->length + objc) != TCL_OK) { + return TCL_ERROR; + } + count = oldSize; + for (i = 0; i < objc; i++) { + if (Blt_ExprDoubleFromObj(interp, objv[i], &value) != TCL_OK) { + Blt_Vec_ChangeLength(interp, vPtr, count); + return TCL_ERROR; + } + vPtr->valueArr[count++] = value; + } + vPtr->notifyFlags |= UPDATE_RANGE; + return TCL_OK; +} + +/* Vector instance option commands */ + +/* + *--------------------------------------------------------------------------- + * + * AppendOp -- + * + * Appends one of more TCL lists of values, or vector objects onto the + * end of the current vector object. + * + * Results: + * A standard TCL result. If a current vector can't be created, + * resized, any of the named vectors can't be found, or one of lists of + * values is invalid, TCL_ERROR is returned. + * + * Side Effects: + * Clients of current vector will be notified of the change. + * + *--------------------------------------------------------------------------- + */ +static int +AppendOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int i; + int result; + Vector *v2Ptr; + + for (i = 2; i < objc; i++) { + v2Ptr = Blt_Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, + Tcl_GetString(objv[i]), (const char **)NULL, NS_SEARCH_BOTH); + if (v2Ptr != NULL) { + result = AppendVector(vPtr, v2Ptr); + } else { + int nElem; + Tcl_Obj **elemObjArr; + + if (Tcl_ListObjGetElements(interp, objv[i], &nElem, &elemObjArr) + != TCL_OK) { + return TCL_ERROR; + } + result = AppendList(vPtr, nElem, elemObjArr); + } + if (result != TCL_OK) { + return TCL_ERROR; + } + } + if (objc > 2) { + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ClearOp -- + * + * Deletes all the accumulated array indices for the TCL array associated + * will the vector. This routine can be used to free excess memory from + * a large vector. + * + * Results: + * Always returns TCL_OK. + * + * Side Effects: + * Memory used for the entries of the TCL array variable is freed. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ClearOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Blt_Vec_FlushCache(vPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DeleteOp -- + * + * Deletes the given indices from the vector. If no indices are provided + * the entire vector is deleted. + * + * Results: + * A standard TCL result. If any of the given indices is invalid, + * interp->result will an error message and TCL_ERROR is returned. + * + * Side Effects: + * The clients of the vector will be notified of the vector + * deletions. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +DeleteOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + unsigned char *unsetArr; + int i, j; + int count; + char *string; + + /* FIXME: Don't delete vector with no indices. */ + if (objc == 2) { + Blt_Vec_Free(vPtr); + return TCL_OK; + } + + /* Allocate an "unset" bitmap the size of the vector. */ + unsetArr = Blt_AssertCalloc(sizeof(unsigned char), (vPtr->length + 7) / 8); +#define SetBit(i) \ + unsetArr[(i) >> 3] |= (1 << ((i) & 0x07)) +#define GetBit(i) \ + (unsetArr[(i) >> 3] & (1 << ((i) & 0x07))) + + for (i = 2; i < objc; i++) { + string = Tcl_GetString(objv[i]); + if (Blt_Vec_GetIndexRange(interp, vPtr, string, + (INDEX_COLON | INDEX_CHECK), (Blt_VectorIndexProc **) NULL) + != TCL_OK) { + Blt_Free(unsetArr); + return TCL_ERROR; + } + for (j = vPtr->first; j <= vPtr->last; j++) { + SetBit(j); /* Mark the range of elements for deletion. */ + } + } + count = 0; + for (i = 0; i < vPtr->length; i++) { + if (GetBit(i)) { + continue; /* Skip elements marked for deletion. */ + } + if (count < i) { + vPtr->valueArr[count] = vPtr->valueArr[i]; + } + count++; + } + Blt_Free(unsetArr); + vPtr->length = count; + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * DupOp -- + * + * Creates one or more duplicates of the vector object. + * + * Results: + * A standard TCL result. If a new vector can't be created, + * or and existing vector resized, TCL_ERROR is returned. + * + * Side Effects: + * Clients of existing vectors will be notified of the change. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +DupOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int i; + + for (i = 2; i < objc; i++) { + Vector *v2Ptr; + char *name; + int isNew; + + name = Tcl_GetString(objv[i]); + v2Ptr = Blt_Vec_Create(vPtr->dataPtr, name, name, name, &isNew); + if (v2Ptr == NULL) { + return TCL_ERROR; + } + if (v2Ptr == vPtr) { + continue; + } + if (Blt_Vec_Duplicate(v2Ptr, vPtr) != TCL_OK) { + return TCL_ERROR; + } + if (!isNew) { + if (v2Ptr->flush) { + Blt_Vec_FlushCache(v2Ptr); + } + Blt_Vec_UpdateClients(v2Ptr); + } + } + return TCL_OK; +} + + +/* spinellia@acm.org START */ + +/* fft implementation */ +/*ARGSUSED*/ +static int +FFTOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Vector *v2Ptr = NULL; + int isNew; + FFTData data; + char *realVecName; + + memset(&data, 0, sizeof(data)); + data.delta = 1.0; + + realVecName = Tcl_GetString(objv[2]); + v2Ptr = Blt_Vec_Create(vPtr->dataPtr, realVecName, realVecName, + realVecName, &isNew); + if (v2Ptr == NULL) { + return TCL_ERROR; + } + if (v2Ptr == vPtr) { + Tcl_AppendResult(interp, "real vector \"", realVecName, "\"", + " can't be the same as the source", (char *)NULL); + return TCL_ERROR; + } + if (Blt_ParseSwitches(interp, fftSwitches, objc - 3, objv + 3, &data, + BLT_SWITCH_DEFAULTS) < 0) { + return TCL_ERROR; + } + if (Blt_Vec_FFT(interp, v2Ptr, data.imagPtr, data.freqPtr, data.delta, + data.mask, vPtr) != TCL_OK) { + return TCL_ERROR; + } + /* Update bookkeeping. */ + if (!isNew) { + if (v2Ptr->flush) { + Blt_Vec_FlushCache(v2Ptr); + } + Blt_Vec_UpdateClients(v2Ptr); + } + if (data.imagPtr != NULL) { + if (data.imagPtr->flush) { + Blt_Vec_FlushCache(data.imagPtr); + } + Blt_Vec_UpdateClients(data.imagPtr); + } + if (data.freqPtr != NULL) { + if (data.freqPtr->flush) { + Blt_Vec_FlushCache(data.freqPtr); + } + Blt_Vec_UpdateClients(data.freqPtr); + } + return TCL_OK; +} + +/*ARGSUSED*/ +static int +InverseFFTOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int isNew; + char *name; + Vector *srcImagPtr; + Vector *destRealPtr; + Vector *destImagPtr; + + name = Tcl_GetString(objv[2]); + if (Blt_Vec_LookupName(vPtr->dataPtr, name, &srcImagPtr) != TCL_OK ) { + return TCL_ERROR; + } + name = Tcl_GetString(objv[3]); + destRealPtr = Blt_Vec_Create(vPtr->dataPtr, name, name, name, &isNew); + name = Tcl_GetString(objv[4]); + destImagPtr = Blt_Vec_Create(vPtr->dataPtr, name, name, name, &isNew); + + if (Blt_Vec_InverseFFT(interp, srcImagPtr, destRealPtr, destImagPtr, vPtr) + != TCL_OK ){ + return TCL_ERROR; + } + if (destRealPtr->flush) { + Blt_Vec_FlushCache(destRealPtr); + } + Blt_Vec_UpdateClients(destRealPtr); + + if (destImagPtr->flush) { + Blt_Vec_FlushCache(destImagPtr); + } + Blt_Vec_UpdateClients(destImagPtr); + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * IndexOp -- + * + * Sets or reads the value of the index. This simulates what the + * vector's variable does. + * + * Results: + * A standard TCL result. If the index is invalid, + * interp->result will an error message and TCL_ERROR is returned. + * Otherwise interp->result will contain the values. + * + *--------------------------------------------------------------------------- + */ +static int +IndexOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int first, last; + char *string; + + string = Tcl_GetString(objv[2]); + if (Blt_Vec_GetIndexRange(interp, vPtr, string, INDEX_ALL_FLAGS, + (Blt_VectorIndexProc **) NULL) != TCL_OK) { + return TCL_ERROR; + } + first = vPtr->first, last = vPtr->last; + if (objc == 3) { + Tcl_Obj *listObjPtr; + + if (first == vPtr->length) { + Tcl_AppendResult(interp, "can't get index \"", string, "\"", + (char *)NULL); + return TCL_ERROR; /* Can't read from index "++end" */ + } + listObjPtr = GetValues(vPtr, first, last); + Tcl_SetObjResult(interp, listObjPtr); + } else { + double value; + + /* FIXME: huh? Why set values here?. */ + if (first == SPECIAL_INDEX) { + Tcl_AppendResult(interp, "can't set index \"", string, "\"", + (char *)NULL); + return TCL_ERROR; /* Tried to set "min" or "max" */ + } + if (Blt_ExprDoubleFromObj(interp, objv[3], &value) != TCL_OK) { + return TCL_ERROR; + } + if (first == vPtr->length) { + if (Blt_Vec_ChangeLength(interp, vPtr, vPtr->length + 1) + != TCL_OK) { + return TCL_ERROR; + } + } + ReplicateValue(vPtr, first, last, value); + Tcl_SetObjResult(interp, objv[3]); + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * LengthOp -- + * + * Returns the length of the vector. If a new size is given, the + * vector is resized to the new vector. + * + * Results: + * A standard TCL result. If the new length is invalid, + * interp->result will an error message and TCL_ERROR is returned. + * Otherwise interp->result will contain the length of the vector. + * + *--------------------------------------------------------------------------- + */ +static int +LengthOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + if (objc == 3) { + int nElem; + + if (Tcl_GetIntFromObj(interp, objv[2], &nElem) != TCL_OK) { + return TCL_ERROR; + } + if (nElem < 0) { + Tcl_AppendResult(interp, "bad vector size \"", + Tcl_GetString(objv[2]), "\"", (char *)NULL); + return TCL_ERROR; + } + if ((Blt_Vec_SetSize(interp, vPtr, nElem) != TCL_OK) || + (Blt_Vec_SetLength(interp, vPtr, nElem) != TCL_OK)) { + return TCL_ERROR; + } + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + } + Tcl_SetIntObj(Tcl_GetObjResult(interp), vPtr->length); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * MapOp -- + * + * Queries or sets the offset of the array index from the base + * address of the data array of values. + * + * Results: + * A standard TCL result. If the source vector doesn't exist + * or the source list is not a valid list of numbers, TCL_ERROR + * returned. Otherwise TCL_OK is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +MapOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + if (objc > 2) { + if (Blt_Vec_MapVariable(interp, vPtr, Tcl_GetString(objv[2])) + != TCL_OK) { + return TCL_ERROR; + } + } + if (vPtr->arrayName != NULL) { + Tcl_SetStringObj(Tcl_GetObjResult(interp), vPtr->arrayName, -1); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * MaxOp -- + * + * Returns the maximum value of the vector. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +MaxOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Tcl_SetDoubleObj(Tcl_GetObjResult(interp), Blt_Vec_Max(vPtr)); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * MergeOp -- + * + * Merges the values from the given vectors to the current vector. + * + * Results: + * A standard TCL result. If any of the given vectors differ in size, + * TCL_ERROR is returned. Otherwise TCL_OK is returned and the + * vector data will contain merged values of the given vectors. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +MergeOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Vector **vecArr; + int refSize, nElem; + int i; + double *valuePtr, *valueArr; + Vector **vPtrPtr; + + /* Allocate an array of vector pointers of each vector to be + * merged in the current vector. */ + vecArr = Blt_AssertMalloc(sizeof(Vector *) * objc); + vPtrPtr = vecArr; + + refSize = -1; + nElem = 0; + for (i = 2; i < objc; i++) { + Vector *v2Ptr; + int length; + + if (Blt_Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), &v2Ptr) + != TCL_OK) { + Blt_Free(vecArr); + return TCL_ERROR; + } + /* Check that all the vectors are the same length */ + length = v2Ptr->last - v2Ptr->first + 1; + if (refSize < 0) { + refSize = length; + } else if (length != refSize) { + Tcl_AppendResult(vPtr->interp, "vectors \"", vPtr->name, + "\" and \"", v2Ptr->name, "\" differ in length", + (char *)NULL); + Blt_Free(vecArr); + return TCL_ERROR; + } + *vPtrPtr++ = v2Ptr; + nElem += refSize; + } + *vPtrPtr = NULL; + + valueArr = Blt_Malloc(sizeof(double) * nElem); + if (valueArr == NULL) { + Tcl_AppendResult(vPtr->interp, "not enough memory to allocate ", + Blt_Itoa(nElem), " vector elements", (char *)NULL); + return TCL_ERROR; + } + + /* Merge the values from each of the vectors into the current vector */ + valuePtr = valueArr; + for (i = 0; i < refSize; i++) { + Vector **vpp; + + for (vpp = vecArr; *vpp != NULL; vpp++) { + *valuePtr++ = (*vpp)->valueArr[i + (*vpp)->first]; + } + } + Blt_Free(vecArr); + Blt_Vec_Reset(vPtr, valueArr, nElem, nElem, TCL_DYNAMIC); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * MinOp -- + * + * Returns the minimum value of the vector. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +MinOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Tcl_SetDoubleObj(Tcl_GetObjResult(interp), Blt_Vec_Min(vPtr)); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NormalizeOp -- + * + * Normalizes the vector. + * + * Results: + * A standard TCL result. If the density is invalid, TCL_ERROR + * is returned. Otherwise TCL_OK is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +NormalizeOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int i; + double range; + + Blt_Vec_UpdateRange(vPtr); + range = vPtr->max - vPtr->min; + if (objc > 2) { + Vector *v2Ptr; + int isNew; + char *string; + + string = Tcl_GetString(objv[2]); + v2Ptr = Blt_Vec_Create(vPtr->dataPtr, string, string, string, &isNew); + if (v2Ptr == NULL) { + return TCL_ERROR; + } + if (Blt_Vec_SetLength(interp, v2Ptr, vPtr->length) != TCL_OK) { + return TCL_ERROR; + } + for (i = 0; i < vPtr->length; i++) { + v2Ptr->valueArr[i] = (vPtr->valueArr[i] - vPtr->min) / range; + } + Blt_Vec_UpdateRange(v2Ptr); + if (!isNew) { + if (v2Ptr->flush) { + Blt_Vec_FlushCache(v2Ptr); + } + Blt_Vec_UpdateClients(v2Ptr); + } + } else { + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (i = 0; i < vPtr->length; i++) { + double norm; + + norm = (vPtr->valueArr[i] - vPtr->min) / range; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(norm)); + } + Tcl_SetObjResult(interp, listObjPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NotifyOp -- + * + * Notify clients of vector. + * + * Results: + * A standard TCL result. If any of the given vectors differ in size, + * TCL_ERROR is returned. Otherwise TCL_OK is returned and the + * vector data will contain merged values of the given vectors. + * + * x vector notify now + * x vector notify always + * x vector notify whenidle + * x vector notify update {} + * x vector notify delete {} + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +NotifyOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int option; + int bool; + enum optionIndices { + OPTION_ALWAYS, OPTION_NEVER, OPTION_WHENIDLE, + OPTION_NOW, OPTION_CANCEL, OPTION_PENDING + }; + static const char *optionArr[] = { + "always", "never", "whenidle", "now", "cancel", "pending", NULL + }; + + if (Tcl_GetIndexFromObj(interp, objv[2], optionArr, "qualifier", TCL_EXACT, + &option) != TCL_OK) { + return TCL_OK; + } + switch (option) { + case OPTION_ALWAYS: + vPtr->notifyFlags &= ~NOTIFY_WHEN_MASK; + vPtr->notifyFlags |= NOTIFY_ALWAYS; + break; + case OPTION_NEVER: + vPtr->notifyFlags &= ~NOTIFY_WHEN_MASK; + vPtr->notifyFlags |= NOTIFY_NEVER; + break; + case OPTION_WHENIDLE: + vPtr->notifyFlags &= ~NOTIFY_WHEN_MASK; + vPtr->notifyFlags |= NOTIFY_WHENIDLE; + break; + case OPTION_NOW: + /* FIXME: How does this play when an update is pending? */ + Blt_Vec_NotifyClients(vPtr); + break; + case OPTION_CANCEL: + if (vPtr->notifyFlags & NOTIFY_PENDING) { + vPtr->notifyFlags &= ~NOTIFY_PENDING; + Tcl_CancelIdleCall(Blt_Vec_NotifyClients, (ClientData)vPtr); + } + break; + case OPTION_PENDING: + bool = (vPtr->notifyFlags & NOTIFY_PENDING); + Tcl_SetBooleanObj(Tcl_GetObjResult(interp), bool); + break; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * PopulateOp -- + * + * Creates or resizes a new vector based upon the density specified. + * + * Results: + * A standard TCL result. If the density is invalid, TCL_ERROR + * is returned. Otherwise TCL_OK is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +PopulateOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Vector *v2Ptr; + int size, density; + int isNew; + int i, j; + double *valuePtr; + int count; + char *string; + + string = Tcl_GetString(objv[2]); + v2Ptr = Blt_Vec_Create(vPtr->dataPtr, string, string, string, &isNew); + if (v2Ptr == NULL) { + return TCL_ERROR; + } + if (vPtr->length == 0) { + return TCL_OK; /* Source vector is empty. */ + } + if (Tcl_GetIntFromObj(interp, objv[3], &density) != TCL_OK) { + return TCL_ERROR; + } + if (density < 1) { + Tcl_AppendResult(interp, "bad density \"", Tcl_GetString(objv[3]), + "\"", (char *)NULL); + return TCL_ERROR; + } + size = (vPtr->length - 1) * (density + 1) + 1; + if (Blt_Vec_SetLength(interp, v2Ptr, size) != TCL_OK) { + return TCL_ERROR; + } + count = 0; + valuePtr = v2Ptr->valueArr; + for (i = 0; i < (vPtr->length - 1); i++) { + double slice, range; + + range = vPtr->valueArr[i + 1] - vPtr->valueArr[i]; + slice = range / (double)(density + 1); + for (j = 0; j <= density; j++) { + *valuePtr = vPtr->valueArr[i] + (slice * (double)j); + valuePtr++; + count++; + } + } + count++; + *valuePtr = vPtr->valueArr[i]; + assert(count == v2Ptr->length); + if (!isNew) { + if (v2Ptr->flush) { + Blt_Vec_FlushCache(v2Ptr); + } + Blt_Vec_UpdateClients(v2Ptr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ValuesOp -- + * + * Print the values vector. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ValuesOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + PrintSwitches switches; + + switches.formatObjPtr = NULL; + switches.from = 0; + switches.to = vPtr->length - 1; + indexSwitch.clientData = vPtr; + if (Blt_ParseSwitches(interp, printSwitches, objc - 2, objv + 2, &switches, + BLT_SWITCH_DEFAULTS) < 0) { + return TCL_ERROR; + } + if (switches.from > switches.to) { + int tmp; + /* swap positions. */ + tmp = switches.to; + switches.to = switches.from; + switches.from = tmp; + } + if (switches.formatObjPtr == NULL) { + Tcl_Obj *listObjPtr; + int i; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + for (i = switches.from; i <= switches.to; i++) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(vPtr->valueArr[i])); + } + Tcl_SetObjResult(interp, listObjPtr); + } else { + Tcl_DString ds; + char buffer[200]; + const char *fmt; + int i; + + Tcl_DStringInit(&ds); + fmt = Tcl_GetString(switches.formatObjPtr); + for (i = switches.from; i <= switches.to; i++) { + sprintf(buffer, fmt, vPtr->valueArr[i]); + Tcl_DStringAppend(&ds, buffer, -1); + } + Tcl_DStringResult(interp, &ds); + Tcl_DStringFree(&ds); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * RangeOp -- + * + * Returns a TCL list of the range of vector values specified. + * + * Results: + * A standard TCL result. If the given range is invalid, TCL_ERROR + * is returned. Otherwise TCL_OK is returned and interp->result + * will contain the list of values. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +RangeOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Tcl_Obj *listObjPtr; + int first, last; + int i; + + if (objc == 2) { + first = 0; + last = vPtr->length - 1; + } else if (objc == 4) { + if ((Blt_Vec_GetIndex(interp, vPtr, Tcl_GetString(objv[2]), &first, + INDEX_CHECK, (Blt_VectorIndexProc **) NULL) != TCL_OK) || + (Blt_Vec_GetIndex(interp, vPtr, Tcl_GetString(objv[3]), &last, + INDEX_CHECK, (Blt_VectorIndexProc **) NULL) != TCL_OK)) { + return TCL_ERROR; + } + } else { + Tcl_AppendResult(interp, "wrong # args: should be \"", + Tcl_GetString(objv[0]), " range ?first last?", (char *)NULL); + return TCL_ERROR; + } + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (first > last) { + /* Return the list reversed */ + for (i = last; i <= first; i++) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(vPtr->valueArr[i])); + } + } else { + for (i = first; i <= last; i++) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(vPtr->valueArr[i])); + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * InRange -- + * + * Determines if a value lies within a given range. + * + * The value is normalized and compared against the interval + * [0..1], where 0.0 is the minimum and 1.0 is the maximum. + * DBL_EPSILON is the smallest number that can be represented + * on the host machine, such that (1.0 + epsilon) != 1.0. + * + * Please note, min cannot be greater than max. + * + * Results: + * If the value is within of the interval [min..max], 1 is + * returned; 0 otherwise. + * + *--------------------------------------------------------------------------- + */ +INLINE static int +InRange(double value, double min, double max) +{ + double range; + + range = max - min; + if (range < DBL_EPSILON) { + return (FABS(max - value) < DBL_EPSILON); + } else { + double norm; + + norm = (value - min) / range; + return ((norm >= -DBL_EPSILON) && ((norm - 1.0) < DBL_EPSILON)); + } +} + +enum NativeFormats { + FMT_UNKNOWN = -1, + FMT_UCHAR, FMT_CHAR, + FMT_USHORT, FMT_SHORT, + FMT_UINT, FMT_INT, + FMT_ULONG, FMT_LONG, + FMT_FLOAT, FMT_DOUBLE +}; + +/* + *--------------------------------------------------------------------------- + * + * GetBinaryFormat + * + * Translates a format string into a native type. Valid formats are + * + * signed i1, i2, i4, i8 + * unsigned u1, u2, u4, u8 + * real r4, r8, r16 + * + * There must be a corresponding native type. For example, this for + * reading 2-byte binary integers from an instrument and converting them + * to unsigned shorts or ints. + * + *--------------------------------------------------------------------------- + */ +static enum NativeFormats +GetBinaryFormat(Tcl_Interp *interp, char *string, int *sizePtr) +{ + char c; + + c = tolower(string[0]); + if (Tcl_GetInt(interp, string + 1, sizePtr) != TCL_OK) { + Tcl_AppendResult(interp, "unknown binary format \"", string, + "\": incorrect byte size", (char *)NULL); + return FMT_UNKNOWN; + } + switch (c) { + case 'r': + if (*sizePtr == sizeof(double)) { + return FMT_DOUBLE; + } else if (*sizePtr == sizeof(float)) { + return FMT_FLOAT; + } + break; + + case 'i': + if (*sizePtr == sizeof(char)) { + return FMT_CHAR; + } else if (*sizePtr == sizeof(int)) { + return FMT_INT; + } else if (*sizePtr == sizeof(long)) { + return FMT_LONG; + } else if (*sizePtr == sizeof(short)) { + return FMT_SHORT; + } + break; + + case 'u': + if (*sizePtr == sizeof(unsigned char)) { + return FMT_UCHAR; + } else if (*sizePtr == sizeof(unsigned int)) { + return FMT_UINT; + } else if (*sizePtr == sizeof(unsigned long)) { + return FMT_ULONG; + } else if (*sizePtr == sizeof(unsigned short)) { + return FMT_USHORT; + } + break; + + default: + Tcl_AppendResult(interp, "unknown binary format \"", string, + "\": should be either i#, r#, u# (where # is size in bytes)", + (char *)NULL); + return FMT_UNKNOWN; + } + Tcl_AppendResult(interp, "can't handle format \"", string, "\"", + (char *)NULL); + return FMT_UNKNOWN; +} + +static int +CopyValues(Vector *vPtr, char *byteArr, enum NativeFormats fmt, int size, + int length, int swap, int *indexPtr) +{ + int i, n; + int newSize; + + if ((swap) && (size > 1)) { + int nBytes = size * length; + unsigned char *p; + int left, right; + + for (i = 0; i < nBytes; i += size) { + p = (unsigned char *)(byteArr + i); + for (left = 0, right = size - 1; left < right; left++, right--) { + p[left] ^= p[right]; + p[right] ^= p[left]; + p[left] ^= p[right]; + } + + } + } + newSize = *indexPtr + length; + if (newSize > vPtr->length) { + if (Blt_Vec_ChangeLength(vPtr->interp, vPtr, newSize) != TCL_OK) { + return TCL_ERROR; + } + } +#define CopyArrayToVector(vPtr, arr) \ + for (i = 0, n = *indexPtr; i < length; i++, n++) { \ + (vPtr)->valueArr[n] = (double)(arr)[i]; \ + } + + switch (fmt) { + case FMT_CHAR: + CopyArrayToVector(vPtr, (char *)byteArr); + break; + + case FMT_UCHAR: + CopyArrayToVector(vPtr, (unsigned char *)byteArr); + break; + + case FMT_INT: + CopyArrayToVector(vPtr, (int *)byteArr); + break; + + case FMT_UINT: + CopyArrayToVector(vPtr, (unsigned int *)byteArr); + break; + + case FMT_LONG: + CopyArrayToVector(vPtr, (long *)byteArr); + break; + + case FMT_ULONG: + CopyArrayToVector(vPtr, (unsigned long *)byteArr); + break; + + case FMT_SHORT: + CopyArrayToVector(vPtr, (short int *)byteArr); + break; + + case FMT_USHORT: + CopyArrayToVector(vPtr, (unsigned short int *)byteArr); + break; + + case FMT_FLOAT: + CopyArrayToVector(vPtr, (float *)byteArr); + break; + + case FMT_DOUBLE: + CopyArrayToVector(vPtr, (double *)byteArr); + break; + + case FMT_UNKNOWN: + break; + } + *indexPtr += length; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * BinreadOp -- + * + * Reads binary values from a TCL channel. Values are either appended to + * the end of the vector or placed at a given index (using the "-at" + * option), overwriting existing values. Data is read until EOF is found + * on the channel or a specified number of values are read. (note that + * this is not necessarily the same as the number of bytes). + * + * The following flags are supported: + * -swap Swap bytes + * -at index Start writing data at the index. + * -format fmt Specifies the format of the data. + * + * This binary reader was created and graciously donated by Harald Kirsch + * (kir@iitb.fhg.de). Anything that's wrong is due to my (gah) munging + * of the code. + * + * Results: + * Returns a standard TCL result. The interpreter result will contain the + * number of values (not the number of bytes) read. + * + * Caveats: + * Channel reads must end on an element boundary. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +BinreadOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Tcl_Channel channel; + char *byteArr; + char *string; + enum NativeFormats fmt; + int arraySize, bytesRead; + int count, total; + int first; + int size, length, mode; + int swap; + int i; + + string = Tcl_GetString(objv[2]); + channel = Tcl_GetChannel(interp, string, &mode); + if (channel == NULL) { + return TCL_ERROR; + } + if ((mode & TCL_READABLE) == 0) { + Tcl_AppendResult(interp, "channel \"", string, + "\" wasn't opened for reading", (char *)NULL); + return TCL_ERROR; + } + first = vPtr->length; + fmt = FMT_DOUBLE; + size = sizeof(double); + swap = FALSE; + count = 0; + + if (objc > 3) { + string = Tcl_GetString(objv[3]); + if (string[0] != '-') { + long int value; + /* Get the number of values to read. */ + if (Tcl_GetLongFromObj(interp, objv[3], &value) != TCL_OK) { + return TCL_ERROR; + } + if (value < 0) { + Tcl_AppendResult(interp, "count can't be negative", + (char *)NULL); + return TCL_ERROR; + } + count = (size_t)value; + objc--, objv++; + } + } + /* Process any option-value pairs that remain. */ + for (i = 3; i < objc; i++) { + string = Tcl_GetString(objv[i]); + if (strcmp(string, "-swap") == 0) { + swap = TRUE; + } else if (strcmp(string, "-format") == 0) { + i++; + if (i >= objc) { + Tcl_AppendResult(interp, "missing arg after \"", string, + "\"", (char *)NULL); + return TCL_ERROR; + } + string = Tcl_GetString(objv[i]); + fmt = GetBinaryFormat(interp, string, &size); + if (fmt == FMT_UNKNOWN) { + return TCL_ERROR; + } + } else if (strcmp(string, "-at") == 0) { + i++; + if (i >= objc) { + Tcl_AppendResult(interp, "missing arg after \"", string, + "\"", (char *)NULL); + return TCL_ERROR; + } + string = Tcl_GetString(objv[i]); + if (Blt_Vec_GetIndex(interp, vPtr, string, &first, 0, + (Blt_VectorIndexProc **)NULL) != TCL_OK) { + return TCL_ERROR; + } + if (first > vPtr->length) { + Tcl_AppendResult(interp, "index \"", string, + "\" is out of range", (char *)NULL); + return TCL_ERROR; + } + } + } + +#define BUFFER_SIZE 1024 + if (count == 0) { + arraySize = BUFFER_SIZE * size; + } else { + arraySize = count * size; + } + + byteArr = Blt_AssertMalloc(arraySize); + /* FIXME: restore old channel translation later? */ + if (Tcl_SetChannelOption(interp, channel, "-translation", + "binary") != TCL_OK) { + return TCL_ERROR; + } + total = 0; + while (!Tcl_Eof(channel)) { + bytesRead = Tcl_Read(channel, byteArr, arraySize); + if (bytesRead < 0) { + Tcl_AppendResult(interp, "error reading channel: ", + Tcl_PosixError(interp), (char *)NULL); + return TCL_ERROR; + } + if ((bytesRead % size) != 0) { + Tcl_AppendResult(interp, "error reading channel: short read", + (char *)NULL); + return TCL_ERROR; + } + length = bytesRead / size; + if (CopyValues(vPtr, byteArr, fmt, size, length, swap, &first) + != TCL_OK) { + return TCL_ERROR; + } + total += length; + if (count > 0) { + break; + } + } + Blt_Free(byteArr); + + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + + /* Set the result as the number of values read. */ + Tcl_SetIntObj(Tcl_GetObjResult(interp), total); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SearchOp -- + * + * Searches for a value in the vector. Returns the indices of all vector + * elements matching a particular value. + * + * Results: + * Always returns TCL_OK. interp->result will contain a list of the + * indices of array elements matching value. If no elements match, + * interp->result will contain the empty string. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SearchOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + double min, max; + int i; + int wantValue; + char *string; + Tcl_Obj *listObjPtr; + + wantValue = FALSE; + string = Tcl_GetString(objv[2]); + if ((string[0] == '-') && (strcmp(string, "-value") == 0)) { + wantValue = TRUE; + objv++, objc--; + } + if (Blt_ExprDoubleFromObj(interp, objv[2], &min) != TCL_OK) { + return TCL_ERROR; + } + max = min; + if (objc > 4) { + Tcl_AppendResult(interp, "wrong # arguments: should be \"", + Tcl_GetString(objv[0]), " search ?-value? min ?max?", + (char *)NULL); + return TCL_ERROR; + } + if ((objc > 3) && + (Blt_ExprDoubleFromObj(interp, objv[3], &max) != TCL_OK)) { + return TCL_ERROR; + } + if ((min - max) >= DBL_EPSILON) { + return TCL_OK; /* Bogus range. Don't bother looking. */ + } + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + if (wantValue) { + for (i = 0; i < vPtr->length; i++) { + if (InRange(vPtr->valueArr[i], min, max)) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(vPtr->valueArr[i])); + } + } + } else { + for (i = 0; i < vPtr->length; i++) { + if (InRange(vPtr->valueArr[i], min, max)) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewIntObj(i + vPtr->offset)); + } + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * OffsetOp -- + * + * Queries or sets the offset of the array index from the base address of + * the data array of values. + * + * Results: + * A standard TCL result. If the source vector doesn't exist or the + * source list is not a valid list of numbers, TCL_ERROR returned. + * Otherwise TCL_OK is returned. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +OffsetOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + if (objc == 3) { + int newOffset; + + if (Tcl_GetIntFromObj(interp, objv[2], &newOffset) != TCL_OK) { + return TCL_ERROR; + } + vPtr->offset = newOffset; + } + Tcl_SetIntObj(Tcl_GetObjResult(interp), vPtr->offset); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * RandomOp -- + * + * Generates random values for the length of the vector. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +RandomOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int i; + + for (i = 0; i < vPtr->length; i++) { + vPtr->valueArr[i] = drand48(); + } + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SeqOp -- + * + * Generates a sequence of values in the vector. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SeqOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int n; + double start, stop; + + if (Blt_ExprDoubleFromObj(interp, objv[2], &start) != TCL_OK) { + return TCL_ERROR; + } + if (Blt_ExprDoubleFromObj(interp, objv[3], &stop) != TCL_OK) { + return TCL_ERROR; + } + n = vPtr->length; + if ((objc > 4) && (Blt_ExprIntFromObj(interp, objv[4], &n) != TCL_OK)) { + return TCL_ERROR; + } + if (n > 1) { + int i; + double step; + + if (Blt_Vec_SetLength(interp, vPtr, n) != TCL_OK) { + return TCL_ERROR; + } + step = (stop - start) / (double)(n - 1); + for (i = 0; i < n; i++) { + vPtr->valueArr[i] = start + (step * i); + } + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SetOp -- + * + * Sets the data of the vector object from a list of values. + * + * Results: + * A standard TCL result. If the source vector doesn't exist or the + * source list is not a valid list of numbers, TCL_ERROR returned. + * Otherwise TCL_OK is returned. + * + * Side Effects: + * The vector data is reset. Clients of the vector are notified. Any + * cached array indices are flushed. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SetOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int result; + Vector *v2Ptr; + int nElem; + Tcl_Obj **elemObjArr; + + /* The source can be either a list of numbers or another vector. */ + + v2Ptr = Blt_Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, + Tcl_GetString(objv[2]), NULL, NS_SEARCH_BOTH); + if (v2Ptr != NULL) { + if (vPtr == v2Ptr) { + Vector *tmpPtr; + /* + * Source and destination vectors are the same. Copy the source + * first into a temporary vector to avoid memory overlaps. + */ + tmpPtr = Blt_Vec_New(vPtr->dataPtr); + result = Blt_Vec_Duplicate(tmpPtr, v2Ptr); + if (result == TCL_OK) { + result = Blt_Vec_Duplicate(vPtr, tmpPtr); + } + Blt_Vec_Free(tmpPtr); + } else { + result = Blt_Vec_Duplicate(vPtr, v2Ptr); + } + } else if (Tcl_ListObjGetElements(interp, objv[2], &nElem, &elemObjArr) + == TCL_OK) { + result = CopyList(vPtr, interp, nElem, elemObjArr); + } else { + return TCL_ERROR; + } + + if (result == TCL_OK) { + /* + * The vector has changed; so flush the array indices (they're wrong + * now), find the new range of the data, and notify the vector's + * clients that it's been modified. + */ + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + } + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * SimplifyOp -- + * + * Sets the data of the vector object from a list of values. + * + * Results: + * A standard TCL result. If the source vector doesn't exist or the + * source list is not a valid list of numbers, TCL_ERROR returned. + * Otherwise TCL_OK is returned. + * + * Side Effects: + * The vector data is reset. Clients of the vector are notified. Any + * cached array indices are flushed. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SimplifyOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + size_t i, n; + int length, nPoints; + int *simple; + double tolerance = 10.0; + Point2d *orig, *reduced; + + length = vPtr->length; + nPoints = vPtr->length / 2; + simple = Blt_AssertMalloc(nPoints * sizeof(int)); + reduced = Blt_AssertMalloc(nPoints * sizeof(Point2d)); + orig = (Point2d *)vPtr->valueArr; + n = Blt_SimplifyLine(orig, 0, nPoints - 1, tolerance, simple); + for (i = 0; i < n; i++) { + reduced[i] = orig[simple[i]]; + } + Blt_Free(simple); + Blt_Vec_Reset(vPtr, (double *)reduced, n * 2, vPtr->length, TCL_DYNAMIC); + /* + * The vector has changed; so flush the array indices (they're wrong + * now), find the new range of the data, and notify the vector's + * clients that it's been modified. + */ + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * SplitOp -- + * + * Copies the values from the vector evenly into one of more vectors. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +SplitOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + int nVectors; + + nVectors = objc - 2; + if ((vPtr->length % nVectors) != 0) { + Tcl_AppendResult(interp, "can't split vector \"", vPtr->name, + "\" into ", Blt_Itoa(nVectors), " even parts.", (char *)NULL); + return TCL_ERROR; + } + if (nVectors > 0) { + Vector *v2Ptr; + char *string; /* Name of vector. */ + int i, j, k; + int oldSize, newSize, extra, isNew; + + extra = vPtr->length / nVectors; + for (i = 0; i < nVectors; i++) { + string = Tcl_GetString(objv[i+2]); + v2Ptr = Blt_Vec_Create(vPtr->dataPtr, string, string, string, + &isNew); + oldSize = v2Ptr->length; + newSize = oldSize + extra; + if (Blt_Vec_SetLength(interp, v2Ptr, newSize) != TCL_OK) { + return TCL_ERROR; + } + for (j = i, k = oldSize; j < vPtr->length; j += nVectors, k++) { + v2Ptr->valueArr[k] = vPtr->valueArr[j]; + } + Blt_Vec_UpdateClients(v2Ptr); + if (v2Ptr->flush) { + Blt_Vec_FlushCache(v2Ptr); + } + } + } + return TCL_OK; +} + + +static Vector **sortVectors; /* Pointer to the array of values currently + * being sorted. */ +static int nSortVectors; +static int sortDecreasing; /* Indicates the ordering of the sort. If + * non-zero, the vectors are sorted in + * decreasing order */ + +static int +CompareVectors(void *a, void *b) +{ + double delta; + int i; + int sign; + Vector *vPtr; + + sign = (sortDecreasing) ? -1 : 1; + for (i = 0; i < nSortVectors; i++) { + vPtr = sortVectors[i]; + delta = vPtr->valueArr[*(int *)a] - vPtr->valueArr[*(int *)b]; + if (delta < 0.0) { + return (-1 * sign); + } else if (delta > 0.0) { + return (1 * sign); + } + } + return 0; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_SortMap -- + * + * Returns an array of indices that represents the sorted mapping of the + * original vector. + * + * Results: + * A standard TCL result. If any of the auxiliary vectors are a + * different size than the sorted vector object, TCL_ERROR is returned. + * Otherwise TCL_OK is returned. + * + * Side Effects: + * The vectors are sorted. + * + * vecName sort ?switches? vecName vecName... + *--------------------------------------------------------------------------- + */ +size_t * +Blt_Vec_SortMap(Vector **vectors, int nVectors) +{ + size_t *map; + int i; + Vector *vPtr = *vectors; + int length; + + length = vPtr->last - vPtr->first + 1; + map = Blt_AssertMalloc(sizeof(size_t) * length); + for (i = vPtr->first; i <= vPtr->last; i++) { + map[i] = i; + } + /* Set global variables for sorting routine. */ + sortVectors = vectors; + nSortVectors = nVectors; + qsort((char *)map, length, sizeof(size_t), + (QSortCompareProc *)CompareVectors); + return map; +} + +static size_t * +SortVectors(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Vector **vectors, *v2Ptr; + size_t *map; + int i; + + vectors = Blt_AssertMalloc(sizeof(Vector *) * (objc + 1)); + vectors[0] = vPtr; + map = NULL; + for (i = 0; i < objc; i++) { + if (Blt_Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), + &v2Ptr) != TCL_OK) { + goto error; + } + if (v2Ptr->length != vPtr->length) { + Tcl_AppendResult(interp, "vector \"", v2Ptr->name, + "\" is not the same size as \"", vPtr->name, "\"", + (char *)NULL); + goto error; + } + vectors[i + 1] = v2Ptr; + } + map = Blt_Vec_SortMap(vectors, objc + 1); + error: + Blt_Free(vectors); + return map; +} + + +/* + *--------------------------------------------------------------------------- + * + * SortOp -- + * + * Sorts the vector object and any other vectors according to sorting + * order of the vector object. + * + * Results: + * A standard TCL result. If any of the auxiliary vectors are a + * different size than the sorted vector object, TCL_ERROR is returned. + * Otherwise TCL_OK is returned. + * + * Side Effects: + * The vectors are sorted. + * + * vecName sort ?switches? vecName vecName... + *--------------------------------------------------------------------------- + */ +static int +SortOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + Vector *v2Ptr; + double *copy; + size_t *map; + size_t sortLength, nBytes; + int result; + int i; + unsigned int n; + SortSwitches switches; + + sortDecreasing = FALSE; + switches.flags = 0; + i = Blt_ParseSwitches(interp, sortSwitches, objc - 2, objv + 2, &switches, + BLT_SWITCH_OBJV_PARTIAL); + if (i < 0) { + return TCL_ERROR; + } + objc -= i, objv += i; + sortDecreasing = (switches.flags & SORT_DECREASING); + if (objc > 2) { + map = SortVectors(vPtr, interp, objc - 2, objv + 2); + } else { + map = Blt_Vec_SortMap(&vPtr, 1); + } + if (map == NULL) { + return TCL_ERROR; + } + sortLength = vPtr->length; + /* + * Create an array to store a copy of the current values of the + * vector. We'll merge the values back into the vector based upon the + * indices found in the index array. + */ + nBytes = sizeof(double) * sortLength; + copy = Blt_AssertMalloc(nBytes); + memcpy((char *)copy, (char *)vPtr->valueArr, nBytes); + if (switches.flags & SORT_UNIQUE) { + int count; + + for (count = n = 1; n < sortLength; n++) { + size_t next, prev; + + next = map[n]; + prev = map[n - 1]; + if (copy[next] != copy[prev]) { + map[count] = next; + count++; + } + } + sortLength = count; + nBytes = sortLength * sizeof(double); + } + if (sortLength != vPtr->length) { + Blt_Vec_SetLength(interp, vPtr, sortLength); + } + for (n = 0; n < sortLength; n++) { + vPtr->valueArr[n] = copy[map[n]]; + } + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + + /* Now sort any other vectors in the same fashion. The vectors must be + * the same size as the map though. */ + result = TCL_ERROR; + for (i = 2; i < objc; i++) { + if (Blt_Vec_LookupName(vPtr->dataPtr, Tcl_GetString(objv[i]), + &v2Ptr) != TCL_OK) { + goto error; + } + if (sortLength != v2Ptr->length) { + Blt_Vec_SetLength(interp, v2Ptr, sortLength); + } + memcpy((char *)copy, (char *)v2Ptr->valueArr, nBytes); + for (n = 0; n < sortLength; n++) { + v2Ptr->valueArr[n] = copy[map[n]]; + } + Blt_Vec_UpdateClients(v2Ptr); + if (v2Ptr->flush) { + Blt_Vec_FlushCache(v2Ptr); + } + } + result = TCL_OK; + error: + Blt_Free(copy); + Blt_Free(map); + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * InstExprOp -- + * + * Computes the result of the expression which may be either a scalar + * (single value) or vector (list of values). + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +InstExprOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + + if (Blt_ExprVector(interp, Tcl_GetString(objv[2]), (Blt_Vector *)vPtr) + != TCL_OK) { + return TCL_ERROR; + } + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ArithOp -- + * + * Results: + * A standard TCL result. If the source vector doesn't exist or the + * source list is not a valid list of numbers, TCL_ERROR returned. + * Otherwise TCL_OK is returned. + * + * Side Effects: + * The vector data is reset. Clients of the vector are notified. + * Any cached array indices are flushed. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +ArithOp(Vector *vPtr, Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) +{ + double value; + int i; + Vector *v2Ptr; + double scalar; + Tcl_Obj *listObjPtr; + char *string; + + v2Ptr = Blt_Vec_ParseElement((Tcl_Interp *)NULL, vPtr->dataPtr, + Tcl_GetString(objv[2]), NULL, NS_SEARCH_BOTH); + if (v2Ptr != NULL) { + int j; + int length; + + length = v2Ptr->last - v2Ptr->first + 1; + if (length != vPtr->length) { + Tcl_AppendResult(interp, "vectors \"", Tcl_GetString(objv[0]), + "\" and \"", Tcl_GetString(objv[2]), + "\" are not the same length", (char *)NULL); + return TCL_ERROR; + } + string = Tcl_GetString(objv[1]); + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + switch (string[0]) { + case '*': + for (i = 0, j = v2Ptr->first; i < vPtr->length; i++, j++) { + value = vPtr->valueArr[i] * v2Ptr->valueArr[j]; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(value)); + } + break; + + case '/': + for (i = 0, j = v2Ptr->first; i < vPtr->length; i++, j++) { + value = vPtr->valueArr[i] / v2Ptr->valueArr[j]; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(value)); + } + break; + + case '-': + for (i = 0, j = v2Ptr->first; i < vPtr->length; i++, j++) { + value = vPtr->valueArr[i] - v2Ptr->valueArr[j]; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(value)); + } + break; + + case '+': + for (i = 0, j = v2Ptr->first; i < vPtr->length; i++, j++) { + value = vPtr->valueArr[i] + v2Ptr->valueArr[j]; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(value)); + } + break; + } + Tcl_SetObjResult(interp, listObjPtr); + + } else if (Blt_ExprDoubleFromObj(interp, objv[2], &scalar) == TCL_OK) { + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **)NULL); + string = Tcl_GetString(objv[1]); + switch (string[0]) { + case '*': + for (i = 0; i < vPtr->length; i++) { + value = vPtr->valueArr[i] * scalar; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(value)); + } + break; + + case '/': + for (i = 0; i < vPtr->length; i++) { + value = vPtr->valueArr[i] / scalar; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(value)); + } + break; + + case '-': + for (i = 0; i < vPtr->length; i++) { + value = vPtr->valueArr[i] - scalar; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(value)); + } + break; + + case '+': + for (i = 0; i < vPtr->length; i++) { + value = vPtr->valueArr[i] + scalar; + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewDoubleObj(value)); + } + break; + } + Tcl_SetObjResult(interp, listObjPtr); + } else { + return TCL_ERROR; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * VectorInstCmd -- + * + * Parses and invokes the appropriate vector instance command option. + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +static Blt_OpSpec vectorInstOps[] = +{ + {"*", 1, ArithOp, 3, 3, "item",}, /*Deprecated*/ + {"+", 1, ArithOp, 3, 3, "item",}, /*Deprecated*/ + {"-", 1, ArithOp, 3, 3, "item",}, /*Deprecated*/ + {"/", 1, ArithOp, 3, 3, "item",}, /*Deprecated*/ + {"append", 1, AppendOp, 3, 0, "item ?item...?",}, + {"binread", 1, BinreadOp, 3, 0, "channel ?numValues? ?flags?",}, + {"clear", 1, ClearOp, 2, 2, "",}, + {"delete", 2, DeleteOp, 2, 0, "index ?index...?",}, + {"dup", 2, DupOp, 3, 0, "vecName",}, + {"expr", 1, InstExprOp, 3, 3, "expression",}, + {"fft", 1, FFTOp, 3, 0, "vecName ?switches?",}, + {"index", 3, IndexOp, 3, 4, "index ?value?",}, + {"inversefft",3, InverseFFTOp,4, 4, "vecName vecName",}, + {"length", 1, LengthOp, 2, 3, "?newSize?",}, + {"max", 2, MaxOp, 2, 2, "",}, + {"merge", 2, MergeOp, 3, 0, "vecName ?vecName...?",}, + {"min", 2, MinOp, 2, 2, "",}, + {"normalize", 3, NormalizeOp, 2, 3, "?vecName?",}, /*Deprecated*/ + {"notify", 3, NotifyOp, 3, 3, "keyword",}, + {"offset", 1, OffsetOp, 2, 3, "?offset?",}, + {"populate", 1, PopulateOp, 4, 4, "vecName density",}, + {"random", 4, RandomOp, 2, 2, "",}, /*Deprecated*/ + {"range", 4, RangeOp, 2, 4, "first last",}, + {"search", 3, SearchOp, 3, 5, "?-value? value ?value?",}, + {"seq", 3, SeqOp, 4, 5, "begin end ?num?",}, + {"set", 3, SetOp, 3, 3, "list",}, + {"simplify", 2, SimplifyOp, 2, 2, }, + {"sort", 2, SortOp, 2, 0, "?switches? ?vecName...?",}, + {"split", 2, SplitOp, 2, 0, "?vecName...?",}, + {"values", 3, ValuesOp, 2, 0, "?switches?",}, + {"variable", 3, MapOp, 2, 3, "?varName?",}, +}; + +static int nInstOps = sizeof(vectorInstOps) / sizeof(Blt_OpSpec); + +int +Blt_Vec_InstCmd(ClientData clientData, Tcl_Interp *interp, int objc, + Tcl_Obj *const *objv) +{ + VectorCmdProc *proc; + Vector *vPtr = clientData; + + vPtr->first = 0; + vPtr->last = vPtr->length - 1; + proc = Blt_GetOpFromObj(interp, nInstOps, vectorInstOps, BLT_OP_ARG1, objc, + objv, 0); + if (proc == NULL) { + return TCL_ERROR; + } + return (*proc) (vPtr, interp, objc, objv); +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_VarTrace -- + * + * Results: + * Returns NULL on success. Only called from a variable trace. + * + * Side effects: + * + *--------------------------------------------------------------------------- + */ +char * +Blt_Vec_VarTrace(ClientData clientData, Tcl_Interp *interp, const char *part1, + const char *part2, int flags) +{ + Blt_VectorIndexProc *indexProc; + Vector *vPtr = clientData; + int first, last; + int varFlags; +#define MAX_ERR_MSG 1023 + static char message[MAX_ERR_MSG + 1]; + + if (part2 == NULL) { + if (flags & TCL_TRACE_UNSETS) { + Blt_Free(vPtr->arrayName); + vPtr->arrayName = NULL; + if (vPtr->freeOnUnset) { + Blt_Vec_Free(vPtr); + } + } + return NULL; + } + if (Blt_Vec_GetIndexRange(interp, vPtr, part2, INDEX_ALL_FLAGS, &indexProc) + != TCL_OK) { + goto error; + } + first = vPtr->first, last = vPtr->last; + varFlags = TCL_LEAVE_ERR_MSG | (TCL_GLOBAL_ONLY & flags); + if (flags & TCL_TRACE_WRITES) { + double value; + Tcl_Obj *objPtr; + + if (first == SPECIAL_INDEX) { /* Tried to set "min" or "max" */ + return (char *)"read-only index"; + } + objPtr = Tcl_GetVar2Ex(interp, part1, part2, varFlags); + if (objPtr == NULL) { + goto error; + } + if (Blt_ExprDoubleFromObj(interp, objPtr, &value) != TCL_OK) { + if ((last == first) && (first >= 0)) { + /* Single numeric index. Reset the array element to + * its old value on errors */ + Tcl_SetVar2Ex(interp, part1, part2, objPtr, varFlags); + } + goto error; + } + if (first == vPtr->length) { + if (Blt_Vec_ChangeLength((Tcl_Interp *)NULL, vPtr, vPtr->length + 1) + != TCL_OK) { + return (char *)"error resizing vector"; + } + } + /* Set possibly an entire range of values */ + ReplicateValue(vPtr, first, last, value); + } else if (flags & TCL_TRACE_READS) { + double value; + Tcl_Obj *objPtr; + + if (vPtr->length == 0) { + if (Tcl_SetVar2(interp, part1, part2, "", varFlags) == NULL) { + goto error; + } + return NULL; + } + if (first == vPtr->length) { + return (char *)"write-only index"; + } + if (first == last) { + if (first >= 0) { + value = vPtr->valueArr[first]; + } else { + vPtr->first = 0, vPtr->last = vPtr->length - 1; + value = (*indexProc) ((Blt_Vector *) vPtr); + } + objPtr = Tcl_NewDoubleObj(value); + if (Tcl_SetVar2Ex(interp, part1, part2, objPtr, varFlags) == NULL) { + Tcl_DecrRefCount(objPtr); + goto error; + } + } else { + objPtr = GetValues(vPtr, first, last); + if (Tcl_SetVar2Ex(interp, part1, part2, objPtr, varFlags) == NULL) { + Tcl_DecrRefCount(objPtr); + goto error; + } + } + } else if (flags & TCL_TRACE_UNSETS) { + int i, j; + + if ((first == vPtr->length) || (first == SPECIAL_INDEX)) { + return (char *)"special vector index"; + } + /* + * Collapse the vector from the point of the first unset element. + * Also flush any array variable entries so that the shift is + * reflected when the array variable is read. + */ + for (i = first, j = last + 1; j < vPtr->length; i++, j++) { + vPtr->valueArr[i] = vPtr->valueArr[j]; + } + vPtr->length -= ((last - first) + 1); + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + } else { + return (char *)"unknown variable trace flag"; + } + if (flags & (TCL_TRACE_UNSETS | TCL_TRACE_WRITES)) { + Blt_Vec_UpdateClients(vPtr); + } + Tcl_ResetResult(interp); + return NULL; + + error: + strncpy(message, Tcl_GetStringResult(interp), MAX_ERR_MSG); + message[MAX_ERR_MSG] = '\0'; + return message; +} diff --git a/src/bltVecInt.h b/src/bltVecInt.h new file mode 100644 index 0000000..5d30f97 --- /dev/null +++ b/src/bltVecInt.h @@ -0,0 +1,251 @@ + +/* + * bltVecInt.h -- + * + * Copyright 1995-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +#include "bltInt.h" +#include <bltHash.h> +#include <bltChain.h> +#include <bltVector.h> + +#define VECTOR_THREAD_KEY "BLT Vector Data" +#define VECTOR_MAGIC ((unsigned int) 0x46170277) + +/* These defines allow parsing of different types of indices */ + +#define INDEX_SPECIAL (1<<0) /* Recognize "min", "max", and "++end" as + * valid indices */ +#define INDEX_COLON (1<<1) /* Also recognize a range of indices separated + * by a colon */ +#define INDEX_CHECK (1<<2) /* Verify that the specified index or range of + * indices are within limits */ +#define INDEX_ALL_FLAGS (INDEX_SPECIAL | INDEX_COLON | INDEX_CHECK) + +#define SPECIAL_INDEX -2 + +#define FFT_NO_CONSTANT (1<<0) +#define FFT_BARTLETT (1<<1) +#define FFT_SPECTRUM (1<<2) + +typedef struct { + Blt_HashTable vectorTable; /* Table of vectors */ + Blt_HashTable mathProcTable; /* Table of vector math functions */ + Blt_HashTable indexProcTable; + Tcl_Interp *interp; + unsigned int nextId; +} VectorInterpData; + +/* + * Vector -- + * + * A vector is an array of double precision values. It can be accessed + * through a TCL command, a TCL array variable, or C API. The storage for + * the array points initially to a statically allocated buffer, but to + * malloc-ed memory if more is necessary. + * + * Vectors can be shared by several clients (for example, two different + * graph widgets). The data is shared. When a client wants to use a + * vector, it allocates a vector identifier, which identifies the client. + * Clients use this ID to specify a callback routine to be invoked + * whenever the vector is modified or destroyed. Whenever the vector is + * updated or destroyed, each client is notified of the change by their + * callback routine. + */ + +typedef struct { + + /* + * If you change these fields, make sure you change the definition of + * Blt_Vector in bltInt.h and blt.h too. + */ + + double *valueArr; /* Array of values (malloc-ed) */ + + int length; /* Current number of values in the array. */ + + int size; /* Maximum number of values that can be stored + * in the value array. */ + + double min, max; /* Minimum and maximum values in the vector */ + + int dirty; /* Indicates if the vector has been updated */ + + int reserved; + + /* The following fields are local to this module */ + + const char *name; /* The namespace-qualified name of the vector. + * It points to the hash key allocated for the + * entry in the vector hash table. */ + + VectorInterpData *dataPtr; + Tcl_Interp *interp; /* Interpreter associated with the + * vector */ + + Blt_HashEntry *hashPtr; /* If non-NULL, pointer in a hash table to + * track the vectors in use. */ + + Tcl_FreeProc *freeProc; /* Address of procedure to call to release + * storage for the value array, Optionally can + * be one of the following: TCL_STATIC, + * TCL_DYNAMIC, or TCL_VOLATILE. */ + + const char *arrayName; /* The name of the TCL array variable mapped + * to the vector (malloc'ed). If NULL, + * indicates that the vector isn't mapped to + * any variable */ + + Tcl_Namespace *nsPtr; /* Namespace context of the vector itself. */ + + int offset; /* Offset from zero of the vector's starting + * index */ + + Tcl_Command cmdToken; /* Token for vector's TCL command. */ + + Blt_Chain chain; /* List of clients using this vector */ + + int notifyFlags; /* Notification flags. See definitions + * below */ + + int varFlags; /* Indicate if the variable is global, + * namespace, or local */ + + int freeOnUnset; /* For backward compatibility only: If + * non-zero, free the vector when its variable + * is unset. */ + int flush; + + int first, last; /* Selected region of vector. This is used + * mostly for the math routines */ +} Vector; + +#define NOTIFY_UPDATED ((int)BLT_VECTOR_NOTIFY_UPDATE) +#define NOTIFY_DESTROYED ((int)BLT_VECTOR_NOTIFY_DESTROY) + +#define NOTIFY_NEVER (1<<3) /* Never notify clients of updates to + * the vector */ +#define NOTIFY_ALWAYS (1<<4) /* Notify clients after each update + * of the vector is made */ +#define NOTIFY_WHENIDLE (1<<5) /* Notify clients at the next idle point + * that the vector has been updated. */ + +#define NOTIFY_PENDING (1<<6) /* A do-when-idle notification of the + * vector's clients is pending. */ +#define NOTIFY_NOW (1<<7) /* Notify clients of changes once + * immediately */ + +#define NOTIFY_WHEN_MASK (NOTIFY_NEVER|NOTIFY_ALWAYS|NOTIFY_WHENIDLE) + +#define UPDATE_RANGE (1<<9) /* The data of the vector has changed. + * Update the min and max limits when + * they are needed */ + +#define FindRange(array, first, last, min, max) \ +{ \ + min = max = 0.0; \ + if (first <= last) { \ + register int i; \ + min = max = array[first]; \ + for (i = first + 1; i <= last; i++) { \ + if (min > array[i]) { \ + min = array[i]; \ + } else if (max < array[i]) { \ + max = array[i]; \ + } \ + } \ + } \ +} + +BLT_EXTERN void Blt_Vec_InstallSpecialIndices(Blt_HashTable *tablePtr); + +BLT_EXTERN void Blt_Vec_InstallMathFunctions(Blt_HashTable *tablePtr); + +BLT_EXTERN void Blt_Vec_UninstallMathFunctions(Blt_HashTable *tablePtr); + +BLT_EXTERN VectorInterpData *Blt_Vec_GetInterpData (Tcl_Interp *interp); + +BLT_EXTERN double Blt_Vec_Max(Vector *vecObjPtr); +BLT_EXTERN double Blt_Vec_Min(Vector *vecObjPtr); + +BLT_EXTERN Vector *Blt_Vec_New(VectorInterpData *dataPtr); + +BLT_EXTERN int Blt_Vec_Duplicate(Vector *destPtr, Vector *srcPtr); + +BLT_EXTERN int Blt_Vec_SetLength(Tcl_Interp *interp, Vector *vPtr, + int length); + +BLT_EXTERN int Blt_Vec_SetSize(Tcl_Interp *interp, Vector *vPtr, + int size); + +BLT_EXTERN int Blt_Vec_ChangeLength(Tcl_Interp *interp, Vector *vPtr, + int length); + +BLT_EXTERN Vector *Blt_Vec_ParseElement(Tcl_Interp *interp, + VectorInterpData *dataPtr, const char *start, const char **endPtr, + int flags); + +BLT_EXTERN void Blt_Vec_Free(Vector *vPtr); + +BLT_EXTERN size_t *Blt_Vec_SortMap(Vector **vectors, int nVectors); + +BLT_EXTERN int Blt_Vec_LookupName(VectorInterpData *dataPtr, + const char *vecName, Vector **vPtrPtr); + +BLT_EXTERN Vector *Blt_Vec_Create(VectorInterpData *dataPtr, + const char *name, const char *cmdName, const char *varName, + int *newPtr); + +BLT_EXTERN void Blt_Vec_UpdateRange(Vector *vPtr); + +BLT_EXTERN void Blt_Vec_UpdateClients(Vector *vPtr); + +BLT_EXTERN void Blt_Vec_FlushCache(Vector *vPtr); + +BLT_EXTERN int Blt_Vec_Reset(Vector *vPtr, double *dataArr, + int nValues, int arraySize, Tcl_FreeProc *freeProc); + +BLT_EXTERN int Blt_Vec_GetIndex(Tcl_Interp *interp, Vector *vPtr, + const char *string, int *indexPtr, int flags, + Blt_VectorIndexProc **procPtrPtr); + +BLT_EXTERN int Blt_Vec_GetIndexRange(Tcl_Interp *interp, Vector *vPtr, + const char *string, int flags, Blt_VectorIndexProc **procPtrPtr); + +BLT_EXTERN int Blt_Vec_MapVariable(Tcl_Interp *interp, Vector *vPtr, + const char *name); + +BLT_EXTERN int Blt_Vec_FFT(Tcl_Interp *interp, Vector *realPtr, + Vector *phasesPtr, Vector *freqPtr, double delta, + int flags, Vector *srcPtr); + +BLT_EXTERN int Blt_Vec_InverseFFT(Tcl_Interp *interp, Vector *iSrcPtr, + Vector *rDestPtr, Vector *iDestPtr, Vector *srcPtr); + +BLT_EXTERN Tcl_ObjCmdProc Blt_Vec_InstCmd; + +BLT_EXTERN Tcl_VarTraceProc Blt_Vec_VarTrace; + +BLT_EXTERN Tcl_IdleProc Blt_Vec_NotifyClients; + diff --git a/src/bltVecMath.C b/src/bltVecMath.C new file mode 100644 index 0000000..a0bd4af --- /dev/null +++ b/src/bltVecMath.C @@ -0,0 +1,1895 @@ + +/* + * bltVecMath.c -- + * + * This module implements mathematical expressions with vector data + * objects. + * + * Copyright 1995-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include "bltVecInt.h" +#include "bltNsUtil.h" +#include "bltParse.h" + +/* + * Three types of math functions: + * + * ComponentProc Function is applied in multiple calls to + * each component of the vector. + * VectorProc Entire vector is passed, each component is + * modified. + * ScalarProc Entire vector is passed, single scalar value + * is returned. + */ + +typedef double (ComponentProc)(double value); +typedef int (VectorProc)(Vector *vPtr); +typedef double (ScalarProc)(Vector *vPtr); + +/* + * Built-in math functions: + */ +typedef int (GenericMathProc) _ANSI_ARGS_(ANYARGS); + +/* + * MathFunction -- + * + * Contains information about math functions that can be called + * for vectors. The table of math functions is global within the + * application. So you can't define two different "sqrt" + * functions. + */ +typedef struct { + const char *name; /* Name of built-in math function. If + * NULL, indicates that the function + * was user-defined and dynamically + * allocated. Function names are + * global across all interpreters. */ + + void *proc; /* Procedure that implements this math + * function. */ + + ClientData clientData; /* Argument to pass when invoking the + * function. */ + +} MathFunction; + + +/* + * Macros for testing floating-point values for certain special cases: + * + * IS_NAN Test for not-a-number by comparing a value against itself + * IF_INF Test for infinity by comparing against the largest floating + * point value. + */ + +#define IS_NAN(v) ((v) != (v)) + +#ifdef DBL_MAX +# define IS_INF(v) (((v) > DBL_MAX) || ((v) < -DBL_MAX)) +#else +# define IS_INF(v) 0 +#endif + +/* The data structure below is used to describe an expression value, + * which can be either a double-precision floating-point value, or a + * string. A given number has only one value at a time. */ + +#define STATIC_STRING_SPACE 150 + +/* + * Tokens -- + * + * The token types are defined below. In addition, there is a + * table associating a precedence with each operator. The order + * of types is important. Consult the code before changing it. + */ +enum Tokens { + VALUE, OPEN_PAREN, CLOSE_PAREN, COMMA, END, UNKNOWN, + MULT = 8, DIVIDE, MOD, PLUS, MINUS, + LEFT_SHIFT, RIGHT_SHIFT, + LESS, GREATER, LEQ, GEQ, EQUAL, NEQ, + OLD_BIT_AND, EXPONENT, OLD_BIT_OR, OLD_QUESTY, OLD_COLON, + AND, OR, UNARY_MINUS, OLD_UNARY_PLUS, NOT, OLD_BIT_NOT +}; + +typedef struct { + Vector *vPtr; + char staticSpace[STATIC_STRING_SPACE]; + ParseValue pv; /* Used to hold a string value, if any. */ +} Value; + +/* + * ParseInfo -- + * + * The data structure below describes the state of parsing an + * expression. It's passed among the routines in this module. + */ +typedef struct { + const char *expr; /* The entire right-hand side of the + * expression, as originally passed to + * Blt_ExprVector. */ + + const char *nextPtr; /* Position of the next character to + * be scanned from the expression + * string. */ + + enum Tokens token; /* Type of the last token to be parsed + * from nextPtr. See below for + * definitions. Corresponds to the + * characters just before nextPtr. */ + +} ParseInfo; + +/* + * Precedence table. The values for non-operator token types are ignored. + */ +static int precTable[] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, + 12, 12, 12, /* MULT, DIVIDE, MOD */ + 11, 11, /* PLUS, MINUS */ + 10, 10, /* LEFT_SHIFT, RIGHT_SHIFT */ + 9, 9, 9, 9, /* LESS, GREATER, LEQ, GEQ */ + 8, 8, /* EQUAL, NEQ */ + 7, /* OLD_BIT_AND */ + 13, /* EXPONENTIATION */ + 5, /* OLD_BIT_OR */ + 4, /* AND */ + 3, /* OR */ + 2, /* OLD_QUESTY */ + 1, /* OLD_COLON */ + 14, 14, 14, 14 /* UNARY_MINUS, OLD_UNARY_PLUS, NOT, + * OLD_BIT_NOT */ +}; + + +/* + * Forward declarations. + */ + +static int NextValue(Tcl_Interp *interp, ParseInfo *piPtr, int prec, + Value *valuePtr); + +#include <bltMath.h> + +/* + *--------------------------------------------------------------------------- + * + * Sort -- + * + * A vector math function. Sorts the values of the given + * vector. + * + * Results: + * Always TCL_OK. + * + * Side Effects: + * The vector is sorted. + * + *--------------------------------------------------------------------------- + */ +static int +Sort(Vector *vPtr) +{ + size_t *map; + double *values; + int i; + + map = Blt_Vec_SortMap(&vPtr, 1); + values = Blt_AssertMalloc(sizeof(double) * vPtr->length); + for(i = vPtr->first; i <= vPtr->last; i++) { + values[i] = vPtr->valueArr[map[i]]; + } + Blt_Free(map); + for (i = vPtr->first; i <= vPtr->last; i++) { + vPtr->valueArr[i] = values[i]; + } + Blt_Free(values); + return TCL_OK; +} + +static double +Length(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + + return (double)(vPtr->last - vPtr->first + 1); +} + +double +Blt_VecMax(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + + return Blt_Vec_Max(vPtr); +} + +double +Blt_VecMin(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + + return Blt_Vec_Min(vPtr); +} + + +static double +Product(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double prod; + double *vp, *vend; + + prod = 1.0; + for(vp = vPtr->valueArr + vPtr->first, + vend = vPtr->valueArr + vPtr->last; vp <= vend; vp++) { + prod *= *vp; + } + return prod; +} + +static double +Sum(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double sum, c; + double *vp, *vend; + + /* Kahan summation algorithm */ + + vp = vPtr->valueArr + vPtr->first; + sum = *vp++; + c = 0.0; /* A running compensation for lost + * low-order bits.*/ + for (vend = vPtr->valueArr + vPtr->last; vp <= vend; vp++) { + double y, t; + + y = *vp - c; /* So far, so good: c is zero.*/ + t = sum + y; /* Alas, sum is big, y small, so + * low-order digits of y are lost.*/ + c = (t - sum) - y; /* (t - sum) recovers the high-order + * part of y; subtracting y recovers + * -(low part of y) */ + sum = t; + } + return sum; +} + +static double +Mean(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double sum; + int n; + + sum = Sum(vectorPtr); + n = vPtr->last - vPtr->first + 1; + return sum / (double)n; +} + +/* + * var = 1/N Sum( (x[i] - mean)^2 ) + */ +static double +Variance(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double var, mean; + double *vp, *vend; + int count; + + mean = Mean(vectorPtr); + var = 0.0; + count = 0; + for(vp = vPtr->valueArr + vPtr->first, + vend = vPtr->valueArr + vPtr->last; vp <= vend; vp++) { + double dx; + + dx = *vp - mean; + var += dx * dx; + count++; + } + if (count < 2) { + return 0.0; + } + var /= (double)(count - 1); + return var; +} + +/* + * skew = Sum( (x[i] - mean)^3 ) / (var^3/2) + */ +static double +Skew(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double diff, var, skew, mean, diffsq; + double *vp, *vend; + int count; + + mean = Mean(vectorPtr); + var = skew = 0.0; + count = 0; + for(vp = vPtr->valueArr + vPtr->first, + vend = vPtr->valueArr + vPtr->last; vp <= vend; vp++) { + diff = *vp - mean; + diff = FABS(diff); + diffsq = diff * diff; + var += diffsq; + skew += diffsq * diff; + count++; + } + if (count < 2) { + return 0.0; + } + var /= (double)(count - 1); + skew /= count * var * sqrt(var); + return skew; +} + +static double +StdDeviation(Blt_Vector *vectorPtr) +{ + double var; + + var = Variance(vectorPtr); + if (var > 0.0) { + return sqrt(var); + } + return 0.0; +} + + +static double +AvgDeviation(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double diff, avg, mean; + double *vp, *vend; + int count; + + mean = Mean(vectorPtr); + avg = 0.0; + count = 0; + for(vp = vPtr->valueArr + vPtr->first, + vend = vPtr->valueArr + vPtr->last; vp <= vend; vp++) { + diff = *vp - mean; + avg += FABS(diff); + count++; + } + if (count < 2) { + return 0.0; + } + avg /= (double)count; + return avg; +} + + +static double +Kurtosis(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double diff, diffsq, kurt, var, mean; + double *vp, *vend; + int count; + + mean = Mean(vectorPtr); + var = kurt = 0.0; + count = 0; + for(vp = vPtr->valueArr + vPtr->first, + vend = vPtr->valueArr + vPtr->last; vp <= vend; vp++) { + diff = *vp - mean; + diffsq = diff * diff; + var += diffsq; + kurt += diffsq * diffsq; + count++; + } + if (count < 2) { + return 0.0; + } + var /= (double)(count - 1); + if (var == 0.0) { + return 0.0; + } + kurt /= (count * var * var); + return kurt - 3.0; /* Fisher Kurtosis */ +} + + +static double +Median(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + size_t *map; + double q2; + int mid; + + if (vPtr->length == 0) { + return -DBL_MAX; + } + map = Blt_Vec_SortMap(&vPtr, 1); + mid = (vPtr->length - 1) / 2; + + /* + * Determine Q2 by checking if the number of elements [0..n-1] is + * odd or even. If even, we must take the average of the two + * middle values. + */ + if (vPtr->length & 1) { /* Odd */ + q2 = vPtr->valueArr[map[mid]]; + } else { /* Even */ + q2 = (vPtr->valueArr[map[mid]] + + vPtr->valueArr[map[mid + 1]]) * 0.5; + } + Blt_Free(map); + return q2; +} + +static double +Q1(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double q1; + size_t *map; + + if (vPtr->length == 0) { + return -DBL_MAX; + } + map = Blt_Vec_SortMap(&vPtr, 1); + + if (vPtr->length < 4) { + q1 = vPtr->valueArr[map[0]]; + } else { + int mid, q; + + mid = (vPtr->length - 1) / 2; + q = mid / 2; + + /* + * Determine Q1 by checking if the number of elements in the + * bottom half [0..mid) is odd or even. If even, we must + * take the average of the two middle values. + */ + if (mid & 1) { /* Odd */ + q1 = vPtr->valueArr[map[q]]; + } else { /* Even */ + q1 = (vPtr->valueArr[map[q]] + + vPtr->valueArr[map[q + 1]]) * 0.5; + } + } + Blt_Free(map); + return q1; +} + +static double +Q3(Blt_Vector *vectorPtr) +{ + Vector *vPtr = (Vector *)vectorPtr; + double q3; + size_t *map; + + if (vPtr->length == 0) { + return -DBL_MAX; + } + + map = Blt_Vec_SortMap(&vPtr, 1); + + if (vPtr->length < 4) { + q3 = vPtr->valueArr[map[vPtr->length - 1]]; + } else { + int mid, q; + + mid = (vPtr->length - 1) / 2; + q = (vPtr->length + mid) / 2; + + /* + * Determine Q3 by checking if the number of elements in the + * upper half (mid..n-1] is odd or even. If even, we must + * take the average of the two middle values. + */ + if (mid & 1) { /* Odd */ + q3 = vPtr->valueArr[map[q]]; + } else { /* Even */ + q3 = (vPtr->valueArr[map[q]] + + vPtr->valueArr[map[q + 1]]) * 0.5; + } + } + Blt_Free(map); + return q3; +} + + +static int +Norm(Blt_Vector *vector) +{ + Vector *vPtr = (Vector *)vector; + double norm, range, min, max; + int i; + + min = Blt_Vec_Min(vPtr); + max = Blt_Vec_Max(vPtr); + range = max - min; + for (i = 0; i < vPtr->length; i++) { + norm = (vPtr->valueArr[i] - min) / range; + vPtr->valueArr[i] = norm; + } + return TCL_OK; +} + + +static double +Nonzeros(Blt_Vector *vector) +{ + Vector *vPtr = (Vector *)vector; + int count; + double *vp, *vend; + + count = 0; + for(vp = vPtr->valueArr + vPtr->first, + vend = vPtr->valueArr + vPtr->last; vp <= vend; vp++) { + if (*vp == 0.0) { + count++; + } + } + return (double) count; +} + +static double +Fabs(double value) +{ + if (value < 0.0) { + return -value; + } + return value; +} + +static double +Round(double value) +{ + if (value < 0.0) { + return ceil(value - 0.5); + } else { + return floor(value + 0.5); + } +} + +static double +Fmod(double x, double y) +{ + if (y == 0.0) { + return 0.0; + } + return x - (floor(x / y) * y); +} + +/* + *--------------------------------------------------------------------------- + * + * MathError -- + * + * This procedure is called when an error occurs during a + * floating-point operation. It reads errno and sets + * interp->result accordingly. + * + * Results: + * Interp->result is set to hold an error message. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +MathError( + Tcl_Interp *interp, /* Where to store error message. */ + double value) /* Value returned after error; used to + * distinguish underflows from + * overflows. */ +{ + if ((errno == EDOM) || (value != value)) { + Tcl_AppendResult(interp, "domain error: argument not in valid range", + (char *)NULL); + Tcl_SetErrorCode(interp, "ARITH", "DOMAIN", interp->result, + (char *)NULL); + } else if ((errno == ERANGE) || IS_INF(value)) { + if (value == 0.0) { + Tcl_AppendResult(interp, + "floating-point value too small to represent", + (char *)NULL); + Tcl_SetErrorCode(interp, "ARITH", "UNDERFLOW", interp->result, + (char *)NULL); + } else { + Tcl_AppendResult(interp, + "floating-point value too large to represent", + (char *)NULL); + Tcl_SetErrorCode(interp, "ARITH", "OVERFLOW", interp->result, + (char *)NULL); + } + } else { + Tcl_AppendResult(interp, "unknown floating-point error, ", + "errno = ", Blt_Itoa(errno), (char *)NULL); + Tcl_SetErrorCode(interp, "ARITH", "UNKNOWN", interp->result, + (char *)NULL); + } +} + +/* + *--------------------------------------------------------------------------- + * + * ParseString -- + * + * Given a string (such as one coming from command or variable + * substitution), make a Value based on the string. The value + * will be a floating-point or integer, if possible, or else it + * will just be a copy of the string. + * + * Results: + * TCL_OK is returned under normal circumstances, and TCL_ERROR + * is returned if a floating-point overflow or underflow occurred + * while reading in a number. The value at *valuePtr is modified + * to hold a number, if possible. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ + +static int +ParseString( + Tcl_Interp *interp, /* Where to store error message. */ + const char *string, /* String to turn into value. */ + Value *valuePtr) /* Where to store value information. + * Caller must have initialized pv field. */ +{ + const char *endPtr; + double value; + + errno = 0; + + /* + * The string can be either a number or a vector. First try to + * convert the string to a number. If that fails then see if + * we can find a vector by that name. + */ + + value = strtod(string, (char **)&endPtr); + if ((endPtr != string) && (*endPtr == '\0')) { + if (errno != 0) { + Tcl_ResetResult(interp); + MathError(interp, value); + return TCL_ERROR; + } + /* Numbers are stored as single element vectors. */ + if (Blt_Vec_ChangeLength(interp, valuePtr->vPtr, 1) != TCL_OK) { + return TCL_ERROR; + } + valuePtr->vPtr->valueArr[0] = value; + return TCL_OK; + } else { + Vector *vPtr; + + while (isspace(UCHAR(*string))) { + string++; /* Skip spaces leading the vector name. */ + } + vPtr = Blt_Vec_ParseElement(interp, valuePtr->vPtr->dataPtr, + string, &endPtr, NS_SEARCH_BOTH); + if (vPtr == NULL) { + return TCL_ERROR; + } + if (*endPtr != '\0') { + Tcl_AppendResult(interp, "extra characters after vector", + (char *)NULL); + return TCL_ERROR; + } + /* Copy the designated vector to our temporary. */ + Blt_Vec_Duplicate(valuePtr->vPtr, vPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * ParseMathFunction -- + * + * This procedure is invoked to parse a math function from an + * expression string, carry out the function, and return the + * value computed. + * + * Results: + * TCL_OK is returned if all went well and the function's value + * was computed successfully. If the name doesn't match any + * known math function, returns TCL_RETURN. And if a format error + * was found, TCL_ERROR is returned and an error message is left + * in interp->result. + * + * After a successful return piPtr will be updated to point to + * the character just after the function call, the token is set + * to VALUE, and the value is stored in valuePtr. + * + * Side effects: + * Embedded commands could have arbitrary side-effects. + * + *--------------------------------------------------------------------------- + */ +static int +ParseMathFunction( + Tcl_Interp *interp, /* Interpreter to use for error reporting. */ + const char *start, /* Start of string to parse */ + ParseInfo *piPtr, /* Describes the state of the parse. + * piPtr->nextPtr must point to the + * first character of the function's + * name. */ + Value *valuePtr) /* Where to store value, if that is + * what's parsed from string. Caller + * must have initialized pv field + * correctly. */ +{ + Blt_HashEntry *hPtr; + MathFunction *mathPtr; /* Info about math function. */ + char *p; + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + GenericMathProc *proc; + + /* + * Find the end of the math function's name and lookup the + * record for the function. + */ + p = (char *)start; + while (isspace(UCHAR(*p))) { + p++; + } + piPtr->nextPtr = p; + while (isalnum(UCHAR(*p)) || (*p == '_')) { + p++; + } + if (*p != '(') { + return TCL_RETURN; /* Must start with open parenthesis */ + } + dataPtr = valuePtr->vPtr->dataPtr; + *p = '\0'; + hPtr = Blt_FindHashEntry(&dataPtr->mathProcTable, piPtr->nextPtr); + *p = '('; + if (hPtr == NULL) { + return TCL_RETURN; /* Name doesn't match any known function */ + } + /* Pick up the single value as the argument to the function */ + piPtr->token = OPEN_PAREN; + piPtr->nextPtr = p + 1; + valuePtr->pv.next = valuePtr->pv.buffer; + if (NextValue(interp, piPtr, -1, valuePtr) != TCL_OK) { + return TCL_ERROR; /* Parse error */ + } + if (piPtr->token != CLOSE_PAREN) { + Tcl_AppendResult(interp, "unmatched parentheses in expression \"", + piPtr->expr, "\"", (char *)NULL); + return TCL_ERROR; /* Missing right parenthesis */ + } + mathPtr = Blt_GetHashValue(hPtr); + proc = mathPtr->proc; + if ((*proc) (mathPtr->clientData, interp, valuePtr->vPtr) != TCL_OK) { + return TCL_ERROR; /* Function invocation error */ + } + piPtr->token = VALUE; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NextToken -- + * + * Lexical analyzer for expression parser: parses a single value, + * operator, or other syntactic element from an expression string. + * + * Results: + * TCL_OK is returned unless an error occurred while doing lexical + * analysis or executing an embedded command. In that case a + * standard TCL error is returned, using interp->result to hold + * an error message. In the event of a successful return, the token + * and field in piPtr is updated to refer to the next symbol in + * the expression string, and the expr field is advanced past that + * token; if the token is a value, then the value is stored at + * valuePtr. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static int +NextToken( + Tcl_Interp *interp, /* Interpreter to use for error reporting. */ + ParseInfo *piPtr, /* Describes the state of the parse. */ + Value *valuePtr) /* Where to store value, if that is + * what's parsed from string. Caller + * must have initialized pv field + * correctly. */ +{ + const char *p; + const char *endPtr; + const char *var; + int result; + + p = piPtr->nextPtr; + while (isspace(UCHAR(*p))) { + p++; + } + if (*p == '\0') { + piPtr->token = END; + piPtr->nextPtr = p; + return TCL_OK; + } + /* + * Try to parse the token as a floating-point number. But check + * that the first character isn't a "-" or "+", which "strtod" + * will happily accept as an unary operator. Otherwise, we might + * accidently treat a binary operator as unary by mistake, which + * will eventually cause a syntax error. + */ + if ((*p != '-') && (*p != '+')) { + double value; + + errno = 0; + value = strtod(p, (char **)&endPtr); + if (endPtr != p) { + if (errno != 0) { + MathError(interp, value); + return TCL_ERROR; + } + piPtr->token = VALUE; + piPtr->nextPtr = endPtr; + + /* + * Save the single floating-point value as an 1-component vector. + */ + if (Blt_Vec_ChangeLength(interp, valuePtr->vPtr, 1) != TCL_OK) { + return TCL_ERROR; + } + valuePtr->vPtr->valueArr[0] = value; + return TCL_OK; + } + } + piPtr->nextPtr = p + 1; + switch (*p) { + case '$': + piPtr->token = VALUE; + var = Tcl_ParseVar(interp, p, &endPtr); + if (var == NULL) { + return TCL_ERROR; + } + piPtr->nextPtr = endPtr; + Tcl_ResetResult(interp); + result = ParseString(interp, var, valuePtr); + return result; + + case '[': + piPtr->token = VALUE; + result = Blt_ParseNestedCmd(interp, p + 1, 0, &endPtr, &valuePtr->pv); + if (result != TCL_OK) { + return result; + } + piPtr->nextPtr = endPtr; + Tcl_ResetResult(interp); + result = ParseString(interp, valuePtr->pv.buffer, valuePtr); + return result; + + case '"': + piPtr->token = VALUE; + result = Blt_ParseQuotes(interp, p + 1, '"', 0, &endPtr, &valuePtr->pv); + if (result != TCL_OK) { + return result; + } + piPtr->nextPtr = endPtr; + Tcl_ResetResult(interp); + result = ParseString(interp, valuePtr->pv.buffer, valuePtr); + return result; + + case '{': + piPtr->token = VALUE; + result = Blt_ParseBraces(interp, p + 1, &endPtr, &valuePtr->pv); + if (result != TCL_OK) { + return result; + } + piPtr->nextPtr = endPtr; + Tcl_ResetResult(interp); + result = ParseString(interp, valuePtr->pv.buffer, valuePtr); + return result; + + case '(': + piPtr->token = OPEN_PAREN; + break; + + case ')': + piPtr->token = CLOSE_PAREN; + break; + + case ',': + piPtr->token = COMMA; + break; + + case '*': + piPtr->token = MULT; + break; + + case '/': + piPtr->token = DIVIDE; + break; + + case '%': + piPtr->token = MOD; + break; + + case '+': + piPtr->token = PLUS; + break; + + case '-': + piPtr->token = MINUS; + break; + + case '^': + piPtr->token = EXPONENT; + break; + + case '<': + switch (*(p + 1)) { + case '<': + piPtr->nextPtr = p + 2; + piPtr->token = LEFT_SHIFT; + break; + case '=': + piPtr->nextPtr = p + 2; + piPtr->token = LEQ; + break; + default: + piPtr->token = LESS; + break; + } + break; + + case '>': + switch (*(p + 1)) { + case '>': + piPtr->nextPtr = p + 2; + piPtr->token = RIGHT_SHIFT; + break; + case '=': + piPtr->nextPtr = p + 2; + piPtr->token = GEQ; + break; + default: + piPtr->token = GREATER; + break; + } + break; + + case '=': + if (*(p + 1) == '=') { + piPtr->nextPtr = p + 2; + piPtr->token = EQUAL; + } else { + piPtr->token = UNKNOWN; + } + break; + + case '&': + if (*(p + 1) == '&') { + piPtr->nextPtr = p + 2; + piPtr->token = AND; + } else { + piPtr->token = UNKNOWN; + } + break; + + case '|': + if (*(p + 1) == '|') { + piPtr->nextPtr = p + 2; + piPtr->token = OR; + } else { + piPtr->token = UNKNOWN; + } + break; + + case '!': + if (*(p + 1) == '=') { + piPtr->nextPtr = p + 2; + piPtr->token = NEQ; + } else { + piPtr->token = NOT; + } + break; + + default: + piPtr->token = VALUE; + result = ParseMathFunction(interp, p, piPtr, valuePtr); + if ((result == TCL_OK) || (result == TCL_ERROR)) { + return result; + } else { + Vector *vPtr; + + while (isspace(UCHAR(*p))) { + p++; /* Skip spaces leading the vector name. */ + } + vPtr = Blt_Vec_ParseElement(interp, valuePtr->vPtr->dataPtr, + p, &endPtr, NS_SEARCH_BOTH); + if (vPtr == NULL) { + return TCL_ERROR; + } + Blt_Vec_Duplicate(valuePtr->vPtr, vPtr); + piPtr->nextPtr = endPtr; + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * NextValue -- + * + * Parse a "value" from the remainder of the expression in piPtr. + * + * Results: + * Normally TCL_OK is returned. The value of the expression is + * returned in *valuePtr. If an error occurred, then interp->result + * contains an error message and TCL_ERROR is returned. + * InfoPtr->token will be left pointing to the token AFTER the + * expression, and piPtr->nextPtr will point to the character just + * after the terminating token. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static int +NextValue( + Tcl_Interp *interp, /* Interpreter to use for error reporting. */ + ParseInfo *piPtr, /* Describes the state of the parse + * just before the value (i.e. NextToken will + * be called to get first token of value). */ + int prec, /* Treat any un-parenthesized operator + * with precedence <= this as the end + * of the expression. */ + Value *valuePtr) /* Where to store the value of the expression. + * Caller must have initialized pv field. */ +{ + Value value2; /* Second operand for current operator. */ + int operator; /* Current operator (either unary or binary). */ + int gotOp; /* Non-zero means already lexed the operator + * (while picking up value for unary operator). + * Don't lex again. */ + int result; + Vector *vPtr, *v2Ptr; + int i; + + /* + * There are two phases to this procedure. First, pick off an initial + * value. Then, parse (binary operator, value) pairs until done. + */ + + vPtr = valuePtr->vPtr; + v2Ptr = Blt_Vec_New(vPtr->dataPtr); + gotOp = FALSE; + value2.vPtr = v2Ptr; + value2.pv.buffer = value2.pv.next = value2.staticSpace; + value2.pv.end = value2.pv.buffer + STATIC_STRING_SPACE - 1; + value2.pv.expandProc = Blt_ExpandParseValue; + value2.pv.clientData = NULL; + + result = NextToken(interp, piPtr, valuePtr); + if (result != TCL_OK) { + goto done; + } + if (piPtr->token == OPEN_PAREN) { + + /* Parenthesized sub-expression. */ + + result = NextValue(interp, piPtr, -1, valuePtr); + if (result != TCL_OK) { + goto done; + } + if (piPtr->token != CLOSE_PAREN) { + Tcl_AppendResult(interp, "unmatched parentheses in expression \"", + piPtr->expr, "\"", (char *)NULL); + result = TCL_ERROR; + goto done; + } + } else { + if (piPtr->token == MINUS) { + piPtr->token = UNARY_MINUS; + } + if (piPtr->token >= UNARY_MINUS) { + operator = piPtr->token; + result = NextValue(interp, piPtr, precTable[operator], valuePtr); + if (result != TCL_OK) { + goto done; + } + gotOp = TRUE; + /* Process unary operators. */ + switch (operator) { + case UNARY_MINUS: + for(i = 0; i < vPtr->length; i++) { + vPtr->valueArr[i] = -(vPtr->valueArr[i]); + } + break; + + case NOT: + for(i = 0; i < vPtr->length; i++) { + vPtr->valueArr[i] = (double)(!vPtr->valueArr[i]); + } + break; + default: + Tcl_AppendResult(interp, "unknown operator", (char *)NULL); + goto error; + } + } else if (piPtr->token != VALUE) { + Tcl_AppendResult(interp, "missing operand", (char *)NULL); + goto error; + } + } + if (!gotOp) { + result = NextToken(interp, piPtr, &value2); + if (result != TCL_OK) { + goto done; + } + } + /* + * Got the first operand. Now fetch (operator, operand) pairs. + */ + for (;;) { + operator = piPtr->token; + + value2.pv.next = value2.pv.buffer; + if ((operator < MULT) || (operator >= UNARY_MINUS)) { + if ((operator == END) || (operator == CLOSE_PAREN) || + (operator == COMMA)) { + result = TCL_OK; + goto done; + } else { + Tcl_AppendResult(interp, "bad operator", (char *)NULL); + goto error; + } + } + if (precTable[operator] <= prec) { + result = TCL_OK; + goto done; + } + result = NextValue(interp, piPtr, precTable[operator], &value2); + if (result != TCL_OK) { + goto done; + } + if ((piPtr->token < MULT) && (piPtr->token != VALUE) && + (piPtr->token != END) && (piPtr->token != CLOSE_PAREN) && + (piPtr->token != COMMA)) { + Tcl_AppendResult(interp, "unexpected token in expression", + (char *)NULL); + goto error; + } + /* + * At this point we have two vectors and an operator. + */ + + if (v2Ptr->length == 1) { + double *opnd; + double scalar; + + /* + * 2nd operand is a scalar. + */ + scalar = v2Ptr->valueArr[0]; + opnd = vPtr->valueArr; + switch (operator) { + case MULT: + for(i = 0; i < vPtr->length; i++) { + opnd[i] *= scalar; + } + break; + + case DIVIDE: + if (scalar == 0.0) { + Tcl_AppendResult(interp, "divide by zero", (char *)NULL); + goto error; + } + for(i = 0; i < vPtr->length; i++) { + opnd[i] /= scalar; + } + break; + + case PLUS: + for(i = 0; i < vPtr->length; i++) { + opnd[i] += scalar; + } + break; + + case MINUS: + for(i = 0; i < vPtr->length; i++) { + opnd[i] -= scalar; + } + break; + + case EXPONENT: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = pow(opnd[i], scalar); + } + break; + + case MOD: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = Fmod(opnd[i], scalar); + } + break; + + case LESS: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] < scalar); + } + break; + + case GREATER: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] > scalar); + } + break; + + case LEQ: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] <= scalar); + } + break; + + case GEQ: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] >= scalar); + } + break; + + case EQUAL: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] == scalar); + } + break; + + case NEQ: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] != scalar); + } + break; + + case AND: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] && scalar); + } + break; + + case OR: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] || scalar); + } + break; + + case LEFT_SHIFT: + { + int offset; + + offset = (int)scalar % vPtr->length; + if (offset > 0) { + double *hold; + int j; + + hold = Blt_AssertMalloc(sizeof(double) * offset); + for (i = 0; i < offset; i++) { + hold[i] = opnd[i]; + } + for (i = offset, j = 0; i < vPtr->length; i++, j++) { + opnd[j] = opnd[i]; + } + for (i = 0, j = vPtr->length - offset; + j < vPtr->length; i++, j++) { + opnd[j] = hold[i]; + } + Blt_Free(hold); + } + } + break; + + case RIGHT_SHIFT: + { + int offset; + + offset = (int)scalar % vPtr->length; + if (offset > 0) { + double *hold; + int j; + + hold = Blt_AssertMalloc(sizeof(double) * offset); + for (i = vPtr->length - offset, j = 0; + i < vPtr->length; i++, j++) { + hold[j] = opnd[i]; + } + for (i = vPtr->length - offset - 1, + j = vPtr->length - 1; i >= 0; i--, j--) { + opnd[j] = opnd[i]; + } + for (i = 0; i < offset; i++) { + opnd[i] = hold[i]; + } + Blt_Free(hold); + } + } + break; + + default: + Tcl_AppendResult(interp, "unknown operator in expression", + (char *)NULL); + goto error; + } + + } else if (vPtr->length == 1) { + double *opnd; + double scalar; + + /* + * 1st operand is a scalar. + */ + scalar = vPtr->valueArr[0]; + Blt_Vec_Duplicate(vPtr, v2Ptr); + opnd = vPtr->valueArr; + switch (operator) { + case MULT: + for(i = 0; i < vPtr->length; i++) { + opnd[i] *= scalar; + } + break; + + case PLUS: + for(i = 0; i < vPtr->length; i++) { + opnd[i] += scalar; + } + break; + + case DIVIDE: + for(i = 0; i < vPtr->length; i++) { + if (opnd[i] == 0.0) { + Tcl_AppendResult(interp, "divide by zero", + (char *)NULL); + goto error; + } + opnd[i] = (scalar / opnd[i]); + } + break; + + case MINUS: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = scalar - opnd[i]; + } + break; + + case EXPONENT: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = pow(scalar, opnd[i]); + } + break; + + case MOD: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = Fmod(scalar, opnd[i]); + } + break; + + case LESS: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(scalar < opnd[i]); + } + break; + + case GREATER: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(scalar > opnd[i]); + } + break; + + case LEQ: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(scalar >= opnd[i]); + } + break; + + case GEQ: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(scalar <= opnd[i]); + } + break; + + case EQUAL: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] == scalar); + } + break; + + case NEQ: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] != scalar); + } + break; + + case AND: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] && scalar); + } + break; + + case OR: + for(i = 0; i < vPtr->length; i++) { + opnd[i] = (double)(opnd[i] || scalar); + } + break; + + case LEFT_SHIFT: + case RIGHT_SHIFT: + Tcl_AppendResult(interp, "second shift operand must be scalar", + (char *)NULL); + goto error; + + default: + Tcl_AppendResult(interp, "unknown operator in expression", + (char *)NULL); + goto error; + } + } else { + double *opnd1, *opnd2; + /* + * Carry out the function of the specified operator. + */ + if (vPtr->length != v2Ptr->length) { + Tcl_AppendResult(interp, "vectors are different lengths", + (char *)NULL); + goto error; + } + opnd1 = vPtr->valueArr, opnd2 = v2Ptr->valueArr; + switch (operator) { + case MULT: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] *= opnd2[i]; + } + break; + + case DIVIDE: + for (i = 0; i < vPtr->length; i++) { + if (opnd2[i] == 0.0) { + Tcl_AppendResult(interp, + "can't divide by 0.0 vector component", + (char *)NULL); + goto error; + } + opnd1[i] /= opnd2[i]; + } + break; + + case PLUS: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] += opnd2[i]; + } + break; + + case MINUS: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] -= opnd2[i]; + } + break; + + case MOD: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = Fmod(opnd1[i], opnd2[i]); + } + break; + + case EXPONENT: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = pow(opnd1[i], opnd2[i]); + } + break; + + case LESS: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = (double)(opnd1[i] < opnd2[i]); + } + break; + + case GREATER: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = (double)(opnd1[i] > opnd2[i]); + } + break; + + case LEQ: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = (double)(opnd1[i] <= opnd2[i]); + } + break; + + case GEQ: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = (double)(opnd1[i] >= opnd2[i]); + } + break; + + case EQUAL: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = (double)(opnd1[i] == opnd2[i]); + } + break; + + case NEQ: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = (double)(opnd1[i] != opnd2[i]); + } + break; + + case AND: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = (double)(opnd1[i] && opnd2[i]); + } + break; + + case OR: + for (i = 0; i < vPtr->length; i++) { + opnd1[i] = (double)(opnd1[i] || opnd2[i]); + } + break; + + case LEFT_SHIFT: + case RIGHT_SHIFT: + Tcl_AppendResult(interp, "second shift operand must be scalar", + (char *)NULL); + goto error; + + default: + Tcl_AppendResult(interp, "unknown operator in expression", + (char *)NULL); + goto error; + } + } + } + done: + if (value2.pv.buffer != value2.staticSpace) { + Blt_Free(value2.pv.buffer); + } + Blt_Vec_Free(v2Ptr); + return result; + + error: + if (value2.pv.buffer != value2.staticSpace) { + Blt_Free(value2.pv.buffer); + } + Blt_Vec_Free(v2Ptr); + return TCL_ERROR; +} + +/* + *--------------------------------------------------------------------------- + * + * EvaluateExpression -- + * + * This procedure provides top-level functionality shared by + * procedures like Tcl_ExprInt, Tcl_ExprDouble, etc. + * + * Results: + * The result is a standard TCL return value. If an error + * occurs then an error message is left in interp->result. + * The value of the expression is returned in *valuePtr, in + * whatever form it ends up in (could be string or integer + * or double). Caller may need to convert result. Caller + * is also responsible for freeing string memory in *valuePtr, + * if any was allocated. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static int +EvaluateExpression( + Tcl_Interp *interp, /* Context in which to evaluate the + * expression. */ + char *string, /* Expression to evaluate. */ + Value *valuePtr) /* Where to store result. Should + * not be initialized by caller. */ +{ + ParseInfo info; + int result; + Vector *vPtr; + double *vp, *vend; + + info.expr = info.nextPtr = string; + valuePtr->pv.buffer = valuePtr->pv.next = valuePtr->staticSpace; + valuePtr->pv.end = valuePtr->pv.buffer + STATIC_STRING_SPACE - 1; + valuePtr->pv.expandProc = Blt_ExpandParseValue; + valuePtr->pv.clientData = NULL; + + result = NextValue(interp, &info, -1, valuePtr); + if (result != TCL_OK) { + return result; + } + if (info.token != END) { + Tcl_AppendResult(interp, ": syntax error in expression \"", + string, "\"", (char *)NULL); + return TCL_ERROR; + } + vPtr = valuePtr->vPtr; + + /* Check for NaN's and overflows. */ + for (vp = vPtr->valueArr, vend = vp + vPtr->length; vp < vend; vp++) { + if (!FINITE(*vp)) { + /* + * IEEE floating-point error. + */ + MathError(interp, *vp); + return TCL_ERROR; + } + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Math Functions -- + * + * This page contains the procedures that implement all of the + * built-in math functions for expressions. + * + * Results: + * Each procedure returns TCL_OK if it succeeds and places result + * information at *resultPtr. If it fails it returns TCL_ERROR + * and leaves an error message in interp->result. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +static int +ComponentFunc( + ClientData clientData, /* Contains address of procedure that + * takes one double argument and + * returns a double result. */ + Tcl_Interp *interp, + Vector *vPtr) +{ + ComponentProc *procPtr = (ComponentProc *) clientData; + double *vp, *vend; + + errno = 0; + for(vp = vPtr->valueArr + vPtr->first, + vend = vPtr->valueArr + vPtr->last; vp <= vend; vp++) { + *vp = (*procPtr) (*vp); + if (errno != 0) { + MathError(interp, *vp); + return TCL_ERROR; + } + if (!FINITE(*vp)) { + /* + * IEEE floating-point error. + */ + MathError(interp, *vp); + return TCL_ERROR; + } + } + return TCL_OK; +} + +static int +ScalarFunc(ClientData clientData, Tcl_Interp *interp, Vector *vPtr) +{ + double value; + ScalarProc *procPtr = (ScalarProc *) clientData; + + errno = 0; + value = (*procPtr) (vPtr); + if (errno != 0) { + MathError(interp, value); + return TCL_ERROR; + } + if (Blt_Vec_ChangeLength(interp, vPtr, 1) != TCL_OK) { + return TCL_ERROR; + } + vPtr->valueArr[0] = value; + return TCL_OK; +} + +/*ARGSUSED*/ +static int +VectorFunc(ClientData clientData, Tcl_Interp *interp, Vector *vPtr) +{ + VectorProc *procPtr = (VectorProc *) clientData; + + return (*procPtr) (vPtr); +} + + +static MathFunction mathFunctions[] = +{ + {"abs", ComponentFunc, Fabs}, + {"acos", ComponentFunc, acos}, + {"asin", ComponentFunc, asin}, + {"atan", ComponentFunc, atan}, + {"adev", ScalarFunc, AvgDeviation}, + {"ceil", ComponentFunc, ceil}, + {"cos", ComponentFunc, cos}, + {"cosh", ComponentFunc, cosh}, + {"exp", ComponentFunc, exp}, + {"floor", ComponentFunc, floor}, + {"kurtosis",ScalarFunc, Kurtosis}, + {"length", ScalarFunc, Length}, + {"log", ComponentFunc, log}, + {"log10", ComponentFunc, log10}, + {"max", ScalarFunc, Blt_VecMax}, + {"mean", ScalarFunc, Mean}, + {"median", ScalarFunc, Median}, + {"min", ScalarFunc, Blt_VecMin}, + {"norm", VectorFunc, Norm}, + {"nz", ScalarFunc, Nonzeros}, + {"q1", ScalarFunc, Q1}, + {"q3", ScalarFunc, Q3}, + {"prod", ScalarFunc, Product}, + {"random", ComponentFunc, drand48}, + {"round", ComponentFunc, Round}, + {"sdev", ScalarFunc, StdDeviation}, + {"sin", ComponentFunc, sin}, + {"sinh", ComponentFunc, sinh}, + {"skew", ScalarFunc, Skew}, + {"sort", VectorFunc, Sort}, + {"sqrt", ComponentFunc, sqrt}, + {"sum", ScalarFunc, Sum}, + {"tan", ComponentFunc, tan}, + {"tanh", ComponentFunc, tanh}, + {"var", ScalarFunc, Variance}, + {(char *)NULL,}, +}; + +void +Blt_Vec_InstallMathFunctions(Blt_HashTable *tablePtr) +{ + MathFunction *mathPtr; + + for (mathPtr = mathFunctions; mathPtr->name != NULL; mathPtr++) { + Blt_HashEntry *hPtr; + int isNew; + + hPtr = Blt_CreateHashEntry(tablePtr, mathPtr->name, &isNew); + Blt_SetHashValue(hPtr, (ClientData)mathPtr); + } +} + +void +Blt_Vec_UninstallMathFunctions(Blt_HashTable *tablePtr) +{ + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(tablePtr, &cursor); hPtr != NULL; + hPtr = Blt_NextHashEntry(&cursor)) { + MathFunction *mathPtr; + + mathPtr = Blt_GetHashValue(hPtr); + if (mathPtr->name == NULL) { + Blt_Free(mathPtr); + } + } +} + + +static void +InstallIndexProc( + Blt_HashTable *tablePtr, + const char *string, + Blt_VectorIndexProc *procPtr) /* Pointer to function to be called + * when the vector finds the named index. + * If NULL, this indicates to remove + * the index from the table. + */ +{ + Blt_HashEntry *hPtr; + int dummy; + + hPtr = Blt_CreateHashEntry(tablePtr, string, &dummy); + if (procPtr == NULL) { + Blt_DeleteHashEntry(tablePtr, hPtr); + } else { + Blt_SetHashValue(hPtr, (ClientData)procPtr); + } +} + +void +Blt_Vec_InstallSpecialIndices(Blt_HashTable *tablePtr) +{ + InstallIndexProc(tablePtr, "min", Blt_VecMin); + InstallIndexProc(tablePtr, "max", Blt_VecMax); + InstallIndexProc(tablePtr, "mean", Mean); + InstallIndexProc(tablePtr, "sum", Sum); + InstallIndexProc(tablePtr, "prod", Product); +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_ExprVector -- + * + * Evaluates an vector expression and returns its value(s). + * + * Results: + * Each of the procedures below returns a standard TCL result. + * If an error occurs then an error message is left in + * interp->result. Otherwise the value of the expression, + * in the appropriate form, is stored at *resultPtr. If + * the expression had a result that was incompatible with the + * desired form then an error is returned. + * + * Side effects: + * None. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ExprVector( + Tcl_Interp *interp, /* Context in which to evaluate the + * expression. */ + char *string, /* Expression to evaluate. */ + Blt_Vector *vector) /* Where to store result. */ +{ + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + Vector *vPtr = (Vector *)vector; + Value value; + + dataPtr = (vector != NULL) + ? vPtr->dataPtr : Blt_Vec_GetInterpData(interp); + value.vPtr = Blt_Vec_New(dataPtr); + if (EvaluateExpression(interp, string, &value) != TCL_OK) { + Blt_Vec_Free(value.vPtr); + return TCL_ERROR; + } + if (vPtr != NULL) { + Blt_Vec_Duplicate(vPtr, value.vPtr); + } else { + Tcl_Obj *listObjPtr; + double *vp, *vend; + + /* No result vector. Put values in interp->result. */ + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + for (vp = value.vPtr->valueArr, vend = vp + value.vPtr->length; + vp < vend; vp++) { + Tcl_ListObjAppendElement(interp, listObjPtr, Tcl_NewDoubleObj(*vp)); + } + Tcl_SetObjResult(interp, listObjPtr); + } + Blt_Vec_Free(value.vPtr); + return TCL_OK; +} diff --git a/src/bltVector.C b/src/bltVector.C new file mode 100644 index 0000000..e332b9d --- /dev/null +++ b/src/bltVector.C @@ -0,0 +1,2808 @@ + +/* + * bltVector.c -- + * + * This module implements vector data objects. + * + * Copyright 1995-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* + * TODO: + * o Add H. Kirsch's vector binary read operation + * x binread file0 + * x binread -file file0 + * + * o Add ASCII/binary file reader + * x read fileName + * + * o Allow Tcl-based client notifications. + * vector x + * x notify call Display + * x notify delete Display + * x notify reorder #1 #2 + */ + +#include "bltVecInt.h" +#include "bltOp.h" +#include "bltNsUtil.h" +#include "bltSwitch.h" +#include <bltMath.h> + +#ifdef TIME_WITH_SYS_TIME +#include <sys/time.h> +#include <time.h> +#else +#ifdef HAVE_SYS_TIME_H +#include <sys/time.h> +#else +#include <time.h> +#endif /* HAVE_SYS_TIME_H */ +#endif /* TIME_WITH_SYS_TIME */ + +#ifndef TCL_NAMESPACE_ONLY +#define TCL_NAMESPACE_ONLY TCL_GLOBAL_ONLY +#endif + +#define DEF_ARRAY_SIZE 64 +#define TRACE_ALL (TCL_TRACE_WRITES | TCL_TRACE_READS | TCL_TRACE_UNSETS) + + +#define VECTOR_CHAR(c) ((isalnum(UCHAR(c))) || \ + (c == '_') || (c == ':') || (c == '@') || (c == '.')) + + +/* + * VectorClient -- + * + * A vector can be shared by several clients. Each client allocates this + * structure that acts as its key for using the vector. Clients can also + * designate a callback routine that is executed whenever the vector is + * updated or destroyed. + * + */ +typedef struct { + unsigned int magic; /* Magic value designating whether this really + * is a vector token or not */ + + Vector *serverPtr; /* Pointer to the master record of the vector. + * If NULL, indicates that the vector has been + * destroyed but as of yet, this client hasn't + * recognized it. */ + + Blt_VectorChangedProc *proc;/* Routine to call when the contents of the + * vector change or the vector is deleted. */ + + ClientData clientData; /* Data passed whenever the vector change + * procedure is called. */ + + Blt_ChainLink link; /* Used to quickly remove this entry from its + * server's client chain. */ +} VectorClient; + +static Tcl_CmdDeleteProc VectorInstDeleteProc; +static Tcl_ObjCmdProc VectorCmd; +static Tcl_InterpDeleteProc VectorInterpDeleteProc; + +typedef struct { + char *varName; /* Requested variable name. */ + char *cmdName; /* Requested command name. */ + int flush; /* Flush */ + int watchUnset; /* Watch when variable is unset. */ +} CreateSwitches; + +static Blt_SwitchSpec createSwitches[] = +{ + {BLT_SWITCH_STRING, "-variable", "varName", + Blt_Offset(CreateSwitches, varName), BLT_SWITCH_NULL_OK}, + {BLT_SWITCH_STRING, "-command", "command", + Blt_Offset(CreateSwitches, cmdName), BLT_SWITCH_NULL_OK}, + {BLT_SWITCH_BOOLEAN, "-watchunset", "bool", + Blt_Offset(CreateSwitches, watchUnset), 0}, + {BLT_SWITCH_BOOLEAN, "-flush", "bool", + Blt_Offset(CreateSwitches, flush), 0}, + {BLT_SWITCH_END} +}; + +typedef int (VectorCmdProc)(Vector *vecObjPtr, Tcl_Interp *interp, + int objc, Tcl_Obj *const *objv); + +static Vector * +FindVectorInNamespace( + VectorInterpData *dataPtr, /* Interpreter-specific data. */ + Blt_ObjectName *objNamePtr) +{ + Tcl_DString dString; + const char *name; + Blt_HashEntry *hPtr; + + name = Blt_MakeQualifiedName(objNamePtr, &dString); + hPtr = Blt_FindHashEntry(&dataPtr->vectorTable, name); + Tcl_DStringFree(&dString); + if (hPtr != NULL) { + return Blt_GetHashValue(hPtr); + } + return NULL; +} + +/* + *--------------------------------------------------------------------------- + * + * GetVectorObject -- + * + * Searches for the vector associated with the name given. Allow for a + * range specification. + * + * Results: + * Returns a pointer to the vector if found, otherwise NULL. + * + *--------------------------------------------------------------------------- + */ +static Vector * +GetVectorObject( + VectorInterpData *dataPtr, /* Interpreter-specific data. */ + const char *name, + int flags) +{ + Blt_ObjectName objName; + Vector *vPtr; + Tcl_Interp *interp; + + interp = dataPtr->interp; + if (!Blt_ParseObjectName(interp, name, &objName, + BLT_NO_ERROR_MSG | BLT_NO_DEFAULT_NS)) { + return NULL; /* Can't find namespace. */ + } + vPtr = NULL; + if (objName.nsPtr != NULL) { + vPtr = FindVectorInNamespace(dataPtr, &objName); + } else { + if (flags & NS_SEARCH_CURRENT) { + objName.nsPtr = Tcl_GetCurrentNamespace(interp); + vPtr = FindVectorInNamespace(dataPtr, &objName); + } + if ((vPtr == NULL) && (flags & NS_SEARCH_GLOBAL)) { + objName.nsPtr = Tcl_GetGlobalNamespace(interp); + vPtr = FindVectorInNamespace(dataPtr, &objName); + } + } + return vPtr; +} + +void +Blt_Vec_UpdateRange(Vector *vPtr) +{ + double min, max; + double *vp, *vend; + + vp = vPtr->valueArr + vPtr->first; + vend = vPtr->valueArr + vPtr->last; + min = max = *vp++; + for (/* empty */; vp <= vend; vp++) { + if (min > *vp) { + min = *vp; + } else if (max < *vp) { + max = *vp; + } + } + vPtr->min = min; + vPtr->max = max; + vPtr->notifyFlags &= ~UPDATE_RANGE; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_GetIndex -- + * + * Converts the string representing an index in the vector, to its + * numeric value. A valid index may be an numeric string of the string + * "end" (indicating the last element in the string). + * + * Results: + * A standard TCL result. If the string is a valid index, TCL_OK is + * returned. Otherwise TCL_ERROR is returned and interp->result will + * contain an error message. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Vec_GetIndex( + Tcl_Interp *interp, + Vector *vPtr, + const char *string, + int *indexPtr, + int flags, + Blt_VectorIndexProc **procPtrPtr) +{ + char c; + int value; + + c = string[0]; + + /* Treat the index "end" like a numeric index. */ + + if ((c == 'e') && (strcmp(string, "end") == 0)) { + if (vPtr->length < 1) { + if (interp != NULL) { + Tcl_AppendResult(interp, "bad index \"end\": vector is empty", + (char *)NULL); + } + return TCL_ERROR; + } + *indexPtr = vPtr->length - 1; + return TCL_OK; + } else if ((c == '+') && (strcmp(string, "++end") == 0)) { + *indexPtr = vPtr->length; + return TCL_OK; + } + if (procPtrPtr != NULL) { + Blt_HashEntry *hPtr; + + hPtr = Blt_FindHashEntry(&vPtr->dataPtr->indexProcTable, string); + if (hPtr != NULL) { + *indexPtr = SPECIAL_INDEX; + *procPtrPtr = Blt_GetHashValue(hPtr); + return TCL_OK; + } + } + if (Tcl_GetInt(interp, (char *)string, &value) != TCL_OK) { + long int lvalue; + /* + * Unlike Tcl_GetInt, Tcl_ExprLong needs a valid interpreter, but the + * interp passed in may be NULL. So we have to use vPtr->interp and + * then reset the result. + */ + if (Tcl_ExprLong(vPtr->interp, (char *)string, &lvalue) != TCL_OK) { + Tcl_ResetResult(vPtr->interp); + if (interp != NULL) { + Tcl_AppendResult(interp, "bad index \"", string, "\"", + (char *)NULL); + } + return TCL_ERROR; + } + value = (int)lvalue; + } + /* + * Correct the index by the current value of the offset. This makes all + * the numeric indices non-negative, which is how we distinguish the + * special non-numeric indices. + */ + value -= vPtr->offset; + + if ((value < 0) || ((flags & INDEX_CHECK) && (value >= vPtr->length))) { + if (interp != NULL) { + Tcl_AppendResult(interp, "index \"", string, "\" is out of range", + (char *)NULL); + } + return TCL_ERROR; + } + *indexPtr = (int)value; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_GetIndexRange -- + * + * Converts the string representing an index in the vector, to its + * numeric value. A valid index may be an numeric string of the string + * "end" (indicating the last element in the string). + * + * Results: + * A standard TCL result. If the string is a valid index, TCL_OK is + * returned. Otherwise TCL_ERROR is returned and interp->result will + * contain an error message. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Vec_GetIndexRange( + Tcl_Interp *interp, + Vector *vPtr, + const char *string, + int flags, + Blt_VectorIndexProc **procPtrPtr) +{ + int ielem; + char *colon; + + colon = NULL; + if (flags & INDEX_COLON) { + colon = strchr(string, ':'); + } + if (colon != NULL) { + if (string == colon) { + vPtr->first = 0; /* Default to the first index */ + } else { + int result; + + *colon = '\0'; + result = Blt_Vec_GetIndex(interp, vPtr, string, &ielem, flags, + (Blt_VectorIndexProc **) NULL); + *colon = ':'; + if (result != TCL_OK) { + return TCL_ERROR; + } + vPtr->first = ielem; + } + if (*(colon + 1) == '\0') { + /* Default to the last index */ + vPtr->last = (vPtr->length > 0) ? vPtr->length - 1 : 0; + } else { + if (Blt_Vec_GetIndex(interp, vPtr, colon + 1, &ielem, flags, + (Blt_VectorIndexProc **) NULL) != TCL_OK) { + return TCL_ERROR; + } + vPtr->last = ielem; + } + if (vPtr->first > vPtr->last) { + if (interp != NULL) { + Tcl_AppendResult(interp, "bad range \"", string, + "\" (first > last)", (char *)NULL); + } + return TCL_ERROR; + } + } else { + if (Blt_Vec_GetIndex(interp, vPtr, string, &ielem, flags, + procPtrPtr) != TCL_OK) { + return TCL_ERROR; + } + vPtr->last = vPtr->first = ielem; + } + return TCL_OK; +} + +Vector * +Blt_Vec_ParseElement( + Tcl_Interp *interp, + VectorInterpData *dataPtr, /* Interpreter-specific data. */ + const char *start, + const char **endPtr, + int flags) +{ + char *p; + char saved; + Vector *vPtr; + + p = (char *)start; + /* Find the end of the vector name */ + while (VECTOR_CHAR(*p)) { + p++; + } + saved = *p; + *p = '\0'; + + vPtr = GetVectorObject(dataPtr, start, flags); + if (vPtr == NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "can't find vector \"", start, "\"", + (char *)NULL); + } + *p = saved; + return NULL; + } + *p = saved; + vPtr->first = 0; + vPtr->last = vPtr->length - 1; + if (*p == '(') { + int count, result; + + start = p + 1; + p++; + + /* Find the matching right parenthesis */ + count = 1; + while (*p != '\0') { + if (*p == ')') { + count--; + if (count == 0) { + break; + } + } else if (*p == '(') { + count++; + } + p++; + } + if (count > 0) { + if (interp != NULL) { + Tcl_AppendResult(interp, "unbalanced parentheses \"", start, + "\"", (char *)NULL); + } + return NULL; + } + *p = '\0'; + result = Blt_Vec_GetIndexRange(interp, vPtr, start, + (INDEX_COLON | INDEX_CHECK), (Blt_VectorIndexProc **) NULL); + *p = ')'; + if (result != TCL_OK) { + return NULL; + } + p++; + } + if (endPtr != NULL) { + *endPtr = p; + } + return vPtr; +} + + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_NotifyClients -- + * + * Notifies each client of the vector that the vector has changed + * (updated or destroyed) by calling the provided function back. The + * function pointer may be NULL, in that case the client is not notified. + * + * Results: + * None. + * + * Side effects: + * The results depend upon what actions the client callbacks + * take. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Vec_NotifyClients(ClientData clientData) +{ + Vector *vPtr = clientData; + Blt_ChainLink link, next; + Blt_VectorNotify notify; + + notify = (vPtr->notifyFlags & NOTIFY_DESTROYED) + ? BLT_VECTOR_NOTIFY_DESTROY : BLT_VECTOR_NOTIFY_UPDATE; + vPtr->notifyFlags &= ~(NOTIFY_UPDATED | NOTIFY_DESTROYED | NOTIFY_PENDING); + for (link = Blt_Chain_FirstLink(vPtr->chain); link != NULL; link = next) { + VectorClient *clientPtr; + + next = Blt_Chain_NextLink(link); + clientPtr = Blt_Chain_GetValue(link); + if ((clientPtr->proc != NULL) && (clientPtr->serverPtr != NULL)) { + (*clientPtr->proc) (vPtr->interp, clientPtr->clientData, notify); + } + } + /* + * Some clients may not handle the "destroy" callback properly (they + * should call Blt_FreeVectorId to release the client identifier), so mark + * any remaining clients to indicate that vector's server has gone away. + */ + if (notify == BLT_VECTOR_NOTIFY_DESTROY) { + for (link = Blt_Chain_FirstLink(vPtr->chain); link != NULL; + link = Blt_Chain_NextLink(link)) { + VectorClient *clientPtr; + + clientPtr = Blt_Chain_GetValue(link); + clientPtr->serverPtr = NULL; + } + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_UpdateClients -- + * + * Notifies each client of the vector that the vector has changed + * (updated or destroyed) by calling the provided function back. + * + * Results: + * None. + * + * Side effects: + * The individual client callbacks are eventually invoked. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Vec_UpdateClients(Vector *vPtr) +{ + vPtr->dirty++; + vPtr->max = vPtr->min = Blt_NaN(); + if (vPtr->notifyFlags & NOTIFY_NEVER) { + return; + } + vPtr->notifyFlags |= NOTIFY_UPDATED; + if (vPtr->notifyFlags & NOTIFY_ALWAYS) { + Blt_Vec_NotifyClients(vPtr); + return; + } + if (!(vPtr->notifyFlags & NOTIFY_PENDING)) { + vPtr->notifyFlags |= NOTIFY_PENDING; + Tcl_DoWhenIdle(Blt_Vec_NotifyClients, vPtr); + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_FlushCache -- + * + * Unsets all the elements of the TCL array variable associated with the + * vector, freeing memory associated with the variable. This includes + * both the hash table and the hash keys. The down side is that this + * effectively flushes the caching of vector elements in the array. This + * means that the subsequent reads of the array will require a decimal to + * string conversion. + * + * This is needed when the vector changes its values, making the array + * variable out-of-sync. + * + * Results: + * None. + * + * Side effects: + * All elements of array variable (except one) are unset, freeing + * the memory associated with the variable. + * + *--------------------------------------------------------------------------- + */ +void +Blt_Vec_FlushCache(Vector *vPtr) +{ + Tcl_Interp *interp = vPtr->interp; + + if (vPtr->arrayName == NULL) { + return; /* Doesn't use the variable API */ + } + /* Turn off the trace temporarily so that we can unset all the + * elements in the array. */ + + Tcl_UntraceVar2(interp, vPtr->arrayName, (char *)NULL, + TRACE_ALL | vPtr->varFlags, Blt_Vec_VarTrace, vPtr); + + /* Clear all the element entries from the entire array */ + Tcl_UnsetVar2(interp, vPtr->arrayName, (char *)NULL, vPtr->varFlags); + + /* Restore the "end" index by default and the trace on the entire array */ + Tcl_SetVar2(interp, vPtr->arrayName, "end", "", vPtr->varFlags); + Tcl_TraceVar2(interp, vPtr->arrayName, (char *)NULL, + TRACE_ALL | vPtr->varFlags, Blt_Vec_VarTrace, vPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_LookupName -- + * + * Searches for the vector associated with the name given. Allow for a + * range specification. + * + * Results: + * Returns a pointer to the vector if found, otherwise NULL. If the name + * is not associated with a vector and the TCL_LEAVE_ERR_MSG flag is set, + * and interp->result will contain an error message. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Vec_LookupName( + VectorInterpData *dataPtr, /* Interpreter-specific data. */ + const char *vecName, + Vector **vPtrPtr) +{ + Vector *vPtr; + const char *endPtr; + + vPtr = Blt_Vec_ParseElement(dataPtr->interp, dataPtr, vecName, &endPtr, + NS_SEARCH_BOTH); + if (vPtr == NULL) { + return TCL_ERROR; + } + if (*endPtr != '\0') { + Tcl_AppendResult(dataPtr->interp, + "extra characters after vector name", (char *)NULL); + return TCL_ERROR; + } + *vPtrPtr = vPtr; + return TCL_OK; +} + +double +Blt_Vec_Min(Vector *vecObjPtr) +{ + double *vp, *vend; + double min; + + vp = vecObjPtr->valueArr + vecObjPtr->first; + vend = vecObjPtr->valueArr + vecObjPtr->last; + min = *vp++; + for (/* empty */; vp <= vend; vp++) { + if (min > *vp) { + min = *vp; + } + } + vecObjPtr->min = min; + return vecObjPtr->min; +} + +double +Blt_Vec_Max(Vector *vecObjPtr) +{ + double max; + double *vp, *vend; + + max = Blt_NaN(); + vp = vecObjPtr->valueArr + vecObjPtr->first; + vend = vecObjPtr->valueArr + vecObjPtr->last; + max = *vp++; + for (/* empty */; vp <= vend; vp++) { + if (max < *vp) { + max = *vp; + } + } + vecObjPtr->max = max; + return vecObjPtr->max; +} + +/* + *--------------------------------------------------------------------------- + * + * DeleteCommand -- + * + * Deletes the TCL command associated with the vector, without triggering + * a callback to "VectorInstDeleteProc". + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +DeleteCommand(Vector *vPtr) /* Vector associated with the TCL command. */ +{ + Tcl_Interp *interp = vPtr->interp; + char *qualName; /* Name of TCL command. */ + Tcl_CmdInfo cmdInfo; + Tcl_DString dString; + Blt_ObjectName objName; + + Tcl_DStringInit(&dString); + objName.name = Tcl_GetCommandName(interp, vPtr->cmdToken); + objName.nsPtr = Blt_GetCommandNamespace(vPtr->cmdToken); + qualName = Blt_MakeQualifiedName(&objName, &dString); + if (Tcl_GetCommandInfo(interp, qualName, &cmdInfo)) { + /* Disable the callback before deleting the TCL command.*/ + cmdInfo.deleteProc = NULL; + Tcl_SetCommandInfo(interp, qualName, &cmdInfo); + Tcl_DeleteCommandFromToken(interp, vPtr->cmdToken); + } + Tcl_DStringFree(&dString); + vPtr->cmdToken = 0; +} + +/* + *--------------------------------------------------------------------------- + * + * UnmapVariable -- + * + * Destroys the trace on the current TCL variable designated to access + * the vector. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +UnmapVariable(Vector *vPtr) +{ + Tcl_Interp *interp = vPtr->interp; + + /* Unset the entire array */ + Tcl_UntraceVar2(interp, vPtr->arrayName, (char *)NULL, + (TRACE_ALL | vPtr->varFlags), Blt_Vec_VarTrace, vPtr); + Tcl_UnsetVar2(interp, vPtr->arrayName, (char *)NULL, vPtr->varFlags); + + if (vPtr->arrayName != NULL) { + Blt_Free(vPtr->arrayName); + vPtr->arrayName = NULL; + } +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_MapVariable -- + * + * Sets up traces on a TCL variable to access the vector. + * + * If another variable is already mapped, it's first untraced and + * removed. Don't do anything else for variables named "" (even though + * Tcl allows this pathology). Saves the name of the new array variable. + * + * Results: + * A standard TCL result. If an error occurs setting the variable + * TCL_ERROR is returned and an error message is left in the interpreter. + * + * Side effects: + * Traces are set for the new variable. The new variable name is saved in + * a malloc'ed string in vPtr->arrayName. If this variable is non-NULL, + * it indicates that a TCL variable has been mapped to this vector. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Vec_MapVariable( + Tcl_Interp *interp, + Vector *vPtr, + const char *path) +{ + Blt_ObjectName objName; + char *newPath; + const char *result; + Tcl_DString dString; + + if (vPtr->arrayName != NULL) { + UnmapVariable(vPtr); + } + if ((path == NULL) || (path[0] == '\0')) { + return TCL_OK; /* If the variable pathname is the empty + * string, simply return after removing any + * existing variable. */ + } + /* Get the variable name (without the namespace qualifier). */ + if (!Blt_ParseObjectName(interp, path, &objName, BLT_NO_DEFAULT_NS)) { + return TCL_ERROR; + } + if (objName.nsPtr == NULL) { + /* + * If there was no namespace qualifier, try harder to see if the + * variable is non-local. + */ + objName.nsPtr = Blt_GetVariableNamespace(interp, objName.name); + } + Tcl_DStringInit(&dString); + vPtr->varFlags = 0; + if (objName.nsPtr != NULL) { /* Global or namespace variable. */ + newPath = Blt_MakeQualifiedName(&objName, &dString); + vPtr->varFlags |= (TCL_NAMESPACE_ONLY | TCL_GLOBAL_ONLY); + } else { /* Local variable. */ + newPath = (char *)objName.name; + } + + /* + * To play it safe, delete the variable first. This has the benefical + * side-effect of unmapping the variable from another vector that may be + * currently associated with it. + */ + Tcl_UnsetVar2(interp, newPath, (char *)NULL, 0); + + /* + * Set the index "end" in the array. This will create the variable + * immediately so that we can check its namespace context. + */ + result = Tcl_SetVar2(interp, newPath, "end", "", TCL_LEAVE_ERR_MSG); + if (result == NULL) { + Tcl_DStringFree(&dString); + return TCL_ERROR; + } + /* Create a full-array trace on reads, writes, and unsets. */ + Tcl_TraceVar2(interp, newPath, (char *)NULL, TRACE_ALL, Blt_Vec_VarTrace, + vPtr); + vPtr->arrayName = Blt_AssertStrdup(newPath); + Tcl_DStringFree(&dString); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_SetSize -- + * + * Resizes the vector to the designated new size. + * + * If the new size is the same as the old, simply return. Otherwise + * we're copying the data from one memory location to another. + * + * If the storage changed memory locations, free up the old location if + * it was dynamically allocated. + * + * Results: + * A standard TCL result. If the reallocation is successful, + * TCL_OK is returned, otherwise TCL_ERROR. + * + * Side effects: + * Memory for the array is reallocated. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Vec_SetSize( + Tcl_Interp *interp, + Vector *vPtr, + int newSize) /* Size of array in elements */ +{ + if (newSize <= 0) { + newSize = DEF_ARRAY_SIZE; + } + if (newSize == vPtr->size) { + /* Same size, use the current array. */ + return TCL_OK; + } + if (vPtr->freeProc == TCL_DYNAMIC) { + double *newArr; + + /* Old memory was dynamically allocated, so use realloc. */ + newArr = Blt_Realloc(vPtr->valueArr, newSize * sizeof(double)); + if (newArr == NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "can't reallocate ", + Blt_Itoa(newSize), " elements for vector \"", + vPtr->name, "\"", (char *)NULL); + } + return TCL_ERROR; + } + vPtr->size = newSize; + vPtr->valueArr = newArr; + return TCL_OK; + } + + { + double *newArr; + + /* Old memory was created specially (static or special allocator). + * Replace with dynamically allocated memory (malloc-ed). */ + + newArr = Blt_Calloc(newSize, sizeof(double)); + if (newArr == NULL) { + if (interp != NULL) { + Tcl_AppendResult(interp, "can't allocate ", + Blt_Itoa(newSize), " elements for vector \"", + vPtr->name, "\"", (char *)NULL); + } + return TCL_ERROR; + } + { + int used, wanted; + + /* Copy the contents of the old memory into the new. */ + used = vPtr->length; + wanted = newSize; + + if (used > wanted) { + used = wanted; + } + /* Copy any previous data */ + if (used > 0) { + memcpy(newArr, vPtr->valueArr, used * sizeof(double)); + } + } + + assert(vPtr->valueArr != NULL); + + /* + * We're not using the old storage anymore, so free it if it's not + * TCL_STATIC. It's static because the user previously reset the + * vector with a statically allocated array (setting freeProc to + * TCL_STATIC). + */ + if (vPtr->freeProc != TCL_STATIC) { + if (vPtr->freeProc == TCL_DYNAMIC) { + Blt_Free(vPtr->valueArr); + } else { + (*vPtr->freeProc) ((char *)vPtr->valueArr); + } + } + vPtr->freeProc = TCL_DYNAMIC; /* Set the type of the new storage */ + vPtr->valueArr = newArr; + vPtr->size = newSize; + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_SetSize -- + * + * Set the length (the number of elements currently in use) of the + * vector. If the new length is greater than the size (total number of + * slots), then the vector is grown. + * + * Results: + * A standard TCL result. If the reallocation is successful, TCL_OK is + * returned, otherwise TCL_ERROR. + * + * Side effects: + * Memory for the array is possibly reallocated. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Vec_SetLength( + Tcl_Interp *interp, + Vector *vPtr, + int newLength) /* Size of array in elements */ +{ + if (vPtr->size < newLength) { + if (Blt_Vec_SetSize(interp, vPtr, newLength) != TCL_OK) { + return TCL_ERROR; + } + } + vPtr->length = newLength; + vPtr->first = 0; + vPtr->last = newLength - 1; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_ChangeLength -- + * + * Resizes the vector to the new size. + * + * The new size of the vector is computed by doubling the size of the + * vector until it fits the number of slots needed (designated by + * *length*). + * + * If the new size is the same as the old, simply adjust the length of + * the vector. Otherwise we're copying the data from one memory location + * to another. The trailing elements of the vector need to be reset to + * zero. + * + * If the storage changed memory locations, free up the old location if + * it was dynamically allocated. + * + * Results: + * A standard TCL result. If the reallocation is successful, + * TCL_OK is returned, otherwise TCL_ERROR. + * + * Side effects: + * Memory for the array is reallocated. + * + *--------------------------------------------------------------------------- + */ + +int +Blt_Vec_ChangeLength( + Tcl_Interp *interp, + Vector *vPtr, + int newLength) +{ + if (newLength < 0) { + newLength = 0; + } + if (newLength > vPtr->size) { + int newSize; /* Size of array in elements */ + + /* Compute the new size of the array. It's a multiple of + * DEF_ARRAY_SIZE. */ + newSize = DEF_ARRAY_SIZE; + while (newSize < newLength) { + newSize += newSize; + } + if (newSize != vPtr->size) { + if (Blt_Vec_SetSize(interp, vPtr, newSize) != TCL_OK) { + return TCL_ERROR; + } + } + } + vPtr->length = newLength; + vPtr->first = 0; + vPtr->last = newLength - 1; + return TCL_OK; + +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_Reset -- + * + * Resets the vector data. This is called by a client to indicate that + * the vector data has changed. The vector does not need to point to + * different memory. Any clients of the vector will be notified of the + * change. + * + * Results: + * A standard TCL result. If the new array size is invalid, TCL_ERROR is + * returned. Otherwise TCL_OK is returned and the new vector data is + * recorded. + * + * Side Effects: + * Any client designated callbacks will be posted. Memory may be changed + * for the vector array. + * + *--------------------------------------------------------------------------- + */ +int +Blt_Vec_Reset( + Vector *vPtr, + double *valueArr, /* Array containing the elements of the + * vector. If NULL, indicates to reset the + * vector size to the default. */ + int length, /* The number of elements that the vector + * currently holds. */ + int size, /* The maximum number of elements that the + * array can hold. */ + Tcl_FreeProc *freeProc) /* Address of memory deallocation routine + * for the array of values. Can also be + * TCL_STATIC, TCL_DYNAMIC, or TCL_VOLATILE. */ +{ + if (vPtr->valueArr != valueArr) { /* New array of values resides + * in different memory than + * the current vector. */ + if ((valueArr == NULL) || (size == 0)) { + /* Empty array. Set up default values */ + valueArr = Blt_Malloc(sizeof(double) * DEF_ARRAY_SIZE); + size = DEF_ARRAY_SIZE; + if (valueArr == NULL) { + Tcl_AppendResult(vPtr->interp, "can't allocate ", + Blt_Itoa(size), " elements for vector \"", + vPtr->name, "\"", (char *)NULL); + return TCL_ERROR; + } + freeProc = TCL_DYNAMIC; + length = 0; + } else if (freeProc == TCL_VOLATILE) { + double *newArr; + /* Data is volatile. Make a copy of the value array. */ + newArr = Blt_Malloc(size * sizeof(double)); + if (newArr == NULL) { + Tcl_AppendResult(vPtr->interp, "can't allocate ", + Blt_Itoa(size), " elements for vector \"", + vPtr->name, "\"", (char *)NULL); + return TCL_ERROR; + } + memcpy((char *)newArr, (char *)valueArr, + sizeof(double) * length); + valueArr = newArr; + freeProc = TCL_DYNAMIC; + } + + if (vPtr->freeProc != TCL_STATIC) { + /* Old data was dynamically allocated. Free it before attaching + * new data. */ + if (vPtr->freeProc == TCL_DYNAMIC) { + Blt_Free(vPtr->valueArr); + } else { + (*freeProc) ((char *)vPtr->valueArr); + } + } + vPtr->freeProc = freeProc; + vPtr->valueArr = valueArr; + vPtr->size = size; + } + + vPtr->length = length; + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + return TCL_OK; +} + +Vector * +Blt_Vec_New(VectorInterpData *dataPtr) /* Interpreter-specific data. */ +{ + Vector *vPtr; + + vPtr = Blt_AssertCalloc(1, sizeof(Vector)); + vPtr->valueArr = Blt_Malloc(sizeof(double) * DEF_ARRAY_SIZE); + if (vPtr->valueArr == NULL) { + Blt_Free(vPtr); + return NULL; + } + vPtr->size = DEF_ARRAY_SIZE; + vPtr->freeProc = TCL_DYNAMIC; + vPtr->length = 0; + vPtr->interp = dataPtr->interp; + vPtr->hashPtr = NULL; + vPtr->chain = Blt_Chain_Create(); + vPtr->flush = FALSE; + vPtr->min = vPtr->max = Blt_NaN(); + vPtr->notifyFlags = NOTIFY_WHENIDLE; + vPtr->dataPtr = dataPtr; + return vPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_Free -- + * + * Removes the memory and frees resources associated with the vector. + * + * o Removes the trace and the TCL array variable and unsets + * the variable. + * o Notifies clients of the vector that the vector is being + * destroyed. + * o Removes any clients that are left after notification. + * o Frees the memory (if necessary) allocated for the array. + * o Removes the entry from the hash table of vectors. + * o Frees the memory allocated for the name. + * + * Results: + * None. + * + * Side effects: + * + *--------------------------------------------------------------------------- + */ +void +Blt_Vec_Free(Vector *vPtr) +{ + Blt_ChainLink link; + + if (vPtr->cmdToken != 0) { + DeleteCommand(vPtr); + } + if (vPtr->arrayName != NULL) { + UnmapVariable(vPtr); + } + vPtr->length = 0; + + /* Immediately notify clients that vector is going away */ + if (vPtr->notifyFlags & NOTIFY_PENDING) { + vPtr->notifyFlags &= ~NOTIFY_PENDING; + Tcl_CancelIdleCall(Blt_Vec_NotifyClients, vPtr); + } + vPtr->notifyFlags |= NOTIFY_DESTROYED; + Blt_Vec_NotifyClients(vPtr); + + for (link = Blt_Chain_FirstLink(vPtr->chain); link != NULL; + link = Blt_Chain_NextLink(link)) { + VectorClient *clientPtr; + + clientPtr = Blt_Chain_GetValue(link); + Blt_Free(clientPtr); + } + Blt_Chain_Destroy(vPtr->chain); + if ((vPtr->valueArr != NULL) && (vPtr->freeProc != TCL_STATIC)) { + if (vPtr->freeProc == TCL_DYNAMIC) { + Blt_Free(vPtr->valueArr); + } else { + (*vPtr->freeProc) ((char *)vPtr->valueArr); + } + } + if (vPtr->hashPtr != NULL) { + Blt_DeleteHashEntry(&vPtr->dataPtr->vectorTable, vPtr->hashPtr); + } +#ifdef NAMESPACE_DELETE_NOTIFY + if (vPtr->nsPtr != NULL) { + Blt_DestroyNsDeleteNotify(vPtr->interp, vPtr->nsPtr, vPtr); + } +#endif /* NAMESPACE_DELETE_NOTIFY */ + Blt_Free(vPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * VectorInstDeleteProc -- + * + * Deletes the command associated with the vector. This is called only + * when the command associated with the vector is destroyed. + * + * Results: + * None. + * + *--------------------------------------------------------------------------- + */ +static void +VectorInstDeleteProc(ClientData clientData) +{ + Vector *vPtr = clientData; + + vPtr->cmdToken = 0; + Blt_Vec_Free(vPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_Vec_Create -- + * + * Creates a vector structure and the following items: + * + * o TCL command + * o TCL array variable and establishes traces on the variable + * o Adds a new entry in the vector hash table + * + * Results: + * A pointer to the new vector structure. If an error occurred NULL is + * returned and an error message is left in interp->result. + * + * Side effects: + * A new TCL command and array variable is added to the interpreter. + * + * ---------------------------------------------------------------------- + */ +Vector * +Blt_Vec_Create( + VectorInterpData *dataPtr, /* Interpreter-specific data. */ + const char *vecName, /* Namespace-qualified name of the vector */ + const char *cmdName, /* Name of the TCL command mapped to + * the vector */ + const char *varName, /* Name of the TCL array mapped to the + * vector */ + int *isNewPtr) +{ + Tcl_DString dString; + Vector *vPtr; + int isNew; + Blt_ObjectName objName; + char *qualName; + Blt_HashEntry *hPtr; + Tcl_Interp *interp = dataPtr->interp; + + isNew = 0; + vPtr = NULL; + + if (!Blt_ParseObjectName(interp, vecName, &objName, 0)) { + return NULL; + } + Tcl_DStringInit(&dString); + if ((objName.name[0] == '#') && (strcmp(objName.name, "#auto") == 0)) { + + do { /* Generate a unique vector name. */ + char string[200]; + + sprintf_s(string, 200, "vector%d", dataPtr->nextId++); + objName.name = string; + qualName = Blt_MakeQualifiedName(&objName, &dString); + hPtr = Blt_FindHashEntry(&dataPtr->vectorTable, qualName); + } while (hPtr != NULL); + } else { + const char *p; + + for (p = objName.name; *p != '\0'; p++) { + if (!VECTOR_CHAR(*p)) { + Tcl_AppendResult(interp, "bad vector name \"", objName.name, + "\": must contain digits, letters, underscore, or period", + (char *)NULL); + goto error; + } + } + qualName = Blt_MakeQualifiedName(&objName, &dString); + vPtr = Blt_Vec_ParseElement((Tcl_Interp *)NULL, dataPtr, qualName, + NULL, NS_SEARCH_CURRENT); + } + if (vPtr == NULL) { + hPtr = Blt_CreateHashEntry(&dataPtr->vectorTable, qualName, &isNew); + vPtr = Blt_Vec_New(dataPtr); + vPtr->hashPtr = hPtr; + vPtr->nsPtr = objName.nsPtr; + + vPtr->name = Blt_GetHashKey(&dataPtr->vectorTable, hPtr); +#ifdef NAMESPACE_DELETE_NOTIFY + Blt_CreateNsDeleteNotify(interp, objName.nsPtr, vPtr, + VectorInstDeleteProc); +#endif /* NAMESPACE_DELETE_NOTIFY */ + Blt_SetHashValue(hPtr, vPtr); + } + if (cmdName != NULL) { + Tcl_CmdInfo cmdInfo; + + if ((cmdName == vecName) || + ((cmdName[0] == '#') && (strcmp(cmdName, "#auto")==0))) { + cmdName = qualName; + } + if (Tcl_GetCommandInfo(interp, (char *)cmdName, &cmdInfo)) { + if (vPtr != cmdInfo.objClientData) { + Tcl_AppendResult(interp, "command \"", cmdName, + "\" already exists", (char *)NULL); + goto error; + } + /* We get here only if the old name is the same as the new. */ + goto checkVariable; + } + } + if (vPtr->cmdToken != 0) { + DeleteCommand(vPtr); /* Command already exists, delete old first */ + } + if (cmdName != NULL) { + Tcl_DString dString2; + + Tcl_DStringInit(&dString2); + if (cmdName != qualName) { + if (!Blt_ParseObjectName(interp, cmdName, &objName, 0)) { + goto error; + } + cmdName = Blt_MakeQualifiedName(&objName, &dString2); + } + vPtr->cmdToken = Tcl_CreateObjCommand(interp, (char *)cmdName, + Blt_Vec_InstCmd, vPtr, VectorInstDeleteProc); + Tcl_DStringFree(&dString2); + } + checkVariable: + if (varName != NULL) { + if ((varName[0] == '#') && (strcmp(varName, "#auto") == 0)) { + varName = qualName; + } + if (Blt_Vec_MapVariable(interp, vPtr, varName) != TCL_OK) { + goto error; + } + } + + Tcl_DStringFree(&dString); + *isNewPtr = isNew; + return vPtr; + + error: + Tcl_DStringFree(&dString); + if (vPtr != NULL) { + Blt_Vec_Free(vPtr); + } + return NULL; +} + + +int +Blt_Vec_Duplicate(Vector *destPtr, Vector *srcPtr) +{ + size_t nBytes; + size_t length; + + if (destPtr == srcPtr) { + /* Copying the same vector. */ + } + length = srcPtr->last - srcPtr->first + 1; + if (Blt_Vec_ChangeLength(destPtr->interp, destPtr, length) != TCL_OK) { + return TCL_ERROR; + } + nBytes = length * sizeof(double); + memcpy(destPtr->valueArr, srcPtr->valueArr + srcPtr->first, nBytes); + destPtr->offset = srcPtr->offset; + return TCL_OK; +} + + +/* + *--------------------------------------------------------------------------- + * + * VectorNamesOp -- + * + * Reports the names of all the current vectors in the interpreter. + * + * Results: + * A standard TCL result. interp->result will contain a list of + * all the names of the vector instances. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +VectorNamesOp( + ClientData clientData, /* Interpreter-specific data. */ + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + VectorInterpData *dataPtr = clientData; + Tcl_Obj *listObjPtr; + + listObjPtr = Tcl_NewListObj(0, (Tcl_Obj **) NULL); + if (objc == 2) { + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(&dataPtr->vectorTable, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + char *name; + + name = Blt_GetHashKey(&dataPtr->vectorTable, hPtr); + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(name, -1)); + } + } else { + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(&dataPtr->vectorTable, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + char *name; + int i; + + name = Blt_GetHashKey(&dataPtr->vectorTable, hPtr); + for (i = 2; i < objc; i++) { + char *pattern; + + pattern = Tcl_GetString(objv[i]); + if (Tcl_StringMatch(name, pattern)) { + Tcl_ListObjAppendElement(interp, listObjPtr, + Tcl_NewStringObj(name, -1)); + break; + } + } + } + } + Tcl_SetObjResult(interp, listObjPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * VectorCreateOp -- + * + * Creates a TCL command, and array variable representing an instance of + * a vector. + * + * vector a + * vector b(20) + * vector c(-5:14) + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ + +/*ARGSUSED*/ +static int +VectorCreate2( + ClientData clientData, /* Interpreter-specific data. */ + Tcl_Interp *interp, + int argStart, + int objc, + Tcl_Obj *const *objv) +{ + VectorInterpData *dataPtr = clientData; + Vector *vPtr; + int count, i; + CreateSwitches switches; + + /* + * Handle switches to the vector command and collect the vector name + * arguments into an array. + */ + count = 0; + vPtr = NULL; + for (i = argStart; i < objc; i++) { + char *string; + + string = Tcl_GetString(objv[i]); + if (string[0] == '-') { + break; + } + } + count = i - argStart; + if (count == 0) { + Tcl_AppendResult(interp, "no vector names supplied", (char *)NULL); + return TCL_ERROR; + } + memset(&switches, 0, sizeof(switches)); + if (Blt_ParseSwitches(interp, createSwitches, objc - i, objv + i, + &switches, BLT_SWITCH_DEFAULTS) < 0) { + return TCL_ERROR; + } + if (count > 1) { + if (switches.cmdName != NULL) { + Tcl_AppendResult(interp, + "can't specify more than one vector with \"-command\" switch", + (char *)NULL); + goto error; + } + if (switches.varName != NULL) { + Tcl_AppendResult(interp, + "can't specify more than one vector with \"-variable\" switch", + (char *)NULL); + goto error; + } + } + for (i = 0; i < count; i++) { + char *leftParen, *rightParen; + char *string; + int isNew; + int size, first, last; + + size = first = last = 0; + string = Tcl_GetString(objv[i + argStart]); + leftParen = strchr(string, '('); + rightParen = strchr(string, ')'); + if (((leftParen != NULL) && (rightParen == NULL)) || + ((leftParen == NULL) && (rightParen != NULL)) || + (leftParen > rightParen)) { + Tcl_AppendResult(interp, "bad vector specification \"", string, + "\"", (char *)NULL); + goto error; + } + if (leftParen != NULL) { + int result; + char *colon; + + *rightParen = '\0'; + colon = strchr(leftParen + 1, ':'); + if (colon != NULL) { + + /* Specification is in the form vecName(first:last) */ + *colon = '\0'; + result = Tcl_GetInt(interp, leftParen + 1, &first); + if ((*(colon + 1) != '\0') && (result == TCL_OK)) { + result = Tcl_GetInt(interp, colon + 1, &last); + if (first > last) { + Tcl_AppendResult(interp, "bad vector range \"", + string, "\"", (char *)NULL); + result = TCL_ERROR; + } + size = (last - first) + 1; + } + *colon = ':'; + } else { + /* Specification is in the form vecName(size) */ + result = Tcl_GetInt(interp, leftParen + 1, &size); + } + *rightParen = ')'; + if (result != TCL_OK) { + goto error; + } + if (size < 0) { + Tcl_AppendResult(interp, "bad vector size \"", string, "\"", + (char *)NULL); + goto error; + } + } + if (leftParen != NULL) { + *leftParen = '\0'; + } + /* + * By default, we create a TCL command by the name of the vector. + */ + vPtr = Blt_Vec_Create(dataPtr, string, + (switches.cmdName == NULL) ? string : switches.cmdName, + (switches.varName == NULL) ? string : switches.varName, &isNew); + if (leftParen != NULL) { + *leftParen = '('; + } + if (vPtr == NULL) { + goto error; + } + vPtr->freeOnUnset = switches.watchUnset; + vPtr->flush = switches.flush; + vPtr->offset = first; + if (size > 0) { + if (Blt_Vec_ChangeLength(interp, vPtr, size) != TCL_OK) { + goto error; + } + } + if (!isNew) { + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + } + } + Blt_FreeSwitches(createSwitches, (char *)&switches, 0); + if (vPtr != NULL) { + /* Return the name of the last vector created */ + Tcl_SetStringObj(Tcl_GetObjResult(interp), vPtr->name, -1); + } + return TCL_OK; + error: + Blt_FreeSwitches(createSwitches, (char *)&switches, 0); + return TCL_ERROR; +} + +/* + *--------------------------------------------------------------------------- + * + * VectorCreateOp -- + * + * Creates a TCL command, and array variable representing an instance of + * a vector. + * + * vector a + * vector b(20) + * vector c(-5:14) + * + * Results: + * A standard TCL result. + * + * Side effects: + * See the user documentation. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +VectorCreateOp( + ClientData clientData, + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + return VectorCreate2(clientData, interp, 2, objc, objv); +} + +/* + *--------------------------------------------------------------------------- + * + * VectorDestroyOp -- + * + * Destroys the vector and its related TCL command and array variable (if + * they exist). + * + * Results: + * A standard TCL result. + * + * Side effects: + * Deletes the vector. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +VectorDestroyOp( + ClientData clientData, /* Interpreter-specific data. */ + Tcl_Interp *interp, /* Not used. */ + int objc, + Tcl_Obj *const *objv) +{ + VectorInterpData *dataPtr = clientData; + Vector *vPtr; + int i; + + for (i = 2; i < objc; i++) { + if (Blt_Vec_LookupName(dataPtr, Tcl_GetString(objv[i]), &vPtr) + != TCL_OK) { + return TCL_ERROR; + } + Blt_Vec_Free(vPtr); + } + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * VectorExprOp -- + * + * Computes the result of the expression which may be either a scalar + * (single value) or vector (list of values). + * + * Results: + * A standard TCL result. + * + *--------------------------------------------------------------------------- + */ +/*ARGSUSED*/ +static int +VectorExprOp( + ClientData clientData, /* Not Used. */ + Tcl_Interp *interp, + int objc, /* Not used. */ + Tcl_Obj *const *objv) +{ + return Blt_ExprVector(interp, Tcl_GetString(objv[2]), (Blt_Vector *)NULL); +} + +static Blt_OpSpec vectorCmdOps[] = +{ + {"create", 1, VectorCreateOp, 3, 0, + "vecName ?vecName...? ?switches...?",}, + {"destroy", 1, VectorDestroyOp, 3, 0, + "vecName ?vecName...?",}, + {"expr", 1, VectorExprOp, 3, 3, "expression",}, + {"names", 1, VectorNamesOp, 2, 3, "?pattern?...",}, +}; + +static int nCmdOps = sizeof(vectorCmdOps) / sizeof(Blt_OpSpec); + +/*ARGSUSED*/ +static int +VectorCmd( + ClientData clientData, /* Interpreter-specific data. */ + Tcl_Interp *interp, + int objc, + Tcl_Obj *const *objv) +{ + VectorCmdProc *proc; + /* + * Try to replicate the old vector command's behavior: + */ + if (objc > 1) { + char *string; + char c; + int i; + Blt_OpSpec *specPtr; + + string = Tcl_GetString(objv[1]); + c = string[0]; + for (specPtr = vectorCmdOps, i = 0; i < nCmdOps; i++, specPtr++) { + if ((c == specPtr->name[0]) && + (strcmp(string, specPtr->name) == 0)) { + goto doOp; + } + } + /* + * The first argument is not an operation, so assume that its + * actually the name of a vector to be created + */ + return VectorCreate2(clientData, interp, 1, objc, objv); + } + doOp: + /* Do the usual vector operation lookup now. */ + proc = Blt_GetOpFromObj(interp, nCmdOps, vectorCmdOps, BLT_OP_ARG1, + objc, objv,0); + if (proc == NULL) { + return TCL_ERROR; + } + return (*proc) (clientData, interp, objc, objv); +} + +/* + *--------------------------------------------------------------------------- + * + * VectorInterpDeleteProc -- + * + * This is called when the interpreter hosting the "vector" command + * is deleted. + * + * Results: + * None. + * + * Side effects: + * Destroys the math and index hash tables. In addition removes + * the hash table managing all vector names. + * + *--------------------------------------------------------------------------- + */ +/* ARGSUSED */ +static void +VectorInterpDeleteProc( + ClientData clientData, /* Interpreter-specific data. */ + Tcl_Interp *interp) +{ + VectorInterpData *dataPtr = clientData; + Blt_HashEntry *hPtr; + Blt_HashSearch cursor; + + for (hPtr = Blt_FirstHashEntry(&dataPtr->vectorTable, &cursor); + hPtr != NULL; hPtr = Blt_NextHashEntry(&cursor)) { + Vector *vPtr; + + vPtr = Blt_GetHashValue(hPtr); + vPtr->hashPtr = NULL; + Blt_Vec_Free(vPtr); + } + Blt_DeleteHashTable(&dataPtr->vectorTable); + + /* If any user-defined math functions were installed, remove them. */ + Blt_Vec_UninstallMathFunctions(&dataPtr->mathProcTable); + Blt_DeleteHashTable(&dataPtr->mathProcTable); + + Blt_DeleteHashTable(&dataPtr->indexProcTable); + Tcl_DeleteAssocData(interp, VECTOR_THREAD_KEY); + Blt_Free(dataPtr); +} + +VectorInterpData * +Blt_Vec_GetInterpData(Tcl_Interp *interp) +{ + VectorInterpData *dataPtr; + Tcl_InterpDeleteProc *proc; + + dataPtr = (VectorInterpData *) + Tcl_GetAssocData(interp, VECTOR_THREAD_KEY, &proc); + if (dataPtr == NULL) { + dataPtr = Blt_AssertMalloc(sizeof(VectorInterpData)); + dataPtr->interp = interp; + dataPtr->nextId = 0; + Tcl_SetAssocData(interp, VECTOR_THREAD_KEY, VectorInterpDeleteProc, + dataPtr); + Blt_InitHashTable(&dataPtr->vectorTable, BLT_STRING_KEYS); + Blt_InitHashTable(&dataPtr->mathProcTable, BLT_STRING_KEYS); + Blt_InitHashTable(&dataPtr->indexProcTable, BLT_STRING_KEYS); + Blt_Vec_InstallMathFunctions(&dataPtr->mathProcTable); + Blt_Vec_InstallSpecialIndices(&dataPtr->indexProcTable); +#ifdef HAVE_SRAND48 + srand48(time((time_t *) NULL)); +#endif + } + return dataPtr; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_VectorCmdInitProc -- + * + * This procedure is invoked to initialize the "vector" command. + * + * Results: + * None. + * + * Side effects: + * Creates the new command and adds a new entry into a global Tcl + * associative array. + * + *--------------------------------------------------------------------------- + */ + +int +Blt_VectorCmdInitProc(Tcl_Interp *interp) +{ + static Blt_InitCmdSpec cmdSpec = {"vector", VectorCmd, }; + + cmdSpec.clientData = Blt_Vec_GetInterpData(interp); + return Blt_InitCmd(interp, "::blt", &cmdSpec); +} + + + +/* C Application interface to vectors */ + +/* + *--------------------------------------------------------------------------- + * + * Blt_CreateVector -- + * + * Creates a new vector by the name and size. + * + * Results: + * A standard TCL result. If the new array size is invalid or a vector + * already exists by that name, TCL_ERROR is returned. Otherwise TCL_OK + * is returned and the new vector is created. + * + * Side Effects: + * Memory will be allocated for the new vector. A new TCL command and + * Tcl array variable will be created. + * + *--------------------------------------------------------------------------- + */ + +/*LINTLIBRARY*/ +int +Blt_CreateVector2( + Tcl_Interp *interp, + const char *vecName, const char *cmdName, const char *varName, + int initialSize, + Blt_Vector **vecPtrPtr) +{ + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + Vector *vPtr; + int isNew; + char *nameCopy; + + if (initialSize < 0) { + Tcl_AppendResult(interp, "bad vector size \"", Blt_Itoa(initialSize), + "\"", (char *)NULL); + return TCL_ERROR; + } + dataPtr = Blt_Vec_GetInterpData(interp); + + nameCopy = Blt_AssertStrdup(vecName); + vPtr = Blt_Vec_Create(dataPtr, nameCopy, cmdName, varName, &isNew); + Blt_Free(nameCopy); + + if (vPtr == NULL) { + return TCL_ERROR; + } + if (initialSize > 0) { + if (Blt_Vec_ChangeLength(interp, vPtr, initialSize) != TCL_OK) { + return TCL_ERROR; + } + } + if (vecPtrPtr != NULL) { + *vecPtrPtr = (Blt_Vector *) vPtr; + } + return TCL_OK; +} + +int +Blt_CreateVector( + Tcl_Interp *interp, + const char *name, + int size, + Blt_Vector **vecPtrPtr) +{ + return Blt_CreateVector2(interp, name, name, name, size, vecPtrPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DeleteVector -- + * + * Deletes the vector of the given name. All clients with designated + * callback routines will be notified. + * + * Results: + * A standard TCL result. If no vector exists by that name, TCL_ERROR is + * returned. Otherwise TCL_OK is returned and vector is deleted. + * + * Side Effects: + * Memory will be released for the new vector. Both the TCL command and + * array variable will be deleted. All clients which set call back + * procedures will be notified. + * + *--------------------------------------------------------------------------- + */ +/*LINTLIBRARY*/ +int +Blt_DeleteVector(Blt_Vector *vecPtr) +{ + Vector *vPtr = (Vector *)vecPtr; + + Blt_Vec_Free(vPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_DeleteVectorByName -- + * + * Deletes the vector of the given name. All clients with designated + * callback routines will be notified. + * + * Results: + * A standard TCL result. If no vector exists by that name, TCL_ERROR is + * returned. Otherwise TCL_OK is returned and vector is deleted. + * + * Side Effects: + * Memory will be released for the new vector. Both the TCL command and + * array variable will be deleted. All clients which set call back + * procedures will be notified. + * + *--------------------------------------------------------------------------- + */ +/*LINTLIBRARY*/ +int +Blt_DeleteVectorByName(Tcl_Interp *interp, const char *name) +{ + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + Vector *vPtr; + char *nameCopy; + int result; + + /* + * If the vector name was passed via a read-only string (e.g. "x"), the + * Blt_Vec_ParseElement routine will segfault when it tries to write into + * the string. Therefore make a writable copy and free it when we're + * done. + */ + nameCopy = Blt_AssertStrdup(name); + dataPtr = Blt_Vec_GetInterpData(interp); + result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr); + Blt_Free(nameCopy); + + if (result != TCL_OK) { + return TCL_ERROR; + } + Blt_Vec_Free(vPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_VectorExists2 -- + * + * Returns whether the vector associated with the client token still + * exists. + * + * Results: + * Returns 1 is the vector still exists, 0 otherwise. + * + *--------------------------------------------------------------------------- + */ +int +Blt_VectorExists2(Tcl_Interp *interp, const char *vecName) +{ + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + + dataPtr = Blt_Vec_GetInterpData(interp); + if (GetVectorObject(dataPtr, vecName, NS_SEARCH_BOTH) != NULL) { + return TRUE; + } + return FALSE; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_VectorExists -- + * + * Returns whether the vector associated with the client token + * still exists. + * + * Results: + * Returns 1 is the vector still exists, 0 otherwise. + * + *--------------------------------------------------------------------------- + */ +int +Blt_VectorExists(Tcl_Interp *interp, const char *vecName) +{ + char *nameCopy; + int result; + + /* + * If the vector name was passed via a read-only string (e.g. "x"), the + * Blt_VectorParseName routine will segfault when it tries to write into + * the string. Therefore make a writable copy and free it when we're + * done. + */ + nameCopy = Blt_AssertStrdup(vecName); + result = Blt_VectorExists2(interp, nameCopy); + Blt_Free(nameCopy); + return result; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetVector -- + * + * Returns a pointer to the vector associated with the given name. + * + * Results: + * A standard TCL result. If there is no vector "name", TCL_ERROR is + * returned. Otherwise TCL_OK is returned and vecPtrPtr will point to + * the vector. + * + *--------------------------------------------------------------------------- + */ +int +Blt_GetVector(Tcl_Interp *interp, const char *name, Blt_Vector **vecPtrPtr) +{ + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + Vector *vPtr; + char *nameCopy; + int result; + + dataPtr = Blt_Vec_GetInterpData(interp); + /* + * If the vector name was passed via a read-only string (e.g. "x"), the + * Blt_VectorParseName routine will segfault when it tries to write into + * the string. Therefore make a writable copy and free it when we're + * done. + */ + nameCopy = Blt_AssertStrdup(name); + result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr); + Blt_Free(nameCopy); + if (result != TCL_OK) { + return TCL_ERROR; + } + Blt_Vec_UpdateRange(vPtr); + *vecPtrPtr = (Blt_Vector *) vPtr; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetVectorFromObj -- + * + * Returns a pointer to the vector associated with the given name. + * + * Results: + * A standard TCL result. If there is no vector "name", TCL_ERROR + * is returned. Otherwise TCL_OK is returned and vecPtrPtr will + * point to the vector. + * + *--------------------------------------------------------------------------- + */ +int +Blt_GetVectorFromObj( + Tcl_Interp *interp, + Tcl_Obj *objPtr, + Blt_Vector **vecPtrPtr) +{ + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + Vector *vPtr; + + dataPtr = Blt_Vec_GetInterpData(interp); + if (Blt_Vec_LookupName(dataPtr, Tcl_GetString(objPtr), &vPtr) != TCL_OK) { + return TCL_ERROR; + } + Blt_Vec_UpdateRange(vPtr); + *vecPtrPtr = (Blt_Vector *) vPtr; + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ResetVector -- + * + * Resets the vector data. This is called by a client to indicate that + * the vector data has changed. The vector does not need to point to + * different memory. Any clients of the vector will be notified of the + * change. + * + * Results: + * A standard TCL result. If the new array size is invalid, + * TCL_ERROR is returned. Otherwise TCL_OK is returned and the + * new vector data is recorded. + * + * Side Effects: + * Any client designated callbacks will be posted. Memory may + * be changed for the vector array. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ResetVector( + Blt_Vector *vecPtr, + double *valueArr, /* Array containing the elements of the + * vector. If NULL, indicates to reset the + * vector.*/ + int length, /* The number of elements that the vector + * currently holds. */ + int size, /* The maximum number of elements that the + * array can hold. */ + Tcl_FreeProc *freeProc) /* Address of memory deallocation routine + * for the array of values. Can also be + * TCL_STATIC, TCL_DYNAMIC, or TCL_VOLATILE. */ +{ + Vector *vPtr = (Vector *)vecPtr; + + if (size < 0) { + Tcl_AppendResult(vPtr->interp, "bad array size", (char *)NULL); + return TCL_ERROR; + } + return Blt_Vec_Reset(vPtr, valueArr, length, size, freeProc); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_ResizeVector -- + * + * Changes the size of the vector. All clients with designated callback + * routines will be notified of the size change. + * + * Results: + * A standard TCL result. If no vector exists by that name, TCL_ERROR is + * returned. Otherwise TCL_OK is returned and vector is resized. + * + * Side Effects: + * Memory may be reallocated for the new vector size. All clients which + * set call back procedures will be notified. + * + *--------------------------------------------------------------------------- + */ +int +Blt_ResizeVector(Blt_Vector *vecPtr, int length) +{ + Vector *vPtr = (Vector *)vecPtr; + + if (Blt_Vec_ChangeLength((Tcl_Interp *)NULL, vPtr, length) != TCL_OK) { + Tcl_AppendResult(vPtr->interp, "can't resize vector \"", vPtr->name, + "\"", (char *)NULL); + return TCL_ERROR; + } + if (vPtr->flush) { + Blt_Vec_FlushCache(vPtr); + } + Blt_Vec_UpdateClients(vPtr); + return TCL_OK; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_AllocVectorId -- + * + * Creates an identifier token for an existing vector. The identifier is + * used by the client routines to get call backs when (and if) the vector + * changes. + * + * Results: + * A standard TCL result. If "vecName" is not associated with a vector, + * TCL_ERROR is returned and interp->result is filled with an error + * message. + * + *--------------------------------------------------------------------------- + */ +Blt_VectorId +Blt_AllocVectorId(Tcl_Interp *interp, const char *name) +{ + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + Vector *vPtr; + VectorClient *clientPtr; + Blt_VectorId clientId; + int result; + char *nameCopy; + + dataPtr = Blt_Vec_GetInterpData(interp); + /* + * If the vector name was passed via a read-only string (e.g. "x"), the + * Blt_VectorParseName routine will segfault when it tries to write into + * the string. Therefore make a writable copy and free it when we're + * done. + */ + nameCopy = Blt_AssertStrdup(name); + result = Blt_Vec_LookupName(dataPtr, nameCopy, &vPtr); + Blt_Free(nameCopy); + + if (result != TCL_OK) { + return (Blt_VectorId) 0; + } + /* Allocate a new client structure */ + clientPtr = Blt_AssertCalloc(1, sizeof(VectorClient)); + clientPtr->magic = VECTOR_MAGIC; + + /* Add the new client to the server's list of clients */ + clientPtr->link = Blt_Chain_Append(vPtr->chain, clientPtr); + clientPtr->serverPtr = vPtr; + clientId = (Blt_VectorId) clientPtr; + return clientId; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_SetVectorChangedProc -- + * + * Sets the routine to be called back when the vector is changed or + * deleted. *clientData* will be provided as an argument. If *proc* is + * NULL, no callback will be made. + * + * Results: + * None. + * + * Side Effects: + * The designated routine will be called when the vector is changed + * or deleted. + * + *--------------------------------------------------------------------------- + */ +void +Blt_SetVectorChangedProc( + Blt_VectorId clientId, /* Client token identifying the vector */ + Blt_VectorChangedProc *proc,/* Address of routine to call when the contents + * of the vector change. If NULL, no routine + * will be called */ + ClientData clientData) /* One word of information to pass along when + * the above routine is called */ +{ + VectorClient *clientPtr = (VectorClient *)clientId; + + if (clientPtr->magic != VECTOR_MAGIC) { + return; /* Not a valid token */ + } + clientPtr->clientData = clientData; + clientPtr->proc = proc; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_FreeVectorId -- + * + * Releases the token for an existing vector. This indicates that the + * client is no longer interested the vector. Any previously specified + * callback routine will no longer be invoked when (and if) the vector + * changes. + * + * Results: + * None. + * + * Side Effects: + * Any previously specified callback routine will no longer be + * invoked when (and if) the vector changes. + * + *--------------------------------------------------------------------------- + */ +void +Blt_FreeVectorId(Blt_VectorId clientId) +{ + VectorClient *clientPtr = (VectorClient *)clientId; + + if (clientPtr->magic != VECTOR_MAGIC) { + return; /* Not a valid token */ + } + if (clientPtr->serverPtr != NULL) { + /* Remove the client from the server's list */ + Blt_Chain_DeleteLink(clientPtr->serverPtr->chain, clientPtr->link); + } + Blt_Free(clientPtr); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_NameOfVectorId -- + * + * Returns the name of the vector (and array variable). + * + * Results: + * The name of the array variable is returned. + * + *--------------------------------------------------------------------------- + */ +const char * +Blt_NameOfVectorId(Blt_VectorId clientId) +{ + VectorClient *clientPtr = (VectorClient *)clientId; + + if ((clientPtr->magic != VECTOR_MAGIC) || (clientPtr->serverPtr == NULL)) { + return NULL; + } + return clientPtr->serverPtr->name; +} + +const char * +Blt_NameOfVector(Blt_Vector *vecPtr) /* Vector to query. */ +{ + Vector *vPtr = (Vector *)vecPtr; + return vPtr->name; +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_VectorNotifyPending -- + * + * Returns the name of the vector (and array variable). + * + * Results: + * The name of the array variable is returned. + * + *--------------------------------------------------------------------------- + */ +int +Blt_VectorNotifyPending(Blt_VectorId clientId) +{ + VectorClient *clientPtr = (VectorClient *)clientId; + + if ((clientPtr == NULL) || (clientPtr->magic != VECTOR_MAGIC) || + (clientPtr->serverPtr == NULL)) { + return 0; + } + return (clientPtr->serverPtr->notifyFlags & NOTIFY_PENDING); +} + +/* + *--------------------------------------------------------------------------- + * + * Blt_GetVectorById -- + * + * Returns a pointer to the vector associated with the client + * token. + * + * Results: + * A standard TCL result. If the client token is not associated + * with a vector any longer, TCL_ERROR is returned. Otherwise, + * TCL_OK is returned and vecPtrPtr will point to vector. + * + *--------------------------------------------------------------------------- + */ +int +Blt_GetVectorById( + Tcl_Interp *interp, + Blt_VectorId clientId, /* Client token identifying the vector */ + Blt_Vector **vecPtrPtr) +{ + VectorClient *clientPtr = (VectorClient *)clientId; + + if (clientPtr->magic != VECTOR_MAGIC) { + Tcl_AppendResult(interp, "bad vector token", (char *)NULL); + return TCL_ERROR; + } + if (clientPtr->serverPtr == NULL) { + Tcl_AppendResult(interp, "vector no longer exists", (char *)NULL); + return TCL_ERROR; + } + Blt_Vec_UpdateRange(clientPtr->serverPtr); + *vecPtrPtr = (Blt_Vector *) clientPtr->serverPtr; + return TCL_OK; +} + +/*LINTLIBRARY*/ +void +Blt_InstallIndexProc(Tcl_Interp *interp, const char *string, + Blt_VectorIndexProc *procPtr) +{ + VectorInterpData *dataPtr; /* Interpreter-specific data. */ + Blt_HashEntry *hPtr; + int isNew; + + dataPtr = Blt_Vec_GetInterpData(interp); + hPtr = Blt_CreateHashEntry(&dataPtr->indexProcTable, string, &isNew); + if (procPtr == NULL) { + Blt_DeleteHashEntry(&dataPtr->indexProcTable, hPtr); + } else { + Blt_SetHashValue(hPtr, procPtr); + } +} + +/* spinellia@acm.org START */ + + +#define SWAP(a,b) tempr=(a);(a)=(b);(b)=tempr + +/* routine by Brenner + * data is the array of complex data points, perversely + * starting at 1 + * nn is the number of complex points, i.e. half the length of data + * isign is 1 for forward, -1 for inverse + */ +static void +four1(double *data, unsigned long nn, int isign) +{ + unsigned long n,mmax,m,j,istep,i; + double wtemp,wr,wpr,wpi,wi,theta; + double tempr,tempi; + + n=nn << 1; + j=1; + for (i = 1;i<n;i+=2) { + if (j > i) { + SWAP(data[j],data[i]); + SWAP(data[j+1],data[i+1]); + } + m=n >> 1; + while (m >= 2 && j > m) { + j -= m; + m >>= 1; + } + j += m; + } + mmax=2; + while (n > mmax) { + istep=mmax << 1; + theta=isign*(6.28318530717959/mmax); + wtemp=sin(0.5*theta); + wpr = -2.0*wtemp*wtemp; + wpi=sin(theta); + wr=1.0; + wi=0.0; + for (m=1;m<mmax;m+=2) { + for (i=m;i<=n;i+=istep) { + j=i+mmax; + tempr=wr*data[j]-wi*data[j+1]; + tempi=wr*data[j+1]+wi*data[j]; + data[j]=data[i]-tempr; + data[j+1]=data[i+1]-tempi; + data[i] += tempr; + data[i+1] += tempi; + } + wr=(wtemp=wr)*wpr-wi*wpi+wr; + wi=wi*wpr+wtemp*wpi+wi; + } + mmax=istep; + } +} +#undef SWAP + +static int +smallest_power_of_2_not_less_than(int x) +{ + int pow2 = 1; + + while (pow2 < x){ + pow2 <<= 1; + } + return pow2; +} + + +int +Blt_Vec_FFT( + Tcl_Interp *interp, /* Interpreter to report errors to */ + Vector *realPtr, /* If non-NULL, indicates to compute and + store the real values in this vector. */ + Vector *phasesPtr, /* If non-NULL, indicates to compute + * and store the imaginary values in + * this vector. */ + Vector *freqPtr, /* If non-NULL, indicates to compute + * and store the frequency values in + * this vector. */ + double delta, /* */ + int flags, /* Bit mask representing various + * flags: FFT_NO_constANT, + * FFT_SPECTRUM, and FFT_BARTLETT. */ + Vector *srcPtr) +{ + int length; + int pow2len; + double *paddedData; + int i; + double Wss = 0.0; + /* TENTATIVE */ + int middle = 1; + int noconstant; + + noconstant = (flags & FFT_NO_CONSTANT) ? 1 : 0; + + /* Length of the original vector. */ + length = srcPtr->last - srcPtr->first + 1; + /* new length */ + pow2len = smallest_power_of_2_not_less_than( length ); + + /* We do not do in-place FFTs */ + if (realPtr == srcPtr) { + Tcl_AppendResult(interp, "real vector \"", realPtr->name, + "\" can't be the same as the source", (char *)NULL); + return TCL_ERROR; + } + if (phasesPtr != NULL) { + if (phasesPtr == srcPtr) { + Tcl_AppendResult(interp, "imaginary vector \"", phasesPtr->name, + "\" can't be the same as the source", (char *)NULL); + return TCL_ERROR; + } + if (Blt_Vec_ChangeLength(interp, phasesPtr, + pow2len/2-noconstant+middle) != TCL_OK) { + return TCL_ERROR; + } + } + if (freqPtr != NULL) { + if (freqPtr == srcPtr) { + Tcl_AppendResult(interp, "frequency vector \"", freqPtr->name, + "\" can't be the same as the source", (char *)NULL); + return TCL_ERROR; + } + if (Blt_Vec_ChangeLength(interp, freqPtr, + pow2len/2-noconstant+middle) != TCL_OK) { + return TCL_ERROR; + } + } + + /* Allocate memory zero-filled array. */ + paddedData = Blt_Calloc(pow2len * 2, sizeof(double)); + if (paddedData == NULL) { + Tcl_AppendResult(interp, "can't allocate memory for padded data", + (char *)NULL); + return TCL_ERROR; + } + + /* + * Since we just do real transforms, only even locations will be + * filled with data. + */ + if (flags & FFT_BARTLETT) { /* Bartlett window 1 - ( (x - N/2) / (N/2) ) */ + double Nhalf = pow2len*0.5; + double Nhalf_1 = 1.0 / Nhalf; + double w; + + for (i = 0; i < length; i++) { + w = 1.0 - fabs( (i-Nhalf) * Nhalf_1 ); + Wss += w; + paddedData[2*i] = w * srcPtr->valueArr[i]; + } + for(/*empty*/; i < pow2len; i++) { + w = 1.0 - fabs((i-Nhalf) * Nhalf_1); + Wss += w; + } + } else { /* Squared window, i.e. no data windowing. */ + for (i = 0; i < length; i++) { + paddedData[2*i] = srcPtr->valueArr[i]; + } + Wss = pow2len; + } + + /* Fourier */ + four1(paddedData-1, pow2len, 1); + + /* + for(i=0;i<pow2len;i++){ + printf( "(%f %f) ", paddedData[2*i], paddedData[2*i+1] ); + } + */ + + /* the spectrum is the modulus of the transforms, scaled by 1/N^2 */ + /* or 1/(N * Wss) for windowed data */ + if (flags & FFT_SPECTRUM) { + double re, im, reS, imS; + double factor = 1.0 / (pow2len*Wss); + double *v = realPtr->valueArr; + + for (i = 0 + noconstant; i < pow2len / 2; i++) { + re = paddedData[2*i]; + im = paddedData[2*i+1]; + reS = paddedData[2*pow2len-2*i-2]; + imS = paddedData[2*pow2len-2*i-1]; + v[i - noconstant] = factor * ( +# if 0 + hypot( paddedData[2*i], paddedData[2*i+1] ) + + hypot( + paddedData[pow2len*2-2*i-2], + paddedData[pow2len*2-2*i-1] + ) +# else + sqrt( re*re + im* im ) + sqrt( reS*reS + imS*imS ) +# endif + ); + } + } else { + for(i = 0 + noconstant; i < pow2len / 2 + middle; i++) { + realPtr->valueArr[i - noconstant] = paddedData[2*i]; + } + } + if( phasesPtr != NULL ){ + for (i = 0 + noconstant; i < pow2len / 2 + middle; i++) { + phasesPtr->valueArr[i-noconstant] = paddedData[2*i+1]; + } + } + + /* Compute frequencies */ + if (freqPtr != NULL) { + double N = pow2len; + double denom = 1.0 / N / delta; + for( i=0+noconstant; i<pow2len/2+middle; i++ ){ + freqPtr->valueArr[i-noconstant] = ((double) i) * denom; + } + } + + /* Memory is necessarily dynamic, because nobody touched it ! */ + Blt_Free(paddedData); + + realPtr->offset = 0; + return TCL_OK; +} + + +int +Blt_Vec_InverseFFT(Tcl_Interp *interp, Vector *srcImagPtr, Vector *destRealPtr, + Vector *destImagPtr, Vector *srcPtr) +{ + int length; + int pow2len; + double *paddedData; + int i; + double oneOverN; + + if ((destRealPtr == srcPtr) || (destImagPtr == srcPtr )){ +/* we do not do in-place FFTs */ + return TCL_ERROR; + } + length = srcPtr->last - srcPtr->first + 1; + +/* minus one because of the magical middle element! */ + pow2len = smallest_power_of_2_not_less_than( (length-1)*2 ); + oneOverN = 1.0 / pow2len; + + if (Blt_Vec_ChangeLength(interp, destRealPtr, pow2len) != TCL_OK) { + return TCL_ERROR; + } + if (Blt_Vec_ChangeLength(interp, destImagPtr, pow2len) != TCL_OK) { + return TCL_ERROR; + } + + if( length != (srcImagPtr->last - srcImagPtr->first + 1) ){ + Tcl_AppendResult(srcPtr->interp, + "the length of the imagPart vector must ", + "be the same as the real one", (char *)NULL); + return TCL_ERROR; + } + + paddedData = Blt_AssertMalloc( pow2len*2*sizeof(double) ); + if( paddedData == NULL ){ + if (interp != NULL) { + Tcl_AppendResult(interp, "memory allocation failed", (char *)NULL); + } + return TCL_ERROR; + } + for(i=0;i<pow2len*2;i++) { paddedData[i] = 0.0; } + for(i=0;i<length-1;i++){ + paddedData[2*i] = srcPtr->valueArr[i]; + paddedData[2*i+1] = srcImagPtr->valueArr[i]; + paddedData[pow2len*2 - 2*i - 2 ] = srcPtr->valueArr[i+1]; + paddedData[pow2len*2 - 2*i - 1 ] = - srcImagPtr->valueArr[i+1]; + } +/* mythical middle element */ + paddedData[(length-1)*2] = srcPtr->valueArr[length-1]; + paddedData[(length-1)*2+1] = srcImagPtr->valueArr[length-1]; + +/* +for(i=0;i<pow2len;i++){ + printf( "(%f %f) ", paddedData[2*i], paddedData[2*i+1] ); +} + */ + +/* fourier */ + four1( paddedData-1, pow2len, -1 ); + +/* put values in their places, normalising by 1/N */ + for(i=0;i<pow2len;i++){ + destRealPtr->valueArr[i] = paddedData[2*i] * oneOverN; + destImagPtr->valueArr[i] = paddedData[2*i+1] * oneOverN; + } + +/* memory is necessarily dynamic, because nobody touched it ! */ + Blt_Free( paddedData ); + + return TCL_OK; +} + + +/* spinellia@acm.org STOP */ + + + +static double +FindSplit(Point2d *points, int i, int j, int *split) +{ + double maxDist2; + + maxDist2 = -1.0; + if ((i + 1) < j) { + int k; + double a, b, c; + + /* + * + * dist2 P(k) = | 1 P(i).x P(i).y | + * | 1 P(j).x P(j).y | + * | 1 P(k).x P(k).y | + * ------------------------------------------ + * (P(i).x - P(j).x)^2 + (P(i).y - P(j).y)^2 + */ + + a = points[i].y - points[j].y; + b = points[j].x - points[i].x; + c = (points[i].x * points[j].y) - (points[i].y * points[j].x); + for (k = (i + 1); k < j; k++) { + double dist2; + + dist2 = (points[k].x * a) + (points[k].y * b) + c; + if (dist2 < 0.0) { + dist2 = -dist2; + } + if (dist2 > maxDist2) { + maxDist2 = dist2; /* Track the maximum. */ + *split = k; + } + } + /* Correction for segment length---should be redone if can == 0 */ + maxDist2 *= maxDist2 / (a * a + b * b); + } + return maxDist2; +} + + +/* Douglas-Peucker line simplification algorithm */ +int +Blt_SimplifyLine(Point2d *inputPts, int low, int high, double tolerance, + int *indices) +{ +#define StackPush(a) s++, stack[s] = (a) +#define StackPop(a) (a) = stack[s], s-- +#define StackEmpty() (s < 0) +#define StackTop() stack[s] + int *stack; + int split = -1; + double dist2, tolerance2; + int s = -1; /* Points to top stack item. */ + int count; + + stack = Blt_AssertMalloc(sizeof(int) * (high - low + 1)); + StackPush(high); + count = 0; + indices[count++] = 0; + tolerance2 = tolerance * tolerance; + while (!StackEmpty()) { + dist2 = FindSplit(inputPts, low, StackTop(), &split); + if (dist2 > tolerance2) { + StackPush(split); + } else { + indices[count++] = StackTop(); + StackPop(low); + } + } + Blt_Free(stack); + return count; +} diff --git a/src/bltVector.h b/src/bltVector.h new file mode 100644 index 0000000..78eddc5 --- /dev/null +++ b/src/bltVector.h @@ -0,0 +1,137 @@ + +/* + * bltVector.h -- + * + * Copyright 1993-2004 George A Howlett. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, + * copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following + * conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY + * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR + * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS + * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#ifndef _BLT_VECTOR_H +#define _BLT_VECTOR_H + +typedef enum { + BLT_VECTOR_NOTIFY_UPDATE = 1, /* The vector's values has been updated */ + BLT_VECTOR_NOTIFY_DESTROY /* The vector has been destroyed and the client + * should no longer use its data (calling + * Blt_FreeVectorId) */ +} Blt_VectorNotify; + +typedef struct _Blt_VectorId *Blt_VectorId; + +typedef void (Blt_VectorChangedProc)(Tcl_Interp *interp, ClientData clientData, + Blt_VectorNotify notify); + +typedef struct { + double *valueArr; /* Array of values (possibly malloc-ed) */ + int numValues; /* Number of values in the array */ + int arraySize; /* Size of the allocated space */ + double min, max; /* Minimum and maximum values in the vector */ + int dirty; /* Indicates if the vector has been updated */ + int reserved; /* Reserved for future use */ + +} Blt_Vector; + +typedef double (Blt_VectorIndexProc)(Blt_Vector * vecPtr); + +typedef enum { + BLT_MATH_FUNC_SCALAR = 1, /* The function returns a single double + * precision value. */ + BLT_MATH_FUNC_VECTOR /* The function processes the entire vector. */ +} Blt_MathFuncType; + +/* + * To be safe, use the macros below, rather than the fields of the + * structure directly. + * + * The Blt_Vector is basically an opaque type. But it's also the + * actual memory address of the vector itself. I wanted to make the + * API as unobtrusive as possible. So instead of giving you a copy of + * the vector, providing various functions to access and update the + * vector, you get your hands on the actual memory (array of doubles) + * shared by all the vector's clients. + * + * The trade-off for speed and convenience is safety. You can easily + * break things by writing into the vector when other clients are + * using it. Use Blt_ResetVector to get around this. At least the + * macros are a reminder it isn't really safe to reset the data + * fields, except by the API routines. + */ +#define Blt_VecData(v) ((v)->valueArr) +#define Blt_VecLength(v) ((v)->numValues) +#define Blt_VecSize(v) ((v)->arraySize) +#define Blt_VecDirty(v) ((v)->dirty) + +BLT_EXTERN double Blt_VecMin(Blt_Vector *vPtr); +BLT_EXTERN double Blt_VecMax(Blt_Vector *vPtr); + +BLT_EXTERN Blt_VectorId Blt_AllocVectorId(Tcl_Interp *interp, + const char *vecName); + +BLT_EXTERN void Blt_SetVectorChangedProc(Blt_VectorId clientId, + Blt_VectorChangedProc *proc, ClientData clientData); + +BLT_EXTERN void Blt_FreeVectorId(Blt_VectorId clientId); + +BLT_EXTERN int Blt_GetVectorById(Tcl_Interp *interp, Blt_VectorId clientId, + Blt_Vector **vecPtrPtr); + +BLT_EXTERN const char *Blt_NameOfVectorId(Blt_VectorId clientId); + +BLT_EXTERN const char *Blt_NameOfVector(Blt_Vector *vecPtr); + +BLT_EXTERN int Blt_VectorNotifyPending(Blt_VectorId clientId); + +BLT_EXTERN int Blt_CreateVector(Tcl_Interp *interp, const char *vecName, + int size, Blt_Vector ** vecPtrPtr); + +BLT_EXTERN int Blt_CreateVector2(Tcl_Interp *interp, const char *vecName, + const char *cmdName, const char *varName, int initialSize, + Blt_Vector **vecPtrPtr); + +BLT_EXTERN int Blt_GetVector(Tcl_Interp *interp, const char *vecName, + Blt_Vector **vecPtrPtr); + +BLT_EXTERN int Blt_GetVectorFromObj(Tcl_Interp *interp, Tcl_Obj *objPtr, + Blt_Vector **vecPtrPtr); + +BLT_EXTERN int Blt_VectorExists(Tcl_Interp *interp, const char *vecName); + +BLT_EXTERN int Blt_ResetVector(Blt_Vector *vecPtr, double *dataArr, int n, + int arraySize, Tcl_FreeProc *freeProc); + +BLT_EXTERN int Blt_ResizeVector(Blt_Vector *vecPtr, int n); + +BLT_EXTERN int Blt_DeleteVectorByName(Tcl_Interp *interp, const char *vecName); + +BLT_EXTERN int Blt_DeleteVector(Blt_Vector *vecPtr); + +BLT_EXTERN int Blt_ExprVector(Tcl_Interp *interp, char *expr, + Blt_Vector *vecPtr); + +BLT_EXTERN void Blt_InstallIndexProc(Tcl_Interp *interp, const char *indexName, + Blt_VectorIndexProc * procPtr); + +BLT_EXTERN int Blt_VectorExists2(Tcl_Interp *interp, const char *vecName); + +#endif /* _BLT_VECTOR_H */ |