Here follows the description of some of my test code
(very crude, these are quick and dirty examples i use to debug things)

Under Windows , run these programs FULL SCREEN in exclusive mode
(i've included some Windows 3.1 PIF files to show you how to set 'em
 use the Windows PIF editor to look into them).
Assembling these programs you will need at least 256k of free low memory
and 128k of free extended memory, if you have not, try to reduce
the EXTMIN and LOWMIN constants declared into 386Power.inc
(the minimum value for EXTMIN must be 64)

To compile these you'll need Borland's TASM and MAKE utilities
or equivalent programs (if you use MASM you will have to change
some makefile options and syntax)

To run EXAMPLE0 remember to set text mode to 80x25
Yeah! 386P initializes in mode 03h, that usually is 80x25
but on some sistems it can be set to different values
and the "raw" text i/o code into example0 was coded
to deal with 80x25. 
Of course startup & shutdown messages are not affected
(they use bios calls).

EXAMPLE0.ASM
        Create it typing:
                make example0
                
        It tries to "get up" (386P check)
        detecting system type (VCPI,DPMI,XMS,HARD)
        and cpu type (386,486,Pentium or "successive")
        then reads the file hello.txt
        and writes it to screen in text mode.
        Sees if there are arguments on the command line & then
        displays them if present.
        Then shows an example of "raw" keyboard
        handling (press & release keys to see what key you pressed).
        The _RKB table is cleared at every keypress.
        Pressing ESC you terminate the program.
        First execute it as:
        example0
        Then try to run it with the following options to see how
        command line parameters are read:
        example0 -THESE these -ARE are -OPTIONS filenames
        example0 hocus.pocus -FOOBAR 638398 -657 good*day inter*.zip -OK
        
TED.ASM
        Assemble with:
             make ted
        Execute typing:
                ted
        This is a simple "Tiled background EDitor".
        It reads the CHARSET.CBF font file and the TILES.TBF tile file
        and lets you edit a .TMF file or create a new one.
        When it starts, it loads a PCX "program name image"
        then when you press any key
        it "opens" a menu demo with one active submenu
        (look in the submenu to see if the current XVD.XVD driver
         has been loaded and if it has been properly installed)
        (see the "flags" for driver found, bios check, hardware check
         and mode initialized) (n.b. those flags can be modified by you
         within the menu, but this has no effects on the program)
        (by the way, TED.ASM is useful when you have to test
         the xvd driver you devenloped and want to see where it fails)
        ( up/down arrows to change menu entry
          left/right to decrese/increse values
          ENTER for "direct input" )
        Pressing ESC or selecting the first entry you get into the
        "tile map editor" (sort of)
        Notice the menu entries can be "fully programmed" with bound
        checking and "automatic correction", what's more, multiple
        input methods are possible for numeric values.


        The numbers in the lower window are:
        FRAME_RATE   TIME_COUNT_FROM_PROGRAM_START (truncated to 32bit)
        MOUSE_X      MOUSE_Y
        There is also a "horizontal position" indicator
        (a black line with a white point "stretching" it
         and then "moving inside it") this because the "virtual screen"
         is TEN TIMES the screen width (and "only" TWO times the screen
         height).

        esc   = exit from program
        <- -> = (left/right cursor) change "selected" tile
        F2 F3 = load/save tile file
        mouse click = write "selected" tile
                      (the leftmost one on the tile scrollbar)

        Move the cursor "hand" to the screen borders to scroll around.
        Your initial position is the top-left "virtual screen" border.
        THIS PROGRAM WILL USE THE DEFAULT XSD DRIVER (XSD.XSD)
        IF PRESENT (i've included a driver for my chips&tech 450 vga card)
        AND THE HARDWARE CHECK IS OK
        else is the driver is not present or the install check fails
        it will use the "integral" mode 13h driver.
        (with an xsd driver capable to drive directly your card you totally
         eliminate flicker and get better looking scrolling).
        When you "move the mouse" without scrolling the "delta blitting"
        (_PageFlip1)
        method is used, while when you "click" or scroll around
        the "brute force blit-everything" (_PageFlip0) method is used
        THIS WAY YOU CAN QUICKLY SEE THE "difference" BETWEEN ONE METHOD
        AND THE OTHER.

        N.B. The current "delta blitting" method is the SIMPLEST USEFUL
             delta blitting method.
             Knowing what you want from your program
             you can "customize" the delta blitting strategy
             and use it for scrolling too!
             (a GENERIC "delta blit" method cannot take advantage
              of the things you know the program will do
              so you cannot optimize it to get fast scrolling, that's why
              i simply used a "brute force" method to blit the screen
              image when scrolling)
             [Heck! I need to keep some "secrets" to get an edge!]
             [But i gave you enough hints to let you code an
              "improved" delta-blit routine] [See the docs and the source
              code].
        
JOY.ASM
        Make it with:
                make joy
        A sample program showing you how to calibrate the joystick
        and use the 386joy.asm module.
        It uses XSD.XSD too!

VGAREG.ASM
        Make it with:
                make vgareg.asm
        This program simply gets in protected mode and then
        tries to read the values of VGA/SVGA internal registers
        then it writes the values into vgareg.tbl
        this is useful when you want to see what are the internal register values
        to make an enhanced video driver for your card.

PCX2TBF.ASM
        Make it with:
                make pcx2tbf
        This program accepts two file names from the command line
        the first file must be a .PCX 320x200 256 colors image
        the second is the destination files (usually a .TBF one).
        The pcx file is subdivided into a "matrix"
        of 10*7 "patterns" 32x24 pixel each
        and then the patterns are stored sequentially into the .TBF file.
        (you can use the TBF files to edit tiled maps with TED)
        If you want to make TBF files with more than 70 patterns
        simple "join" (using the copy command with the "+" parameters
        and the "/B" switches) the TBF files produced by PCX2TBF
        into a single TBF file.

PCX2CBF.ASM
        Make it with:
                make pcx2cbf
        This is the "character bitmap" converter
        it works in a way similar to PCX2TBF but generates
        256 8x8 patterns the CHARIO.ASM module uses to draw characters.
        It also estracts the "character palette" entries
        so when you load a character set it will always "start"
        with its default color palette.
        (SEE FILEFMTS.TXT FOR MORE INFO)

