POW works in terms of objects (although at the moment, it's not written 
using object-oriented TCL).  Each of these objects has a name (just an 
ASCII string).  Once an object is "constructed", you use the name
to refer to it in the various things you want to do to it ("methods").
The main objects are:

PowData - this object is an array (in the C sense) in memory somewhere
          along with info on data type and the length of the array.
          At creation, you can specify that POW should make it's own copy
          of the data, allowing you to "free" your copy, or you can save
          space by allowing POW to use your copy of the data, just don't
          free or change it unless you destroy the PowData object first.

PowVector, PowImage - these are your choices for what you can create using
          your PowData, they give "physical" meaning to the data by specifying
          units and, for images, dimensions.  You can make any number of 
          Images and Vectors from one chunk of Data, and you can specify 
          offsets so as to use only part of the Data.

PowCurve - This is a collection of 1 to 6 vectors which represent a curve in
           space and its associated errors. Currently, nothing is done
           with the z and z-error vectors, but suggestions are welcome.

PowGraph - This is the only *displayed* object in POW.  I.e. you can display
           your Images and Curves only by creating a Graph with them as 
           members, or by plotting them on an existing Graph (at which
           point they become part of that Graph).  One Image or vector
           can, of course, appear in any number of Graphs.  


The TCL interface:

*arguments in angle brackets are optional


"Constructors"
powSetupColormap  toplevel free_cells ?force_cmap? ?options? -
	You should call this to create the first toplevel window for your
	application unless you really want to do your own colormap 
	management.  This proc will use the default colormap if it can
        allocate enough colors or will allocate a Private pseudocolor colormap
        with an	attempt to minimize flashing.  If this fails to find any
	pseudocolor visuals, it will use the default colormap and disable
        pseudocolor images in POW.

	toplevel - this is the name of the toplevel you want to create.
	           it should probably be the first toplevel your application
                   creates (e.g. .mytop)  and all subsequent toplevel creation
                   statements should include a "-colormap .mytop" option.

	free_cells - the number of colors your application will need in 
	             addition to what POW allocates for itself.  If you get
	             BadColor errors (or the like) in your application, try 
	             making this number bigger.  If you keep getting a Private
                     colormap when your Default colormap is full, try making 
	             this number smaller.
	
	force_cmap - Forces different colormap behaviors.  You might want 
                     to give your users a way to set this themselves.: 
	           0 - Default behavior.  I.e. choose the "best" colormap.
	           1 - Force POW to setup a new private pseudocolor colormap 
                       (very safe)
                   2 - Force POW to use truecolor mode (very safe, but 
                       looks bad on low color displays and runs slower than
                       pseudocolor).  Note: this will cause powSetupColormap
                       to look for a truecolor visual; if it can't find one,
                       it will allow the main Tk code to pick a visual,
                       but POW will still use "truecolor mode" (i.e. the
                       Tk photo widget) to display images.
                   3 - Force use of the screen default colormap. This should
                       be reasonably safe now, but often won't be what you
                       want.
                       
 
	options - a string of extra options to hand to the toplevel creation
                  command, if you need them.
	
	See comments under powInit for more details.


powInit ?XColormapWindow? ?container? ?powGUI? - creates the .pow toplevel 
	window, all the user interface buttons and the .pow.pow
        canvas.  The second optional argument is the pathname of a 
	container window for POW if you want to embed POW in your own
        toplevel (only works for Tcl/Tk8.0 and later versions). 
	The first optional argument is the name of a window in your
	application and tells POW to use the same X colormap as that
        window;  this will allow your user to reliably see both POW
        and your application in the proper colors at the same time.
        Note, if you give an argument to powInit, that window should 
	have a pseudocolor visual with at least 60 free read-write 
	colorcells (call powSetupColormap first) or POW will disable 
        pseudocolor images.  The third argument indicates wether you 
        want POW to wrap its main canvas in an enduser GUI. Unless
        you're embedding POW in a specialized application, you'll
        want to leave this at the default of 1; a value of 0 removes
        the GUI.

	If you call 'powInit none' (or with no argument) pow will handle 
	its own colormap needs, but if it creates a private colormap, you 
	will see serious flashing between your application's windows and 
	the POW window.

	Usually, the window you specify for powInit would be the toplevel
        window for your application and you should use powSetupColormap
        to avoid excessive flashing and Xlib induced crashes.  Make sure 
	you create any other toplevels with the same colormap. Unfortunately,
        Tk has a stupid default behavior for picking the visual of a 
        new toplevel when it's colormap is specified, so it's recommended
        that you use powToplevel to create all your toplevels (sorry folks,
        this one's not my fault). Ok, since this is probably confusing, 
  	here's an example.

	Suppose (for argument) your application uses 10 colors (for 
	backgrounds highlights, etc) and your application's main window
	is '.mytop'.  And you want the background of your application to
        be pink and you want it to be 100 pixels wide.  
	When you create .mytop instead of calling 'toplevel', instead do:

	powSetupColormap .mytop 10 0 "-background pink -width 100"
         
        Invoke POW with:

	powInit .mytop

        If you create any other toplevel windows, be sure to create
	them with:

        powToplevel .mydialogbox .mytop

	If you need to pass other options to "toplevel", put them 
        all in one string like:

        powToplevel .mydialogbox .mytop "-class \"My Extra Window\" -bg blue"

powToplevel topwin refwin ?option_string? -
	This is a replacement for the Tk toplevel command.  The Tk toplevel
        command with a "-colormap" argument but no "-visual" argument 
        *doesn't* use the visual of the given colormap to create the new 
        window; instead it uses the screen default visual and then dies
        if they're not compatible.  Why? Who knows? 

  topwin  The name of the toplevel you want to create.

  refwin  The window whose colormap you want to use.

  option_string  Any other options you want to pass to the "toplevel" command.
          This needs to be a single string.

        If you don't want to call powToplevel, doing this yourself is simple.
        Here's the code for the powToplevel proc:

proc powToplevel {topwin refwin {options ""}} {
#this implements what *should* be default behavior.  Apparently the evil
#of Xlib colormap handling is contagious.

    eval "toplevel $topwin -colormap $refwin -visual \"[winfo visual $refwin] [winfo depth $refwin]\" $options"

}
       


powCreateData data_name data_pointer data_type length ?copy? -
           This "constructs" a PowData object.  The other ways
           to create PowData at present are with the powCreateVectorEN
           or the powCreateDataFromList commands, see below.

  data_pointer  This argument will probably be the return value from either:
                $fitsfile load image
                   or
                $fitsfile load column
                See fitsTcl documentation for details.  Or you can write your
                own TCL command to make data.  Just have it return a void
                pointer formatted with:
                sprintf(interp->result,rstring,"%p",(void *)dataptr);

  data_type     This is one of the strings (or an integer):
                  "BYTE"     or  0  or   8                   1 byte
                  "SHORTINT" or  1  or  16                   2 bytes
                  "INT"      or  2  or  32                   4 bytes
                  "REAL" or "FLOAT" or 3 or -32              4 bytes
                  "DOUBLE"   or  4  or -64                   8 bytes

                Note: 8 byte integers are not supported at this time

     
  copy          If copy is a positive integer, POW makes its own copy of the 
                data array and uses that, freeing it when the object gets
                destroyed.  If copy is zero, POW uses the supplied
                data_pointer directly (no copy), but does not try to free
                it when destroyed.  If copy is negative, POW takes ownership
                of the data_pointer, using it directly and freeing it when
                the object gets destroyed.  In this last case, the
                data_pointer *must* have been allocated using TCL's
                ckalloc() function (always true for data from fitsTcl). 
                The default value is 0.


powCloneData new_data_name old_data_name ?offset? ?length? ?copy?
        This creates a new PowData object from an existing PowData object.
        !!Use this function with caution unless you are specifying 
        a copy flag > 0 or you could wind up with POW Data objects that
        point to invalid areas of memory if you destroy one of the 
        partners of the clone but not the other!! 
       
        Returns the length of the new POW Data object.

  offset    Specifies an offset to the starting point of the data
            in memory. Default is 0.

  length    How much of the old data do you want to use?  If you specify
            "NULL" the new data will have the same endpoint as the
            old data.  If you specify a length that ends beyond the end 
            of the previous data, the length will be adjusted to match
            the endpoint of the old data. Default is "NULL".

  copy      If copy is a positive integer, POW makes a new copy of the 
            old data array and uses that, freeing it when the object gets
            destroyed.  If copy is zero, POW uses the old data pointer
            (plus offset) directly (no copy), and does not try to free
            the memory when the new data object is destroyed.  If copy is 
            negative, POW will flag the new_data_name as the "owner" of
            the data array so destroying the old_data_name will not
            free the associated memory, but destroying the new_data_name
            will.  If you specify copy < 0 and offset != 0, powCloneData
            will return an error.  The default value of copy is 0.

powCreateDataFromList data_name list_o_data ?stringflag? -
	This creates a PowData object using the contents of a TCL list.
        The data object will be of type DOUBLE unless stringflag is
        is Yes.  String data should only be used as the "z" vector
        of a PowCurve object, in which case, the specified string will
        be plotted at the position given by the corresponding x and y
        values.

powRegisterData powdata_pointer
        If you have an application that creates it's own PowData objects (like
        the LHEA orbit library or the internal routines in TAKO), you must
        "register" them in the main PowData hash table in order to use
        them in plotting functions.  Naturally, if the PowData objects
        aren't properly or fully created, you could run into trouble.
        The pointer is a string created the same way as described above for 
        the data_pointer argument to powCreateData, except that it should
        be a pointer to a PowData structure rather than to a simple array.

powCreateVector vector_name data_name offset length units - 
           Creates a PowVector. If length is "NULL" uses the length
           of the Data.

powCreateVectorEN vector_name data_name length start increment units -
           Creates a vector and the data to go with it.  This is nice
           for generating test data among other things.  You *can*
           make a PowImage using the data this generates, by the way.
           (EN stands for Ex Nihilo)

powCreateImage image_name data_name xoffset yoffset width height xorigin \
xinc yorigin yinc xunits yunits zunits - 
           Creates a PowImage.  The xorigin and xinc arguments are the origin
           and pixel size in the units specified in the xunits and yunits 
           arguments.

powCreateCurve curve_name x_vector x_error y_vector y_error ?z_vector z_error?
         - Creates a PowCurve (displayable).  All but one of the component
           vector arguments can be the string "NULL" and POW will deal with 
           it in a hopefully sensible default manner. The length of the 
           curve will be the length of the first non-null vector (I might
           change this to be length of the shortest vector present).
           I'm also thinking of allowing scalar errors indicated by an 
           "=" sign in the argument (but this isn't done yet).

	   POW curves are now implemented with a new canvas item type.
	   For a curve named ACURVE displayed on a graph named BGRAPH,
           the powCurve item has a tag "ACURVEBGRAPH".  powCurve supports
           most of the options available for the Tk native "line" type.
           So to change the fill color of ACURVE to blue and make it a dashed
           line (5 pixel dashes) do:

           .pow.pow itemconfigure ACURVEBGRAPH -fill blue -dash 5

           The only use of z_vector so far is if the z_vector is
           created from STRING type data (e.g. using powCreateDataFromList),
           then the strings will be printed at the positions given by the
           corresponding x and y elements.


powCreateGraph graph_name curves images xunits yunits xlabel\
         ylabel ?xdimdisp ydimdisp xmin ymin xmax ymax?	 -
	 This is the main one that actually draws on the .pow.pow canvas. 
	 See discussion of powStartNewRow below to see how POW decides 
	 where to place incoming graphs.  Some details (hopefully the
	 rest is self-explanatory):

  curves, images - these are Tcl "lists" of PowImages and PowCurves to plot
  
  xunits, yunits - These are the physical units associated with an axis
         and will be printed next to the label.

  xlabel, ylabel - An optional label for each axis.  The y-axis label will
         be printed horizontally at the top of the y-axis since the Tk 
         canvas does not allow rotated text at this time.
  
  xdimdisp, ydimdisp - the "maximum size" for the display of the graph in
          screen pixels. The graph will be shrunk or expanded from its
          "natural" size to fit into an area of the canvas of this requested
          size.  If "NULL" is passed, a default value will be used.

  xmin ymin xmax ymax - the bounding region for the displayed area of a 
          graph.  These are in the units of each respective axis.  Parts
          of images or curves falling outside this box will not be plotted.
          Each of these arguments can be a list if more than one y or x axis is
          present.

powGraphOptions graph_name option value ?option value option value ...? -
	This function was added to allow easy customization of several
        (more every day :) additional options that would have been too 
        unweildy to add to the already too long powCreateGraph call.
        Specify as many option value pairs as you like.  Boolean values
        should have values of Yes/No if one wants POW's menus to properly
        reflect the new values.  In addition to all of the arguments to
        PowCreateGraph, current options are:
	
	bgcolor - A background color for the whole graph
	
	xmargin - The amount of space around a graph (in pixels by default)
	ymargin - This will only affect subsequent operations on the graph
                  (chain alignments, replottings, etc.), it doesn't move
                  the graph immediately.

        handletext - Change the text that normally says:
	           "Select/Move: graphname"
        handleanchor - Change the anchor point of the handletext. Default
                   is "sw".
        handleposition - Change where on the graph's bounding box the 
                   handle is anchored to.  Choices are:
	           t - midpoint of top
                   l - midpoint of left side
                   b - midpoint of bottom
                   r - midpoint of right side
                   Combine to get corners.  Default is "tl".

        xNumTicks   - An integer number used to indicate how many ticks to
                      place on the X axis.  3-6 are reasonable values.
        yNumTicks   - An integer number used to indicate how many ticks to
                      place on the Y axis.  3-6 are reasonable values.
	xTickLength - 4 element list indicating how long to draw the x
                      tick marks on each of the 4 sides of the graph.  Order
                      is {left right top bottom}.  Negative values cause
                      tickmarks to be drawn inside the graph box.
	yTickLength - Same for y tick marks.
	xLabelTicks - 4 element boolean list indicating whether the x tick
                      marks should be labeled along each side of the graph.
                      Order is {left right top bottom}.
	yLabelTicks - Same for y tick labels.
        xTickScal   - Scaling method for the X tick marks.  Valid values
                      are "linear", "wcs" (for celestial coordinates/right
                      ascension), or "log" (for logarithmic scaling).  Tick
                      marks and labels will be drawn accordingly.  WCS scaling
                      occurs only if WCS information exists for the graph.
                      Logarithmic scaling *does not* affect the drawing of
                      curves (ie, curve data are assumed to be in logarithmic
                      format).
        yTickScal   - Same for y ticks.  WCS scaling assumes declination
                      values for the y axis, though.
        GridLines   - A boolean value indicating whether to draw grid lines
                      connecting the graph's tick marks
        GridColor   - The color of the grid lines
        GridDash    - Dash value of the grid lines.  Formats are:
                        " "    - Solid line
                        "10"   - 10 pixel dashes and spaces
                        "15 5" - 15 pixel dashes, 5 pixel spaces
                        "15 10 5 10" - Dash-dot
                        etc.
        useSixties  - A boolean value indicating whether to attempt to use
                      base 60 tick marks (works only with WCS data).

powSetCurveOptions graph curve ?option value option value ...? -
        This function allows one to set the display parameters for a curve
        in the indicated graph.  If this function is not called *prior* to
        creating the graph, a curve will be assigned default values.  When
        called after the graph is created (and curve plotted), this function
        will update the appearance of the curve in both the main graph and,
        if it is the current graph, the scopebox.  The allowed options and
        values (boolean values should be Yes/No) are:

           Option Name    Value Type    Option Meaning
             pDisp     -->  boolean  -->  Display Points?
             pShape    -->  string   -->  Point shape (Cross, Diamond, Box,
                                             Octagon, Triangle, "Inv. Triangle")
             pSizeErr  -->  boolean  -->  Draw point the size of errorbars?
             pSize     -->  integer  -->  Size of point
             pFill     -->  boolean  -->  Fill in point, if an outline
             pColor    -->  color    -->  Color of points (any color name
                                             or #RRGGBB value)
         	       	    	     	  
             lDisp     -->  boolean  -->  Display line?
             lStyle    -->  dash     -->  Dash style of line (" " is solid, 
                                             "20" is 20-pixel dashes,
                                             "15 10 4 10" is Dash-dot, etc)
             lWidth    -->  integer  -->  Width of line
             lStep     -->  boolean  -->  Draw line as histogram?
             lBoxFill  -->  boolean  -->  Fill histogram boxes?
             lColor    -->  color    -->  Color of line (any color name
                                             or #RRGGBB value)

        If no option/value pairs are given, this function will return all the
        defined options.  If the curve has been drawn already, all the options
        will be defined.

powSetImageOptions graph image ?option value option value ...? -
        This function allows one to set the display parameters for an image
        in the indicated graph.  If this function is not called *prior* to
        creating the graph, an image will be assigned default values.  When
        called after the graph is created (and image plotted), this function
        will update the appearance of the image in both the main graph and,
        if it is the current graph, the scopebox.  It will also update a
        colorbar (or if changing a colorbar option, the original image).
        The allowed options and values (boolean values should be Yes/No) are:

           Option Name    Value Type    Option Meaning
             colormap  -->  string   -->  Which colormap to use
             invert    -->  boolean  -->  Invert colormap?
             scale     -->  string   -->  Scaling law to use to create the
                                             colormap (linear, sqrt, log)

        If no option/value pairs are given, this function will return all the
        defined options.  If the image has been drawn already, all the options
        will be defined.


"Destructors"

powDestroyX  Xname  - Destroys the named POW Object.  "X" can be:
                      Graph, Curve, Image, Vector, or Data.  Be careful,
                      don't destroy a low-level object (e.g. data) before
                      destroying a high-level one that depends on it (e.g.
                      Graph or Curve); the destructors don't (yet anyway)
                      search through all objects to handle these dependencies,
                      it's up to you to keep track of them if you need to.
                      The POWData destructor *will* free the associated 
                      memory if the Data object was created with the 
                      copy flag set.


"Methods" 

powPlotCurves graph curves ?canvas?- adds the list of Curves to an existing
                                     Graph on the Canvas (default .pow.pow)

powAddCurves graph curves - adds the list of Curves to an existing Graph,
                            updating the scope box as necessary

powPlotImages graph images - adds the list of Images to an existing Graph

powMagGraph graph xMagstep yMagstep - resize a Graph to the given X and Y
              magsteps (magstep = 1 is the "natural" size of the graph).
              Magsteps can be any real value and X and Y may be different.

powStretchGraph graph xFactor yFactor - shrink or grow a Graph by the given
                 X and Y factors.

powStretchGraphToSize graph xDim yDim - Set the size of the Graph to the
                 given X and Y dimensions (in pixels).

powStartNewRow - POW displays incoming graphs are placed to the right
                 of all existing  material in the current "row".
	         A "row" is defined by an (invisible) line on the graph.
                 Initially this boundary line is 10 pixels from the
                 top of the canvas.  powStartNewRow moves this line to
                 just below all material currently displayed on the
                 canvas.  To make a 3x2  "grid" of graphs do:

	         %powCreateGraph graph1 ...
	         %powCreateGraph graph2 ...
	         %powCreateGraph graph3 ...
                 %powStartNewRow	
	         %powCreateGraph graph4 ...
	         %powCreateGraph graph5	 ...
	         %powCreateGraph graph6	 ...
                  
                 If the end-user moves or resizes something during
                 this process, you won't get a strict rectangular
                 grid, but new graphs will not land on top of existing
                 ones.


Note:  %x and %y return cursor positions in X coordinates, to turn
       these into canvas coordinates, use '.pow.pow canvasx %x' etc.


General Interface Concepts

The general way for a developer to get back info from
his users would be to bind the left mouse button on the .pow.pow
canvas to whatever you want it to do (the only things on the canvas
that are currently bound to the left mouse button are the "purple"
handles, so this should be safe).  Once you've got a coordinate (or
set of coordinates) use '.pow.pow canvasx' and 'powCanvasToGraph graph
X' to find out what physical coordinates your user is interested in.
powWhereAmI can tell you which graph they appear to be inside of if
you need to know that easily.

If you set the global variable powClickCallback, <ButtonPress-1>, 
<Double-Button-1>, <ButtonPress-2>, or <ButtonPress-3> events on the
main POW canvas will fire your callback with the arguments "graphname
x y binding" where: 

graphname - is the graph the user clicked inside of, if they click outside of
            all graphs, nothing happens
x and y - are the graph (i.e. "physical") coordinates of the point they 
          clicked.
binding - is the X event which fired the callback currently the only strings
          returned are "B1", "B2", and "B1D" (for double clicking button 1)
          but if you'd like to see more bindings,  let me know ("B3" is 
	  currently in use for Region of Interest zooming).

If you set the global variable powPreScrollCallback or powPostScrollCallback,
when the user manipulates a scrollbar on the main .pow.pow canvas,
your callback will be fired with the same arguments as would be
recieved by the function specified in a '-command' argument to the
scrollbar creation command.  See the Tk scrollbar documentation 
for details.  The "Pre" form will fire your callback *before* the
.pow.pow canvas is scrolled and the "Post" form will fire *after*.
Combinations of the two should hopefully allow any custom behaviors
you want.

POW has general canvas and/or image bindings for changing the
colortable of an image and for dragging out a Region of Interest
(ROI).  By default, these are bound to B1 and B3 respectively (on 2
button mice under Windows these are the two available buttons).  If
you need to move these bindings to other buttons (to make way for your
application's own behavior) you can set $powLutButton or $powROIButton
to a different number after loading libpow.so but before calling
powInit.  You can also disable either function entirely by setting 
the corresponding variable to "0" or "NULL". For example, to move
colortable "diddling" to button 2 and disable ROI dragging do:

load libpow.so
set powLutButton "2"
set powROIButton "0"
powInit .someWindow


powGraphToCanvas graph x y ?canvas? -  takes physical coordinates
             and returns a two element list giving the corresponding position
	     on the specified canvas (.pow.pow by default).

powCanvasToGraph graph x y ?canvas? - takes a canvas coordinate 
             and returns the corresponding physical coordinates.
             Optional argument specifies the canvas (.pow.pow by default). 

powWhereAmI x y - takes an (x,y) pair of canvas coordinates and returns
             which graph (or subgraph) they are inside of. If they are outside
             of all graphs, returns "NULL".

powFindCurvesMinMax curves X|Y|Z - takes a list of curves and an axis 
            (X,Y, or Z) and returns the minimum and maximum values.


Provided Interface Routines

There will be more of these as I get feedback on what people need/want.

powDragRange X|Y tag color callback - This will set up a binding on the
left mouse button so that the user can click and drag a range in either
Y or X for the *selected graph*.  He will see a line joining the current
cursor position and the start position.  When he releases the LMB, all
of the graph points that fall in the selected range will be tagged
with the "tag" argument and will appear with the chosen "color".  The
"callback" routine will be called with arguments graphname, X0 and X1 
(or Y0 and Y1), specifying the edges of the user selected range in 
*graph* (i.e. physical) coordinates.  To remove a  previous selection,
just execute the Tk commands: 
".pow.pow itemconfigure $tag -fill black; .pow.pow delete $tag" 

This could be used to implement an "undo" feature.
powDragRange will also select the congruent range on all graphs with axes
linked to the chosen axis in the current graph.

powDragRect tag color callback -  This works the same as powDragRange, but
the user chooses a rectangular region of the selected graph.  And the
callback routine recieves 5 arguments (graphname X0 Y0 X1 Y1). Also, 
powDragRect ignores linked axes because it's not clear what "should"
happen to the unlinked axis. If someone wants to make a case for a
different (or selectable) behavior here, feel free.

Linked Axes

POW allows you to "link" any number of axes on different graphs together.
The resulting set of linked axes is called a "chain".  Each axis can only
be a member of one chain.  Linking an axis from one chain to an axis in 
another chain has the effect of merging the two chains.  Zooming on a
region of interest on one graph will affect the linked axis on any other
graph.  There are several utility routines.  Also, the GUI allows the
user to view links as light pink lines connecting linked axes.

powLinkAxes graph1 axis1 graph2 axis2 - The axis can be specified with a
            capital 'X' or 'Y'.

powBreakLink graph axis - removes the specified axis from its chain.

powAlignChain graph axis orientation ?gap? - orientation can be H 
	(for horizontal) or V (for vertical).  This routine will move
	all graphs belonging to the same chain as the specified graph 
	so that they are aligned on the canvas.  I.e.  it "stacks" the
	graphs up in a column or lines them up in a row on the users screen.
	The optional "gap" argument determines how much blank space (in 
	pixels to leave between graphs).



"Useful Stuff that should be safe to access"

The name of the pow canvas is ".pow.pow"

The tag for the axis box for a graph is:
${graphname}box
When multi-axes are done, it will be:
$graphname$xunits${yunits}box

Everything belonging to a graph is tagged with the graph name.





Do bugs still exist.  You bet!  Still too many to make a list yet, really; 
you'll know 'em when you see 'em.  Known bugs in the latest release are
listed on the "fv known bugs list" web page: 

        http://heasarc.gsfc.nasa.gov/ftools/fv/fv_bugs.html


Some info on the FitsTcl functions:


I checked in the new fitstcl with the function you need to load a column
 in a table into memory.

Usage : FitsObj load column $colName $nulValue
	where  	colName - column name
	 	nulValue - the default Null value you want to set

it returns "$address $dataType $numElements"
	where 	(1) data can be recovered by "sscanf(address, "%p", &databuff)
			with void *databuff
	        (2) dataType 0 - byte
			     1 - int
	 		     2 - long
		             3 - float
	 		     4 - double
	       	(3) numElement : size of the array

Thanks

Jianjun



C Interface:

All of the functions do the same thing as their TCL counterparts.  I'll
list the definitions below.  The parallels should be obvious.  The one
thing you will need is an event handler (i.e., when you call Pow, your
program has to stop and let the user play with his or her graph).  To 
do this you call an Event Handler.  When the user activates the "Close Pow"
button, control returns to your program.  Eventually you'll be able
to fork off the Event Handler etc., but for now, this is it.

Only the "Constructors" are available from C, for now.  All of the "Methods"
are written in TCL, so rather than creating Oroburos code with C calls
TCL calls C calls ..., if you want to use any of them, just call

Tcl_VarEval(proc,argument,argument,...,NULL);  - Note: all arguments
                                                 are STRINGS ! 

(see Ousterhout for details). 


Event Handlers

void PowHandleEvents( )  Your program stops, when the user closes POW
                         your program begins again.

void PowWishHandleEvents( ) Your program stops, until the user closes the POW
                            GUI she can type in TCL commands at a wish
                            prompt.  Useful for debugging and probably
                            in production code as well. When the user closes
                            POW, your program begins again.

"Constructors"

All of the POW functions have a status argument rather than just returning 
the status.  Yes I know it's awkward, but it makes FORTRAN happier, of course
noone's actually calling it from FORTRAN, but it was in the requirements....


void PowInit(char *powSetupColormapArgs, char *powInitArgs, int *status)  - 
      Call this before calling any other POW functions.  PowInit first calls
      the general POW initialization routine (in the TCL version, this gets
      called when you load libpow.so).  Then it calls powSetupColormap if
      you've specified anything in the powSetupColormapArgs argument.  Then
      it calls the TCL proc powInit with any powInitArgs you've specified.
      See above for descriptions of how powSetupColormap and powInit work.
	Example:  To force truecolor when you have no additional windows
                  to create and your application will be using no more than
                  10 non-POW colors do:

        PowInit(".dummy 10 2",".dummy ",&status);

        Tcl_VarEval(interp,"wm withdraw .dummy",(char *)NULL);



void PowCreateData(char *data_name, void *data_array, int *data_type,
		   int *length, int *copy, int *status) 


void PowCreateVector(char *vector_name, char *data_name, int *offset,
		     int *length, char *units, int *status) 

void PowCreateVectorEN(char *vector_name, char *data_name, 
			     int *length, double *start, double *increment, 
			     char *units, int *status) 

void PowCreateImage(char *image_name,char *data_name, int *xoffset, 
		    int *yoffset, int *width, int *height, double *xorigin, 
		    double *xinc, double *yorigin, double *yinc,char *xunits,
		    char *yunits, char *zunits, int *status)

void PowCreateCurve(char *curve_name, char *x_vector, char *x_error,
		    char *y_vector, char *y_error, char *z_vector, 
		    char *z_error, int *status)

void PowCreateGraph(char *graph_name, char *curves, char *images,
		    char *xunits, char *yunits, char *xlabel, char *ylabel,
		    int *xdimdisp, int *ydimdisp, double *xmin_in, 
		    double *ymin_in, double *xmax_in, double *ymax_in, 
		    int *status)




Pages maintained by Bryan Irby
Send bug reports or feature requests via the FTOOLS help desk.


HEASARC Home | Observatories | Archive | Calibration | Software | Tools | Students/Teachers/Public

Last modified: Tuesday, 01-Aug-2006 14:44:00 EDT