Before I concentrate on the FujiNet and SQL bindings for the library, I have made one last update to add a new gadget and input function. I also added some screen shots to the documentation to make it easier to visualize what some of the gadgets do. This is the 1.5 release.

Gadget added: GSpin()

Numeric input spinner control.

Input added: WaitKCX()

This function expands on WaitKC. It is intended for XL/XE computers and will properly handle the HELP key, and F1 through F4. It will also handle the inverse key found on all 8 bit lines, as well as toggle the case when CAPS is pressed.

Input modified: WaitKC()

This function will now handle toggling the case when CAPS is pressed.

The disk image is ATR, however, it was uploaded with a “.ODT” extension due to hosting provided restrictions. Simply download it, rename it so “.ATR” is the only extension. The API documentation is in PDF format.

Version 1.6 will include the FujiNet and SQL bindings. I do not have an ETA on that release yet.

Downloads

Library ATR file (ActionLibV15.ATR):

Library PDF API Document (ActionLibReference_150-A.pdf):

Here is a video of a sample application written using the library and its latest features:

Enjoy.

I’ve been working on a new program and decided I needed a numeric input spinner rather than using the GInput() gadget I wrote before. The GInput gadget works well and can limit to entry to numeric fields, but when using it with small numbers that are only 1 or 2 digits wide, it becomes confusing to use due to the cursor movement across that limited cell count. On top of that, there is numeric conversion from the string that GInput returns that must be dealt with in accommodating numeric sizes.

This new gadget is designed for small numbers (bytes) from 0 to 100. It can be used for number values up to 252. The last 3 values are reserved for gadget and form control. It increments and decrements with up, down, left, and right keys. It also allows for limiting the value to a lower and upper value.

Here I present the new function in my gadget library called GSpin(). This function can be used on an input form with other input gadgets or by itself. It will be included in the next release of the library. Essentially when it becomes active, the value is inversed and updated as the keystroked move the value up and down.

Code

; --------------------------------------
; Func..: GSpin(BYTE bN,x,y,bL,bM,bP)
; Desc..: Displays value and spin 0 to 100
; Params: bN = Window handle number
;         x = Column of window to place spinner
;         y = Row of window
;         bL = Lowest value
;         bM = Max value
;         bP = initial value
; Req...: LIBWIN.ACT
;         LIBSTR.ACT
; --------------------------------------
BYTE FUNC GSpin(BYTE bN,x,y,bL,bM,bP)
BYTE bD,bK,bR
CHAR ARRAY cL(4)

; Set working value
bD=bP

; Loop until exit
DO
  ; Convert to string & inverse
  StrB(bD,cL)
  StrPad(cL,32,3)
  StrInv(cL,cL(0))

  ; Print value at spot
  WPrint(bN,x,y,cL)

  ; Get key
  bK=WaitKC()

  ; Process keystroke
  if bK=KLEFT or bK=KPLUS or bK=KDOWN or bK=KEQUAL then
    bD==-1
    if bD<bL then bD=bL fi

  elseif bK=KRIGHT or bK=KASTER or bK=KUP or bK=KMINUS then
    bD==+1
    if bD>bM then bD=bM fi

  elseif bK=KESC then
    bR=XESC 

    ; Convert to string
    StrB(bP,cL)

    exit

  elseif bK=KTAB then
    bR=XTAB

    ; Convert to string
    StrB(bP,cL)

    exit

  elseif bK=KENTER then
    ; Set return value
    bR=bD

    ; Convert to string
    StrB(bD,cL)

    exit
  fi
OD

; Redisplay value
StrPad(cL,32,3)
WPrint(bN,x,y,cL)

RETURN(bR)

Screenshots

The first is during editing:

The second shows the return value:

Deprecated:

Use new version here: https://unfinishedbitness.info/2022/07/17/action-library-v1-5/

Original Post

I fixed several issues in my Action! library, and have added many new features. I was going to release this as version 1.5 once I complete some FujiNet and SQL bindings. Those are taking a little longer than anticipated due to time availability.

The functions published individually since the last library update are included, as well as new fully documented API with sample source code. The sample source programs are also included on the library disk.

The disk image is ATR, however, it was uploaded with a “.ODT” extension due to hosting provided restrictions. Simply download it, rename it so “.ATR” is the only extension. The API documentation is in PDF format.

Version 1.5 will include the FujiNet and SQL bindings. I do not have an ETA on that release yet.

Downloads

Library ATR file (ActionLibV14.ATR):

Library PDF API Document (ActionLibReference_140-C.pdf). (If you downloaded this on or before 2202.07.13, download it again as it has a few corrections). This is revision C and the title page now references it:

Here is a video of a sample application written using the library and its latest features:

Enjoy.

In the last post I showed a function to trim a string.  In this post I go the other way and demonstrate how to pad one.  This is useful when trying to print data in alignment.

The Function

This function was primarily written to left pad numbers.  As such there is a limit of 10 in length which is longer than the longest Action! number.  The code is again pretty well documented and will be including in the next release of my Action! library.  Here is short summary of how it works.

The procedure is called with 3 parameters.  The first is a pointer to a character array, which can not be a static string and must be a variable because the length will be altered.  The second parameter is the character you want to pad the string with.  Common values are space and zero.  The third parameter is the length to pad to (no more than 10).

First the procedure fills a temporary string with 10 of the desired pad character.  Next it copies the incoming string into the padded temporary string at the furthest right position to accommodate the length of the incoming string, essentially right justifying it.  Next the temporary padded string is copied back to the incoming string pointer, and the incoming string length is set to the specified pad length.

; --------------------------------------
; Proc..: StrPad(CHAR POINTER pS CHAR bc BYTE bL)
; Param.: pS=Pointer to string to pad
;         bC=Character to pad with
;         bL=Length to pad to
; Desc..: Left pads a string with a char
; Notes.: Max of 10 in length.
; --------------------------------------
PROC StrPad(CHAR POINTER pS CHAR bC BYTE bL)
; Declare a string filled with 10 spaces
CHAR ARRAY pA="          "

; Fill the temp string with desired char
; Use pA+1 which is the first character of the string.
; pA is the length of the string so skip over it.
SetBlock(pA+1, 10, bC)

; Copy incoming string into temp string
; Use desired length - incoming string length + 1 as position in temp string
; which puts incoming string at correct rightmost spot to accommodate its length.
SAssign(pA, pS, bL-pS(0)+1, bL)

; Copy newly padded temp string to incoming string
SCopy(pS, pA)

; Set incoming string pointer to new length
pS(0)=bL

RETURN

Sample Usage

Here is a short program demonstrating it usage.  Note that in this example the StrPad() function is not seen as its been incorporated into the LIBSTR.ACT file as part of my Action! library.  This will pad a byte, a card, and int to various lengths.

INCLUDE "D3:DEFINES.ACT"
INCLUDE "D3:LIBSTR.ACT"

PROC Main()
; Declare a byte, a card, an integer, and character array of 10 in length
BYTE bnum
CARD cnum
INT inum
CHAR ARRAY snum(10)

; Pad single character length byte to 2 positions with 0 character
bnum=1
; Convert the number into a string
StrB(bnum,snum)
; Call the pad function, passing the string, the pad character, and pad length
StrPad(snum, '0, 2)
; Show result
PrintF("Num: (2) [.....1]->[%S]%E",snum)

; Pad two character length byte to 4 positions with 0 character
bnum=21
; Convert the number into a string
StrB(bnum,snum)
; Call the pad function, passing the string, the pad character, and pad length
StrPad(snum, '0, 4)
; Show result
PrintF("Num: (4) [....21]->[%S]%E",snum)

; Pad five character length card to 5 positions with 0 character
cnum=64256
; Convert the number into a string
StrC(cnum,snum)
; Call the pad function, passing the string, the pad character, and pad length
StrPad(snum, '0, 5)
; Show result
PrintF("Num: (5) [.64256]->[%S]%E",snum)

; Pad five character length int to 8 positions with space character
inum=24768
; Convert the number into a string
StrI(inum,snum)
; Call the pad function, passing the string, the pad character, and pad length
StrPad(snum, 32, 8)
; Show result
PrintF("Num: (8) [.24768]->[%S]%E",snum)

; Pad six character length negative int to 8 positions with space character
inum=-24768
; Convert the number into a string
StrI(inum,snum)
; Call the pad function, passing the string, the pad character, and pad length
StrPad(snum, 32, 8)
; Show result
PrintF("Num: (8) [-24768]->[%S]%E",snum)

RETURN

Output

Here is the output showing that it works:

This post will demonstrate a function to trim a string.  By trim, I mean to remove all trailing spaces and stop at the first non space character.

The Function

Here is the function, which I’ve added to my Action! library.  A new version will be released soon that will include recent additions and many fixes.  It’s pretty well documented, but here is a short summary.

The procedure is called by passing a reference to a character array in (the string you want to trim).  This procedure will modify it directly, so it can not be a static string and must be a variable.  The procedure will start by setting a counter to the length of the incoming string.  It will move from the end to the beginning by decreasing this counter.  It examines the character at the counters position in the string.  If it’s a space, it sets the the new string length to the counter position minus one (to eliminate the space).  If it’s not a space, the procedure exits having found a termination point.   Each iteration through the loop, the counter is decremented by one to move one character left.

; -------------------------------------- 
; Proc..: StrTrim(CHAR POINTER ps)
; Param.: pS=Pointer to string to trim
; Desc  : Trims space from string end
; -------------------------------------- 
PROC StrTrim(CHAR POINTER pS)
BYTE bL,bC

; Set counter to end of string 
bL=pS(Ø)

; Loop from string end to start 
while bL>=1
DO
  ; If char is space, set len to curr-1 
  if pS(bL)=32 then
    bC=bL-1 
  else
    ; Char is not space, exit loop
    exit
  fi

  ; Decrease counter
  bL==-1 
OD

; Set string pointer length to new value 
pS(Ø)=bC

RETURN

; Include library file that has StrTrim() in it.
INCLUDE "D3:LIBSTR.ACT"

MODULE

PROC Main()
; Declare character array of 20 in length
CHAR ARRAY cA(20)

; Copy some content in the char array defining all 20 chars
SCopy(cA,"12345 abc !         ")

; Print it to show a valid padded definition
PrintF("B4 : [%S]%E",cA)

; Call the trim function passing the char array pointer
StrTrim(cA)

; Print it again to show its been trimmed
PrintF("Aft: [%S]%E",cA)

RETURN

Over the course of my interactions with Action!, for whatever reason, I never had a need for defining a string value.  While numeric definitions are cake, string ones turned out not to be so much.

Let’s explore what I wanted to do.  I wanted to compare a variable that was input against a static string.  Why not just hard code the string?  Well, it is used in multiple locations, and having it DEFINEd makes it easy to change in all of them at once.  Thats the whole point of using DEFINE.  The source code I wanted to write:

if SCompare(sA, SSREADY) = 0 then

So using a define for SSREADY in an INCLUDEd source file accomplishes the goal of making it easy to change in just one place and use it multiple times across projects.  Something like this was needed for my code work:

DEFINE SSREADY = "TEST"

That works for numbers with no problem:

DEFINE NVAL = "100"

Anywhere that NVAL is found in the source, it will be replaced with 100.

So what is the issue?  Used in the context of SCompare above, it ends up producing code like this:

if SCompare(sA, TEST) = 0 then

Obviously thats not the intent of the source and it won’t work, and the compiler will tell you so immediately.  The compiler will think TEST is an undefined variable.  The word TEST needs double quotes around it.  Thats the goal.

Reading through the manual you will understand that in order to print double quotes, you have to precede each one with another.  Such as:

PrintE("Hello ""world""!")

which produces the output:

Hello "world"!

So moving back to the DEFINE statement it appears it needs to look like this:

DEFINE SSREADY = ""TEST""

But that doesn’t work either.  The compiler doesn’t like it.  The solution is to wrap the dual double quoted value in another set of double quotes.  But there is a caveat – they can not be all run together, or the compiler doesn’t understand which two of the 3 should be translated into a single double quote.  So you need to place a space between the DEFINE’s double quotes and the values double quote pair.  The proper syntax for DEFINEing a string value is:

DEFINE SSREADY = " ""TEST"" "

Here is a sample program that demonstrates this concept:

DEFINE NVAL = "100"
DEFINE SVAL = " ""TEST"" "

PROC Main()
PrintF("NVAL=[%B]%E",NVAL)
PrintF("SVAL=[%S]%E",SVAL)
RETURN

Deprecated:

Use the latest version found here: https://unfinishedbitness.info/2022/07/17/action-library-v1-5/

A few people have been following the Action! posts and attempted to compile the code only to find there were some missing unpublished routines (unfinished bits 😉 ).  The routines do in fact exist.  I thought I had published all of it in pieces, apparently not.  Attached here is the complete library.  You will need to remove the .ODT file extension leaving just .ATR.  It is NOT an ODT file, WordPress wouldn’t allow the ATR file type.

Hopefully it helps you.