Changeset 1719


Ignore:
Timestamp:
May 18, 2010 4:26:32 PM (12 years ago)
Author:
gah
Message:
 
Location:
branches/blt4
Files:
23 edited

Legend:

Unmodified
Added
Removed
  • branches/blt4/gui/scripts/Makefile.in

    r1677 r1719  
    1414INSTALL         = @INSTALL@
    1515MKDIR_P         = @MKDIR_P@
    16 TCLSH           = $(bindir)/tclsh8.5
     16TCL_VERSION     = @TCL_VERSION@
     17TCLSH           = $(bindir)/tclsh$(TCL_VERSION)
    1718VPATH           = $(srcdir)
    1819PACKAGE_VERSION = @PACKAGE_VERSION@
  • branches/blt4/gui/scripts/balloon.tcl

    r1646 r1719  
    221221        #         resized but XHeightOfScreen XWidthOfScreen still
    222222        #         report the initial size.
     223        #
     224        #         Fixed in new BLT.
     225        #
    223226        wm geometry $p +$px+$py
    224227    } else {
  • branches/blt4/gui/scripts/deviceEditor.tcl

    r1539 r1719  
    2424    constructor {owner args} {
    2525        Rappture::ControlOwner::constructor $owner
    26     } { # defined below }
    27 
     26    } {
     27        # defined below
     28    }
    2829    public method value {args}
    2930    public method download {option args}
    3031    public method add {dataobj {settings ""}}
    3132    public method delete {args}
    32     public method parameters {title args} { # do nothing }
     33    public method parameters {title args} {
     34        # do nothing
     35    }
     36    public method snap {w h}
    3337
    3438    protected method _redraw {}
     
    217221    return "device1D"
    218222}
     223
     224itcl::body Rappture::DeviceEditor::snap { w h } {
     225    return [$_current snap $w $h]
     226}
  • branches/blt4/gui/scripts/deviceresult.tcl

    r1342 r1719  
    2828    public method delete {args}
    2929    public method scale {args}
     30    public method snap {w h}
    3031    public method parameters {title args} { # do nothing }
    3132    public method download {option args}
     
    131132    return [eval $itk_component(viewer) download $option $args]
    132133}
     134
     135itcl::body Rappture::DeviceResult::snap { w h } {
     136    return [$itk_component(viewer) snap $w $h]
     137}
  • branches/blt4/gui/scripts/field2dresult.tcl

    r1543 r1719  
    3838    public method delete {args}
    3939    public method scale {args}
     40    public method snap {w h}
    4041    public method parameters {title args} { # do nothing }
    4142    public method download {option args}
     
    151152    $itk_component(renderer) download $option
    152153}
     154
     155itcl::body Rappture::Field2DResult::snap { w h } {
     156    return [$itk_component(renderer) snap $w $h]
     157}
  • branches/blt4/gui/scripts/field3dresult.tcl

    r1506 r1719  
    3737    public method delete {args}
    3838    public method scale {args}
     39    public method snap {w h}
    3940    public method parameters {title args} { # do nothing }
    4041    public method download {option args}
     
    153154    $itk_component(renderer) download $option $args
    154155}
     156
     157itcl::body Rappture::Field3DResult::snap { w h } {
     158    return [$itk_component(renderer) snap $w $h]
     159}
  • branches/blt4/gui/scripts/flowvisviewer.tcl

    r1695 r1719  
    4545
    4646    constructor { hostlist args } {
    47         Rappture::VisViewer::constructor $hostlist
     47        Rappture::VisViewer::constructor $hostlist
    4848    } {
    4949        # defined below
  • branches/blt4/gui/scripts/heightmapviewer.tcl

    r1646 r1719  
    5555    public method delete {args}
    5656    public method scale {args}
     57    public method snap { w h }
    5758    public method download {option args}
    5859    public method parameters {title args} {
     
    12451246    return $list
    12461247}
     1248
     1249itcl::body Rappture::HeightmapViewer::snap { w h } {
     1250    if { $w <= 0 || $h <= 0 } {
     1251        set w [image width $_image(plot)]
     1252        set h [image height $_image(plot)]
     1253    }
     1254    set img [image create picture -width $w -height $h]
     1255    $img resample $_image(plot)
     1256    return $img
     1257}
  • branches/blt4/gui/scripts/imageresult.tcl

    r1710 r1719  
    3232    public method delete {args}
    3333    public method scale {args}
     34    public method snap {x y}
    3435    public method parameters {title args} { # do nothing }
    3536    public method download {option args}
     
    593594    }
    594595}
     596
     597itcl::body Rappture::ImageResult::snap { w h } {
     598    if { $w <= 0 || $h <= 0 } {
     599        set w [image width $_image(plot)]
     600        set h [image height $_image(plot)]
     601    }
     602    set img [image create picture -width $w -height $h]
     603    $img resample $_image(final)
     604    return $img
     605}
  • branches/blt4/gui/scripts/moleculeViewer.tcl

    r1648 r1719  
    2828    itk_option define -device device Device ""
    2929
    30     constructor {tool args} { # defined below }
    31     destructor { # defined below }
     30    constructor {tool args} {
     31        # defined below
     32    }
     33    destructor {
     34        # defined below
     35    }
    3236
    3337    public method add {dataobj {settings ""}}
    3438    public method get {}
    3539    public method delete {args}
    36     public method parameters {title args} { # do nothing }
    37 
     40    public method snap {w h}
     41    public method parameters {title args} {
     42        # do nothing
     43    }
    3844    public method emblems {option}
    3945    public method download {option args}
     
    693699    $_dispatcher event -idle !redraw
    694700}
     701
     702itcl::body Rappture::DeviceEditor::snap { w h } {
     703    if { $w <= 0 || $h <= 0 } {
     704        set w [winfo width $itk_component(area)]
     705        set h [winfo height $itk_component(area)]
     706    }
     707    set img [image create picture]
     708    if { [catch {
     709        $img snap $itk_component(area) -width $w -height $h
     710    } ] != 0 } {
     711        $_download blank \#000000
     712    }
     713}
  • branches/blt4/gui/scripts/molvisviewer.tcl

    r1695 r1719  
    4141    itk_option define -device device Device ""
    4242
     43    private variable _icon 0
     44
     45    private variable _mevent;           # info used for mouse event operations
     46    private variable _rocker;           # info used for rock operations
     47    private variable _dlist "";         # list of dataobj objects
     48    private variable _dataobjs;         # data objects on server
     49    private variable _dobj2transparency;# maps dataobj => transparency
     50    private variable _dobj2raise;       # maps dataobj => raise flag 0/1
     51
     52    private variable _active;           # array of active models.
     53    private variable _obj2models;       # array containing list of models
     54                                        # for each data object.
     55
     56    private variable _view
     57    private variable _click
     58
     59    private variable _model
     60    private variable _mlist
     61    private variable _mrepresentation "ballnstick"
     62
     63    private variable _imagecache
     64    private variable _state
     65    private variable _labels  "default"
     66    private variable _cacheid ""
     67    private variable _cacheimage ""
     68
     69    private variable _delta1 10
     70    private variable _delta2 2
     71
     72    private common _settings  ;         # Array of settings for all known
     73                                        # widgets
     74    private variable _initialized
     75
     76    private common _downloadPopup;      # Download options from popup
     77    private variable _pdbdata;          # PDB data from run file sent to pymol
     78    private common _hardcopy
     79    private variable _nextToken 0
     80    private variable _outbuf "";
     81    private variable _buffering 0;
     82    private variable _resizePending 0;
     83    private variable _width
     84    private variable _height
     85    private variable _restore 1;        # Restore camera settings
     86
    4387    constructor { hostlist args } {
    4488        Rappture::VisViewer::constructor $hostlist
     
    58102    private method ReceiveImage { size cacheid frame rock }
    59103    private method WaitIcon { option widget }
     104    private method DownloadPopup { popup command }
     105    private method EnableDownload { popup what }
    60106
    61107    protected method Map {}
     
    74120    public method ResetView {}
    75121    public method add {dataobj {options ""}}
    76     public method spherescale {option {models "all"} }
    77     public method stickradius {option {models "all"} }
     122    public method cartoontrace {option {model "all"}}
    78123    public method delete {args}
    79124    public method download {option args}
     
    81126    public method isconnected {}
    82127    public method labels {option {model "all"}}
    83     public method cartoontrace {option {model "all"}}
    84128    public method opacity {option {models "all"} }
    85129    public method parameters {title args} {
    86130        # do nothing
    87131    }
     132    public method snap { w h }
     133    public method spherescale {option {models "all"} }
     134    public method stickradius {option {models "all"} }
    88135    public method projection {option}
    89136    public method representation {option {model "all"} }
    90137    public method rock {option}
    91     private method DownloadPopup { popup command }
    92     private method EnableDownload { popup what }
    93 
    94     private variable _icon 0
    95 
    96     private variable _mevent;           # info used for mouse event operations
    97     private variable _rocker;           # info used for rock operations
    98     private variable _dlist "";         # list of dataobj objects
    99     private variable _dataobjs;         # data objects on server
    100     private variable _dobj2transparency;# maps dataobj => transparency
    101     private variable _dobj2raise;       # maps dataobj => raise flag 0/1
    102 
    103     private variable _active;           # array of active models.
    104     private variable _obj2models;       # array containing list of models
    105                                         # for each data object.
    106 
    107     private variable _view
    108     private variable _click
    109 
    110     private variable _model
    111     private variable _mlist
    112     private variable _mrepresentation "ballnstick"
    113 
    114     private variable _imagecache
    115     private variable _state
    116     private variable _labels  "default"
    117     private variable _cacheid ""
    118     private variable _cacheimage ""
    119 
    120     private variable _delta1 10
    121     private variable _delta2 2
    122 
    123     private common _settings  ;         # Array of settings for all known
    124                                         # widgets
    125     private variable _initialized
    126 
    127     private common _downloadPopup;      # Download options from popup
    128     private variable _pdbdata;          # PDB data from run file sent to pymol
    129     private common _hardcopy
    130     private variable _nextToken 0
    131     private variable _outbuf "";
    132     private variable _buffering 0;
    133     private variable _resizePending 0;
    134     private variable _width
    135     private variable _height
     138
    136139}
    137140
     
    179182    set _state(client) 1
    180183    set _hostlist $hostlist
     184    set _restore 1
    181185
    182186    array set _view {
     
    595599        return 0
    596600    }
     601    set _restore 1
    597602    set result [VisViewer::Connect $hosts]
    598603    if { $result } {
     
    665670    global count
    666671    incr count
    667     debug "$count: cacheid=$cacheid frame=$frame\n"
    668672    if { $cacheid != $_cacheid } {
    669673        array unset _imagecache
     
    702706    set _buffering 1
    703707
    704     set _rocker(server) 0
    705     set _cacheid 0
    706     SendCmd "raw -defer {set auto_color,0}"
    707     SendCmd "raw -defer {set auto_show_lines,0}"
    708 
     708    if { $_restore } {
     709        set _rocker(server) 0
     710        set _cacheid 0
     711        SendCmd "raw -defer {set auto_color,0}"
     712        SendCmd "raw -defer {set auto_show_lines,0}"
     713    }
    709714    set dlist [get]
    710715    foreach dataobj $dlist {
     
    797802            set _mlist($model) 1
    798803        }
    799 
    800804        if { $_mlist($model) == 1 } {
    801805            if {  [info exists _model($model-newtransparency)] ||
     
    834838        set _state(client) 1
    835839        SendCmd "frame 1"
     840        set flush 1
    836841    } elseif { ![info exists _imagecache($state,$_rocker(client))] } {
    837842        set _state(server) $state
    838843        set _state(client) $state
    839844        SendCmd "frame $state"
     845        set flush 1
    840846    } else {
    841847        set _state(client) $state
    842848        Update
    843     }
    844     # Reset viewing parameters
    845     set w  [winfo width $itk_component(3dview)]
    846     set h  [winfo height $itk_component(3dview)]
    847     SendCmd [subst {
    848         reset
    849         screen $w $h
    850         rotate $_view(mx) $_view(my) $_view(mz)
    851         pan $_view(x) $_view(y)
    852         zoom $_view(zoom)
    853     }]
    854     debug "rebuild: rotate $_view(mx) $_view(my) $_view(mz)"
    855 
    856     # foreach all models
    857     spherescale update
    858     stickradius update
    859     labels update
    860     opacity update
    861     cartoontrace update
    862 
    863     projection update
    864     representation update
    865 
     849        set flush 0
     850    }
     851    if { $_restore } {
     852        # Set or restore viewing parameters.  We do this for the first
     853        # model and assume this works for everything else.
     854        set w  [winfo width $itk_component(3dview)]
     855        set h  [winfo height $itk_component(3dview)]
     856        SendCmd [subst {
     857            reset
     858            screen $w $h
     859            rotate $_view(mx) $_view(my) $_view(mz)
     860            pan $_view(x) $_view(y)
     861            zoom $_view(zoom)
     862        }]
     863        debug "rebuild: rotate $_view(mx) $_view(my) $_view(mz)"
     864
     865        # Default settings for all models.
     866        spherescale update
     867        stickradius update
     868        labels update
     869        opacity update
     870        cartoontrace update
     871       
     872        projection update
     873        representation update
     874        SendCmd "raw -defer {zoom complete=1}"
     875        set _restore 0
     876    }
     877
     878    if { $flush } {
     879        SendCmd "bmp";                  # Flush the results.
     880    }
    866881    set _buffering 0;                   # Turn off buffering.
    867     # Actually write the commands to the server socket.  If it fails, we don't
    868     # care.  We're finished here.
     882
    869883    blt::busy hold $itk_component(hull)
     884
     885    # Actually write the commands to the server socket. 
     886    # If it fails, we don't care.  We're finished here.
    870887    SendBytes $_outbuf;                 
     888    set _outbuf "";                     # Clear the buffer.             
    871889    blt::busy release $itk_component(hull)
    872     set _outbuf "";                     # Clear the buffer.             
    873890
    874891    debug "exiting rebuild"
     
    877894itcl::body Rappture::MolvisViewer::Unmap { } {
    878895    # Pause rocking loop while unmapped (saves CPU time)
    879     puts stderr "unmap $this"
    880     puts stderr "rock pause"
    881896    rock pause
    882897
     
    891906
    892907itcl::body Rappture::MolvisViewer::Map { } {
    893     puts stderr "map $this"
    894908    if { [isconnected] } {
    895909        # Resume rocking loop if it was on
    896         puts stderr "rock unpause"
    897910        rock unpause
    898911        # Rebuild image if modified, or redisplay cached image if not
     
    13641377        }
    13651378        set _dobj2raise($dataobj) $params(-raise)
     1379        debug "setting parameters for $dataobj\n"
    13661380
    13671381        if { [isconnected] } {
     1382            debug "calling rebuild\n"
    13681383            $_dispatcher event -idle !rebuild
    13691384        }
     
    16201635    set _settings($this-spherescale) $radius
    16211636    if { $models == "all" } {
    1622         set models [array names _mlist]
     1637        SendCmd "spherescale -model all $radius"
     1638        return
    16231639    }
    16241640    set overrideradius [expr $radius * 0.8]
     
    16551671    set _settings($this-stickradius) $radius
    16561672    if { $models == "all" } {
    1657         set models [array names _mlist]
     1673        SendCmd "stickradius -model all $radius"
     1674        return
    16581675    }
    16591676    set overrideradius [expr $radius * 0.8]
     
    16891706    }
    16901707    set _settings($this-opacity) $opacity
     1708    set transparency [expr 1.0 - $opacity]
    16911709    if { $models == "all" } {
    1692         set models [array names _mlist]
     1710        SendCmd "transparency -model all $transparency"
     1711        return
    16931712    }
    16941713    set overridetransparency 0.60
    1695     set transparency [expr 1.0 - $opacity]
    16961714    SendCmd "transparency -model all $overridetransparency"
    16971715    foreach model $models {
     
    17201738    set _settings($this-showlabels) $showlabels
    17211739    if { $models == "all" } {
    1722         set models [array names _mlist]
     1740        SendCmd "label -model all $showlabels"
     1741        return
    17231742    }
    17241743    SendCmd "label -model all off"
     
    17501769    set _settings($this-cartoontrace) $trace
    17511770    if { $models == "all" } {
    1752         set models [array names _mlist]
     1771        SendCmd "cartoontrace -model all $trace"
     1772        return
    17531773    }
    17541774    SendCmd "cartoontrace -model all off"
     
    18561876}
    18571877
     1878itcl::body Rappture::MolvisViewer::snap { w h } {
     1879    if { $w <= 0 || $h <= 0 } {
     1880        set w [image width $_image(plot)]
     1881        set h [image height $_image(plot)]
     1882    }
     1883    set tag "$_state(client),$_rocker(client)"
     1884    if { $_image(id) != "$tag" } {
     1885        while { ![info exists _imagecache($tag)] } {
     1886            update idletasks
     1887            update
     1888            after 100
     1889        }
     1890        if { [info exists _imagecache($tag)] } {
     1891            $_image(plot) configure -data $_imagecache($tag)
     1892            set _image(id) "$tag"
     1893        }
     1894    }
     1895    set img [image create picture -width $w -height $h]
     1896    $img resample $_image(plot)
     1897    return $img
     1898}
  • branches/blt4/gui/scripts/nanovisviewer.tcl

    r1646 r1719  
    8282    public method rmdupmarker { m x }
    8383    public method scale {args}
     84    public method snap { w h }
    8485    public method updatetransferfuncs {}
    8586
     
    20092010}
    20102011
     2012
     2013itcl::body Rappture::NanovisViewer::snap { w h } {
     2014    if { $w <= 0 || $h <= 0 } {
     2015        set w [image width $_image(plot)]
     2016        set h [image height $_image(plot)]
     2017    }
     2018    set img [image create picture -width $w -height $h]
     2019    $img resample $_image(plot)
     2020    return $img
     2021}
  • branches/blt4/gui/scripts/sequenceresult.tcl

    r1644 r1719  
    4444    protected method _playFrame {}
    4545    protected method _fixValue {}
     46    private method Capture {w h}
    4647
    4748    private variable _dispatcher "" ;# dispatcher for !events
     
    300301        }
    301302        now {
    302             if {0} {
     303            if {1} {
    303304                # produce a movie of results
    304                 set rval ""
    305305                if {"" != $_topmost} {
    306                     set max [$_topmost size]
    307                     set all ""
    308                     for {set i 0} {$i < $max} {incr i} {
    309                         set dataobj [lindex [$_topmost value $i] 0]
    310                         if {[catch {$dataobj tkimage} imh] == 0} {
    311                             lappend all $imh
    312                         }
    313                     }
    314                     if {[llength $all] > 0} {
    315                         set delay [expr {int(ceil(pow($_play(speed)/10.0+2,2.0)*15))}]
    316                         set rval [eval Rappture::icon::gif_animate $delay $all]
    317                     }
    318                 }
    319                 if {[string length $rval] > 0} {
    320                     return [list .gif $rval]
    321                 }
     306                    return [Capture 0 0]
     307                }
    322308                return ""
    323             }
     309            } else {
    324310            # otherwise, return download of single frame
    325311            return [eval $itk_component(area).viewer download now $args]
     312        }
    326313        }
    327314        default {
     
    559546        return
    560547    }
     548    set val [$itk_component(dial) get -format label current]
     549    set _pos [lsearch -glob $_indices $val*]
     550    # populate the label for this element
    561551    if { "" != [$_topmost hints indexlabel] } {
    562         set val [$itk_component(dial) get -format label current]
    563552        $itk_component(indexValue) configure -text "= $val"
    564         set _pos [lsearch -glob $_indices $val*]
    565     }
    566     # populate the label for this element
     553    }
    567554    $itk_component(eleLabel) configure -text "[$_topmost label $_pos]"
    568555    foreach dataobj [$_topmost value $_pos] {
     
    574561    }
    575562}
     563
     564# ----------------------------------------------------------------------
     565# USAGE: Capture
     566#
     567# Invoked automatically whenever the value on the dial changes.
     568# Updates the viewer to display the value for the selected result.
     569# ----------------------------------------------------------------------
     570itcl::body Rappture::SequenceResult::Capture {w h} {
     571    set viewer $itk_component(area).viewer
     572    if {![winfo exists $viewer]} {
     573        return
     574    }
     575    set label [$itk_component(indexLabel) cget -text]
     576    set imageList {}
     577    update idletasks
     578    update
     579    set old $_pos
     580    for { set i 0 } { $i < [llength $_indices] } { incr i } {
     581        goto $i
     582        _fixValue
     583        update
     584        set img [$viewer snap 0 0]
     585        $img export gif -file frame$i.gif
     586        set value [$itk_component(indexValue) cget -text]
     587        if { $value != "" } {
     588            $img draw text "$label $value" 10 10 \
     589                -font "Arial 10" -color white -shadow 1
     590        }
     591        lappend imageList $img
     592    }
     593    goto $old
     594    _fixValue
     595    update
     596    set dest [image create picture]
     597    eval $dest list replace 0 end $imageList
     598    set delay [expr {int(ceil(pow($_play(speed)/10.0+2,2.0)*15))}]
     599    set delay [expr $_play(speed)]
     600    $dest export gif -animate -delay $delay -data bytes
     601    eval image delete $dest $imageList
     602    return [list .gif $bytes]
     603}
  • branches/blt4/gui/scripts/textentry.tcl

    r1710 r1719  
    1717option add *TextEntry.width 0 widgetDefault
    1818option add *TextEntry.height 0 widgetDefault
    19 option add *TextEntry.editable yes widgetDefault
    2019option add *TextEntry.textBackground white widgetDefault
    2120option add *TextEntry*disabledForeground #a3a3a3 widgetDefault
     
    3433    inherit itk::Widget
    3534
    36     itk_option define -editable editable Editable ""
    3735    itk_option define -state state State "normal"
     36    itk_option define -disabledforeground disabledForeground DisabledForeground ""
     37    itk_option define -disabledbackground disabledBackground DisabledBackground ""
    3838    itk_option define -width width Width 0
    3939    itk_option define -height height Height 0
     
    5151    protected method _newValue {}
    5252    protected method _edit {option args}
    53     protected method _fixState {}
    5453    protected method _uploadValue {args}
    5554    protected method _downloadValue {}
     
    6059
    6160    private variable _layout ""     ;# entry or full text size
    62     private variable _mode "ascii"  ;# ascii text or binary data
    6361    private variable _value ""      ;# value inside the widget
    6462    private variable _size ""       ;# size hint from XML
     
    6664                                                                               
    6765itk::usual TextEntry {
     66    keep -foreground -background -textbackground -font -cursor
    6867}
    6968
     
    10099    set str [$_owner xml get $path.default]
    101100    if {"" != $str} {
    102         _layout  ;# must fix layout or value won't take
    103101        value $str
    104102    }
     
    129127        set newval [lindex $args 0]
    130128        _setValue $newval
    131 
    132         $_dispatcher event -idle !layout
    133         event generate $itk_component(hull) <<Value>>
    134         return $newval
     129        _newValue
    135130
    136131    } elseif {[llength $args] != 0} {
     
    141136    # Query the value and return.
    142137    #
    143     if {$_mode == "ascii"} {
    144         if {$_layout == "entry"} {
    145             return [$itk_component(entry) get]
    146         } elseif {$_layout == "text"} {
    147             return [$itk_component(text) get 1.0 end-1char]
    148         }
    149     } else {
    150         return $_value
     138    switch -- $_layout {
     139        entry {
     140            return [$itk_component(entry) get]
     141        }
     142        text {
     143            return [$itk_component(text) get 1.0 end-1char]
     144        }
     145        binary {
     146            return $_value
     147        }
    151148    }
    152149    return ""
     
    194191        # and count its lines/characters.
    195192        #
    196         set val ""
    197         if {$_layout == "entry"} {
    198             set val [$itk_component(entry) get]
    199         } elseif {$_layout == "text"} {
    200             set val [$itk_component(text) get 1.0 end-1char]
    201         }
    202 
    203         set chars 0
    204         set lines 0
    205         foreach line [split $val \n] {
    206             incr lines
    207             if {[string length $line] > $chars} {
    208                 set chars [string length $line]
     193        if {[string length $_value] > 1920} {
     194            # if size is really big, don't bother counting lines
     195            set size "80x24"
     196        } else {
     197            set chars 0
     198            set lines 0
     199            foreach line [split $_value \n] {
     200                incr lines
     201                if {[string length $line] > $chars} {
     202                    set chars [string length $line]
     203                }
    209204            }
    210         }
    211         incr chars
    212 
    213         if {$lines > 1} {
    214             set size "${chars}x${lines}"
    215         } else {
    216             set size $chars
    217         }
    218     }
    219 
    220     if {[regexp {^[0-9]+$} $size]} {
    221         #
    222         # If the size is WW, then flip to entry mode, with
    223         # a requested size of WW characters.
    224         #
    225         if {$_layout != "entry"} {
    226             set val ""
    227             if {$_layout == "text"} {
    228                 set val [$itk_component(text) get 1.0 end-1char]
    229                 destroy $itk_component(text)
    230                 destroy $itk_component(scrollbars)
     205            incr chars
     206
     207            if {$lines > 1} {
     208                set size "${chars}x${lines}"
     209            } else {
     210                set size $chars
    231211            }
    232 
    233             itk_component add entry {
    234                 entry $itk_interior.entry
    235             } {
    236                 usual
    237                 rename -background -textbackground textBackground Background
    238                 rename -foreground -textforeground textForeground Foreground
    239             }
     212        }
     213    }
     214
     215    if {$size == "binary" || [Rappture::encoding::is binary $_value]} {
     216        set newlayout "binary"
     217    } elseif {[regexp {^[0-9]+$} $size]} {
     218        set newlayout "entry"
     219    } elseif {[regexp {^([0-9]+)x([0-9]+)$} $size match w h]} {
     220        set newlayout "text"
     221    }
     222
     223    if {$newlayout != $_layout} {
     224        set oldval ""
     225        if {$_layout == "entry"} {
     226            set oldval [$itk_component(entry) get]
     227        } elseif {$_layout == "text"} {
     228            set oldval [$itk_component(text) get 1.0 end-1char]
     229        }
     230
     231        # take down any existing widget
     232        foreach win [pack slaves $itk_interior] {
     233            pack forget $win
     234        }
     235
     236        switch -- $newlayout {
     237          entry {
     238            # don't have the entry widget yet? then create it
     239            if {![winfo exists $itk_interior.entry]} {
     240                itk_component add entry {
     241                    entry $itk_interior.entry
     242                } {
     243                    usual
     244                    rename -background -textbackground textBackground Background
     245                    rename -foreground -textforeground textForeground Foreground
     246                }
     247                $itk_component(entry) configure \
     248                    -background $itk_option(-textbackground) \
     249                    -foreground $itk_option(-textforeground)
     250
     251                bind $itk_component(entry) <KeyPress> \
     252                    [itcl::code $this _newValue]
     253                bind $itk_component(entry) <Control-KeyPress-a> \
     254                    "[list $itk_component(entry) selection range 0 end]; break"
     255
     256                itk_component add emenu {
     257                    menu $itk_component(entry).menu -tearoff 0
     258                }
     259                $itk_component(emenu) add command \
     260                    -label "Cut" -accelerator "^X" \
     261                    -command [list event generate $itk_component(entry) <<Cut>>]
     262                $itk_component(emenu) add command \
     263                    -label "Copy" -accelerator "^C" \
     264                    -command [list event generate $itk_component(entry) <<Copy>>]
     265                $itk_component(emenu) add command \
     266                    -label "Paste" -accelerator "^V" \
     267                    -command [list event generate $itk_component(entry) <<Paste>>]
     268                $itk_component(emenu) add command \
     269                    -label "Select All" -accelerator "^A" \
     270                    -command [list $itk_component(entry) selection range 0 end]
     271                bind $itk_component(entry) <<PopupMenu>> \
     272                    [itcl::code $this _edit menu emenu %X %Y]
     273            }
     274
     275            # show the entry widget
    240276            pack $itk_component(entry) -expand yes -fill both
    241             $itk_component(entry) configure \
    242                 -background $itk_option(-textbackground) \
    243                 -foreground $itk_option(-textforeground)
    244 
    245             bind $itk_component(entry) <KeyPress> [itcl::code $this _newValue]
    246             bind $itk_component(entry) <Control-KeyPress-a> \
    247                 "[list $itk_component(entry) selection range 0 end]; break"
    248 
    249             itk_component add emenu {
    250                 menu $itk_component(entry).menu -tearoff 0
    251             }
    252             $itk_component(emenu) add command -label "Cut" -accelerator "^X" \
    253                 -command [list event generate $itk_component(entry) <<Cut>>]
    254             $itk_component(emenu) add command -label "Copy" -accelerator "^C" \
    255                 -command [list event generate $itk_component(entry) <<Copy>>]
    256             $itk_component(emenu) add command -label "Paste" -accelerator "^V" \
    257                 -command [list event generate $itk_component(entry) <<Paste>>]
    258             $itk_component(emenu) add command -label "Select All" -accelerator "^A" -command [list $itk_component(entry) selection range 0 end]
    259             bind $itk_component(entry) <<PopupMenu>> \
    260                 [itcl::code $this _edit menu emenu %X %Y]
    261 
    262             set _layout "entry"
    263             _setValue $val
    264         }
    265         $itk_component(entry) configure -width $size
    266 
    267     } elseif {[regexp {^([0-9]+)x([0-9]+)$} $size match w h]} {
    268         #
    269         # If the size is WWxHH, then flip to text mode, with
    270         # a requested size of HH lines by WW characters.
    271         #
    272         if {$_layout != "text"} {
    273             set val ""
    274             if {$_layout == "entry"} {
    275                 set val [$itk_component(entry) get]
    276                 destroy $itk_component(entry)
    277             }
    278 
    279             itk_component add scrollbars {
    280                 blt::scrollset $itk_interior.scrl \
    281                     -xscrollbar $itk_interior.scrl.xs \
    282                     -yscrollbar $itk_interior.scrl.ys \
    283                     -window $itk_interior.scrl.text
    284             }
    285             blt::tk::scrollbar $itk_interior.scrl.xs
    286             blt::tk::scrollbar $itk_interior.scrl.ys
     277
     278            # load any previous value
     279            regsub -all "\n" $oldval "" oldval
     280            $itk_component(entry) delete 0 end
     281            $itk_component(entry) insert end $oldval
     282          }
     283
     284          text {
     285            if {![winfo exists $itk_interior.scrl]} {
     286                itk_component add scrollbars {
     287                    blt::scrollset $itk_interior.scrl \
     288                        -xscrollbar $itk_interior.scrl.xs \
     289                        -yscrollbar $itk_interior.scrl.ys \
     290                        -window $itk_interior.scrl.text
     291                }
     292                blt::tk::scrollbar $itk_interior.scrl.xs
     293                blt::tk::scrollbar $itk_interior.scrl.ys
     294                pack $itk_component(scrollbars) -expand yes -fill both
     295
     296                itk_component add text {
     297                    text $itk_component(scrollbars).text \
     298                        -width 1 -height 1 -wrap char
     299                } {
     300                    usual
     301                    rename -background -textbackground textBackground Background
     302                    rename -foreground -textforeground textForeground Foreground
     303                    rename -font -codefont codeFont CodeFont
     304                }
     305                $itk_component(text) configure \
     306                    -background $itk_option(-textbackground) \
     307                    -foreground $itk_option(-textforeground) \
     308                    -font $itk_option(-codefont)
     309
     310                bind $itk_component(text) <KeyPress> \
     311                    [itcl::code $this _newValue]
     312                bind $itk_component(text) <Control-KeyPress-a> \
     313                    "[list $itk_component(text) tag add sel 1.0 end]; break"
     314
     315                itk_component add tmenu {
     316                    menu $itk_component(text).menu -tearoff 0
     317                }
     318                $itk_component(tmenu) add command \
     319                    -label "Cut" -accelerator "^X" \
     320                    -command [list event generate $itk_component(text) <<Cut>>]
     321                $itk_component(tmenu) add command \
     322                    -label "Copy" -accelerator "^C" \
     323                    -command [list event generate $itk_component(text) <<Copy>>]
     324                $itk_component(tmenu) add command \
     325                    -label "Paste" -accelerator "^V" \
     326                    -command [list event generate $itk_component(text) <<Paste>>]
     327                $itk_component(tmenu) add command \
     328                    -label "Select All" -accelerator "^A" \
     329                    -command [list $itk_component(text) tag add sel 1.0 end]
     330                $itk_component(tmenu) add separator
     331
     332                $itk_component(tmenu) add command \
     333                    -label [Rappture::filexfer::label upload] \
     334                    -command [itcl::code $this _uploadValue -start]
     335                $itk_component(tmenu) add command \
     336                    -label [Rappture::filexfer::label download] \
     337                    -command [itcl::code $this _downloadValue]
     338
     339                bind $itk_component(text) <<PopupMenu>> \
     340                    [itcl::code $this _edit menu tmenu %X %Y]
     341            }
     342
     343            # show the text editor widget
    287344            pack $itk_component(scrollbars) -expand yes -fill both
    288 
    289             itk_component add text {
    290                 text $itk_component(scrollbars).text \
    291                     -width 1 -height 1 -wrap char
    292             } {
    293                 usual
    294                 rename -background -textbackground textBackground Background
    295                 rename -foreground -textforeground textForeground Foreground
    296                 rename -font -codefont codeFont CodeFont
    297             }
    298             $itk_component(text) configure \
    299                 -background $itk_option(-textbackground) \
    300                 -foreground $itk_option(-textforeground) \
    301                 -font $itk_option(-codefont)
    302 
    303             bind $itk_component(text) <KeyPress> [itcl::code $this _newValue]
    304             bind $itk_component(text) <Control-KeyPress-a> \
    305                 "[list $itk_component(text) tag add sel 1.0 end]; break"
    306 
    307             itk_component add tmenu {
    308                 menu $itk_component(text).menu -tearoff 0
    309             }
    310             $itk_component(tmenu) add command -label "Cut" -accelerator "^X" \
    311                 -command [list event generate $itk_component(text) <<Cut>>]
    312             $itk_component(tmenu) add command -label "Copy" -accelerator "^C" \
    313                 -command [list event generate $itk_component(text) <<Copy>>]
    314             $itk_component(tmenu) add command -label "Paste" -accelerator "^V" \
    315                 -command [list event generate $itk_component(text) <<Paste>>]
    316             $itk_component(tmenu) add command -label "Select All" -accelerator "^A" -command [list $itk_component(text) tag add sel 1.0 end]
    317             $itk_component(tmenu) add separator
    318 
    319             $itk_component(tmenu) add command \
    320                 -label [Rappture::filexfer::label upload] \
    321                 -command [itcl::code $this _uploadValue -start]
    322             $itk_component(tmenu) add command \
    323                 -label [Rappture::filexfer::label download] \
    324                 -command [itcl::code $this _downloadValue]
    325 
    326             bind $itk_component(text) <<PopupMenu>> \
    327                 [itcl::code $this _edit menu tmenu %X %Y]
    328 
    329             set _layout "text"
    330             _setValue $val
    331         }
    332         $itk_component(text) configure -width $w -height $h
     345            $itk_component(text) configure -width $w -height $h
     346
     347            # load any previous value
     348            $itk_component(text) delete 1.0 end
     349            $itk_component(text) insert end $oldval
     350          }
     351
     352          binary {
     353            if {![winfo exists $itk_interior.bin]} {
     354                itk_component add binary {
     355                    frame $itk_interior.bin
     356                }
     357
     358                itk_component add binicon {
     359                    ::label $itk_component(binary).binicon \
     360                        -image [Rappture::icon binary] -borderwidth 0
     361                }
     362                pack $itk_component(binicon) -side left
     363
     364                itk_component add bininfo {
     365                    ::label $itk_component(binary).bininfo \
     366                        -text "Empty\n0 bytes" \
     367                        -width 5 -justify left -anchor w -borderwidth 0
     368                }
     369                pack $itk_component(bininfo) -side left -expand yes -fill x -padx 4
     370
     371                itk_component add bmenu {
     372                    menu $itk_component(binary).menu -tearoff 0
     373                }
     374                $itk_component(bmenu) add command \
     375                    -label [Rappture::filexfer::label upload] \
     376                    -command [itcl::code $this _uploadValue -start]
     377                $itk_component(bmenu) add command \
     378                    -label [Rappture::filexfer::label download] \
     379                    -command [itcl::code $this _downloadValue]
     380
     381                bind $itk_component(binicon) <<PopupMenu>> \
     382                    [itcl::code $this _edit menu bmenu %X %Y]
     383                bind $itk_component(bininfo) <<PopupMenu>> \
     384                    [itcl::code $this _edit menu bmenu %X %Y]
     385            }
     386
     387            # show the binary mode rep
     388            pack $itk_component(binary) -side top -fill x
     389
     390          }
     391          default {
     392              error "don't know how to handle mode \"$newlayout\" for string editor"
     393          }
     394        }
     395        set _layout $newlayout
    333396    }
    334397
     
    356419    if {[Rappture::encoding::is binary $newval]} {
    357420        # looks like a binary file
    358         set _mode "binary"
    359421        set _value $newval
    360 
    361         if {$_layout == "entry" || [string match {*x[01]} $_size]} {
    362             set newval [Rappture::utils::hexdump -lines 0 $_value]
    363         } else {
    364             set newval [Rappture::utils::hexdump -lines 1000 $_value]
    365         }
    366422    } else {
    367423        # ascii file -- map carriage returns to line feeds
    368         set _mode "ascii"
    369         set _value ""
    370424        regsub -all "\r\n" $newval "\n" newval
    371425        regsub -all "\r" $newval "\n" newval
    372     }
    373 
    374     if {$_layout == "entry"} {
    375         $itk_component(entry) configure -state normal
    376         $itk_component(emenu) entryconfigure "Cut" -state normal
    377         $itk_component(emenu) entryconfigure "Paste" -state normal
    378         $itk_component(entry) delete 0 end
    379         $itk_component(entry) insert 0 $newval
    380         if {!$itk_option(-editable) || $_mode == "binary"} {
    381             $itk_component(entry) configure -state disabled
    382             $itk_component(emenu) entryconfigure "Cut" -state disabled
    383             $itk_component(emenu) entryconfigure "Paste" -state disabled
    384         }
    385     } elseif {$_layout == "text"} {
    386         $itk_component(text) configure -state normal
    387         $itk_component(tmenu) entryconfigure "Cut" -state normal
    388         $itk_component(tmenu) entryconfigure "Paste" -state normal
    389         $itk_component(text) delete 1.0 end
    390         $itk_component(text) insert end $newval
    391         if {!$itk_option(-editable) || $_mode == "binary"} {
    392             set hull $itk_component(hull)
    393             set dfg [option get $hull disabledForeground Foreground]
    394             set dbg [option get $hull disabledBackground Background]
    395             $itk_component(text) configure -state disabled \
    396                 -background $dbg -foreground $dfg
    397             $itk_component(tmenu) entryconfigure "Cut" -state disabled
    398             $itk_component(tmenu) entryconfigure "Paste" -state disabled
    399         } else {
    400             $itk_component(text) configure \
    401                 -background $itk_option(-textbackground) \
    402                 -foreground $itk_option(-textforeground)
    403         }
     426        set _value $newval
     427    }
     428
     429    # fix up the layout so the display widgets exist, then load the new value
     430    _layout
     431
     432    switch -- $_layout {
     433        entry {
     434            $itk_component(entry) configure -state normal
     435            $itk_component(entry) delete 0 end
     436            $itk_component(entry) insert end $_value
     437            $itk_component(entry) configure -state $itk_option(-state)
     438        }
     439        text {
     440            $itk_component(text) configure -state normal
     441            $itk_component(text) delete 1.0 end
     442            $itk_component(text) insert end $_value
     443            $itk_component(text) configure -state $itk_option(-state)
     444        }
     445        binary {
     446            set desc [Rappture::utils::datatype $_value]
     447            append desc "\n[Rappture::utils::binsize [string length $_value]]"
     448            $itk_component(bininfo) configure -text $desc
     449        }
    404450    }
    405451}
     
    437483            error "bad option \"$option\": should be menu"
    438484        }
    439     }
    440 }
    441 
    442 # ----------------------------------------------------------------------
    443 # USAGE: _fixState
    444 #
    445 # Used internally to update the internal widgets whenever the
    446 # -state/-editable options change.  Enables or disables various
    447 # widgets.
    448 # ----------------------------------------------------------------------
    449 itcl::body Rappture::TextEntry::_fixState {} {
    450     if {$itk_option(-editable) && $itk_option(-state) == "normal"} {
    451         set state normal
    452     } else {
    453         set state disabled
    454     }
    455     if {$_layout == "entry"} {
    456         $itk_component(entry) configure -state $state
    457         $itk_component(emenu) entryconfigure "Cut" -state $state
    458         $itk_component(emenu) entryconfigure "Copy" -state $state
    459         $itk_component(emenu) entryconfigure "Paste" -state $state
    460     } elseif {$_layout == "text"} {
    461         $itk_component(text) configure -state $state
    462         $itk_component(tmenu) entryconfigure "Cut" -state $state
    463         $itk_component(tmenu) entryconfigure "Copy" -state $state
    464         $itk_component(tmenu) entryconfigure "Paste" -state $state
    465485    }
    466486}
     
    525545
    526546# ----------------------------------------------------------------------
    527 # CONFIGURATION OPTION: -editable
    528 # ----------------------------------------------------------------------
    529 itcl::configbody Rappture::TextEntry::editable {
    530     if {![string is boolean -strict $itk_option(-editable)]} {
    531         error "bad value \"$itk_option(-editable)\": should be boolean"
    532     }
    533     _fixState
    534 }
    535 
    536 # ----------------------------------------------------------------------
    537547# CONFIGURATION OPTION: -state
    538548# ----------------------------------------------------------------------
     
    540550    set valid {normal disabled}
    541551    if {[lsearch -exact $valid $itk_option(-state)] < 0} {
    542         error "bad value \"$itk_option(-state)\": should be [join $valid {, }]"
    543     }
    544     if {$_layout == "text"} {
    545         if {$itk_option(-state) == "disabled"} {
    546             set fg [option get $itk_component(text) disabledForeground Foreground]
    547         } else {
    548             set fg $itk_option(-foreground)
    549         }
    550         $itk_component(text) configure -foreground $fg
    551     }
    552     _fixState
     552        error "bad value \"$itk_option(-state)\": should be [join $valid {, }]"
     553    }
     554    if {[info exists itk_component(text)]} {
     555        $itk_component(text) configure -state $itk_option(-state)
     556        $itk_component(tmenu) entryconfigure "Cut" -state $itk_option(-state)
     557        $itk_component(tmenu) entryconfigure "Copy" -state $itk_option(-state)
     558        $itk_component(tmenu) entryconfigure "Paste" -state $itk_option(-state)
     559        if {$itk_option(-state) == "disabled"} {
     560            $itk_component(text) configure \
     561                -foreground $itk_option(-disabledforeground) \
     562                -background $itk_option(-disabledbackground)
     563        } else {
     564            $itk_component(text) configure \
     565                -foreground $itk_option(-foreground) \
     566                -background $itk_option(-textbackground)
     567        }
     568    }
     569    if {[info exists itk_component(entry)]} {
     570        $itk_component(entry) configure -state $itk_option(-state)
     571        $itk_component(emenu) entryconfigure "Cut" -state $itk_option(-state)
     572        $itk_component(emenu) entryconfigure "Copy" -state $itk_option(-state)
     573        $itk_component(emenu) entryconfigure "Paste" -state $itk_option(-state)
     574    }
    553575}
    554576
  • branches/blt4/gui/scripts/tool.tcl

    r1625 r1719  
    198198            set simulation simulation
    199199            if { $id != "" && $vers != "" } {
    200                 set simulation ${id}_r${vers}
     200                set pid [pid]
     201                set simulation ${pid}_${id}_r${vers}
    201202            }
    202203            puts stderr "MiddlewareTime: job=[incr jobnum] event=$simulation start=$times(start) walltime=$times(walltime) cputime=$times(cputime) status=$status"
  • branches/blt4/gui/scripts/tooltip.tcl

    r1695 r1719  
    3838    itk_option define -message message Message ""
    3939
    40     private common pending "" ;         # after ID for pending "tooltip show"
    41     private common catalog    ;         # maps widget => message
    42     private common delay      ;         # The delay in milliseconds to wait
    43                                         # before presenting the tooltip.
    44     constructor {args} {
    45         # defined below
    46     }
    47     public method show { where }
     40    constructor {args} { # defined below }
     41
     42    public method show {where}
    4843    public method hide {}
    49    
    50     public proc for { widget args }
    51     public proc text { widget args }
     44
     45    public proc for {widget args}
     46    public proc text {widget args}
     47    private common catalog    ;# maps widget => message
     48
    5249    public proc tooltip {option args}
     50    private common pending "" ;# after ID for pending "tooltip show"
     51
    5352    public proc cue {option args}
    54     public proc delay { widget args }
    5553
    5654    bind RapptureTooltip <Enter> \
     
    298296                after cancel $pending
    299297            }
    300             set t 750
    301             if { [info exists delay($widget)] } {
    302                 set t $delay($widget)
    303             }
    304             set pending [after $t [itcl::code tooltip show $widget $loc]]
     298            set pending [after 750 [itcl::code tooltip show $widget $loc]]
    305299        }
    306300        show {
     
    390384
    391385# ----------------------------------------------------------------------
    392 # USAGE: delay <widget> ?<value>?
    393 #
    394 # Used to query or set the text used for the tooltip for a widget.
    395 # This is done automatically when you call the "for" proc, but it
    396 # is sometimes handy to query or change the text later.
    397 # ----------------------------------------------------------------------
    398 itcl::body Rappture::Tooltip::delay {widget args} {
    399     if {[llength $args] == 0} {
    400         if {[info exists delay($widget)]} {
    401             return $delay($widget)
    402         }
    403         return ""
    404     } elseif {[llength $args] == 1} {
    405         set time [lindex $args 0]
    406         set delay($widget) $time
    407     } else {
    408         error "wrong # args: should be \"delay widget ?millisecs?\""
    409     }
    410 }
    411 
    412 # ----------------------------------------------------------------------
    413386# CONFIGURATION OPTION: -icon
    414387# ----------------------------------------------------------------------
  • branches/blt4/gui/scripts/utils.tcl

    r1342 r1719  
    3131    set args ""
    3232
    33     set size [string length $newval]
    34     foreach {factor units} {
    35         1073741824 GB
    36         1048576 MB
    37         1024 kB
    38         1 bytes
    39     } {
    40         if {$size/$factor > 0} {
    41             if {$factor > 1} {
    42                 set size [format "%.2f" [expr {double($size)/$factor}]]
    43             }
    44             break
    45         }
    46     }
    47 
    48     set rval "<binary> $size $units"
     33    set rval "<binary> [Rappture::utils::binsize [string length $newval]]"
    4934
    5035    if {$params(-lines) != "unlimited" && $params(-lines) <= 0} {
     
    8469    return $rval
    8570}
     71
     72# ----------------------------------------------------------------------
     73# USAGE: binsize <length>
     74#
     75# Returns a user-friendly expression of data size, like "12 kB" or
     76# "144 MB".
     77# ----------------------------------------------------------------------
     78proc Rappture::utils::binsize {size} {
     79    foreach {factor units} {
     80        1073741824 GB
     81        1048576 MB
     82        1024 kB
     83        1 bytes
     84    } {
     85        if {$size/$factor > 0} {
     86            if {$factor > 1} {
     87                set size [format "%.1f" [expr {double($size)/$factor}]]
     88            }
     89            break
     90        }
     91    }
     92    return "$size $units"
     93}
     94
     95# ----------------------------------------------------------------------
     96# USAGE: datatype <binary>
     97#
     98# Examines the given <binary> string and returns a description of
     99# the data format.
     100# ----------------------------------------------------------------------
     101proc Rappture::utils::datatype {binary} {
     102    set fileprog [auto_execok file]
     103    if {[string length $binary] == 0} {
     104        set desc "Empty"
     105    } elseif {"" != $fileprog} {
     106        #
     107        # Use Unix "file" program to get info about type
     108        # HACK ALERT! must send binary data in by creating a tmp file
     109        #   or else it gets corrupted and misunderstood
     110        #
     111        set id [pid]
     112        while {[file exists /tmp/datatype$id]} {
     113            incr id
     114        }
     115        set fname "/tmp/datatype$id"
     116        set fid [open $fname w]
     117        fconfigure $fid -translation binary -encoding binary
     118        puts -nonewline $fid [string range $binary 0 1024]
     119        close $fid
     120        if {[catch {exec $fileprog -b $fname} desc]} {
     121            set desc "Binary data"
     122        }
     123        catch {file delete $fname}
     124    } else {
     125        set desc "Binary data"
     126    }
     127    return $desc
     128}
  • branches/blt4/gui/scripts/xyprint.tcl

    r1674 r1719  
    289289itcl::body Rappture::XyPrint::CloneGraph { orig } {
    290290    set top $itk_interior
    291 
    292 
    293 
    294 
    295 
    296291    if { [winfo exists $top.graph] } {
    297292        destroy $top.graph
  • branches/blt4/gui/scripts/xyresult.tcl

    r1683 r1719  
    8383    public method delete {args}
    8484    public method scale {args}
     85    public method snap { w h }
    8586    public method parameters {title args} { # do nothing }
    8687    public method download {option args}
     
    16011602    }
    16021603}
     1604
     1605itcl::body Rappture::XyResult::snap { w h } {
     1606    set g $itk_component(plot)
     1607    if { $w <= 0 || $h <= 0 } {
     1608        set w [winfo width $g]
     1609        set h [winfo height $g]
     1610    }
     1611    set img [image create picture -width $w -height $h]
     1612    $g snap $img -width $w -height $h
     1613    return $img
     1614}
  • branches/blt4/lang/tcl/scripts/result.tcl

    r1018 r1719  
    4848    }
    4949
    50     set oname "run[clock seconds].xml"
     50    # fake milliseconds by using clock clicks
     51    # fake microseconds by using 000
     52    # this will be fixed when tcl uses C bindings
     53    set timestamp [format %d%03d%03d [clock seconds] [expr [clock clicks -milliseconds]%1000] 0]
     54    set oname "run$timestamp.xml"
    5155    set fid [open $oname w]
    5256    puts $fid "<?xml version=\"1.0\"?>"
  • branches/blt4/packages/vizservers/nanovis/RpAVTranslate.h

    r1571 r1719  
    1717#include "nvconf.h"
    1818#include "RpOutcome.h"
    19 
    20 #ifdef __cplusplus
    21     extern "C" {
    22 #endif // ifdef __cplusplus
    2319
    2420#ifdef HAVE_FFMPEG_AVFORMAT_H
     
    9187} // namespace Rappture
    9288 
    93 #ifdef __cplusplus
    94     }
    95 #endif // ifdef __cplusplus
    96 
    9789#endif // RAPPTURE_AVTRANSLATE_H
  • branches/blt4/packages/vizservers/nanovis/VolumeRenderer.cpp

    r1697 r1719  
    236236        // Render cutplanes first with depth test enabled.  They will mark the
    237237        // image with their depth values.  Then we render other volume slices.
    238         // These volume slices will be occluded correctly by the cutplanexPolygon static_poly;
     238        // These volume slices will be occluded correctly by the cutplanes and
     239        // vice versa.
     240
     241        ConvexPolygon static_poly;
    239242        for(int j = 0; j < volPtr->get_cutplane_count(); j++) {
    240243            if(!volPtr->cutplane_is_enabled(j))
  • branches/blt4/packages/vizservers/pymolproxy/pymolproxy.c

    r1565 r1719  
    106106static long _flags = 0;
    107107#endif
     108static FILE *scriptFile;
     109static int savescript = 0;
    108110
    109111typedef struct Image {
    110     struct Image *next;         /* Next image in chain of images. The list is
     112    struct Image *nextPtr;      /* Next image in chain of images. The list is
    111113                                 * ordered by the most recently received image
    112114                                 * from the pymol server to the least. */
     115    struct Image *prevPtr;      /* Previous image in chain of images. The list
     116                                 * is ordered by the most recently received
     117                                 * image from the pymol server to the
     118                                 * least. */
    113119    ssize_t nWritten;           /* Number of bytes of image data already
    114120                                 * delivered.*/
     
    147153typedef struct {
    148154    Tcl_Interp *interp;
    149     unsigned int flags;         /* Various flags. */
    150     Image *head;                /* List of images to be delivered to the
    151                                  * client.  The most recent images are in the
    152                                  * front of the list. */
    153     Image *current;             /* The image currently being delivered to the
    154                                  * client.  We make sure we finish delivering
    155                                  * this image before selecting the most recent
    156                                  * image. */
     155    unsigned int flags;                 /* Various flags. */
     156    Image *headPtr, *tailPtr;           /* List of images to be delivered to
     157                                         * the client.  The most recent images
     158                                         * are in the front of the list. */
    157159
    158160    int serverInput, serverOutput, serverError;  /* Server file descriptors. */
     
    192194
    193195static void
     196script TCL_VARARGS_DEF(char *, arg1)
     197{
     198    if (savescript) {
     199        char *format;
     200        va_list args;
     201
     202        format = TCL_VARARGS_START(char *, arg1, args);
     203        vfprintf(scriptFile, format, args);
     204        fflush(scriptFile);
     205    }
     206}
     207
     208static void
    194209InitBuffer(ReadBuffer *readPtr, int f)
    195210{
     
    359374    }
    360375#ifndef notdef
    361     trace("Entering Expect(want=%s, maxSize=%d)\n", match, maxSize);
     376    trace("Entering Expect(want=\"%s\", maxSize=%d)\n", match, maxSize);
    362377#endif
    363378    c = match[0];
     
    370385        if (line != NULL) {
    371386#ifndef notdef
    372             trace("pymol says:%.*s", nBytes, out);
     387            trace("pymol says (read %d bytes):%.*s", nBytes, nBytes, line);
    373388#endif
    374389            if ((c == line[0]) && (strncmp(line, match, length) == 0)) {
     
    549564        abort();
    550565    }
     566    imgPtr->prevPtr = imgPtr->nextPtr = NULL;
    551567    imgPtr->bytesLeft = dataLength;
    552     imgPtr->next = proxyPtr->head;
    553     proxyPtr->head = imgPtr;
     568    if (proxyPtr->headPtr != NULL) {
     569        proxyPtr->headPtr->prevPtr = imgPtr;
     570    }
     571    imgPtr->nextPtr = proxyPtr->headPtr;
     572    if (proxyPtr->tailPtr == NULL) {
     573        proxyPtr->tailPtr = imgPtr;
     574    }
     575    proxyPtr->headPtr = imgPtr;
    554576    imgPtr->nWritten = 0;
    555577    return imgPtr;
     
    566588WriteImage(PymolProxy *proxyPtr, int fd)
    567589{
    568     Image *imgPtr, *img2Ptr, *nextPtr;
    569     ssize_t bytesLeft;
    570 
    571     imgPtr =  (proxyPtr->current == NULL) ? proxyPtr->head : proxyPtr->current;
    572     if (imgPtr == NULL) {
     590    Image *imgPtr, *prevPtr;
     591
     592    if (proxyPtr->tailPtr == NULL) {
    573593        trace("Should not be here: no image available to write");
    574594        return;
    575595    }
    576        
     596    for (imgPtr = proxyPtr->tailPtr; imgPtr != NULL; imgPtr = prevPtr) {
     597        ssize_t bytesLeft;
     598
     599        assert(imgPtr->nextPtr == NULL);
     600        prevPtr = imgPtr->prevPtr;
    577601#ifdef notdef
    578     trace("WriteImage: want to write %d bytes.", imgPtr->bytesLeft);
    579 #endif
    580     for (bytesLeft = imgPtr->bytesLeft; bytesLeft > 0; /*empty*/) {
    581         ssize_t nWritten;
     602        trace("WriteImage: want to write %d bytes.", imgPtr->bytesLeft);
     603#endif
     604        for (bytesLeft = imgPtr->bytesLeft; bytesLeft > 0; /*empty*/) {
     605            ssize_t nWritten;
    582606#ifdef notdef
    583         trace("WriteImage: try to write %d bytes.", bytesLeft);
    584 #endif
    585         nWritten = write(fd, imgPtr->data + imgPtr->nWritten, bytesLeft);
     607            trace("WriteImage: try to write %d bytes.", bytesLeft);
     608#endif
     609            nWritten = write(fd, imgPtr->data + imgPtr->nWritten, bytesLeft);
    586610#ifdef notdef
    587         trace("WriteImage: wrote %d bytes.", nWritten);
    588 #endif
    589         if (nWritten < 0) {
    590             trace("Error writing fd(%d), %d/%s.", fd, errno,
    591                   strerror(errno));
    592             return;
    593         }
    594         bytesLeft -= nWritten;
    595         if (bytesLeft > 0) {
    596             /* Wrote a short buffer, means we would block. */
     611            trace("WriteImage: wrote %d bytes.", nWritten);
     612#endif
     613            if (nWritten < 0) {
     614                trace("Error writing fd(%d), %d/%s.", fd, errno,
     615                      strerror(errno));
     616                return;
     617            }
     618            bytesLeft -= nWritten;
     619            if (bytesLeft > 0) {
     620                /* Wrote a short buffer, means we would block. */
     621                imgPtr->nWritten += nWritten;
     622                imgPtr->bytesLeft = bytesLeft;
     623                return;
     624            }
    597625            imgPtr->nWritten += nWritten;
    598             imgPtr->bytesLeft = bytesLeft;
    599             return;
    600         }
    601         imgPtr->nWritten += nWritten;
    602     }
    603     /* Check if image is on the head.  */
    604     if (proxyPtr->head == imgPtr) {
    605         proxyPtr->head = NULL;
    606     } else {
    607         /* Otherwise find it in the list of images and disconnect it. */
    608         for (img2Ptr = proxyPtr->head; img2Ptr != NULL; img2Ptr = nextPtr) {
    609             nextPtr = img2Ptr->next;
    610             if (nextPtr == imgPtr) {
    611                 img2Ptr->next = NULL;
    612             }
    613         }
    614     }
    615     /* Remove add images from this image on down. */
    616     for (/*empty*/; imgPtr != NULL; imgPtr = nextPtr) {
    617         nextPtr = imgPtr->next;
     626        }
     627        /* Check if image is on the head.  */
     628        proxyPtr->tailPtr = prevPtr;
     629        if (prevPtr != NULL) {
     630            prevPtr->nextPtr = NULL;
     631        }
    618632        FreeImage(imgPtr);
    619633    }
    620     proxyPtr->current = NULL;
     634    proxyPtr->headPtr = NULL;
    621635}
    622636
     
    668682   
    669683    trace("to-pymol>(%s) code=%d", buffer, result);
     684    script("%s\n", buffer);
     685   
    670686   
    671687    /* Write the command out to the server. */
     
    676692              nWritten, length);
    677693    }
    678 
    679694    for (p = buffer; *p != '\0'; p++) {
    680         if (isspace(*p)) {
     695        if (*p == '\n') {
    681696            *p = '\0';
    682697            break;
     
    821836        }
    822837    }
    823     proxyPtr->flags |= INVALIDATE_CACHE;  
     838    proxyPtr->flags |= INVALIDATE_CACHE; /* cartoon */
    824839    if (!defer || push) {
    825840        proxyPtr->flags |= UPDATE_PENDING;
     
    863878        }
    864879    }
    865     proxyPtr->flags |= INVALIDATE_CACHE;  
     880    proxyPtr->flags |= INVALIDATE_CACHE; /* cartoon_trace  */
    866881    if (!defer || push) {
    867882        proxyPtr->flags |= UPDATE_PENDING;
     
    895910    }
    896911
    897     proxyPtr->flags |= INVALIDATE_CACHE;  /* Disable */
     912    proxyPtr->flags |= INVALIDATE_CACHE;  /* disable */
    898913    if (!defer || push) {
    899914        proxyPtr->flags |= UPDATE_PENDING;
     
    929944        }
    930945    }
    931     proxyPtr->flags |= INVALIDATE_CACHE; /* Enable */
     946    proxyPtr->flags |= INVALIDATE_CACHE; /* enable */
    932947    if (!defer || push) {
    933948        proxyPtr->flags |= UPDATE_PENDING;
     
    10041019        }
    10051020    }
    1006     proxyPtr->flags |= INVALIDATE_CACHE;  /* Label */
     1021    proxyPtr->flags |= INVALIDATE_CACHE;  /* label */
    10071022    if (!defer || push) {
    10081023        proxyPtr->flags |= UPDATE_PENDING;
     
    10821097        fclose(f);
    10831098        Pymol(proxyPtr, "load %s,%s,%d\n", fileName, name, state);
     1099#ifdef notdef
    10841100        Pymol(proxyPtr, "zoom complete=1\n");
     1101#endif
    10851102    }
    10861103    return proxyPtr->status;
     
    11081125        }
    11091126    }
    1110     proxyPtr->flags |= INVALIDATE_CACHE;  
     1127    proxyPtr->flags |= INVALIDATE_CACHE; /* orthoscopic */
    11111128    if (!defer || push) {
    11121129        proxyPtr->flags |= UPDATE_PENDING;
     
    11561173        return TCL_ERROR;
    11571174    }
    1158     proxyPtr->flags |= INVALIDATE_CACHE; /* Pan */
     1175    proxyPtr->flags |= INVALIDATE_CACHE; /* pan */
    11591176    if (!defer || push) {
    11601177        proxyPtr->flags |= UPDATE_PENDING;
     
    11811198
    11821199    clear_error(proxyPtr);
    1183 
    1184     if (proxyPtr->flags & INVALIDATE_CACHE)
    1185         proxyPtr->cacheId++;
    1186 
    1187     proxyPtr->flags &= ~(UPDATE_PENDING | FORCE_UPDATE | INVALIDATE_CACHE);
    11881200
    11891201    /* Force pymol to update the current scene. */
     
    12291241    clear_error(proxyPtr);
    12301242
    1231     if (proxyPtr->flags & INVALIDATE_CACHE)
    1232         proxyPtr->cacheId++;
    1233 
    1234     proxyPtr->flags &= ~(UPDATE_PENDING | FORCE_UPDATE | INVALIDATE_CACHE);
    1235 
    12361243    if (argc != 5) {
    12371244        Tcl_AppendResult(interp, "wrong # arguments: should be \"",
     
    13021309    }
    13031310
    1304     proxyPtr->flags |= INVALIDATE_CACHE; /* Raw */
     1311    proxyPtr->flags |= INVALIDATE_CACHE; /* raw */
    13051312    if (!defer || push) {
    13061313        proxyPtr->flags |= UPDATE_PENDING;
     
    13291336    }
    13301337               
    1331     proxyPtr->flags |= INVALIDATE_CACHE; /* Reset */
     1338    proxyPtr->flags |= INVALIDATE_CACHE; /* reset */
    13321339    if (!defer || push) {
    13331340        proxyPtr->flags |= UPDATE_PENDING;
     
    14061413    }
    14071414
    1408     proxyPtr->flags |= INVALIDATE_CACHE;
     1415    proxyPtr->flags |= INVALIDATE_CACHE; /* representation */
    14091416    if (!defer || push) {
    14101417        proxyPtr->flags |= UPDATE_PENDING;
     
    15141521        }
    15151522    }
    1516     proxyPtr->flags |= INVALIDATE_CACHE; /* Rotate */
     1523    proxyPtr->flags |= INVALIDATE_CACHE; /* rotate */
    15171524    if (!defer || push) {
    15181525        proxyPtr->flags |= UPDATE_PENDING;
     
    16011608        }
    16021609    }
    1603     proxyPtr->flags |= INVALIDATE_CACHE;  /* SphereScale */
     1610    proxyPtr->flags |= INVALIDATE_CACHE;  /* sphere_scale */
    16041611    if (!defer || push) {
    16051612        proxyPtr->flags |= UPDATE_PENDING;
     
    16431650        }
    16441651    }
    1645     proxyPtr->flags |= INVALIDATE_CACHE;  /* Spheres */
     1652    proxyPtr->flags |= INVALIDATE_CACHE;  /* stick_radius */
    16461653    if (!defer || push) {
    16471654        proxyPtr->flags |= UPDATE_PENDING;
     
    16871694        }
    16881695    }
    1689     proxyPtr->flags |= INVALIDATE_CACHE;
     1696    proxyPtr->flags |= INVALIDATE_CACHE; /* transparency */
    16901697    if (!defer || push) {
    16911698        proxyPtr->flags |= UPDATE_PENDING;
     
    19721979        flog = fopen(fileName, "w");
    19731980    }   
     1981    scriptFile = NULL;
     1982    if (savescript) {
     1983        char fileName[200];
     1984        sprintf(fileName, "/tmp/pymolproxy.py");
     1985        scriptFile = fopen(fileName, "w");
     1986    }   
    19741987    ProxyInit(fileno(stdout), fileno(stdin), argv + 1);
    19751988    return 0;
     
    20102023        int timeout, nChannels;
    20112024
    2012         nChannels =  (proxyPtr->head != NULL) ? 4 : 3;
     2025        nChannels =  (proxyPtr->headPtr != NULL) ? 4 : 3;
    20132026
    20142027#define PENDING_TIMEOUT         10  /* milliseconds. */
     
    21242137
    21252138        /* Write the current image buffer. */
    2126         if (proxyPtr->head == NULL) {
     2139        if (proxyPtr->headPtr == NULL) {
    21272140            /* We might want to refresh the image if we're not currently
    21282141             * transmitting an image back to the client. The image will be
     
    21372150            }
    21382151        }
    2139         if ((proxyPtr->head != NULL) && (pollResults[3].revents & POLLOUT)) {
     2152        if ((proxyPtr->headPtr != NULL) &&
     2153            (pollResults[3].revents & POLLOUT)) {
    21402154            WriteImage(proxyPtr, pollResults[3].fd);
    21412155        }
Note: See TracChangeset for help on using the changeset viewer.