It was so good we did it again! Classic PowerBASIC Console Compiler is a proven product with value pricing. It's a true professional compiler... Not too long ago, it was known as PowerBASIC Console Compiler 4.0 for Windows. Competitively priced at $169. But you can buy it today for just $49! What a great way to learn about PowerBASIC... it's a wonderful gift, an entry-level compiler, perfect for anyone who wants real value pricing.

Ever wished for a 32-bit BASIC compiler? One with the straightforward DOS text mode interface but megabytes and megabytes of memory? Ever wished for a 32-bit Windows compiler that's truly easy to use? Well, now it's here. Today. The PowerBASIC Console Compiler for Windows. With PB/CC, it's a whole new Windows! Text mode for Win95, Win98, WinME, WinNT, WinXP, Vista, and Win7!

Classic PowerBASIC Console Compiler sports a number of exciting new features. A complete graphics engine, a printer package for Windows-Only printers, dynamic pointers, and thread local storage, to name just a few. But more about them later.

Classic PowerBASIC Console Compiler supports INPUT, PRINT, LOCATE, LINE INPUT, INKEY$, INSTAT, CLS, COLOR, KEY, KEY$, and LPRINT. All of the standard text functions. But then we added more. CONSHNDL, CURSOR, INSHIFT, PAGE, PAGEACTIVE, PAGEVISIBLE, SCREENATTR, PCOPY, WAITKEY$ and WAITSTAT. A complete set of mouse handling routines. SCROLL any region of the screen in any direction. STDIN, STDOUT, and STDERR. Even a PARSE statement and PARSE$ function to extract delimited fields, and new options for the EXTRACT$ function, too. All the text tools you'll ever need.

What is a Console? The Console is a text mode interface connected right to the heart of Windows. It looks and acts just like a text mode DOS program, but it's actually a True Windows application! With a console application, there's no fluff, no animated puppets, just intense computing power. Port existing Basic code from DOS to Windows today! Access a flat memory model that's practically unlimited. Boost performance with true 32-bit code. Launch multiple concurrent threads. Use the CPU and numeric coprocessor directly with Inline Assembler. Choose Register Variables for your most critical code. With Classic PowerBASIC Console Compiler, size and performance are the prime factors.

Since the console device is a text-only window, can a console compiler offer graphics? Of course! Just open one or more graphic windows and you're ready to go! You'll use GRAPHIC PRINT to draw plain text or fancy text... Any font. Any size. Any color. Bold. Underline. Italic and strikeout. Mix any combination of fonts on any window. Print just about anything, just about anywhere, even on private bitmaps that aren't yet visible. You'll copy or stretch bitmaps. Shrink them or change them. Circles, ovals, lines and boxes. Fat lines, skinny lines, stylized lines. Arcs, circles, rounded rectangles. Ellipses, pie sections, polygons, polylines. Even get or set pixels -- one by one. Filled forms or empty. Colors or not. The choices are endless. You can mix new colors with those which exist, and measure proportional text size before you print it. Then create a custom scaling system, even with fractional floating point coordinates! Of course, once you've built that work of art, you need to load and save it. So load from a resource, load and save a BMP on disk!

And then there's printing. Access to printers has always been something of an issue, but not any more. We've added extended printing (XPRINT), even for "Windows-Only" printers! Just like GRAPHIC for the screen, XPRINT offers it all on the printer. Print plain text or fancy text -- any font, any size, any color. Bitmaps and images, lines and boxes, circles and polygons, virtually all the features of the GRAPHIC screen are there for printers, too! You can retrieve the size of the printer page, the printable area, the margins, even the number of points per inch. Select landscape or portrait mode, even the print quality setting. The PRINTER$() function returns the name and port of every available printer. You can attach a printer by its name, by default, or just display a printer dialog to let the user decide. It's all in there.

Another interesting point is that graphics are extensible. Using the DC (Device Context) from PowerBASIC, you can call the Windows API, your own custom code, even third-party code for special graphic functions. With GRAPHIC GET/SET BITS, you can even manipulate the bitmap directly... each pixel is stored in succession as a long integer color value.

So, can you get here from DOS? But of course! Classic PowerBASIC Console Compiler's high degree of compatibility with PowerBASIC, QuickBasic, GW-BASIC and BASICA means that you can port existing DOS applications to Win32 with ease. Stop CHAINing from module to module in DOS when you can create a single 32-bit machine code executable up to 2 gigabytes in size. And creating an array that uses 50 megabytes of RAM is as simple as:

    Dim x%(0 To 26214400)

So just how fast is Classic PowerBASIC Console Compiler anyway? We thought you'd never ask! This tiny example may give you some idea of the power of Classic PowerBASIC Console Compiler

    x## = 1
    y## = 1.000001
    t!  = Timer
    For i& = 1 To 100000000
        x## = x## * y##
    Next
    t! = Timer - t!

What do we have here? 100,000,000 iterations of a simple floating point operation. On an AMD 64 CPU, PowerBASIC 3.5 for DOS runs this loop in 1.977 seconds. Pretty respectable, we think. PB3 has been benchmarked favorably against every sort of compiler... C++, Pascal, QuickBasic, you name it. It's always competitive.

So what about the 32-bit PowerBASIC? Same computer. Same operating system (WinXP Pro). Same source code, line for line. No attempt to minimize any background tasks. Elapsed time: 0.209 seconds. May we repeat that? Elapsed time: 0.209 seconds. That's an instant gain of around 945%! Win32 versions of PowerBASIC are more than nine times faster than the best DOS Basic around!

Just like PowerBASIC for DOS, our console compiler creates text mode applications. They just run faster, deal with gigabytes of memory, and offer access to the Win32 API. And since the source code is so similar to PB3 and QB45, it's incredibly easy porting DOS code to Windows today!

A complete Macro facility is an exciting addition to the latest version, and that's something seldom seen in a high level language. Essentially, a Macro invokes a text substitution engine which allows you to extend the PowerBASIC language in ways not seen before. PowerBASIC supports single line macros, multi-line macros, even function macros which return a result. And they don't occupy one byte of code space unless actually used. Each macro may take up to 240 arguments, so configurability shouldn't be an issue. MACROTEMP may even be used to specify identifiers which are made unique to each macro expansion, thus avoiding name conflicts. With PowerBASIC macros, you can design your own unique, personal language!

PowerBASIC is entirely thread-safe, so multi-threaded applications are a breeze. Isn't it good to know your program can handle 2, 3, or 5000 tasks, all at the same time? You can print a report, while still allowing data entry. Watch for a hardware signal, while calculating data services. All the power you need is packed right into the PowerBASIC THREAD Statement, along with its simple extensions. PowerBASIC even offers THREADED variables for "Thread Local Storage" -- each THREAD get its own unique copy of the variable -- automatically.

Client COM services, and support for the Automation Interface lets you tap the power of components. Invoke libraries and applications with ease, all controlled from your PowerBASIC client program. Invoke an instance of Microsoft Word, load and edit documents, all under the control of PowerBASIC? It's all there now, waiting for your command...

The PowerBASIC IDE had a serious makeover, and we think you'll like the results. First, the editor has block indent/outdent and block comment/uncomment! Then add more undo space, bookmarks in the editor, and source file templates, too. Debug load/unload is faster, and file save offers tab compression for even smaller files. The debugger and editor are unified, so you can set breakpoints in advance, even in include files. How many times have you wondered "Is there an array bounds error somewhere?" or "Where's that pointer error?" Well, here's how you find it! Just set the debugger to "Break on error". Your program runs normally, in the debugger, but halts as soon as any error is generated -- even if you have no error handlers installed. The new watch windows for variables and registers are moveable and resizable -- and all dialogs remember the last used size and location. Help files for add-ons are supported, and there's a direct link to Win32 API help, too. There's color syntax highlighting with selectable colors, fonts, and keyword case. Printed listings in color. The "Code Finder" list view shows every sub, function and macro name, aliases, types, and line numbers. You can sort on any column, in either direction, and change the column order in a flash. All this, and even more, make the new IDE a joy to use.

Extra debugging tools? PowerBASIC shines with an array of built-in functions. PROFILE gives an overview. A list of every sub and function, how many times each was called, and the total time spent executing each of them. CALLSTK captures all stack frames above you. It answers, "How did I get here?". TRACE generates an execution log of each sub, function, label, and TRACE PRINT, as they're executed in sequence. It gives you parameter values, return values, even error codes. TRACE answers "Where have I been?", and "How did I get here?". With these tools, debugging might now be fun!

You know, a quality compiler must offer data types to suit the needs. And PowerBASIC handles that with ease. Signed and unsigned integers to 64-bit. Single, double, and extended precision float. Two forms of currency. Dynamic strings, fixed strings, ASCIIZ strings. User-defined Types and Unions. Guids. Variants, pointers, and more. Now, we've added BIT and SIGNED BIT variables in TYPES and UNIONS. Each may be from 1 to 31 bits wide, packed one after another. Perfect for bit coding, or translation from C code. And FIELD variables? They work with the new FIELD statement, just like in DOS versions of BASIC. A FIELD is a string, mapped to a specific section of a file buffer, or even another string. They're allocated at run-time, so they can be changed as needed. Much like a TYPE that can be altered under program control. Best of all, a new internal design makes them fast, fast, fast!

Pointers are great, but sometimes the syntax is daunting, particularly for very simple tasks. So we implemented Dynamic Pointers, using the original PEEK/POKE as a model: xx# = PEEK(DOUBLE,addr&) This retrieves the double precision value stored at addr&, assigning it to xx#. Very straightforward and it works for all data types. And unlike the old PEEK and POKE, it's just as fast as a pointer variable! Speaking of simplification, LOCAL, STATIC, GLOBAL, and RESET can now use a list of variables, like: STATIC abc, bcd, xyz AS STRING And, ARRAY ASSIGN lets you assign values to every element of an array in a single statement!

Tired of the hassle of "drag and drop form designers"? Lost in a sea of API calls just to display text and numbers in a window? With Classic PowerBASIC Console Compiler, it's a whole new Windows! Compile Basic code to sizzling text mode programs. For Windows 95, 98, Me, NT, 2000, XP, Vista, and Win7. Put your programming effort where it belongs -- at the core of your code. And when your calculations are complete, it's a simple matter to PRINT, or even LPRINT, the results!

Did you say Internet? Create CGI apps for your web server! It's the perfect tool. Classic PowerBASIC Console Compiler offers Standard Input & Output for easy communication. Get standalone executables as small as 10K. All with no run-time requirements of any kind. Whether your program looks up names, or simply calculates a mortgage, it can take data from a web form, process as needed, then deliver the results right to the browser of a distant end user.

You know, a typical shopping cart program written in Visual Basic needs some 5 Megabytes of RAM. So, using VB, you may find you're limited to around 20 simultaneous connections. But use Classic PowerBASIC Console Compiler instead, and memory needs plummet! To around 100K total! That means 1000 simultaneous connections on that very same Web Server!

Built-in support for TCP and UDP means that your application can now communicate with far-away servers on the Internet or local servers on your Intranet. Send email messages with SMTP. Download web pages using HTTP. Even create your own TCP or UDP server for communication with other applications.

High-speed Serial Communications means you can can access modems or other serial devices without struggling with obscure API calls. Dial into remote computers that aren't connected to the internet with just a few lines of code.

Special features of Classic PowerBASIC Console Compiler

• Classic PowerBASIC Console Compiler is compatible with all versions of Windows from Win95 through WinVista and Win7.
• #COMPILER defines the compiler for this program
• #STACK sets the program stack size
• ACODE$() translates unicode strings to ansi
• ARRAY ASSIGN assigns values to multiple elements of an array
• ARRAY SORT, SCAN, INSERT, DELETE
• ARRAYATTR() returns status, data type, subscripts, etc.
• ASCIIZ strings supported for Windows compatibility
• Assembler is built-in for opcodes through Pentium class
• BIN$() allows optional leading zeros to a fixed field size
• BIT CALC set/reset a bit based upon a dynamic calculation
• BIT SHIFT, ROTATE, TEST, SET, RESET and TOGGLE
• BITS() function for bit pattern conversion between signed/unsigned
• CALLSTK captures the entire stack frame
• CHOOSE(index&, choice1, choice2...) chooses one of several values
• CHR$() function may take multiple or a range of parameters
• Client COM/Automation Support - Access and manipulate COM Objects
• Client/Server Network communications using TCP and UDP
• CLSID$(program_id$) returns the associated CLSID
• Code pointer variables particularly suitable for callbacks
• COLOR sets the foreground and background colors for displaying text
• COMM Retrieves the value or status of a communications parameter
• COMM CLOSE closes an open serial port
• COMM LINE receives a CR/LF terminated "line" of data from a serial port
• COMM OPEN opens a serial port
• COMM PRINT sends a "line" of binary data through a serial port
• COMM RECV receives binary data from a serial port
• COMM RESET disables flow control for a given serial port
• COMM SEND sends a string of binary data through a serial port
• COMM SET sets communication options for a serial port
• COMMAND$ returns the command-line used to start the program
• CONSOLE GET LOC retrieves the location of the console window on the screen
• CONSOLE GET SCREEN retrieves the size of the visible part of the console window
• CONSOLE GET SIZE retrieves the size of the console window
• CONSOLE GET VIEW retrieves the position of the viewable part of a virtual screen
• CONSOLE GET VIRTUAL retrieves the size of the screen buffers associated with the console win
• CONSOLE NAME sets the name of the console window caption
• CONSOLE SCREEN changes the size of the console window
• CONSOLE SET FOCUS brings the console window to the foreground and direct the focus to it
• CONSOLE SET LOC moves the console window to a new location on the screen
• CONSOLE SET SCREEN changes the size of the console window and its associated screen buffers
• CONSOLE SET VIEW sets the position of the viewable part of a virtual screen
• CONSOUT determines if standard output has been redirected
• Compile to true machine code for maximum performance
• Conditional compilation (#IF/#ELSEIF/#ELSE/#ENDIF)
• CONSHNDL returns the handle of the Console Window
• CSET centers data within a string with optional padding character
• Currency variables with choice of two or four decimal digits
• CURSOR returns and sets the size status of the caret
• CURSORX returns the current column of the caret
• CURSORY rReturns the current row of the caret
• Data pointer variables with multiple levels of indirection
• DECR statement for optimized execution
• DESKTOP GET CLIENT retrieves the client size of the desktop
• DESKTOP GET LOC retrieves the location of the client area of the desktop
• DIR$ Returns a filename that matches the given mask and optional attribute
• DESKTOP GET SIZE retrieves the total size of the desktop
• DISKFREE function returns the free space
• DISKSIZE function returns the disk size
• ENVIRON modifies environment variables
• ERL retrieves the last line number executed before an error occurred
• Extended-precision (80-bit) floating point variables
• EXTRACT$() returns characters up to a delimiter
• FIELD defines the variables of a file buffer or a FIELD string
• FILEATTR enumerates file numbers in use
• FILECOPY Statement supports overwrite of a previous version
• FILENAME$() function returns the name of an open file
• FILESCAN obtains the number of strings in a file
• FLUSH statement ensures file data buffers are written to disk
• FUNCNAME$ returns the name of the current Sub/Function
• GETATTR returns the file-system attribute(s) of a disk file or directory
• GETSTDERR returns the handle of the initial standard error device
• GETSTDIN returns the handle of the initial standard input device
• GETSTDKBD returns the handle of the standard keyboard device
• GETSTDOUT returns the handle of the initial standard output device
• GETSTDVID returns the handle of a nominated console video page
• GLOBAL may declare a list of variables of one type
• GRAPHIC ARC draws an arc
• GRAPHIC ATTACH selects a window or bitmap for drawing
• GRAPHIC BITMAP END closes a graphic bitmap
• GRAPHIC BITMAP LOAD loads a bitmap from a resource or disk
• GRAPHIC BITMAP NEW creates an empty memory bitmap
• GRAPHIC BOX draws a box with square or rounded corners
• GRAPHIC CHR SIZE retrieves the character size of the selected font
• GRAPHIC CLEAR erases a window or bitmap
• GRAPHIC COLOR sets the default colors
• GRAPHIC COPY copies a bitmap to a window or another bitmap
• GRAPHIC ELLIPSE draws an ellipse or circle
• GRAPHIC FONT selects a font and style for GRAPHIC PRINT
• GRAPHIC GET BITS retrieves a device independent bitmap
• GRAPHIC GET CLIENT retieves the client size of a graphic window or bitmap
• GRAPHIC GET DC retrieves the Device Context handle
• GRAPHIC GET LOC retrieves the screen location of a graphic window
• GRAPHIC GET MIX retrieves the color mix mode
• GRAPHIC GET PIXEL retrieves the color of a specific pixel
• GRAPHIC GET POS retrieves the last graphic point referenced
• GRAPHIC GET PPI retrieves the resolution of the display device
• GRAPHIC LINE draws a line
• GRAPHIC PAINT fills an area with a color or pattern
• GRAPHIC PIE draws a pie section
• GRAPHIC POLYGON draws a polygon
• GRAPHIC POLYLINE draws a polyline
• GRAPHIC PRINT draws text on a graphic window or bitmap
• GRAPHIC REDRAW updates buffered graphics to a window or bitmap
• GRAPHIC RENDER draws an image on a graphic window or bitmap
• GRAPHIC SAVE stores an image to a bitmap (.BMP) file
• GRAPHIC SCALE defines a custom coordinate system for a window or bitmap
• GRAPHIC SET BITS redraws a device independent bitmap
• GRAPHIC SET FOCUS directs focus to a graphic window
• GRAPHIC SET LOC moves a graphic window
• GRAPHIC SET MIX changes the color mix mode
• GRAPHIC SET PIXEL changes the color of a specific pixel
• GRAPHIC SET POS changes the last graphic point referenced
• GRAPHIC STRETCH copies and stretches a bitmap image
• GRAPHIC STYLE changes the drawing line style
• GRAPHIC TEXT SIZE calculates the size of text to be printed
• GRAPHIC WIDTH changes the drawing line style
• GRAPHIC WINDOW END closes a graphic window
• GRAPHIC WINDOW creates a new graphic window
• GUID variables are supported for COM Objects.
• HEX$() allows optional leading zeros to a fixed field size
• HI returns the high part of many data types
• Huge file sizes greater than 2 Gigabytes are supported
• IIF(expr, truepart, falsepart) returns one of two values
• INCR statement for optimized execution
• INKEY$ reads a keyboard character or mouse event from the input buffer, without echoing it to the screen
• INPUT reads a line from the keyboard
• INPUT # loads variables with data from a sequential file
• INPUT FLUSH empties all pending keyboard and mouse events from the input buffer
• INSHIFT returns the state of the keyboard Shift, Ctrl and/or Alt keys
• INSTAT Determine whether a keyboard or mouse event is ready to be retrieved from the input buffer
• ISFALSE and ISTRUE operators
• ITERATE statement restarts loop structures
• JOIN$ adds a binary option for enhanced data packing
• JOIN$() packs a string array into a dynamic string
• KEY assigns a string expression to a function key (F1 to F12)
• KEY$ retrieves the string expression assigned to a function key
• LEFT$ may take a negative length value
• LINE INPUT reads an entire line from the keyboard
• LINE INPUT #1, x$() reads an entire sequential file
• LO returns the low part of many data types
• LOCAL may declare a list of variables of one type
• LOCATE sets the caret position
• LPRINT ATTACH selects a line printer to be used for LPRINT
• LPRINT CLOSE disconnects the line printer
• LPRINT FLUSH sends any buffered text to the line printer
• LPRINT FORMFEED starts a new printer page
• LPRINT outputs text to a line printer
• LPRINT$ retrieves the name of the attached line printer
• MACRO defines a single-line, multi-line, or function Macro
• MACROTEMP defines Temporary identifiers
• MAK creates values of many data types
• MAT statement provides optimized Matrix operations
• MAX() and MAX$() functions take an unlimited number of arguments
• MID$ may take a negative length value
• MIN() and MIN$() functions take an unlimited number of arguments
• MOUSE turns mouse event trapping on and off and defines which mouse events are to be trapped
• MOUSEBUTTONS returns the number of buttons on the system mouse
• MOUSESTAT determines if a mouse event is waiting to be retrieved from the input buffer
• MOUSEX returns the current column position (x coordinate) of the mouse cursor
• MOUSEY returns the current row position (y coordinate) of the mouse cursor
• Native support for I/O redirection (STDOUT, STDIN and STDERR)
• NUL$ creates a string of nul characters
• OCT$() allows optional leading zeros to a fixed field size
• PAGE determines which of 8 console text pages is active and/or visible
• PAGEACTIVE returns the current active page number
• PAGEVISIBLE returns the current visible page number
• PCOPY copies all text from one console text page (screen) to another
• PARSE adds a binary option for enhanced data packing
• PARSE assigns each delimited string to an array element
• PARSE$ adds a binary option for enhanced data packing
• PARSE$() function extracts a delimited field from a string
• PARSECOUNT adds a binary option for enhanced data packing
• PARSECOUNT returns the count of delimited fields in a string
• PEEK acts as a dynamic pointer for any data type
• PEEK acts as a dynamic pointer for any data type
• PEEK$ acts as a dynamic pointer for strings
• PEEK/POKE, PEEK$/POKE$ for memory access
• POKE acts as a dynamic pointer for any data type
• POKE$ acts as a dynamic pointer for strings
• PRINT writes data to the current console text page
• PRINT #1, x$() writes an entire array to a sequential file
• PRINTER$ retrieves printer names and printer port names
• PRINTERCOUNT retrieves the number of installed printers
• PROFILE creates a complete profile of program execution
• PUT #1,, x$() writes an entire array to a binary file
• Quad-word 64-bit integer variables
• READ$(n) function returns a specific DATA item
• Register variables for both integer and floating point optimization
• Regular Expression Search and Replace
• REMAIN$() returns the remainder of a string after extraction
• REMOVE$() returns a string with certain characters removed
• REPEAT$() repeats an entire string expression
• REPLACE statement replaces characters or expressions
• RESET may accept multiple parameters
• RESET var sets a variable or array to zero or null
• RESUME NEXT jumps after a statement which caused an error
• RESUME retries a statement which caused an error
• RIGHT$ may take a negative length value
• RND(x,y) returns a random integer between x and y
• ROUND() function rounds a number to n decimal digits
• SETEOF statement sets the end-file position
• SHELL offers a HANDLES option
• SERIAL port communication is directly supported at all speeds
• SETEOF statement sets the end-file position
• STATIC may declare a list of variables of one type
• STDEOF returns TRUE (non-zero) if the end of standard input has been reached
• STDERR outputs a string expression to the standard error device
• STDIN LINE reads one line of text from the standard input device
• STDOUT outputs a string expression to the standard output device
• Short-Circuit expression evaluation optimizes execution speed
• STRDELETE$() deletes a portion of a string
• String functions support ANY operator to operate on character basis
• String functions support negative position to count from string end
• STRINSERT$() inserts a string into another string
• STRREVERSE$() reverses the character sequence in a string
• SUB/FUNCTION may take up to 32 parameters
• SWITCH(expr1, value1, expr2, value2...) returns one of a series
• TAB$() expands tab characters to a specified tabstop
• TALLY() counts the occurrences of a sub-string expression
• Threads are supported as an intrinsic part of the language
• THREADCOUNT returns the number of active threads
• THREADED declares Thread Local Storage variables
• THREADID function returns the thread identifier
• TRACE creates a trace log of complete program execution
• TRY, CATCH, FINALLY, END TRY offers structured error handling
• TYPE offers BIT and SIGNED BIT member variables
• UCODE$() translates ansi strings to the unicode equivalent
• UNION offers BIT and SIGNED BIT member variables
• USING$() function formats one or more expressions
• Unsigned byte, word, and double word variables
• User-Defined Types and Unions with optional alignment
• VARIANTVT() returns the internal VT data type code
• VERIFY() validates that all characters in string1 occur in string2
• WAITKEY$ reads a character or mouse event from the input buffer, without echoing the character to the screen
• WAITSTAT waits until a key is pressed or a mouse event occurs
• Variant variables are supported for COM Objects.
• Windows API may be easily accessed with no limitations
• XPRINT ARC draws an arc
• XPRINT ATTACH selects a host-based (GDI) printer for XPRINT
• XPRINT BOX draws a box with square or rounded corners
• XPRINT CANCEL aborts a print job
• XPRINT CHR SIZE retrieves the character size of the selected font
• XPRINT CLEAR erases a window or bitmap
• XPRINT CLOSE detaches a printer so printing can begin
• XPRINT COLOR sets the default colors
• XPRINT COPY copies a bitmap to the host printer
• XPRINT ELLIPSE draws an ellipse or circle
• XPRINT FONT selects a font and style for XPRINT
• XPRINT FORMFEED starts a new printer page
• XPRINT GET CLIENT retieves the client size of the host printer page
• XPRINT GET DC retrieves the Device Context handle
• XPRINT GET LINES retrieves the number of lines which can be printed
• XPRINT GET MARGIN retrieves the margin sizes
• XPRINT GET MIX retrieves the color mix mode
• XPRINT GET ORIENTATION retrieves the paper orientation
• XPRINT GET PIXEL retrieves the color of a specific pixel
• XPRINT GET POS retrieves the last point referenced
• XPRINT GET PPI retrieves the resolution of the host printer
• XPRINT GET QUALITY retrieves the print quality setting
• XPRINT GET SIZE retrieves the total page size
• XPRINT LINE draws a line
• XPRINT PIE draws a pie section
• XPRINT POLYGON draws a polygon
• XPRINT POLYLINE draws a polyline
• XPRINT RENDER draws an image on the host printer page
• XPRINT SCALE defines a custom coordinate system for a window or bitmap
• XPRINT SET MIX changes the color mix mode
• XPRINT SET ORIENTATION changes the paper orientation
• XPRINT SET PIXEL changes the color of a specific pixel
• XPRINT SET POS changes the last point referenced
• XPRINT SET QUALITY changes the print quality setting
• XPRINT STRETCH copies and stretches a bitmap image
• XPRINT STYLE changes the drawing line style
• XPRINT TEXT SIZE calculates the size of text to be printed
• XPRINT WIDTH changes the drawing line style
• XPRINT draws text on a "Windows-Only" (GDI) printer
• XPRINT$ retrieves the name of the attached host printer

Classic PowerBASIC Console Compiler is priced at $49. Delivery costs are additional.