July 9, 1996
pad command creates a new Tcl command whose name is pathName. This command may be used to invoke various operations on the widget. It has the following general form:pathName option [arg arg ...]
Option and the args determine the exact behavior of the command. The following widget commands are possible for Pad++ widgets:
[1] pathName addgroupmember [-notransform] tagOrId groupTagOrId
Add all items specified by tagOrId to the group specified by groupTagOrId. If groupTagOrId specifies more than one item, the first one is used. The items are added to the end of the group in the order specified by tagOrId. Groups automatically update their bounding boxes to enclose all of their members. Thus, they will grow and shrink as their members change.
By default, items are transformed so they don't change their location when added to a group, even if the group has a transformation. This is implemented by transforming the item's transformation to be the inverse of the group's transformation. If the -notransform flag is specified, this inverse transformation is not applied, and the item will move by the group's transformation when added. (Also see the removegroupmember, and getgroup commands). Returns an empty string.
Example :
set id0 [.pad create line 0 0 100 100]
254
set id1 [.pad create line -10 20 80 -60]
255
set gid [.pad create group -members "$id0 $id1"]
256
.pad ic $gid -members
254 255
set id3 [.pad create rectangle -20 -20 130 40]
266
.pad addgroupmember $id3 $gid
.pad ic $gid -members
254 255 266
.pad removegroupmember $id0 $gid
.pad ic $gid -members
255 266
.pad getgroup $id2
256
[2] pathName addmodifier modifier
Define modifier to be a user-defined modifier that can be used in future event bindings. (Also see the deletemodifier, setmodifier, getmodifier, and bind commands).
[3] pathName addoption [-nowrite] typename optionname optionscript default
Add a new option (named optionname) to all objects of type typename. typename must either be a built-in type, a user-defined type previously defined by
addtype, or the special word "all" which means that this option applies to all types. When optionscript is called, the following arguments will be added on to the end of the script:pathName: The name of the pad widget the item is on
item: The id of the item being configured
[value]: Optional value. If value is specified, then the option must be set to this value.
optionscript must return the current (or new) value of the option. default specifies the default value of this option. This is used to determine if the option should be written out when the write command is executed. Note that the option will only be written out if the value is different than the default. If -nowrite is specified, then this option won't be written out. See the section APPLICATION-DEFINED ITEM TYPES AND OPTIONS in the Programmer's Guide for more information. (Also see the addtype command.)
[4]
pathName addtag tagToAdd tagOrId ...
For each item specified by the list of tagOrIds, add tagToAdd to the list of tags associated with the item if it isn't already present on that list. It is possible that no items will be specified by tagOrId, in which case the command has no effect. This command returns an empty string.
This command is designed to be used in conjunction with the find command. Notice the necessity of using eval in this example: eval .pad addtag foo [.pad find withtag bar]
[5] pathName addtype typename createscript
Add typename to the list of allowed user defined types. When a new object of type typename is created, the createscript will be evaluated, and it must return an object id. When createscript is evaluated, the pad widget the object is being created on will be added on as an extra argument, followed by any parameters before the options. See the section APPLICATION-DEFINED ITEM TYPES AND OPTIONS in the Programmer's Guide for more information. (Also see the
addoption command.)
[6] pathName
allocborder color
Allocates a border for future use by render callbacks. A border is a fake 3D border created by a slightly lighter and a slightly darker color than specified. Color may have any of the forms accepted by Tk_GetColor. (Also see the
freeborder and drawborder commands).
[7] pathName
alloccolor color
Allocates a color for future use by render callbacks. Color may have any of the forms accepted by Tk_GetColor. (Also see the
freecolor and setcolor commands).
[8] pathName
allocimage file [-norgb]
Allocates an image for future use by image objects and render callbacks. file specifies the name of a file containing an image.
allocimage can always read gif file formats. In addition, if Pad++ is compiled with the appropriate libraries, allocimage can also read jpeg and tiff image file formats, and will automatically determine the file type. Normally, images are stored internally with their full rgb colors in addition to a colormap index. This allows images to be rendered with dithering, but takes 5 bytes per pixel. If the -norgb option is specified, then the original rgb information is not stored with the image and the image can not be rendered with dithering, but only takes 1 byte per pixel. The image may have transparent pixels. This returns an image token which can be used by related commands. (Also see the freeimage, drawimage, and info commands, and the description of image items.).
[9] pathName
bbox [-sticky] tagOrId [tagOrId tagOrId ...]
Returns a list with four elements giving the bounding box for all the items named by the tagOrId argument(s). The list has the form "x1 y1 x2 y2" such that the drawn areas of all the named elements are within the region bounded by x1 on the left, x2 on the right, y1 on the bottom, and y2 on the top. If -sticky is specified, then the bounding box of the item in sticky coordinates, that is, the coordinates of a sticky item that would appear at the same location on the screen is returned. If no items match any of the tagOrId arguments then an empty string is returned.
If the item is sticky then bbox returns the bounding box of the item as it appears for the current view. That is, the bounding box will be different when the view is different. If -sticky is specified, then the bounding box returned is independent of the current view (i.e., it returns the bounding box as if the view was "0 0 1").
If the item is the Pad++ surface (item #1), then bbox will refer to the bounding box of the portion of the surface that is currently visible (based on the view and window size).
.pad bbox 27 37
-75 -55 68 79
[10] pathName bind tagOrId [sequence [command]]
This command associates command with all the items given by tagOrId such that whenever the event sequence given by sequence occurs for one of the items the command will be invoked.
This widget command is similar to the Tk bind command except that it operates on items on a Pad++ widget rather than entire widgets. See the Tk bind manual entry for complete details on the syntax of sequence and the substitutions performed on command before invoking it. The Pad++ widget defines extensions described below, but it is implemented as a complete superset of the standard bind command. I.e., you can do everything you can with the canvas with exactly the same syntax, but you can also do more.
If all arguments are specified then a new binding is created, replacing any existing binding for the same sequence and tagOrId (if the first character of command is "+" then command augments an existing binding rather than replacing it). In this case the return value is an empty string. If both command and sequence are omitted then the command returns a list of all the sequences for which bindings have been defined for tagOrId.
The only events for which bindings may be specified are those related to the mouse and keyboard, such as Enter, Leave, ButtonPress, Motion, ButtonRelease, KeyPress and KeyRelease. In addition, Pad++ supports some extra bindings including: Create, Modify, Delete, PortalIntercept, and Write. The handling of events in Pad++ uses the current item defined in Item IDs and Tags in the Programmer's Guide. Enter and Leave events trigger for an item when it becomes the current item or ceases to be the current item; note that these events are different than Enter and Leave events for windows. Mouse-related events are directed to the current item, if any. Keyboard-related events are directed to the focus item, if any (see the focus command below for more on this).
It is possible for multiple bindings to match a particular event. This could occur, for example, if one binding is associated with the item's id and another is associated with one of the item's tags. When this occurs, all of the matching bindings are invoked. The order of firing is controlled by the pad bindtags command. The default is that a binding associated with the all tag is invoked first, followed by one binding for each of the item's tags (in order), followed by a binding associated with the item's id. If there are multiple matching bindings for a single tag, then only the most specific binding is invoked. A continue command in a binding script terminates that script, and a break command terminates that script and skips any remaining scripts for the event, just as for the bind command.
If bindings have been created for a pad window using the Tk bind command, then they are invoked in addition to bindings created for the pad's items using the bind widget command. The bindings for items will be invoked before any of the bindings for the window as a whole.
The Pad++ bind command is extended in three ways:
bind command makes, Pad++ makes a few more. As with the Tk bind command, all substitutions are made on two character sequences that start with '%'. The special Pad++ substitutions are:
%P: The pad widget that received the event. This is normally the same as %W, but could be different if the event goes through a portal onto a different pad widget.
<Modify> events, it specifies the command that caused the modification. For <PortalIntercept> events, it specifies the name of the event type generating the PortalIntercept. Standard Tcl event names, such as ButtonPress or ButtonRelease are used. This can be used by PortalIntercept events to only let certain event types go through the portal. Note that only a single PortalIntercept event is generated for a Button, Motion, ButtonRelease sequence, so these three events can not be distinguished in this manner.
<create>: This event gets fired whenever new pad items are created. Because items that this is attached to don't have id's yet, it only makes sense to attach this event to a tag. Then this event gets fired immediately after any item of the relevant tag is created. Example:
.pad bind foo <Create> {puts "A foo was created, id=%O"}
.pad create rectangle 0 0 50 50 -tags "foo"
=> A foo was created, id=5
<Modify>: This event gets fired whenever an item is modified. Modification occurs whenever an item's configuration options are changed, and whenever the following commands are executed on an item: coords, itemconfigure, scale, slide, text. The %I macro specifies the command that caused the modification. Example:
.pad bind foo <Modify> {puts "A foo was modified, cmd=%I"}
.pad create rectangle 0 0 50 50 -tags "foo"
.pad itemconfigure foo -pen red
=> A foo was modified, cmd=itemconfigure
<Delete>: This event gets whenever an item is deleted. It is typically used to clean up application resources associated with the item that was deleted.
<Write>: This event fires whenever an item is written out with the pad write command. While Pad++ knows how to generate the Tcl code necessary to recreate itself, items are often part of an application with associated data structures, etc. When an item is written out, it is frequently necessary to write out these associated structures. Sometimes, the application may prefer to substitute its code for pad's. This event provides a mechanism to augment or replace (possibly with an empty string) the Tcl code written out to recreate a pad item.
Whatever string a <Write> event returns is appended on to the string pad uses to write out that object. In addition, the application may modify the special global Tcl variable, Pad_Write which controls whether the item will get written out. This defaults to 1 (true), but may be set to 0 (false) by the event binding. In addition, the <Write> event gets fired on the special tags "preWrite" and "postWrite" at the beginning and end of the file, respectively, to allow an application to write out code at the ends of the file. Example:
.pad bind preWrite <Write> {
return "Stuff at the beginning of the file"
}
.pad bind postWrite <Write> {
return "Stuff at the end of the file"
}
.pad bind foo <Write> {
return "Stuff after foo objects"
}
.pad bind bar <Write> {
set Pad_Write 0
return "Stuff instead of bar objects"
}
# This forces all objects with the "cat" tag
# to have nothing written out. Notice that an
# empty string must be returned, or "0", the
# result of the set command, will be written out.
.pad bind cat <Write> {
set Pad_Write 0
return ""
}
# This example also has nothing written out,
# but in addition, no other event handlers
# will fire (the object could have multiple
# tags, each with <Write> event handlers).
.pad bind dog <Write> {
Set Pad_Write 0
break
}
<PortalIntercept>: This event gets fired just before an event passes through a portal. If the event handler executes the break command, then the event stops at the portal and does not pass through. Example:
# Events will not go through portals of type "foo"
.pad bind foo <PortalIntercept> {
break
}
bind reference pages. A sequence contains a list of modifiers which are direct mappings to hardware such as the shift key, control key, etc. Event handlers fire only for sequences with modifiers that are active, as defined by the hardware.
Pad++ allows user-defined modifiers where the user can control which one of the user-defined modifiers is active (if any). The advantage of modifiers is that many different sets of event bindings may be declared all at once - each with a different user-defined modifier. Then, the application may choose which set of event bindings is active by setting the active user-defined modifier. This situation comes up frequently with many graphical programs where there are modes, and the effect of interacting with the system depends on the current mode.
New modifiers must be declared before they can be used with the pad addmodifier command (and may be deleted if they are no longer needed with the pad deletemodifier command.) Then, the modifier can be used in the pad bind command just like a system defined modifier. There may be at most one active user-defined modifier per pad widget. The active user-defined modifier is set with the setmodifier command (and may be retrieved with the getmodifier command). The current modifier may be set to "" (the default) in which case no user-defined modifier is set. Example:
.pad addmodifier Create
.pad addmodifier Run
.pad bind all <Create-ButtonPress-1> {
# Do stuff to create new objects
}
.pad bind all <Run-ButtonPress-1> {
# Do stuff to interact with existing objects
}
# Now the system will be in "Create" mode
.pad setmodifier Create
...
# Now the system will be in "Run" mode
.pad setmodifier Run
[11] pathName bindtags tagOrId [type]
If type is specified, this command changes the ordering of event firings on all objects referred to by tagOrId. Since more than one event handler may fire for a given event, this controls what order they fire in. If type is "general", events fire most generally first. That is, a binding associated with the all tag is invoked first, followed by one binding for each of the item's tags (in order), followed by a binding associated with the item's id. (i.e., all, tags, id). If type is "specific", then events fire most specific first. That is, a binding associated with the item's id is invoked first, followed by one binding for each of the item's tags (in order), followed by a binding associated with the all tag (i.e., id, tags, all).
If tagOrId is pathName, then it does not change the ordering of any objects, but controls the default ordering of objects created in the future.
The default event firing order for all objects is "general". This command returns the current event firing order for the first item specified by tagOrId.
[12] pathName
center [-twostep] tagOrId [time x y [z [portalID ...]]]]
Change the view so as to center the first of the specified items so the largest dimension of its bounding box fills the specified amount of screen (z). If -twostep is specified, then make the animation in two steps if appropriate (i.e., points not too close). The two steps are such that it zooms out to the midpoint between the two points far enough so that both start and endpoints are visible, and then zooms to the final destination. If time is specified, then make a smooth animation to the item in time milliseconds. The view is changed so that the item's center appears at the position on the screen specified by x and y, both in the range (0.0 ... 1.0). Here, 0.0 represents the left or bottom side of the window, and 1.0 represents the right or top side of the window. x and y default to (0.5, 0.5), i.e. the center of the screen. If a list of portalID's is specified, change the view within the last one specified.
.pad center 23
[13] pathName centerbbox [-twostep] x1 y1 x2 y2 [time [x y [z [portalID ...]]]]
Change the view so as to center the specified bounding box so that its largest dimension fills the specified amount of screen (
z). If -twostep is specified, then make animation in two steps if appropriate (i.e., points not too close). The two steps are such that it zooms out to the midpoint between the two points far enough so that both start and endpoints are visible, and then zooms to the final destination. If time is specified, then make a smooth animation to the item in time milliseconds. The view is changed so that the item's center appears at the position on the screen specified by x and y, both in the range (0.0 ... 1.0). Here, 0.0 represents the left or bottom side of the window, and 1.0 represents the right or top side of the window. x and y default to (0.5, 0.5), i.e. the center of the screen. If a list of portalID's is specified, change the view within the last one specified.
[14] pathName clock [clockName [reset | delete]]
Creates a clock that is set to 0 at the time of creation. Returns the name of the clock. Future calls with clockName return the number of milliseconds since the clock was created (or reset). Calls with reset specified reset the clock counter to 0, and return an empty string. Calls with delete specified delete the clock, and return an empty string.
.pad clock
clock1
.pad clock clock1
8125
.pad clock clock1 reset
.pad clock clock1
1825
.pad clock clock1 delete
[15] pathName configure [option] [value] [option value ...]
Query or modify the configuration options of the widget. If no option is specified, returns a list describing all of the available options for pathName (see
Tk_ConfigureInfo for information on the format of this list). If option is specified with no value, then the command returns a list describing the one named option (this list will be identical to the corresponding sublist of the value returned if no option is specified). If one or more option-value pairs are specified, then the command modifies the given widget option(s) to have the given value(s); in this case the command returns an empty string. Option may have any of the values accepted by the pad command. See the section on WIDGET-SPECIFIC OPTIONS for a description of all the options and their descriptions.
[16] pathName coords [-objectcoords] [-append] [-nooutput] tagOrId [x0 y0 ...]
Query or modify the coordinates that define an item. This command returns a list whose elements are the coordinates of the item named by tagOrId. If coordinates are specified, then they replace the current coordinates for the named item. If tagOrId refers to multiple items, then the first one in the display list is used. The flags may be specified in any order. Note that the
coords command generates a <Modify> event on the items modified by it (see the bind command for a description of the <Modify> event). Locked items may not be modified by the coords command (see the -lock itemconfigure option). The coords command can only be used on line, rectangle, polygon and portal items.
If the flag -objectcoords is specified, then all coordinates are returned in the item's local coordinate system (i.e., as they were originally specified). If this flag is not specified, then all coordinates are returned in the global coordinate system (i.e., they are transformed by that item's translation and scale parameters).
If the flag -append is specified, then all the specified coordinates are appended on to the existing coordinates rather than replacing them.
If the flag -nooutput is specified, then this command returns an empty string. Typically, the -append and -nooutput flags are specified together when adding points to an item and time is of the essence.
set id [.pad create line -200 200]
for {set i -20} {$i <= 20} {incr i} {
set x [expr $i * 10 ]
set y [expr 0.5 * ($i * $i)]
.pad coords -append -nooutput $id $x $y
}
[17] pathName create type [option value ...]
Create a new item in pathName of type type. The exact format of the arguments after type depends on type, but usually they consist of the coordinates for one or more points, followed by specifications for zero or more item options. See the OVERVIEW OF ITEM TYPES subsection below for detail on the syntax of this command. This command returns the id for the new item.
[18] pathName damage [tagOrId]
Indicates that some of the screen is damaged (needs to be redrawn). Damages the entire screen if tagOrId is not specified, or just the bounding box of each of the objects specified by tagOrId. The damage will be repaired as soon as the system is idle, or when the update procedure is called. Returns an empty string.
[19] pathName delete tagOrId [tagOrId ...]
Delete each of the items given by each tagOrId, and return an empty string. Note that the
delete command generates a <Delete> event on the items modified by it (see the delete command for a description of the <Delete> event). Locked items may not be modified by the delete command (see the -lock itemconfigure option).
[20] pathName deletemodifier modifier
Delete modifier from the list of valid user-defined modifiers. Any event bindings that are defined with this modifier become invalid. (Also see the addmodifier, setmodifier, getmodifier, and bind commands).
[21] pathName deletetag tagToDelete tagOrId [tagOrId ...]
For each item specified by the list of tagOrIds, delete tagToDelete from the list of tags associated with the item if it isn't already present on that list. It is possible that no items will be specified by tagOrId, in which case the command has no effect. Note that dtag is an acceptable synonym for deletetag. This command returns an empty string.
This command is designed to be used in conjunction with the find command. Notice the necessity of using eval in this example: eval .pad deletetag foo [.pad find withtag bar]
[22] pathName
drawborder border type width x1 y1 x2 y2
Draws a fake 3D border connecting the specified coordinates. (See
allocborder and freeborder commands). This command can only be called within a render callback. Border must have been previously allocated by allocborder. Type must be one of "raised", "flat", "sunken", "groove", "ridge", "barup", or "bardown". The following example creates an object that draws a border:
set border [.pad allocborder #803030]
.pad create rectangle 0 0 100 100 -renderscript {
.pad drawborder $border raised 5 0 0 100 100
}
[23] pathName drawimage imagetoken x y
Draws the image specified by imagetoken at the point (x, y). (Also see
allocimage, freeimage, and info commands as well as the description of image items). This command can only be called within a render callback.
[24] pathName drawline x1 y1 x2 y2 [xn yn ...]
Draws a multi-segment line connecting the specified coordinates. (See
setcolor, setlinewidth, setcapstyle, and setjoinstyle commands). This command can only be called within a render callback.
[25] pathName drawpolygon x1 y1 x2 y2 [xn yn ...]
Draws a closed polygon connecting the specified coordinates. (See
setcolor and setlinewidth). This command can only be called within a render callback.
[26] pathName drawtext string xloc yloc
Draws the specified text at the specified location. This command can only be called within a render callback. (Also see the
setcolor, setfont, and setfontheight commands.)
[27] pathName find [-groupmembers] searchCommand [arg arg ...]
This command returns a list consisting of all the items that meet the constraints specified by searchCommand and arg's. The objects are returned in display list order, and if -groupmembers is specified, then group members are returned, otherwise, they are not. Note that this command does not return the pad surface (id #1). SearchCommand may take any of these forms:
all
Returns all the items on the pad.
below tagOrId
Returns the item just before (below) the one given by tagOrId in the display list. If tagOrId denotes more than one item, then the first (lowest) of these items in the display list is used.
closest x y [halo] [startTagOrId]
Returns the single item closest to the point given by x and y. If more than one item is at the same closest distance (e.g. two items overlap the point), then the top-most of these items (the last one in the display list) is used. If halo is specified, then any item closer than halo to the point is considered to overlap it. (Halo must be a non-negative number.) If halo is not specified, then only items at the point (x, y) will be found.
The startTagOrId argument may be used to step circularly through all the closest items. If startTagOrId is specified, it names an item using a tag or id (if by tag, it selects the first item in the display list with the given tag). Instead of selecting the topmost closest item, this form will select the topmost closest item that is below start in the display list; if no such item exists, then the selection behaves as if the start argument had not been specified.
withinfo info
Returns all the items containing the string info in their info itemconfigure option.
withlayer layer
Returns all the items on the layer layer.
withname name
Returns all the items having name.
withtag tagOrId
Returns all the items given by tagOrId.
withtext text
Returns all the items containing text.
withtype type
Returns all the items of type type.
enclosed x1 y1 x2 y2
Returns all the items completely enclosed within the rectangular region given by x1, y1, x2, and y2. x1 must be no greater then x2 and y1 must be no greater than y2.
overlapping x1 y1 x2 y2
Returns all the items that overlap or are enclosed within the rectangular region given by x1, y1, x2, and y2. x1 must be no greater then x2 and y1 must be no greater than y2.
.pad find withtag selected
52 72 92
[28] pathName focus [tagOrId [portalID ...]]
Set the keyboard focus for the Pad++ widget to the item given by tagOrId. If a list of portalID's are specified, then the item sits on the surface looked onto by the last portal. If tagOrId refers to several items, then the focus is set to the first such item in the display list. If tagOrId doesn't refer to any items then the focus isn't changed. If tagOrId is an empty string, then the focus item is reset so that no item has the focus. If tagOrId is not specified then the command returns the id for the item that currently has the focus, or an empty string if no item has the focus. If the item sits on a different surface than pathName, then this command also returns the pathName of the item.
Once the focus has been set to an item, all keyboard events will be directed to that item. The focus item within a Pad++ widget and the focus window on the screen (set with the Tk focus command) are totally independent: a given item doesn't actually have the input focus unless (a) its pad is the focus window and (b) the item is the focus item within the pad. In most cases it is advisable to follow the focus widget command with the focus command to set the focus window to the pad (if it wasn't there already). Note that there is no restriction on the type of item that can receive the Pad++ focus.
[29] pathName freeborder border
Frees the border previously allocated by allocborder. (Also see the allocborder and drawborder commands).
Frees the color previously allocated by alloccolor. (Also see the alloccolor and setcolor commands).
[31] pathName freeimage imagetoken
Frees the image previously allocated by allocimage. (Also see the allocimage and drawimage commands, as well as the description of image items).
Returns the current date and time in the standard unix time format.
% .pad getdate
Wed May 29 20:01:49 1996
[33] pathName getgroup tagOrId
Return the group id that tagOrId is a member of. If tagOrId is not a member of a group, then this command returns an empty string. If tagOrId specifies more than one object, then this command refers to the first item specified by tagOrId in display-list order. (Also see the addgroupmember, and removegroupmember commands).
Returns the current render level This command can only be called within a render callback. (See the sections on Refinement and Region Management and Screen Updating in the Programmer's Guide for more information about render levels).
Returns the current magnification of tagOrId for this specific render (it could be rendered multiple times if visible through different portals). Magnification is defined as the multiplication of the current view (including portals) with the object's size (from the -place itemconfigure option). This command can only be called within a render callback.
Return the current active modifier. (Also see the addmodifier, deletemodifier, setmodifier, and bind commands).
[37] pathName
getpads
Returns a list of all the Pad++ widgets currently defined.
Returns the list of the portals the current object is being rendered within. This command can only be called within a render callback.
[39] pathName getsize tagOrId ?portalID ...?
Returns the largest dimension of the first item specified by tagOrId. If a portal list is specified, then the size of the item within the last portal is returned.
Return a list whose elements are the tags associated with the item given by tagOrId. If tagOrId refers to more than one item, then the tags are returned from the first such item in the display list. If tagOrId doesn't refer to any items, or if the item contains no tags, then an empty string is returned.
[41] pathName gettextbbox string
Returns a list with four elements giving the bounding box of string if it is drawn with the
drawtext command. The list has the form "x1 y1 x2 y2" such that the text is within the region bounded by x1 on the left, x2 on the right, y1 on the bottom, and y2 on the top. The bounding box is affected by the setfont and setfontheight commands.
[42] pathName
getview [portalID ...]
Returns the current view of the main window in "xview yview zoom" form. Here, (xview, yview) specifies the point at the center of the window, and zoom specifies the magnification. If a list of portalID's is specified, than the view of the last portal is returned instead of the view of the main window. (See
moveto to set the current view).
.pad getview
14 134 2
.pad ic 221 -place
8 118 1
.pad moveto -250 -150 0.5
.pad getview
-250 -150 0.5
.pad ic 221 -place
8.1125 118.753 1
[43] pathName
grid option arg [arg ...]
The
grid command arranges one or more objects in rows and columns and treats them as a group. It is based on the Tk grid geometry manager and its behavior and Tcl syntax are very similar to it. In pad, all grid commands are sub-commands of the pad command. See the section on GRID ITEMS for a complete description of this command, and how to create and use grids.
[44] pathName hastag tagOrId tag
Determines if the item specified by tagOrId contains the specified tag. This command returns "1" if the item does contains the specified tag, or "0" otherwise. If tagOrId refers to more than one item, then the comparison is performed on the first item in the display list. If tagOrId doesn't refer to any items, then "0" is returned.
A general command for accessing information about pad and items on the pad surface. subcommand may be any of the following: html or image. Each subcommand may have sub-subcommands and options. All the subcommands and their options follow:
html getlastchangedate <tagOrId>
Returns the last date this page was modified as specified by the server.
html getlength <tagOrId>
Returns length of this page in bytes.
html getsource <tagOrId>
Returns HTML source of this page.
html gettype <tagOrId>
Returns Mime type of this page as specified by the server.
image getdim <imagetoken>Returns dimensions {x y} of this image in pixels.
image getname <imagetoken>
Returns filename this image was loaded from.
[46] pathName
islinked
WARNING:
islinked is an obsolete command and will be removed in the next release. Replace all uses of islinked with the Tk 'winfo ismapped' command.
Returns a flag specifying if pathName has been mapped to the display yet.
[47] pathName itemconfigure [-nondefaults] tagOrId [option [value] ...]
This command is similar to the
configure command except that it modifies item-specific options for the items given by tagOrId instead of modifying options for the overall pad widget. ic is an allowed synonym for itemconfigure. If no option is specified, then this command returns a list describing all of the available options for the first item given by tagOrId. If the -nondefaults flag is specified, then only those options modified by an application will be returned. If option is specified with no value, then the command returns the value of that option. If one or more option-value pairs are specified, then the command modifies the given widget option(s) to have the given value(s) in each of the items given by tagOrId; in this case the command returns an empty string. If value is an empty string, then that option is set back to its default value.
The options and values are the same as those permissible in the create command when the item(s) were created; see the sections below starting with OVERVIEW OF ITEM TYPES for details on the legal options. Note that the itemconfigure command generates a <Modify> event on the items modified by it (see the itemconfigure command for a description of the <Modify> event). Locked items may not be modified by the itemconfigure command (see the -lock itemconfigure option).
[48] pathName line2spline error x1 y1 ... xn yn
Takes the coordinates for a line, and uses an adaptive curve fitting algorithm to generate the coordinates for a spline that approximates the line. The spline coordinates are returned. error is a floating point number indicating how closely the spline curve should follow the line. Using a smaller error will tend to generate a spline made with more bezier segments that follow the line more accurately. Using a larger error will produce fewer bezier segments but the fit will be less accurate. See the section on SPLINE ITEMS on how splines are specified in Pad++. (Also see
spline2line.)
[49] pathName lower [-one] tagOrId [belowThis]
Move all of the items given by tagOrId to a new position in the display list just before the item given by belowThis. If tagOrId refers to more than one item then all are moved but the relative order of the moved items will not be changed. belowThis is a tag or id; if it refers to more than one item then the first (bottommost) of these items in the display list is used as the destination location for the moved items. If belowThis is not specified, then tagOrId is lowered to the bottom of the display list. If the -one flag is specified, then tagOrId is lowered down one item in display order which may or may not have a visible effect. -one and aboveThis may not both be specified. If any items to be lowered are group members, they are lowered within their group rather than being lowered on the pad surface. Returns an empty string.
[50] pathName moveto [-twostep] xview yview zoom [time [portalID ...]]
Change the view so that the point "xview yview" is at the center of the screen with a magnification of zoom. If xview, yview, or zoom is specified as "", then that coordinate is not changed. If -twostep is specified, then make animation in two steps if appropriate (i.e., points not too close). The two steps are such that it zooms out to the midpoint between the two points far enough so that both start and endpoints are visible, and then zooms to the final destination. If time is specified, then the change in view will be animated in enough evenly spaced frames to fill up time milliseconds. If a list of portalID's are specified, then the view will be changed within the last specified portalID rather than within the main view. The return value is the current view. (See
getview to get the current view).
Returns a repeatable noise value based on the floating-point value of index. This noise function is equal to 0 whenever index is an integer. Typically, noise is called with slowly incrementing values of index. The closer the consecutive values of index are, the higher the frequency of the resulting noise will be. This noise function is from Ken Perlin at New York University (http://www.mrl.nyu.edu/perlin).
Example:
set coords ""
set noiseindex_x 0.1928
set noiseindex_y 100.93982
set noiseincr 0.052342
for {set i 0} {$i < 100} {incr i } {
set x [expr 500.0 * [.pad noise $noiseindex_x]]
set y [expr 500.0 * [.pad noise $noiseindex_y]]
lappend coords $x
lappend coords $y
set noiseindex_x [expr $noiseindex_x + $noiseincr]
set noiseindex_y [expr $noiseindex_y + $noiseincr]
}
eval .pad create line $coords
[52] pathName padxy [-sticky] [-portals] winx winy [-gridspacing value]
Given a window x-coordinate winx and y-coordinate winy, this command returns the pad x-coordinate and y-coordinate that is displayed at that location. If -sticky is specified, the coordinate transform is done ignoring the current view (i.e., as for sticky objects.) If -portals is specified, then the point (winx, winy) is passed through any portals it on. If -gridspacing is specified, then the pad coordinate is rounded to the nearest multiple of value units.
[53] pathName pick [-divisible] [-indivisible] winx winy
Given a window coordinate (winx, winy), it returns the visible object underneath that point. If the point should pass through any portals, a
<PortalIntercept> event will be fired which will determine if the event will pass through that portal. By default, the pick command uses the divisibility of individual groups to determine if group members should be picked. However the -divisible or -indivisible flags (only one of which may be specified) override group's divisibility. If -divisible is specified, then group members will be picked from any group the point hits. If -indivisible is specified, then group objects and not group members will be picked.
% .pad create line 0 0 100 100
22
.pad create rectangle 30 30 80 80
23
.pad addmodifier Pick
.pad bind all <Pick-ButtonPress-1> {
event_Press %i %j %x %y %O
}
proc event_Press {i j x y obj} {
# Get the group object not the group members
# underneath the point x y
set container [.pad pick -indivisible $x $y]
puts "container $container object: $obj coords: ($i, $j)"
}
.pad setmodifier Pick
Now, group the line and rectangle:
% .pad create group -members "22 23"
24
Now, click on the line, the system response with:
container 24 object: 22 coords: (37.5, 36)
Now, click on the rectangle, system response with:
container 24 object: 23 coords: (66.5, 28)
Now, change the pick command as:
set container [.pad pick -divisible $x $y]:
Then click on the line:
container 22 object: 22 coords: (52.5, 52)
Click on the rectangle:
container 23 object: 23 coords: (63.5, 30)
Pops the top frame off the stack of coordinate frames. The resulting frame on the top of the stack becomes active. Also see
pushcoordframe and resetcoordframe. Returns the frame popped off the stack.
Prints the current hierarchical tree of items to stdout (used for debugging). Returns an empty string.
[56] pathName pushcoordframe tagOrId
pathName pushcoordframe x1 y1 x2 y2
Pushes a coordinate frame onto the stack of coordinate frames. When any coordinate frames are on the stack, all coordinates are interpreted relative to the frame instead of as absolute coordinates. A frame is a bounding box, and all coordinates are specified within the unit square where the unit square is mapped to the frame.
Note that the -penwidth and -minsize and -maxsize itemconfigure options are also relative to the coordinate frame. In these cases, a value of 1 refers to the average of the frame dimensions.
Text and images are scaled so that one line of text, or the height of the image is scaled to the height of the coordinate frame at a scale of 1 (using the -place or -z itemconfigure options).
For example, the following code makes 50 nested rectangles. Note that the width of the rectangles shrinks proportionally.
for {set i 0} {$i < 50} {incr i} {
set id [.pad create rectangle 10 10 80 80 -penwidth 2]
.pad pushcoordframe $id
}
.pad resetcoordframe
Also see popcoordframe and resetcoordframe. Returns the current coordinate frame.
[57] pathName raise [-one] tagOrId [aboveThis]
Move all of the items given by tagOrId to a new position in the display list just after the item given by aboveThis. If tagOrId refers to more than one item then all are moved but the relative order of the moved items will not be changed. aboveThis is a tag or id; if it refers to more than one item then the last (topmost) of these items in the display list is used as the destination location for the moved items. If aboveThis is not specified, then tagOrId is raised to the top of the display list. If the -one flag is specified, then tagOrId is raised up one item in display order which may or may not have a visible effect. -one and aboveThis may not both be specified. If any items to be raised are group members, they are raised within their group rather than being raised on the pad surface. Returns an empty string.
.pad raise 24
If we use the -one option:
.pad raise -one 24
The original position turns to be:
[58] pathName read filename
Executes the tcl commands in the filename. If filename is created with the write command, then this command reads the pad scene back in. Returns an empty string.
[59] pathName removegroupmember [-notransform] tagOrId
Remove all items specified by tagOrId from the group they are a member of, and return them to the pad surface. If any of the items were members of hierarchical groups, they are removed from all groups. If any of the items are not a member of a group, then they are not affected. Items removed are added to the pad surface just after the group in terms of display-list order.
By default, items are transformed so they don't change their location when removed from a group - even if the group has a transformation. This is implemented by transforming the item's transformation to be the inverse of the group's transformation. If the -notransform flag is specified, this inverse transformation is not applied, and the item will move by the group's transformation when removed. (Also see the addgroupmember, and getgroup commands). Returns an empty string.
[60] pathName renderitem [tagOrId]
During a render callback triggered by the -renderscript option, this function actually renders the object. During a -renderscript callback, if
renderitem is not called, then the object will not be rendered. If tagOrId is specified, then all the items specified by tagOrId are rendered (and the current item is not rendered unless it is in tagOrId). This function may only be called during a render callback. Returns an empty string.
Pops all the frames off of the coordinate stack. Results in an empty stack, so all coordinates are back to absolute coordinates. Also see
pushcoordframe and popcoordframe. Returns an empty string.
[62] pathName scale tagOrId [scaleAmount [padX padY]]
Scale each of the items given by tagOrId by multiplying the size of the item with scaleAmount. Scale the items around the item's center, or around the point (padX, padY), if specified. This command returns the scale of the first item. Note that the
scale command generates a <Modify> event on the items modified by it (see the scale command for a description of the <Modify> event). Locked items may not be modified by the scale command (see the -lock itemconfigure option).
[63] pathName setcapstyle capstyle
Sets the capstyle of lines for drawing within render callbacks. Capstyle may be any of: "butt", "projecting", or "round". This command can only be called within a render callback.
[64] pathName
setcolor color
Sets the color for future drawing with render callbacks. Color must have previously been allocated by
alloccolor. This command can only be called within a render callback. (Also see the alloccolor and freecolor commands).
[65] pathname setfont fontname
Sets the font for future drawing with render callbacks. This affects the result of the
gettextbbox command. Fontname must specify a filename which contains an Adobe Type 1 font, or the string "System" which causes the Pad++ line-font to be used. Defaults to "System". (Also see the setfontheight command).
[66] pathname
setfontheight height
Sets the height of the font for future drawing with render callbacks. Height is specified in the current pad units. This affects the result of the
gettextbbox command. (Also see the setfont command).
[67] pathname
setid tagorid id
Sets the id of an existing item to id. If tagord specifies more than one item, then the first item is used. Returns an empty string. This generates an error if an invalid id is specified (i.e., if it is in use), or if tagorid does not specify an object.
[68] pathName
setjoinstyle joinstyle
Sets the joinstyle of lines for drawing within render callbacks. Joinstyle may be any of: "bevel", "miter", or "round". This command can only be called within a render callback.
[69] pathName
setlanguage language
Sets the language to be used for callback scripts that are created in the future. All callback scripts that have already been created will be evaluated in the language that was active at the time they were created. This command refers to all callback scripts including event handlers, render scripts, timer scripts, zoom actions, etc. Pad++ always includes at least the Tcl scripting language, but others may be active, depending on how Pad++ was built. This command controls whatever languages are currently installed. The language defaults to "automatic" where it tries to guess the language based on the syntax of the script. See the SCRIPTING LANGUAGES section in the Programmer's Guide for more details. (Also see the
settoplevel command.)
[70] pathName
setlinewidth width
Sets the linewidth (in current units) to width for future drawing with render callbacks. The actual width of the line will depend on the size of the object and the magnification of the view. If width is 0, then the line is always drawn 1 pixel wide. This command can only be called within a render callback.
[71] pathName setmodifier modifier
Make modifier be the current active modifier for this pad widget. modifier must have been previously defined with the setmodifier command. (Also see the addmodifier, deletemodifier, getmodifier, and bind commands).
[72] pathName settoplevel language
Sets the language that the top-level interpreter should use. Pad++ always includes at least the Tcl scripting language, but others may be added. Returns an empty string. See the SCRIPTING LANGUAGES section in the Programmer's Guide for more details. (Also see the setlanguage command.)
[73] pathName shape [innercoords outercoords]
WARNING: shape has been renamed to windowshape, and will be removed in the next release. Replace all uses of shape with the windowshape command.
[74] pathName
slide tagOrId [dx dy]
Slide each of the items given by tagOrId by adding dx and dy to the x and y coordinates of the item's transformation (i.e., their -place itemconfigure option). This command returns a string with the (x, y) position at the item's anchor point. Note that the
slide command generates a <Modify> event on the items modified by it (see the slide command for a description of the <Modify> event). Locked items may not be modified by the slide command (see the -lock itemconfigure option).
.set id [.pad create line 0 0 200 200]
.pad slide $id -80 30
20.000000 70.000000
[75] pathName spline2line error x1 y1 ... xn yn
Takes the coordinates for a spline and uses an adaptive bezier algorithm to generate the coordinates for a line that apprxoimates the spline. error is how much error is allowed - a small error produces a greater number of points and more accuracy. A large error yields fewer points but the line is less accurate. See the section on SPLINE ITEMS for details on how splines are created. (Also see
line2spline.)
[76] pathName text tagOrId option [arg ...]
Controls all interaction with a text item. See TEXT ITEMS for a description of indices and marks. tagOrId specifies the text item to apply the following command to. Option and the args determine the exact behavior of the command. Note that the
text command generates a <Modify> event on the items modified by it (see the text command for a description of the <Modify> event). Locked items may not be modified by the text command (see the -lock itemconfigure option). The following command options are available:
compare index1 op index2
delete index1 [index2]
get index1 [index2]
index index [char]
insert index chars
mark option [arg arg ...]
mark names
Returns a list whose elements are the names of all the marks that are currently set.
mark set markName index
Sets the mark named markName to a position just before the character at index. If markName already exists, it is moved from its old position; if it doesn't exist, a new mark is created. This command returns an empty string.
mark unset markName [markName ...]
Remove the mark corresponding to each of the markName arguments. The removed marks will not be usable in indices and will not be returned by future calls to
pathName mark names. This command returns an empty string.
[77] pathName tree subcommand [args ...]
This command creates, maintains, and animates dynamic trees of Pad items. Items are created by other pad functions, and are placed into hierarchical tree structures to be managed by this code. These trees support a focus + context viewing structure, multiple focii, and a focus function which has a controlled level of influence on the tree.
Each node has a layout object associated with it which controls the position and resizing of the pad item at that node during a layout. Each layout controls a link item - a pad item created by the tree code, which graphically connects the node to its parent. This link item is maintained automatically by the tree code, but may be accessed and manipulated through the tree subcommand.
Each pad has a treeroot object, which is a list of all pad tree nodes on the surface. Each of these "root nodes" is an invisible treenode which controls certain subtrees on the pad surface. This organization is necessary to keep trees independent. Animation done at a node affects that node and its children, so we need to be careful to organize the nodes in such a way that all nodes we wish to "know" about each other are connected in some manner. Separate hierarchies can be made to "avoid" each other during animation by connecting them togethe under an invisible root node. When the layout function is called on the root node, both hierarchied will be laid out according to the layout object which resides at the root node.
A dynamic tree supports an abitrary number of foci. Management of these foci is left up to the user. A node's focus is spread by a function which has several parameters. See the setfocus subcommand for more information.
Manipulation of the tree structure falls into four parts - tree management, layout, animation control, and parameter control.
Trees are created and manipulated through the tree subcommands:
addnode childtagOrId parenttagOrId
Adds childtagOrId to parenttagOrId as a child. If childtagOrId already has a parent, this command also removes childtagOrId from that parent. When it is added to the tree, the item's current zoom is recorded, and is used in all future calculations in the dynamic tree layouts. This means that an item's size when it is added to the tree is the size that it will have when it has a focus of 1.0. (See the tree setscale command to modify the size of an item after it has been added to a tree.)
animatelayout tagOrId [-view view]
Used in conjunction with computelayout, this command performs the animated layout of a tree. It may be given a view, which forces the system to animate the system view while the tree animation is taking place. Use getlayoutbbox to calculate a view for the finished animation. See computelayout for specific implementation instructions.
Using animatelayout with the -view option forces an animation of the view as the tree is animating. The view animates from the current view to the one specified as the tree animation is taking place.
animateview tagOrId [value]
Sets the animateView flag at tagOrId. Controls whether or not a layout will animate the view when layout is called at tagOrId.
connect tagOrId
Draws links from tagOrId to its parent, and from tagOrId's children to tagOrId.
computelayout tagOrId
Computes the final layout state for a dynamic tree. This places final layout state information in the tree, some of which can be accessed in order to control the layout. For information on accessing some of this information, see the getlayoutbbox command.
This code computes the future layout of a tree, then animates its view so that the center of the tagOrId's future position is in the center of the screen at the end of the animation. Note that any treenode which is a descendant of tagOrId will return valid information on a call to get layoutbbox. Other nodes are not guaranteed to have valid information.
.pad tree computelayout $node set futureBbox [.pad tree getlayoutbbox $node] set view [bbcenter $futureBbox] .pad tree animatelayout -view $view
create tagOrId
Creates a treenode to monitor tagOrId. Creates default layout for treenode. Adds tagOrId to the padroot, in preparation for placement somewhere else in the hierarchy.
createroot
Creates an invisible root node which is used to organize subtrees of information, and returns the pad id of the dummy object at that node. Used to connect several nodes together so that they appear to be root nodes at the same level. Because this is an invisible node, no links will be drawn to it.
delete [-subtree] tagOrId
Delete the tagOrId and its associated pad object, layout, and link. By default, when there is no subtree option, tagOrId's children are promoted to be children of tagOrId's parent. If the -subtree option is used, the entire subtree and all of its associated data and pad objects are deleted.
getchildren tagOrId
Returns a list of the ids of the pad objects which are children of tagOrId
getfocus tagOrId
Returns the focus value at a tagOrId, which is a number on the interval [0.0, 1.0]
getlayoutbbox tagOrId
Returns the approximate bbox tagOrId will have at the end of the current animation. This is only valid when used after computelayout, and before any manipulation of any member of the tree. Moving or resizing any object affected by computelayout will cause a few bugs in the animation of those objects when animatelayout is called. The system will not break, but any moved object will first instantly move to the position it held when computelayout was called, and then will animte to the position computelayout determined for that object. Relative sizing of objects will be ignored by the system.
getlink tagOrId
Return the id of the item which graphically links tagOrId to its parent.
getparent tagOrId
Return the id of the parent of tagOrId.
getroot tagOrId
Gets the root node of tagOrId's hierarchy - the node which resides just below the padroot.
isnode tagOrId
Returns a boolean indicating whether or not tagOrId has a treenode attached to it, and is therefore a member of a hierarchy.
layout tagOrId [-view view]
Performs a recursive layout of the subtree rooted at tagOrId. If the -view option is used, the tree will animate to the view provided.
lower tagOrId [belowtagOrId]
Controls the position of tagOrId in the order of its siblings. If belowtagOrId is not provided, tagOrId is moved to the bottom of the list. If belowtagOrId is provided, tagOrId is moved to a position just above (after) belowtagOrId.
raise tagOrId [abovetagOrId]
Controls the position of tagOrId in the order of its siblings. If abovetagOrId is not provided, tagOrId is moved to the top of the list. If abovetagOrId is provided, tagOrId is moved to a position just above (after) abovetagOrId.
removenode [-subtree] tagOrId
Removes the treenode and layout objects associated with tagOrId. If the -subtree is not included, tagOrId's information is removed, and tagOrId's children are promoted. If the -subtree option is used, the entire treenode hierarchy is removed.
reparent [-subtree] tagOrId parenttagorid
Reparents tagOrId to belong to parenttagorid. The default case, in which the -subtree option is not used, reparents tagOrId, and promotes any children tagOrId may have to be children of tagOrId's original parent. If the -subtree option is used, the subtree rooted at tagOrId is moved.
setanimatespeed tagOrId milliseconds
Sets the time for an animation to occur. If this number is 0, the animation will proceed immediately to the end state. During an animation, if any event is detected, the animation will proceed to the end state. Thus, a double click on a treenode forces the animation to happen instantaneously.
setfocus tagOrId [value [levels [falloff]]]
Set the focus value at a tagOrId. This must be a number on the range [0,1]. If no value is provided, the focus is set to 1.0. The levels parameter controls the number of levels this focus is allowed to spread. The falloff parameter is a multiplier which controls the portion of focus which is passed on to the next level of recursion. For example, if this number is 0.75, then focus*0.75 of the focus is passed on at the next level of recursion.
setfocusmag tagOrId value
Recursive set command - works on the entire subtree of the tagOrId is is given. Set the magnification difference between an object of focus 0 and an object of focus 1.
setscale tagOrId value
Set the scale that an object will have when its focus is 0. This is the smallest size that an object will have in a dynamic tree. When a tree tagOrId is created, this value is automatically set to the z value of the object.
setspacing tagOrId xvalue [yvalue]
Set the x and y spacing at a tagOrId. This is the amount of spacing between a tagOrId and its spatial neighbors.
[78] pathName
type tagOrId
Returns the type of the item given by tagOrId, such as rectangle or text. If tagOrId refers to more than one item, then the type of the first item in the display list is returned. If tagOrId doesn't refer to any items at all then an empty string is returned.
[79] pathName update [-dissolve speed [withRefinement]]
This forces any outstanding updates to occur immediately. If the -dissolve flag is specified, then speed determines how quickly the update is done. If speed is 0, the update will happen quickly with a swap buffer. If speed is between 1 and 3, the update will happen with a dissolve effect where 1 is the fastest and 3 is the slowest. If the withRefinement flag is specified, this forces all refinements to occur immediately as well - which could be a slow process. Returns an empty string.
[80] pathName urlfetch URL ?option value ...?
pathName urlfetch Token
where valid options are:
-file <filename>
-var <variable>
-updatescript <updateScript>
-donescript <doneScript>
-errorscript <errorScript>
Retrieves the specified URL (Universal Resource Locator) from the World Wide Web. This command returns immediately, and the retrieval is done in the background (within the same process using a file handler.) As portions of the data comes in, updateScript will be executed, and doneScript will be executed when all of the data has completely arrived. If there are any errors retrieving the data, then errorScript will be executed. urlfetch returns a token that can be used to interact with this retrieval. This token is appended to updateScript, doneScript and errorScript when the scripts are executed.
There are three methods to access the data retrieved by urlfetch. The first method is to specify a file (with -file) in which case the data is written to that file as it is retrieved. The second method is to specify a Tcl variable (with -var) in which case the data is stored in that global variable as it is retrieved. The variable will be updated with the current data before updateScript and doneScript are executed. Note that the variable is not cleared by urlfetch and it is the responsibility of the caller to free it (with unset). The third method is to use the second form of urlfetch by passing it url token during an updatescript callback in which case it will return the data retrieved by that fetch. Three code segments follow which show the use of urlfetch.
#
# urlfetch example using a file
#
proc done {filename token} {
set file [open $filename "r"]
... # handle file
}
set file "foo"
.pad urlfetch http://www.cs.unm.edu -file $file \
-donescript "done $file"
#
# urlfetch example using a Tcl global variable
#
proc done {token} {
global foo
... # handle data in "foo"
unset foo ;# no longer need URL data
}
.pad urlfetch http://www.cs.unm.edu -var foo \
-donescript "done"
#
# urlfetch example using a token to incrementally
# handle data as it comes in.
#
proc update {token} {
set data [.pad urlfetch $token]
... # handle incremental data
}
.pad urlfetch http://www.cs.unm.edu \
-updatescript "update" -donescript "done"
[81] pathName windowshape [innercoords outercoords]
Changes the shape of the top-level window containing the pad widget specified by pathName. The two parameters each specify lists of coordinates that specify the shape of the window. All coordinates are scaled to fit the existing width of the window, larger numbers in X go to the right, and larger numbers in Y go up. innercoords represents the area that can be painted in, and outercoords represents the overall window shape. The difference between these two shapes becomes the windows border. If innercoords and outercoords are both empty strings, then the window returns to its default rectangular shape. This command returns the current window shape.
For example, the following command changes the top-level window shape to an inverted triangle.
.pad windowshape {0 50 50 50 25 0} {0 50 50 50 25 0}
[82] pathName
write filename [tagOrId tagOrId ...]
Writes the Tcl commands necessary to recreate the items on the Pad++ surface into filename. If tagOrId's are specified, then just those items are written out. The file that is written out should be read back in with the read command. If filename is an empty string, than this command returns the string instead of writing it to a file. If a valid filename is specified, then this command returns an empty string.
Only non-default slots of each object are written out.
As the write command writes out objects on the pad, it generates a <Write> event for each item it writes. The return string from the <Write> event handler will be appended to whatever string this function writes out for each item. See the bind command for more information on this.
[83] pathName zoom zoomFactor padXloc padYloc [animateTime [portalID ...]]
Zoom around specified pad position by multiplicitive factor. If animateTime is specified, then animate the zoom and take animateTime milliseconds for the animation. If an optional list of portals is specified, then change the view within the last portal. The entire list is necessary in case the last portal is sitting on a different surface then this function is called with. Returns an empty string.
Generated with Harlequin WebMaker