Unfinished Bitness

Looking at LOGO

Posted by Ripdubski on 2016.12.21

Posted in: Atari, Programming. Tagged: Atari LOGO, Atari ST-LOGO, LOGO Language. 4 Comments

For my “1632 Atari podcaST” I had the opportunity, or need, to look at the LOGO language implementation by Atari for the Atari ST computer. Back in the 80’s I gave LOGO a passing glance, and thought it was only for turtle graphics. I have now learned that turtle graphics is but a small part of the overall language. I thought it would be fun to learn more about LOGO, and give it the chance I didn’t before. To that end, I set out to write a “Guess My Number” program. In this post, I describe how I did it, provide the source code, and describe how it works.

I set out writing this on the Atari ST using Atari ST-LOGO. I got it all complete except the looping mechanism to keep retrieving guesses until the number is found. I really got hung up on this, and just about gave up. LOGO as a language does not have the benefit of being blessed by a standards committee. Thus each implementation, while sharing core support of the language, offers dialect differences. And just try searching for LOGO resources without pulling back company logo’s, or logo creation, etc.

Since Atari ST-LOGO is buggy and I was having problems saving and loading, I reverted to the Atari 8 bit implementation “Atari LOGO”. I stumbled along with the program and got hung up with the same program flow or looping failure. Failure on my part, not the language.

After posting in the “Inverse ATASCII” Facebook page about a different error I was getting regarding and IF statement that needed to PRINT throwing an error, I received a suggestion from Colin about how to package the PRINT portion of the statement. This worked. Then I had to tackle the looping construct. Unlike other languages there are no built in conditional loop constructs such as WHILE. There is a REPEAT but it needs a finite number of executions to be specified. The answer was creating a WHILE procedure, and breaking the guess input into a procedure and the guess check into a procedure.

One of the quirks with LOGO is how it handles variable references. When declaring one, you use the MAKE primitive and precede the variable name with a single double-quote. Then when referencing it, you precede the name with a colon. This took some getting used to.

First I will present the entire source, then I will break it down.

Entire Source (Atari 8 bit LOGO)

TO WHILE :CONDITION :INSTRUCTIONLIST
IF NOT RUN :CONDITION [STOP]
RUN :INSTRUCTIONLIST
WHILE :CONDITION :INSTRUCTIONLIST
END

TO CHKGUESS
IF ( FIRST :GUESS ) < :NUM [PRINT [Too low]]
IF ( FIRST :GUESS ) > :NUM [PRINT [Too high]]
IF ( FIRST :GUESS ) = :NUM [PRINT [You guessed it!]]
END

TO GETGUESS
PRINT SE [Guess #] :TRY
MAKE "GUESS RL
MAKE "TRY :TRY + 1
END

TO GUESSNUM
MAKE "NUM 1 + RANDOM 100
MAKE "TRY 1
MAKE "GUESS 0
PRINT [I have a number between 1 and 100]
PRINT [What is it?]
WHILE [NOT ( FIRST :GUESS ) = :NUM] [GETGUESS CHKGUESS]
END

Breakdown

The first routine is the LOGO implementation of a WHILE loop. The command is not native and must be written! This implementation is straight out of the Atari LOGO Reference Guide. The first line declares the procedure named WHILE taking two argument variables CONDITION and INSTRUCTIONLIST:

TO WHILE :CONDITION :INSTRUCTIONLIST

This line causes execution to stop if the condition is no longer tested as true:

IF NOT RUN :CONDITION [STOP]

This line causes the passed instruction list to be executed:

RUN :INSTRUCTIONLIST

This line is a recursive call to itself. This keeps the loop moving:

WHILE :CONDITION :INSTRUCTIONLIST

This line terminates the procedure:

END

The next procedure checks the users guess and responds appropriately. This procedure is called repeatedly during the game immediately following the GETGUESS procedure. Both as part of the WHILE loop instruction list. The first line declares the routine named CHKGUESS taking no arguments:

TO CHKGUESS

This line checks if the guess is less than the number and prints “Too low” if so. Because the variable GUESS is actually a list, you must specify the first element of the list. This evaluation must happen before the comparison so it is encapsulated in parenthesis (). The value returned by (FIRST :GUESS) is then compared to :NUM (the random number). If the guess is less, the user is informed its too low. The words “Too low” are encapsulated in square brackets to treat it as one string. The entire PRINT command is also encapsulated in square brackets which suppresses it returning a value to the IF statement. Without, the line will always evaluate, inclusive of printing too low, and then generate an error.

IF ( FIRST :GUESS ) < :NUM [PRINT [Too low]]

The remaining lines handle the “too high” (greater than), and “you guessed it” (equivalence) conditions:

IF ( FIRST :GUESS ) > :NUM [PRINT [Too high]]
IF ( FIRST :GUESS ) = :NUM [PRINT [You guessed it!]]
END

The next procedure gets a guess from the user after displaying their current attempt number. The first line declares the routine named GETGUESS receiving no arguments:

TO GETGUESS

This line prints the guess (attempt) number. It uses the PRINT suffix SE which is short for SENTENCE. SENTENCE prints each list element following it. The first element is [Guess #] which is encapsulated in square brackets [] to treat it as one string. The second element is the variable TRY, which is the counter for the guess (attempt) number:

PRINT SE [Guess #] :TRY

This line gets input from the user using the RL (READLINE) command and assigns the output to the variable GUESS:

MAKE "GUESS RL

The next line increments the guess (attempt) number by one:

MAKE "TRY :TRY + 1
END

Finally, the last procedure is the main procedure for the game. In this procedure the game variables are initialized, game instruction is displayed, and the game loop started. The first line declares the procedure named GUESSNUM receiving no arguments:

TO GUESSNUM

The next three lines declare the game variables NUM, TRY, and GUESS. NUM is declared to be 1 plus a random number between 0 and 100 (0 to 99), so we end up with a number between 1 and 100. TRY is set to 1 (first attempt), and GUESS is set to 0:

MAKE "NUM 1 + RANDOM 100
MAKE "TRY 1
MAKE "GUESS 0

These two lines simply display the game instruction. Both encapsulate the text to be displayed in square brackets to treat them as one string:

PRINT [I have a number between 1 and 100]
PRINT [What is it?]

This line starts the process of retrieving a guess from the user and checking it against the random number. WHILE is the first procedure defined above. It takes a condition list, and instruction list. The condition list is “[NOT (FIRST :GUESS) = :NUM]”, and the instruction list is [GETGUESS CHKGUESS]. This first evaluates the first element in the GUESS variable list, compares it to the NUM variable and applies NOT. If the guess is not the number, then the instruction list is executed:

WHILE [NOT ( FIRST :GUESS ) = :NUM] [GETGUESS CHKGUESS]
END

Atari ST-LOGO Modification

To make this work on the Atari ST, it required a minor modification. The PRINT line in the GETGUESS routine needs to be changed. The # sign causes an error so it must be removed. Because that shortens the text by also removing the preceding space, the square brackets [] can be removed, but must be replaced with a single double-quote preceding the word Guess:

TO GETGUESS
PRINT SE "Guess :TRY
MAKE "GUESS RL
MAKE "TRY :TRY + 1
END

Results

Running on the Atari 8 bit under Atari LOGO:

Running on the Atari ST under Atari ST-LOGO:

One thing this language offers is native support for building and managing linked lists, which is very nice, but I think I’m about done with LOGO for now.

Backing up the backups

Posted by Ripdubski on 2016.09.11

Posted in: NAS. Tagged: Backup, DiskStation, Dropbox, Offsite, Synology. 1 Comment

Until you’ve experienced data loss first hand, or have seen someone go through the process of loss and recovery, you probably don’t pay much attention to backups. I’ve been backing up my data regularly since the mid 1990’s. A few years ago, a backup saved my bacon, and taught me a valuable lesson. Here I detail the importance of backups, and tell you how to make them easy.

You may be thinking, so what, it won’t matter if I lose some documents. Sure, an annoyance, but not severe. But what about your family photos, your financial records, amongst others? Some are not easily reproduced, others simply can’t be.

Causes

There are a bunch of other reasons you want a backup for.

Device Failure

The hard drives in our computers are mostly silent and go largely un-noticed. The question is not “if” they will fail, it is “when” they will fail. As with any device, the hard drive in your computer has a service lifetime. Most desktop and laptop hard drives spin at between 5400 rpm and 7200 rpm. There are a myriad of things that can go wrong and cause a failure, including rated life span.

Theft / Lost

It happens. Your desktop computer could be stolen from your home, or you might lose your laptop. So you say you have them backed up to an external USB drive. OK, but what about the following?

Flood / Fire / Natural Disaster

Yes, these things can ruin all of your equipment in a hurry.

Aliens

It might happen. You never know.

Backup Planning

The first thing you want to do is make a backup plan. You need to identify what needs backed up, their location, and how it will be done.

Here are some items you might want to consider. You will need to have the directory location on your hard drive for each one:

Pictures
Home Movies
Checkbook data files
Tax software data files (returns)
Legal documents in PDF form
Awards / Certificates in PDF form
Source code (if you’re a programmer)

Now you must decide how the backups will be done. There are a plethora of options available.

External Hard Drive

Backing up to external hard drive is great first step. It’s easily accessible if you need to restore. This protects you from primary hard drive failure, but only doing this leaves you susceptible to failure of the backup device, and to all the other causes outlined above.

You should have at least two (2) external hard drives. One should be stored AWAY from the computer being backup up, in the same geo location. The other should be stored offsite, which could be a relatives house or safe deposit box. The idea is that you swap them out after each backup so the most current is local, and the previous one is offsite. If you keep it at a persons house, you will want to make sure it is encrypted. Encrypting it isn’t a bad idea anyway, just in case it is stolen.

This method will yield 2 to 3 copies of your data, depending on if you rotate a 2nd device offsite.

Network Attached Storage (NAS)

This is like an external hard drive backup, but you don’t have to plug it in each time because it is connected to, and accessible on your network. This removes some physical hassle out of doing the backup. However, a NAS device isn’t very suitable to offsite swapping. It is also still susceptible to the disaster scenarios.

The beauty of a NAS is how they can be configured. When implementing a NAS solution, you should look for one that employs at least two (2) drives. When configuring the system, make sure the drives are mirrored (RAID 1). This effectively cuts the storage capacity in half, but if one of the drives fails, the data is still intact on the other one. So if you get a NAS with two 4TB drives, you won’t get 8TB of storage, you’ll get 4TB. With two mirrored drives, you will have 3 copies of your data after a backup is completed.

Another feature some NAS devices offer is the ability to upload data to an offsite Internet Storage provider (see Internet Storage below). This eliminates the physical loss scenarios, and gives you one more copy of your data.

Internet Service

You could use an internet service for backup, which works by using software installed to your computer to upload your data to the providers data center (aka: in the cloud). These often run completely automated, removing all barriers to performing the backup.

Consider the sensitivity of the documents you choose to backup. You may want to encrypt them locally and only have the encrypted versions backed up. Unless of course you completely trust the company providing the service to a) keep your data out of employees hands; b) employ adequate account security to prevent outside access.

Some providers examples are (in no particular order): Carbonite, Crashplan, Mozy, and Amazon Glacier. It’s noteworthy to mention that I tried Amazon Glacier and was not pleased with how the data files are stored. They are plenty secure, but the container names are encoded in such a way that you can’t tell which file is which without using a client that can read the index.

Internet Storage

Similar to the Internet Services above, but these are just storage. You will need to perform the backups by copying files on a schedule you set. Some of them can do some degree of synchronization for you, helping to reduce the burden of rememberance. These typically have smaller storage pools available than the Internet Services, unless you pay extra.

Some examples are (in no particular order): DropBox, Box, Google Drive, OneDrive, etc.

Make It Happen

You’ve identified the what and how. Now what? Implement it!

How I Did It

Let’s look at how I implemented a backup solution. This may help you decide how you want to.

First I divided my primary documents folder into two sections:

Local Only: Documents placed here are only backed up locally. These include correspondence, instructions downloaded, owners manuals, etc. Basically stuff that is not critical if it is lost, or can be easily replaced. These files are still susceptible to the physical loss scenarios.
Offsite: Documents placed here are backed up locally, AND to an offsite location. These include checkbook data, tax returns, bank statements, certifications, legal documents, etc. These files are no longer susceptible to ANY of the loss scenarios.

Next I created a backup script. This script creates a tar file of the Offsite documents, and a separate tar file for my pictures. It then creates a zip file of each tar file. This zip is done with a long encryption key that only I know. You’ll see why the encryption is done shortly. Then the script removes the tar files, and copies the zip files to my NAS drive in a Backup folder. Once copied, the zip files are removed as well. An example of the backup script is here:

#!/bin/sh

iALL=0
iDocs=0
iPics=0
iDebug=0
cUser=`whoami`
cPass=""

# -------------------------------------------------------------------
# Function......: DoSyntax
# Description...: Displays Syntax
# -------------------------------------------------------------------
function DoSyntax {
    echo "Syntax: backup.sh [-a] [-d] [-p][-x]"
    echo "        -a = Backup all"
    echo "        -d = Backup Documents"
    echo "        -p = Backup Pictures"
    echo "        -x = Debug mode (perform no actions)"
    exit 1
}

# -------------------- M A I N   R O U T I N E --------------------

# Get parameters
while getopts ":adpx" opt; do
    case $opt in
        a) iALL=1 ;;
        d) iDocs=1 ;;
        p) iPics=1 ;;
        x) iDebug=1 ;;
        \?) DoSyntax ;;
    esac
done

if [[ ${iDebug} = 1 ]]; then
    echo "*** DEBUG MODE ***"
    echo "--- Actions will NOT occur! ---"
    echo " "
fi

# -------------------- GET PASSWORD FOR MOUNTS --------------------
read -s -p "Enter mount password for user ${cUser}:" cPass
echo " "
if [[ ${iDebug} = 1 ]]; then
    echo "Password: ${cPass}"
fi

# -------------------- BACKUP KEY DATA TO NAS FOR OFFSITE PUSH --------------------
# ----- Documents

if [[ ${iALL} = 1 ]] || [[ ${iDocs} = 1 ]]; then

    # -------------------- PREPARE DOCUMENTS --------------------
    # Tar, Zip Encrypt, Remove unencrypted tar
    if [[ ${iALL} = 1 ]] || [[ ${iDocs} = 1 ]]; then
        echo " "
        echo "Preparing documents for backup..."
        if [[ ${iDebug} = 0 ]]; then
            echo "     - tarring files into one..."
            tar -cvf /Users/username/0ffsite/MyDocuments.tar /Users/username/Documents/*
            echo "     - zipping file with encryption..."
            zip -v -P "super-secret-password" /Users/username/0ffsite/MyDocuments.zip /Users/username/0ffsite/MyDocuments.tar
            echo "     - removing unencrypted tar file..."
            rm -f /Users/username/0ffsite/MyDocuments.tar
        fi
    fi


    # -------------------- COPY DATA TO NAS --------------------

    # Mount the backup drive
    if [[ ${iDebug} = 0 ]]; then
        mkdir /Volumes/Data
        mount_afp -i afp://username:${cPass}@nas.home/Data /Volumes/Data
    fi

    # ---------- COPY DOCUMENTS ----------
    if [[ ${iALL} = 1 ]] || [[ ${iDocs} = 1 ]]; then
        echo " "
        echo "Copying critical (0ffsite) documents to NAS backup..."
        if [[ ${iDebug} = 0 ]]; then
            echo "     - copying zip file to NAS..."
            cp /Users/username/0ffsite/MyDocuments.zip /Volumes/Data/Backup
        fi
    fi

    # Unmount the backup drive
    if [[ ${iDebug} = 0 ]]; then
        umount /Volumes/Data
    fi
fi


# -------------------- BACKUP PICTURE DATA TO NAS FOR OFFSITE PUSH --------------------

if [[ ${iALL} = 1 ]] || [[ ${iPics} = 1 ]]; then

    # -------------------- PREPARE DOCUMENTS --------------------
    # Tar, Zip Encrypt, Remove unencrypted tar
    if [[ ${iALL} = 1 ]] || [[ ${iPics} = 1 ]]; then
        echo " "
        echo "Preparing pictures for backup..."
        if [[ ${iDebug} = 0 ]]; then
            echo "     - tarring files into one..."
            tar -cvf /Users/username/0ffsite/MyPictures.tar /Users/username/Pictures/*
            echo "     - zipping file with encryption..."
            zip -v -P "super-secret-password" /Users/username/0ffsite/MyPictures.zip /Users/username/0ffsite/MyPictures.tar
            echo "     - removing unencrypted tar file..."
            rm -f /Users/username/0ffsite/MyPictures.tar
        fi
    fi


    # -------------------- COPY DATA TO NAS --------------------

    # Mount the backup drive
    if [[ ${iDebug} = 0 ]]; then
        mkdir /Volumes/Data
        mount_afp -i afp://username:${cPass}@nas.home/Data /Volumes/Data
    fi

    # ---------- COPY DOCUMENTS ----------
    if [[ ${iALL} = 1 ]] || [[ ${iPics} = 1 ]]; then
        echo " "
        echo "Copying pictures to NAS backup..."
        if [[ ${iDebug} = 0 ]]; then
            echo "     - copying zip file to NAS..."
            cp /Users/username/0ffsite/MyPictures.zip /Volumes/Data/Backup
        fi
    fi

    # Unmount the backup drive
    if [[ ${iDebug} = 0 ]]; then
        umount /Volumes/Data
    fi
fi

exit 0

Note that I omitted music from my plan. Music is too much data, and it’s easily recovered from the CD’s and/or re-downloaded from the sales provider. Yes, re-ripping 600 CD’s would take some time, but it can be done. You could back music up, just note that the internet location will need to be sized accordingly.

Home video’s were also omitted from my plan. I haven’t determined the best offsite solution for these, primarily due to size of the data. In all likelihood it will be a USB drive stored offsite.

Taking Action

Now, I employ two backup types described in the Backup Planning section above.

First, once a month I perform a USB drive backup. This drive is stored in a safe, in part of the house away from the computer. This provides a second copy of ALL my data.

Second, twice per month, I run my backup script for the critical data. This feeds the encrypted data onto the NAS drive. My NAS drive has 2 hard drives in a RAID 1 (mirrored) configuration. This effectively gives me a third and fourth copy of my critical data.

At this point the data is still susceptible to the physical loss scenarios. To solve that problem, at least for my critical data, I used a feature on my NAS drive to push the data to Dropbox. I encrypted the data because it is going offsite. Yes, Dropbox keeps your data encrypted, but their servers are outside of my control. So if someone gets to the files either internally at Dropbox or externally by hacking, the files are still useless to them. Now, should I lose access to all physical copies, once the computer is replaced, I can still pull the data down from Dropbox. Granted the non critical data is lost, but life goes on.

My next post will detail how I setup the NAS Dropbox feed.

(Edit): The follow up post is Automated Offsite Backup.

OSX, Perl, Curses, and @INC

Posted by Ripdubski on 2016.08.31

Posted in: OSX, Programming. Tagged: @INC, Can't locate, Curses, Perl. Leave a comment

Each time an upgrade to OS X comes along, I end up have to go through a whole mess of updating Perl modules. Why? I made the mistake of writing a utility in Perl that relies on several CPAN modules, including Curses, Curses::UI, Mac::iTunes::Library, and File::HomeDir. At the time I wanted to learn to use Curses. I should remake this utility in something else, but when Perl is working the utility works like I need it to. The utility allows me to sync playlists from my iTunes library to SD cards, without the chore of manually moving them around.

Errors

After an upgrade, I usually end up with several errors like this:

Can't locate Curses.pm in @INC (you may need to install the Curses module) (@INC contains: /Users/xxxxx/Library/Perl /Library/Perl/5.18/darwin-thread-multi-2level /Library/Perl/5.18 /Network/Library/Perl/5.18/darwin-thread-multi-2level /Network/Library/Perl/5.18 /Library/Perl/Updates/5.18.2 /System/Library/Perl/5.18/darwin-thread-multi-2level /System/Library/Perl/5.18 /System/Library/Perl/Extras/5.18/darwin-thread-multi-2level /System/Library/Perl/Extras/5.18 .) at /Users/xxxxx/Library/Perl/Curses/UI/Common.pm line 20.

Fixes

Tired of seeing this, I removed the dependency for “File::HomeDir” with a minor change to my MediaSync perl source code. That still leaves the problem of the other modules.

I described in an earlier post how to install CPAN modules in OS X. Since this method uses sudo, I’ll use it only to install the Curses module.

Improvements

Now I am going to setup a module library that is independent of the Perl version, and not going to become broken when OS X is upgraded.

Create a directory to hold the Perl modules. I chose “~/Library/Perl”, which is in my users Library. Open the Library folder, and create a new sub folder called Perl.
Copy your other CPAN modules to the new “~/Library/Perl” folder. If the module has a directory structure to it, copy it intact. For example, the two modules I need are Curses::UI, and Mac::iTunes::Library. You can see I moved the entire directory structure over intact.

Next, Perl needs to be able to find the custom location of my module library. The @INC path needs to get updated. To do this, you need to export the path you want to add from your bash shell’s profile (~/.bash_profile). Add the following line:

export PERL5LIB=~/Library/Perl

With the above line added, each time the shell is invoked Perl will add the defined path to @INC when started.

Results

Now the my module library is independent of the installed Perl version, and won’t get wiped out by an OS update. You might ask why I didn’t include the Curses module. My response is that the OS Curses library may be updated with an OS update, and I want the Perl module to be rebuilt so it reflects any new or removed functions in the base OS library.

And MediaSync is running again:

cc65 on OSX

Posted by Ripdubski on 2016.08.16

Posted in: OSX, Programming. Tagged: cc65. 2 Comments

I recently needed to install cc65 (http://cc65.github.io/cc65/index.html) on OS X. Sounds easy enough. However, a binary distribution for OS X does not exist! This means it must be built from source code.

To complicate things, instructions I found only carried through the compilation. The current source (2.15 as of this posting) would not process the ‘make install’ on OS X 10.11 El Capitan. A little coercion was needed.

Here you will find how I got it to install.

Xcode

First, you need Xcode. You can install the full package from the Mac App store, or you can install just the command line tools. If you want to install just the command line tools, an easy way is to open the Terminal and type ‘make’. OS X will ask if you want to install them via GUI. Once you elect to install, accept the license agreement.

If you installed the full version of Xcode, execute it once and accept the license agreement. Or if you prefer you can use the Terminal command:

xcodebuild -license

cc65

Download

Download the cc65 sources from Github (https://github.com/cc65/cc65). To do so, just click the green “Clone or Download” button in the top right, and select “Download zip”. This will download a file called ‘cc65-master.zip’ to your download folder.

Extract the contents of ‘cc65-master.zip’. The easiest way is to double click it.

Compile

Open Terminal.

Change directory to the extracted folder. Use “cd fullpathname”.

Compile cc65 by using Xcode’s make. This will cause the cc65 sources to be compiled. They will be compiled into the extracted folder. It will only take a few minutes.

make

Install

The next part requires admin privileges, so you need to use sudo. This will install the compiled binaries, libraries, and includes into a base location you pick. They will be placed in sub-directories of the base directory.

A good place to install is “/usr/local”. Set the prefix environment variable with the following command. This will allow installation of the binaries into /usr/local/bin, and everything else into “/usr/local/share/cc65/xxx” where xxx are various cc65 directories such as lib, target, include, etc:

export prefix=/usr/local

Perform the install by entering “sudo make install”. A lot of messages will scroll by showing you what files were placed where. Review, save it, whatever, you likely won’t need it again.

Environment Setup

Now you just need to add an environment variable to your profile so the cc65 tools are always available to you at login. If you don’t want to do this, fine, just remember you will have to set the variable before using the cc65 tools.

Change to your home directory:

cd ~

Assuming you installed to “/usr/local”, you need to add the following to the file “.bash_profile”. Don’t panic if it doesn’t exist:

export CC65_HOME=/usr/local/share/cc65

If you are familiar with vi, use it to edit “.bash_profile” and add the export above. If you are not, use the echo command to add it. Note this echo command will add to it if it already exists and create it if it does not:

echo "export CC65_HOME=/usr/local/share/cc65" >> .bash_profile"

Done

That’s it. You can now use the cc65 tools.

Action! Windows Gadget – Vertical Menu

Posted by Ripdubski on 2016.07.13

Posted in: Atari, Programming. Tagged: 8 bit, Action!, Window. Leave a comment

What good is any program without a menu? Not much. Without menus you are relegated to memorizing keystroke commands to perform different functions. Because menus are so intuitive to use, that was the next gadget I focused on for my Action! Windowing Library. Maybe this library needs a name now? I’ll think about that.

In this post I detail the function created to present the vertical menu, describe how it works, then finish with a demonstration program, with bonus video of the demonstration in action (pun intended 🙂 ).

Function

This gadget is named GMenuV. The menu is navigated using the UP, DOWN, ENTER, and ESC keys. UP moves the selection indicator up, DOWN moves the selection indicator down. The selection indicator will roll from top to bottom and vise-versa. ENTER selects the currently highlighted item. ESC will exit the menu.

The parameters required are:

bN = BYTE, window handle to display the menu in
x = BYTE, x (column) position in the window to display the menu
y = BYTE, y (row) position in the window to display the menu
w = BYTE, width of each menu item (must be one size fits all)
pS = CHAR POINTER, string containing each menu item without delimiters

The function returns a BYTE value which will be the number of the selected menu item or 0 if ESC is used to exit.

Further documentation of the function is inline:

; --------------------------------------
; Proc..: GMenuV(BYTE bN,x,y,w CHAR POINTER pS)
; Desc..: Displays vertical menu
; Params: bN =  number of window handle
;         x = column for cursor
;         y = row for cursor
;         w = width of menu items
;         pS = menu items string
; --------------------------------------
BYTE FUNC GMenuV(BYTE bN,x,y,w CHAR POINTER pS)
  ; Variables used
  BYTE bL,bR,h,bC,i,bK
  ; String to hold 1 menu item of max size (38)
  CHAR ARRAY cL(39)

  ; Set item number default in return value
  bR=1

  ; Compute # items based on length of the menu string
  ; and specified width of each item.
  bC=pS(0)/w
           
  ; Repeat until done
  DO
    ; Display each item using a loop
    for bL=0 to bC        
    DO
      ; Compute menu item position in menu string
      h=(bL*w)+1
                   
      ; Copy menu item into temp string from menu string 
      ; starting at the computed position, up to the
      ; position plus the menu item length  
      SCopyS(cL,pS,h,h+w)    

      ; If current item is the selected item, 
      ; inverse the selection
      if bL+1=bR then
        ; Inverse the string
        for i=1 to cL(0)
        DO 
          cL(i)==!128
        OD
      fi
      
      ; Print item at column,row count within window
      WPrint(bN,x,y+bL,cL)
    OD

    ; Get key     
    bK=WaitKC()

    ; Process key
    ; -- DOWN --
    if bK=KDOWN then
      ; Increment item number 
      bR==+1
      ; If item number is greater than max, set to 1
      if bR>bC then bR=1 fi
    ; -- UP --
    elseif bK=KUP then
      ; Decrement item number
      bR==-1
      ; If item number is less than 1, set to max
      if bR<1 then bR=bC fi
    ; -- ENTER -- 
    elseif bK=KENTER then  
      ; Exit loop         
      EXIT
    ; -- ESC --
    elseif bK=KESC then
      ; Set item number (return value) to 0, exit loop
      bR=0
      EXIT
    fi
  OD
; Return item number selected
RETURN(bR)

Example Program

This sample program utilizes many pieces of my Action! Windowing Library. It is well documented so I will not break it down. Feel free to ask questions if needed.

; Program: WINMENUV.ACT
; Date...: 2016.07
; Desc...: Test Window Program
; License: Creative Commons
; Attribution-NonCommercial-
; NoDerivatives
; 4.0 International

; Include library
INCLUDE "D3:DEFINES.ACT"
INCLUDE "D3:DEFWIN.ACT"
INCLUDE "D3:LIBSTR.ACT"
INCLUDE "D3:LIBWIN.ACT"
INCLUDE "D3:LIBMISC.ACT"
INCLUDE "D3:LIBGADG.ACT"

; Start
MODULE

PROC Main()
; Window handles and other byte vars
BYTE bW1,bW2,bW3,bCh,bLp,bS
; Menu strings
CHAR ARRAY cM(31),cM2(57)

; Init Window System
WInit()

; Open window 1 (title)
bW1=WOpen(2,2,36,3,WINVON)
WPrint(bW1,WPCENT,1,"Unfinished Bitness")

; Open window 2 (main menu)
bW2=WOpen(15,7,9,5,WINVOFF)
WTitle(bW2,"Menu")

; Define main menu
; Each item is stacked back to back using the
; full width of the desired display size.
; This example is 7 characters.
SCopy(cM," Open> Close Exit ")

; Do this until exit
DO
  ; Display main menu
  ; In window bW2 at position 1,1 (of window)
  ; with menu items 7 chars wide,
  ; in the char string cM.
  ; Save returned selection to bCh.
  bCh=GMenuV(bW2,1,1,7,cM)

  ; Process choice
  ; -- OPEN --
  if bCh=1 then
    ; Open window 3 (sub menu)
    bW3=WOpen(22,8,16,6,WINVOFF)

    ; Define sub menu
    ; Submenu uses 14 character strings.
    SCopy(cM2," FILENAME.001 FILENAME.002 FILENAME.003 FILENAME.004 ")

    ; Display sub menu
    ; In window bW3 at position 1,1 (of window)
    ; with menu items 14 chars wide,
    ; in the char string cM2.
    ; Save returned selection to bCh (not used here).
    bCh=GMenuV(bW3,1,1,14,cM2)

    ; Close sub menu window
    WClose(bW3)
  ; -- EXIT --
  elseif bCh=3 then
    ; Exit loop
    exit
  fi
OD

; Close open windows
WClose(bW2)
WClose(bW1)

RETURN

Results

Screen shot of the primary menu being displayed:

Now the submenu being displayed:

Now a video demonstration:

Printing Like It’s 1986 – Atari Laser Edition

Posted by Ripdubski on 2016.06.21

Posted in: Atari. Tagged: 16 bit, 8 bit, Brother Laser, Epson FX, IBM ProPrinter. Leave a comment

In my previous post I talked about replacing my Canon ink jet printer with a new Brother laser printer. This new printer has two emulation modes that peaked my interest: Epson FX emulation and IBM ProPrinter emulation. Having used Atari 8 bit and 16 bit (ST) computers in the 1980’s with a large amount of my printing done on Epson compatible printers, I decided the Epson FX emulation in the Brother HL-L5200DW needed a deep dive. The goal was simple – get a printout generated by an Atari computer to print on the laser printer, not a PDF, a physical copy, complete with all the jagged-ness that accompanies a dot matrix printer.

To do this I used the following:

Mac computer running OS X 10.11
Brother HL-L5200DW laser printer
Atari800MacX Atari 8 bit emulator
Hatari Atari ST emulator

Setup

Base Printer Setup

I installed the Brother drivers on the Mac. The Brother laser is set to use a wireless ethernet connection. The Brother driver software installs just the drivers, nothing more, and completed in about 15 seconds. Bravo! Once setup I made sure the Mac could print to it by printing a test page:
I then ensured the Epson FX emulation was setup correctly. I had to change a few settings to get the printouts looking correct. Of note, the top and bottom margins were changed from 0.33 to 0.00, which also changes the page line count from 62 to the familiar 66. The other important change is altering the Auto Mask setting from Off to On. Here is the Brothers Epson FX configuration page:

CUPS Setup

Next the CUPS printing system needs a new printer definition. This new definition will be set as a raw device, and will be configured to use LPD. You may have luck using one of the IPP configurations as well, but the LPD method works reliably.

First connect to the Mac’s CUPS web interface (http://localhost:631). If it is not enabled, you will need to enable it by issuing the command “cupsctl WebInterface=yes” as root (or using sudo) from the Terminal. From the main CUPS page, select “Adding Printers and Classes” in the “CUPS for Administrators” section (may be slightly different based on your version of CUPS):
On the Printers and Classes page, select “Add Printer” from the “Printers” section:
On the Add Printer page, select “LPD/LPR Host or Printer”:
On the Add Printer Connections page, enter the URI as “lpd://ip_address_of_printer/queue”. Watch out for auto-correct trying to change lpd to led. In this example I have used 192.168.1.1 which is not my actual lasers address or my network for that matter:
On the Add Printer Name/Description page, enter a name that makes sense such as “Brother_Laser_Epson”. This is how you will reference the printer from the CLI later. Note you can not have spaces! Save those for the description where you can enter whatever you like. In this example I used “Brother Laser Epson Emulation”:
On the Add Printer Make page, use the list selector next to Make to pick “Raw”:
On the Add Printer Model page, use the list selector next to Model to pick “Raw Queue (en)”, then click “Add Printer”:
On the Set Printer Options page, ensure that starting and ending banners are set to none (default), and click “Set Default Options”:
You will get confirmation page that will redirect a few seconds later to a status page for the newly defined printer. The newly defined printer will not show up in OS X printer preferences, but rest assured it is available. If you messed up, you can delete the printer from the “Administration” drop down located on this page. For the definition example I used the name “Brother_Epson_Demo”, but in later output you will see my real name as “Brother_Epson”:
Select the Printers menu/tab option from the CUPS header. This will show you all defined printers. If all went well you will see the Brother printer defined initially to OS X, and the newly defined “Local Raw Printer”:

Printing

For my purposes I used Atari emulators running on OS X. The emulators provide a way to capture printer port data to a file, thereby allowing the Atari computer software to use their own “printer drivers”. This results in a binary data file containing all the data that would have been sent to the printer, in other words, a raw printer file.

If you have ethernet connectivity from the Atari, you may even be able to print directly to the networked printer. The ST should be easier to do than the 8 bit. I will figure this out once I get an Atari (8 or 16 bit) connected via ethernet. It is unlikely I will ever get an 8 bit connected via ethernet, though it would be cool trick.

Atari 8 bit

For the Atari 8 bit using Atari800MacX, I could have just printed to an emulated Epson FX printer and saved the output directly to PDF, then printed the PDF. But what fun is that? I want the printer to raster the page from the Epson FX commands, not a software engine.

If the program you want to print from can print directly to a file, such as many word processors, do that. But don’t do it as plain ASCII, do it using the printer codes/driver. Once you have the output file on either an ATR (simulated floppy disk) or simulated hard drive, copy/extract the output file to the Mac’s local filesystem. Now skip ahead to “Dump Output File” below.

If the program you want to print from can not print directly to a file, then the Atari emulator needs to be setup to capture the printer output to a file on the host computers local filesystem. For Atari800MacX, set the printer to Text. The output file will contain all the binary data even though its a “text” file. The printer type should be called “File” not “Text”.

Atari ST (16/32 bit)

For the Atari ST, simply configure the emulator to send all printer data to a file. Then configure each program you want to print from to use Epson FX printer codes/driver. After each print, simply collect the file. When using Hatari, the default printer output filename will be “hatari.prn”. With the file collected skip ahead to “Dump Output File” below.

Dump Output File

Now you should have a printer output file ready to be sent to the printer. If not, go and create one, then come back here.

Open Terminal and change directory to wherever your printer output file is.
Enter the command “lpstat -p -d”. This will show you the defined printers, their status, and the default destination printer. You are primarily interested in the “Brother_Epson” (or whatever you called it) entry. Just make sure it’s idle and enabled:

MacBook:~ user$ lpstat -p -d
printer Brother_Epson is idle. enabled since Sun Jun 19 16:37:12 2016
printer Brother_HL_L5200DW_Laser is idle. enabled since Sun Jun 19 10:14:31 2016
system default destination: Brother_HL_L5200DW_Laser

Use the “lp” command to send the printer output file to the printer. Make sure you specify the destination printer (-d), the raw option (-o), and the filename:

MacBook:~ user$ lp -d Brother_Epson -o raw 1632_CRLF.prn
request id is Brother_Epson-29 (1 file(s))

Wait a few seconds and the Brother laser should spit the page out in all of it’s simulated dot matrix glory. Now instead of worrying about worn ink spots in the printer ribbon you can worry about low toner and bad drums.

Results

I created a sign using PrintMaster on the Atari ST. I configured Hatari to output to a file. I then printed that file using the method above. A scanned image of the laser printers output is here:

https://unfinishedbitness.files.wordpress.com/2016/06/brother1632_16bitscan.pdf

To contrast that with printing to a simulated Epson FX printer, I took that Hatari generated output file and copied it to a simulated disk on Atari800MacX. I then copied the file byte for byte to the emulated Atari 8 bit printer port set as an emulated Epson FX-80 printer. The simulated printer output was saved as PDF and can be seen here:

https://unfinishedbitness.files.wordpress.com/2016/06/brother1632_8bitdump.pdf

Color Inkjet to Mono Laser

Posted by Ripdubski on 2016.06.19

Posted in: General. Tagged: AirPrint, Color Inkjet, Mono Laser, Printer. Leave a comment

For the last several years I’ve had a Canon MG-6120 color ink jet printer. The print output quality is incredible. However, it chews through ink wells just about as fast as you can replace them. During ownership there has never been a time when at least one of the ink wells has not been “low” or needing replacement. Canon cites a ~450 page yield for cyan, yellow, and magenta, and pigment black at 328 pages. Grey is better at 1515 pages, and normal black at 2185 pages. During the time I’ve owned the printer, I’ve gone through two reams of paper (1000 pages) at most. So, I don’t print a lot, and never ever print photos. The Canon page yield seems closer to 50 for the color ones, and the grays and blacks showing about one fourth of their stated yields.

Here is a cost breakdown for the Canon stated page yields showing both retail, and street pricing with cost per sheet:

	Retail	Yield	Retail-C/S	Street	Street-C/S
Canon MG6120
PGI-225PGBK	$15.99	328	$0.049	$15.99	$0.049
CLI-226BK	$13.99	2,185	$0.006	$13.99	$0.006
CLI-226Y	$13.99	450	$0.031	$13.99	$0.031
CLI-226C	$13.99	462	$0.030	$13.99	$0.030
CLI-226M	$13.99	437	$0.032	$13.99	$0.032
CLI-226GY	$13.99	1,515	$0.009	$13.99	$0.009

As you can see, even at the maximum yield, this printer is quite expensive to run with cost per sheet between 3 and 5 cents.

I’ve grown tired of constantly replaced one ink or another, and having to wait 30+ seconds before it decided to print. Recently after replacing yellow at $14, and a week later needing to replace magenta and cyan (with basically no color printing occurring), I bought a tri-color refill for $46 (post taxes). I was so disappointed that I returned it within two days. I thought about my need for color, and weariness of constantly filling inks. I knew there were monochrome lasers available for under $100 so I started looking at replacements.

Using the same cost breakdown as the Canon above, I created breakdowns for many laser printers, both monochrome and color. I ruled out the color options after carefully considering the amount and type of color printing I do. I can get by with black and white just fine. On those few occasions I need color, I can take the document in PDF format to local pharmacy and have it printed for relatively cheap.

I had several criteria a new printer had to meet. The top three of those are duplex printing, AirPrint support, fast time to print. I previously used Printopia on my Mac to offer AirPrint for the Canon printer, but that means the Mac has to be awake for it to work. I wanted to eliminate that as well.

Narrowing the choices down to eight monochrome laser printers, I weighed the availability of replacement toners and drums, the costs, and user reviews. The two Samsungs at the top of my list were quickly dismissed after reading a ton of reviews citing paper feed issues. A Xerox, Okidata, Canon, and Dell were also eliminated for one reason or another. The Xerox and Dell due to replacement consumable availability, The Canon due to operational page cost. The Okidata due to unit cost. This left me considering two Brother monochrome laser printers: HL-2360DW, and HL-L5100DN. Both of these printers had excellent reviews, and excellent operational page cost. Here is a cost breakdown for both:

	Retail	Yield	Retail-C/S	Street	Street-C/S	Total C/S
Brother HL-2360DW	129.95			79.99
TN630 (Standard)	32.99	1,200	$0.027	30.98	$0.026	$0.032
TN660 (High)	50.99	2,600	$0.020	46.90	$0.018	$0.024
Drum DR630	78.99	12,000	$0.007	73.38	$0.006
PPM Black	32

Brother HL-L5100DN	199.95			159.99
TN820 (Standard)	79.99	3,000	$0.027	66.99	$0.022	$0.026
TN850 (High)	129.99	8,000	$0.016	106.39	$0.013	$0.017
Drum DR820	159.99	30,000	$0.005	120.36	$0.004
PPM Black	42

The breakdowns include a standard yield toner, high yield toner, and image drum. I computed the cost per page for each, then added the image drum cost per page to each toners cost per page to come up with a total cost per page. Both of the Brother printers offered excellent total cost per page, with the SOHO business unit (HL-L5100DN) coming in at 1.7 cents when using the high yield toner.

The Brother HL-L5100DN also has a few additional features I was interested in. Primary is duplex printing. Secondary, is Epson FX and IBM ProPrinter emulation. As an avid Atari computer enthusiast, being able to print to the laser using the emulation is a nice benefit, and in fact I will cover this in the next post. Tertiary is the fast time to print. The HL-2380DW has a first page print in 8.5 seconds, while the HL-L5100DN is 7.2 seconds. In addition to the consumables cost I also looked at printer memory sizes, power consumption, and noise (db level).

For about $20 more the Brother HL-L5200DW offers wireless printing, and comes with a standard yield toner instead of a starter toner. I went with this printer. With a 3000 page yield on the toner and 30 page yield on the drum, I shouldn’t need to replace either for quite some time.

It arrived 2 days after placing the order with a favorite online retailer. Setup was easy. And one thing I was extremely happy with is that the driver installation installs JUST the driver and not a bunch of crapware I don’t want or need. Yay Brother! The only complaint I had during setup was the firmware update. There were two firmwares to update (a primary, and a sub), which required two update cycles. Each update reset the network configuration, necessitating network password entry three times.

Output is crisp and clear. After printing the Brother test page, I test printed various documents and a picture. As expected the picture was less than stellar with only grayscale, but I don’t do any photo printing, so this was just a curiosity more than anything. All other documents were extremely clear using the 600 DPI setting (default). I haven’t tried using the 1200 DPI setting yet.

I also tried AirPrint and it works flawlessly. One I had all the modern computers and devices printing to the new Brother HL-L5200DW, I wanted to get an Atari’s output to it. After a few hours of various configurations I did get it to work. I’ll explain how next.

Action! Windows Gadget – Progress Indicator

Posted by Ripdubski on 2016.05.03

Posted in: Atari, Programming. Tagged: 8 bit, Action!, Windows. Leave a comment

This is about the first widget for my Action! windowing library. To separate a widgets function name from a window function, I used a G. So I’m calling them gadgets instead. This gadget is a progress bar.

Progress Bar (GProg)

The progress bar indicator displays only the actual progress bar at the coordinates within the window specified. This gives the freedom to include other elements in the progress window as desired. Each call to the function displays a bar for the percentage given. It is possible to go backwards as well (i.e.: 100 to 0 instead of 0 to 100).

The function GProg takes four parameters. They are:

Window handle number (bN)
X position / column (x) – within the windows bounds
Y position / row (y) – within the windows bounds
Bar size – percentage complete (0 to 100, whole numbers only)

There is no return value, and as such the function is declared as a PROCedure.

The procedure works as follows:

First, and empty string is created.
Next the string is filled from left to right with inverse spaces. The number of spaces is calculated by taking the bar size parameter and dividing it by 5. Why 5? The bar is 20 characters long. 20 * 5 is 100.
Last the bar is printed to the window using WPrint, which writes directly to screen memory in the appropriate location.

; --------------------------------------
; Proc..: GProg(BYTE bN,x,y,bS)
; Desc..: Displays progress bar
; Params: bN =  number of window handle
;         x = column for cursor
;         y = row for cursor
;         bS = bar size (pct complete)
; --------------------------------------
PROC GProg(BYTE bN,x,y,bS)
  INT i
  CHAR ARRAY cL(21),cB(21)

  ; Set default and block lines
  SCopy(cL,"                    ")

  ; Update bar contents
  ; Div by 5 since bar is 1/5 100
  for i=1 to bS/5
  DO
    cL(i)=CINVSP
  OD

  ; Display new bar
  WPrint(bN,x,y,cL)
RETURN

Usage

To demonstrate this gadget I created a new program. This one opens a window on the left to display each window handles status. A progress bar is displayed while each status is being gathered and printed.

; Program: WINDOW.ACT
; Author.: Wade Ripkowski
; Date...: 2016.04
; Desc...: Test Windowing Library
; License: Creative Commons
;          Attribution-NonCommercial-
;          NoDerivatives
;          4.0 International

; Include library
INCLUDE "D3:DEFINES.ACT"
INCLUDE "D3:DEFWIN.ACT"
INCLUDE "D3:LIBSTR.ACT"
INCLUDE "D3:LIBWIN.ACT"
INCLUDE "D3:LIBMISC.ACT"
INCLUDE "D3:LIBGADG.ACT"

; Start
MODULE

PROC Main()
; Window handles
BYTE bW1,bW2,bLp,bS
INT iP

; Init Window System
WInit()

; Open window 1
bW1=WOpen(9,2,20,14,WINVOFF)
WTitle(bW1,"Status")
WPrint(bW1,1,1,"Window Status")
WPrint(bW1,1,2,"------ ------")

; Open progress bar window
bW2=WOpen(7,18,24,4,WINVOFF)
WPrint(bW2,2,1,"Progress:")

; Display initial progress bar
GProg(bW2,2,2,0)

; Loop through each window handle
for bLp=0 to 9
DO
    ; Get the status
    bS=WStat(bLp)

    ; Print the window handle #
    WPos(bW1,6,3+bLp)
    WPut(bW1,bLp+48)

    ; Print the handle status
    if bS=WSUSED then
        WPrint(bW1,8,3+bLp,"Used")
    else
        WPrint(bW1,8,3+bLp,"Free")
    fi

    ; Update progress bar
    iP=((bLp+1) MOD 10)*10
    if iP=0 then
        iP=100
    fi
    GProg(bW2,2,2,iP)

    ; Wait for a keystroke or console key
    WaitKC()
OD

; Close window 2
WClose(bW2)

; Close window 1
WClose(bW1)

RETURN

Results

When the program is run, it expects a keypress after each status line is printed. Screenshots of the demonstration program. The first is at the first of 10 window handles (or 10 percent):

The next is after the fifth window handle has been displayed (or 50 percent):

The last is after all 10 window handles status have been displayed (or 100 percent):

The next post will be the release of the entire library to date.

Action! Windows – Status

Posted by Ripdubski on 2016.05.01

Posted in: Atari, Programming. Tagged: 8 bit, Action!, Windows. Leave a comment

This post introduces a function to check the status of a window handle: WStat(). It is also part of my Action! library window file LIBWIN.ACT.

Status (WStat)

The status routine simply returns the window handles status. It will be either WSFREE (not in use), or WSUSED (used). It requires one parameter which is the window handle number to check.
The function works in the following manner:

It computes the window handles memory location.
It then returns the window handles status byte value.

; --------------------------------------
; Func..: BYTE WStat(BYTE n)
; Desc..: Tests if window handle is open
; Params: n = number of window handle
; Return: WSUSED (in use) or
;         WSFREE (not used)
; --------------------------------------
BYTE FUNC WStat(BYTE bN)
  ; Find window handle record
  pWn=baW+(WRECSZ*bN)
RETURN(pWn.bS)

Usage

The demonstration program has once again been expanded. This time a fourth window is opened. It it, the status of the first 5 windows is displayed. Notable differences are in the section commented for window 4:

; Program: WINDOW.ACT
; Author.: Wade Ripkowski
; Date...: 2016.04
; Desc...: Test Windowing Library
; License: Creative Commons
;          Attribution-NonCommercial-
;          NoDerivatives
;          4.0 International

; Include library
INCLUDE "D3:DEFINES.ACT"
INCLUDE "D3:DEFWIN.ACT"
INCLUDE "D3:LIBSTR.ACT"
INCLUDE "D3:LIBWIN.ACT"
INCLUDE "D3:LIBMISC.ACT"

; Start
MODULE

PROC Main()
; Window handles
BYTE bW1,bW2,bW3,bW4,bLp,bS

; Init Window System
WInit()

; Open window 1
bW1=WOpen(10,5,20,7,WINVOFF)
WTitle(bW1,"One")
WPrint(bW1,1,1,"Row 1 Column 1")
WPrint(bW1,1,5,"Unfinished Bitness")

; Open window 2
bW2=WOpen(5,15,30,6,WINVON)
WTitle(bW2,"TWO")
WPrint(bW2,2,2,"2,2")
WPrint(bW2,WPCENT,4,"Inverse ATASCII Podcast")

; Open window 3
bW3=WOpen(15,8,10,10,WINVOFF)
WTitle(bW3,"Three")
WPrint(bW3,1,3,"Hello")
WPrint(bW3,3,5,"Hello")
WPrint(bW3,1,7,"Hello")

; Wait for a keystroke or console key
WaitKC()

; Clear window 3
WClr(bW3)

; Draw \ in window 3
WPos(bW3,1,1)
WPut(bW3,42)
WPos(bW3,2,2)
WPut(bW3,42)
WPos(bW3,3,3)
WPut(bW3,42)
WPos(bW3,4,4)
WPut(bW3,42)
WPos(bW3,5,5)
WPut(bW3,42)

; Open window 4
bW4=WOpen(3,3,15,9,WINVOFF)
WTitle(bW4,"4-Status")
WPrint(bW4,1,1,"Window Status")
WPrint(bW4,1,2,"------ ------")

; Loop through the first 5 window handles
for bLp=0 to 4
DO
    ; Get the status
    bS=WStat(bLp)

    ; Print the window handle #
    WPos(bW4,6,3+bLp)
    WPut(bW4,bLp+48)

    ; Print the handle status
    if bS=WSUSED then
        WPrint(bW4,8,3+bLp,"Used")
    else
        WPrint(bW4,8,3+bLp,"Free")
    fi
OD

; Wait for a keystroke or console key
WaitKC()

; Close window 4
WClose(bW4)

; Close window 3
WClose(bW3)

; Close window 2
WClose(bW2)

; Close window 1
WClose(bW1)

RETURN

Results

When the program is run it produces the following results. All but the last screen shot are omitted as they have been covered before. The important output (for this post) is what appears in window 4:

That concludes the Action! window library routines. The next post will feature the first gadget, a progress indicator.

Action! Windows – Position & Put

Posted by Ripdubski on 2016.04.30

Posted in: Atari, Programming. Tagged: 8 bit, Action!, Windows. Leave a comment

In this post I show how the virtual cursor is used and a routine to put single characters in a window. The functions introduced here are part of LIBWIN.ACT. The contents of my library, as well as an API reference, will be released in its entirety at the conclusion of the posts. The functions for this post are position (WPos) and put (WPut).

Position (WPos)

The WPos function is used to position the virtual cursor. It requires three parameters:

Window handle number (n) – This also accepts WPABS which directs the position function to move the virtual cursor to an absolute screen position rather than a window based position.
X position / column (x) – the column within the given window
Y position / row (y) – the row within the given window

WPos returns either 0 (good) or an error code.

The functions works as follows:

First, a default return code of 0 (good) is set.
Next the window handle is checked to see if it is WPABS. If it is, the virtual cursor position is set to the x and y coordinates specified, which are absolute screen coordinates, not window coordinates.
If the window handle is not set as WPABS, the window handles memory location is computed. The window handles status is then checked.
If the window handle status is free, the routine sets the return code to the error code NOT OPEN and exits.
If the window handle status is uses, the virtual cursors x and y positions are set relative the the windows frame coordinates. The routine then exits.

; --------------------------------------
; Func..: BYTE WPos(BYTE n,x,y)
; Desc..: Moves cursor to x,y in window
;         or x,y of screen
; Params: n = number of window handle
;             or WPABS for screen
;         x = column for cursor
;         y = row for cursor
; Return: WERNOPN (not open) or
;         0 (good)
; --------------------------------------
BYTE FUNC WPos(BYTE bN,x,y)
  BYTE bR

  ; Set valid return
  bR=0

  ; If absolute mode
  if bN=WPABS then
    ; Set screen coords
    vCur.vX=x
    vCur.vY=y
  else
    ; Find window handle record
    pWn=baW+(WRECSZ*bN)

    ; Only if handle in use
    if pWn.bS#WSFREE then
      ; Set relative to window
      vCur.vX=pWn.bX+x
      vCur.vY=pWn.bY+y
    else
      ; Set not open return code
      bR=WERNOPN
    fi
  fi
RETURN(bR)

Put (WPut)

The WPut function puts a single character at the windowing systems virtual cursor position. The function requires two parameters:

Window handle number (n)
Character value to print (x) – This should be an ATASCII code. It will be converted to internal code.

The routine will return 0 (good) if successful, otherwise an error code.

The function works in the following manner:

First, a default error return code of NOT OPEN is set.
Next, the byte value passed is converted to a string.
Then the window handles memory location is computed. The window handles status is then checked.
If the window handles status is free, the routine exits returning the previously defined error code of NOT OPEN.
If the window handles status is not free (in use), the routine converts the string to internal code from ATASCII code. If the windows inverse flag is set, the string is inversed.
The screen memory location is computed, and the string (byte) is moved to that location. The virtual cursor position is then incremented by one just like a real cursor.
A return code of 0 (good) is set and the routine exits.

; --------------------------------------
; Func..: BYTE WPut(BYTE n,x)
; Desc..: Puts byte x in window
;         at virtual cursor coord
; Params: n = number of window handle
;         x = ATA byte to display
; Return: WERNOPEN (not open) or
;         0 (good)
; --------------------------------------
BYTE FUNC WPut(BYTE bN,x)
  BYTE bR
  CHAR ARRAY bC(2)
  CARD POINTER pS

  ; Set default return
  bR=WERNOPN

  ; Convert passed byte into string
  bc(0)=1
  bC(1)=x

  ; Find window handle record
  pWn=baW+(WRECSZ*bN)

  ; Only if handle in use
  if pWn.bS#WSFREE then
    ; Convert byte from ATA to INT
    StrAI(bC)

    ; If window is inverse, flip byte
    if pWn.bI=WINVON then
      bC(1)==!128
    fi

    ; Find screen loc based on vCur
    pS=RSCRN+(vCur.vY*40)+vCur.vX

    ; Move byte to screen
    ; pS^=bC(1)
    MoveBlock(pS,bC+1,1)

    ; Inc virtual cur by 1
    vCur.vX==+1

    ; Set return code
    bR=0
  fi
RETURN(bR)

Usage

The previously used demonstration program is expanded here to demonstrate WPos and WPut. Notable differences are the WPos() lines and WPut() lines. After the third window is cleared, WPos and WPut are used to draw a line of asterisks in the window.

; Program: WINDOW.ACT
; Author.: Wade Ripkowski
; Date...: 2016.04
; Desc...: Test Windowing Library
; License: Creative Commons
;          Attribution-NonCommercial-
;          NoDerivatives
;          4.0 International

; Include library
INCLUDE "D3:DEFINES.ACT"
INCLUDE "D3:DEFWIN.ACT"
INCLUDE "D3:LIBSTR.ACT"
INCLUDE "D3:LIBWIN.ACT"
INCLUDE "D3:LIBMISC.ACT"

; Start
MODULE

PROC Main()
; Window handles
BYTE bW1,bW2,bW3

; Init Window System
WInit()

; Open window 1
bW1=WOpen(10,5,20,7,WINVOFF)
WTitle(bW1,"One")
WPrint(bW1,1,1,"Row 1 Column 1")
WPrint(bW1,1,5,"Unfinished Bitness")

; Open window 2
bW2=WOpen(5,15,30,6,WINVON)
WTitle(bW2,"TWO")
WPrint(bW2,2,2,"2,2")
WPrint(bW2,WPCENT,4,"Inverse ATASCII Podcast")

; Open window 3
bW3=WOpen(15,8,10,10,WINVOFF)
WTitle(bW3,"Three")
WPrint(bW3,1,3,"Hello")
WPrint(bW3,3,5,"Hello")
WPrint(bW3,1,7,"Hello")

; Wait for a keystroke or console key
WaitKC()

; Clear window 3
WClr(bW3)

; Draw \ in window 3
WPos(bW3,1,1)
WPut(bW3,42)
WPos(bW3,2,2)
WPut(bW3,42)
WPos(bW3,3,3)
WPut(bW3,42)
WPos(bW3,4,4)
WPut(bW3,42)
WPos(bW3,5,5)
WPut(bW3,42)

; Wait for a keystroke or console key
WaitKC()

; Close window 3
WClose(bW3)

; Close window 2
WClose(bW2)

; Close window 1
WClose(bW1)

RETURN

Results

These screen shots depict the results when the program is run. The first screenshot shows the windows open and populated, and waiting for a keystroke:

Once a key is pressed, window 3 is cleared, then WPos() and WPut() are used to draw a line using asterisks in window 3. It is again waiting for a keystroke:

After the windows are all closed, control is returned to the Action! cartridge:

The next post will include a function for getting the status of a window handle.

Entire Source (Atari 8 bit LOGO)

Breakdown

Atari ST-LOGO Modification

Results

Share this:

Like this:

Causes

Backup Planning

Make It Happen

How I Did It

Share this:

Like this:

Errors

Fixes

Improvements

Results

Share this:

Like this:

Xcode

cc65

Done

Share this:

Like this:

Function

Example Program

Results

Share this:

Like this:

Setup

Base Printer Setup

CUPS Setup

Printing

Atari 8 bit

Atari ST (16/32 bit)

Dump Output File

Results

Share this:

Like this:

Share this:

Like this:

Progress Bar (GProg)

Usage

Results

Share this:

Like this:

Status (WStat)

Usage

Results

Share this:

Like this:

Position (WPos)

Put (WPut)

Usage

Results

Share this:

Like this:

Follow Blog via Email

Recent Posts

Categories

Tags

Archives

Meta