Auxiliary plt functions

If fmtstr is of the form '%nv' then s will be the string representation of x with the maximum resolution possible while using exactly n characters - not counting the decimal point if one is needed. If the field width is too small to allow even one significant digit, then '0' is returned.

These formats are typically used to generate strings to fit into gui objects of a fixed width. The reason the decimal point is not counted is that with the proportional fonts generally used in these gui objects, the extra space taken up by the decimal point is insignificant.

fmtstr may also use any of the numeric formats allowed with sprintf. For example:

plt('ftoa','%7.2f',x) is equivalent to sprintf('%7.2f',x)

 

 Examples:

disp(['numerator polynomial = ' plt('vtoa','%6.2f',bc)]);

fprintf(fID,'%6d: sloss=%6.1f, coef = %s\n',...
        ntry,sloss,plt('vtoa','%5w',coef));
 

except that it displays the time with 1 millisecond resolution instead of 1 second resolution used by the Matlab datestr function. You should only use formats that include the number of seconds in the result. If fmt is not included in the argument list, format 0 is assumed. For example:

a = now; [plt('datestr',a) '   ' datestr(a)]

Will respond with something like:

21-Jan-2007 10:28:02.898   21-Jan-2007 10:28:03

Type help datestr for a description of the allowable formats. You will find format 13 useful when the date is not required, i.e. plt('datestr',now,13) which will return something like: 10:28:02.898

 

[Ret1, Ret2] = plt('metricp',x);

Used to converts a number to a form using standard metric prefixes. Ret1 is the metric prefix (in Ascii) that is most appropriate for displaying the value x, and Ret2 is the number you should multiply x by. For example, if x is in volts, you can display it using a metric prefix as:

[pfix, mult] = plt('metricp',x);
disp([num2str(x*mult) ' ' pfix 'Volts']);

 

plt('grid',ax,'init',color,erMode,In6,In7,In8,In9)
     - Initializes grid lines of color color with erase mode + on axis ax.
              color is optional with default [.3 .3 .3] and erMode is optional with default 'xor'.
          -  In6,In7 is an optional parameter/value pair to apply to the grid lines
          -  In8,In9 is an optional parameter/value pair to apply to the grid lines

plt('grid',ax,'toggle')      - toggle grids (on/off)

plt('grid',ax,'get')      - get current on/off state of grids

plt('grid',ax,'off')      - turn grids off

plt('grid',ax,'on')       - turn grids on

plt('grid',ax,'update')   - update grids

plt('grid',ax)            - update grids (same as above)

All the above calls return 1 if the grids are on and 0 otherwise.

To experiment with these functions, try typing this at the command prompt:

>> a = axes;             % create axis
>> plt('grid',a,'init'); % draw grid lines
>> set(a,'ylim',[0 6]);  % change axis limits
>> plt('grid',a);        % update grid lines

 

The above calls create the edit text object and returns the handle of the text object created. This handle (H) is used as an argument in the calls below:

plt('edit',H,'PropName1','PropVal1','PropName2','PropVal2',...);
If H is a scalar, the specified property values (using items from the table above) are applied to the edit text object identified by handle H. If H is a vector then PropertyName1 of H(k) is set to the kth row of PropertyValue1. If PropertyValue1 doesn't have that many rows, the last row will be used. Only 1 property is allowed.

plt('edit',H,'get','value')
returns the numeric value of the specified edit text object

Keyboard and mouse behavior:
Right clicking on the edit text object always "opens" the object for editing. What this means is that the old edit string appears with the cursor (underscore) at the end of the string indicating that it is ready to accept keys typed at the keyboard. If you start typing right away, the new characters typed will be appended to the end of the old string. To insert the new characters at a point other than the end, simply move the cursor to the desired point using the left/right arrow keys. To remove characters, press <Backspace> or <Delete> to remove a character before or after the cursor. Pressing <Delete> when the cursor is at the end of the string deletes all the characters. This special case makes it easier to enter a new string that bears little resemblance to the previous entry. Note that while typing, the text object is shown in a different color to remind you that a new value is being entered. When you press <Enter>, the new string is accepted and the color returns to the original. If you type an invalid entry, the word "error" will appear. Click again on the "error" string to try the entry again or to recover the previous entry (via <Esc>). A summary of the special keys follow:
 

<Esc>	The edit text object is closed for editing and the original text value is restored as if the edit object was never opened for editing.
<Backspace>	Deletes the character on the left side of the cursor.
<Delete>	Deletes the character on the right side of the cursor. If the cursor is at the end of the string, all the characters are deleted leaving only the underscore cursor.
<Right arrow>	Moves the underscore cursor one position to the right.
<Left arrow>	Moves the underscore cursor one position to the left.
<Enter>	Closes the edit text object, accepting the current entry (without the underscore cursor) as the new value.
<Click>	Clicking the mouse on the edit text object while it is open has the same effect as pressing <Esc> on the keyboard.
i	When entering a scalar value, if lower case "i" (increment) is entered as the last character, this indicates that the entered value should be used as a new "incr" parameter for the object. In this case the text object value from before the object was opened is retained.

Left clicking on the edit text object also opens the object for editing except for one important exception. This exception happens when both of the following conditions are met:

• The edit text object is a scalar (i.e. the length parameter is equal to one).
• The current edit object value is an exact multiple of the "incr" parameter.

Under those conditions, when you left click on the edit text object, its value is incremented or decremented by the object's "incr" parameter. Weather the value is incremented or decremented depends on the position of the mouse click. If you click to the right of the edit object's center, the value will be incremented. Likewise, the value will be decremented for clicks to the left of center. As an example, suppose the current edit text object has a value of 259, and the increment parameter is 1. Left clicking on the 9 will change the edit object's value to 260 (because the 9 is right of the center of the text string). On the other hand, left clicking on the two will decrement the value by one. Now suppose you right click on the object and type "259.5<enter>". The new edit object value becomes 259.5, which you will note is not an even multiple of "incr". Because of this, additional left clicks will not increment/decrement the object's value as before. However left clicks will again increment/decrement the control value after either of the following actions:

• Clicking on the object and entering an integer value into the control
• Clicking on the object and entering ".5i" (or any other number than evenly divides 259.5).

Whenever a number is being typed in, you may also type an expression instead. For example, the following entries are all equivalent:

• 5

• abs(3+4i)

• [2 1] * [2 1]'

• sqrt(3*2^3-cos(pi))

Typing sum(get(gca,'xlim').*[0 1])' would be equivalent to typing in the current upper x axis limit. And to be really perverse, typing log(-1)/(2*pi) would be equivalent to the ".5i" entry mentioned above.

See the curves.m example program for an example of how to use edit text objects as well as the popup text objects described below.
 

The above calls create the popup text object and returns the handle of the text object created. This handle (H) is used as an argument in the calls below:

plt('pop',H,'PropName1','PropVal1','PropName2','PropVal2',...);
If H is a scalar, the specified property values (using items from the table above) are applied to the popup text object identified by handle H. If H is a vector then PropertyName1 of H(k) is set to the kth row of PropertyValue1. If PropertyValue1 doesn't have that many rows, the last row will be used. Only 1 property is allowed.

plt('pop',H,'get','index')
returns the index of the currently selected choice (1 = 1st choice)

plt('pop',H,'get','string')
returns the string corresponding to the selected choice.

plt('pop',H,'get','choices')
returns the cell array of choices.

Mouse behavior:
Left clicking on the popup text object "opens" the popup. What this means is that the popup string is replaced by a list of the popup choices (rendered using colorfr/colorbk). The user then clicks on the desired choice which then becomes the new text string. Right clicking on the popup text object changes the text string to the next available choice. If the last choice is already selected, then right clicking will change the text string to the first available choice (in the "choices" array).

See the curves.m example program for an example of how to use popup text objects as well as the edit text objects described above.
 

To use a slider to enter a numeric value in a gui application, besides the slider object itself one generally also wants an edit box to show the current slider value as well as to allow data entry by typing the number. Usually a label is required to identify the data and two fields that indicate the minimum and maximum values allowed are also handy. The pseudo slider object combines these five objects into one and is included in plt since many gui applications designed around plt may require sliders. To create a slider, use the command:

H = plt('slider',In1,In2,In3,In4,In5,In6,In7)

For the commands below, H is the handle returned from the above slider initialization command.

The get commands:

The set commands: