Unfinished Bitness

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. Leave a comment

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.

Unfinished Bitness

Finishing bits of technology, vintage and new.

OSX, Perl, Curses, and @INC

Errors

Fixes

Improvements

Results

cc65 on OSX

Xcode

cc65

Done

Action! Windows Gadget – Vertical Menu

Function

Example Program

Results

Printing Like It’s 1986 – Atari Laser Edition

Setup

Base Printer Setup

CUPS Setup

Printing

Atari 8 bit

Atari ST (16/32 bit)

Dump Output File

Results

Color Inkjet to Mono Laser

Action! Windows Gadget – Progress Indicator

Progress Bar (GProg)

Usage

Results

Action! Windows – Status

Status (WStat)

Usage

Results

Follow Blog via Email

Recent Posts

Categories

Tags

Archives

Meta

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:

Follow Blog via Email

Recent Posts

Categories

Tags

Archives

Meta