ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng)/ProfitPress-MegaCDROM2.B6I/PROG/PASCAL/OMOUSE.ZIP/OMOUSE.DEM

Text File | 1990-02-23 | 21.1 KB | 941 lines

{

    omouse.dem
    2-23-90
    Demo Omouse unit in graphics mode.

    Copyright 1990
    John W. Small
    All rights reserved

    PSW / Power SoftWare
    P.O. Box 10072
    McLean, Virginia 22102 8072
    [phone]

}


program omouseDemo;

    uses crt, graph, omouse, graphtxt, polylist;

    type

        EaselPtr = ^Easel;
        Easel = object(pmoList)
            toolx, toolw, toolh,            { tool dimension }
            toolsc, toolc,                    { Default tool color }
            toolscb, toolcb,
            color, background : integer;    { current tool color }
            doItDrawID : pointer;            { InterTool comm }
            quit : boolean;
            constructor init;
            procedure SelectTool(sx, sy : integer);
            procedure toolDraw(toolID : pointer;    { InterTool comm }
                c, b : integer);
            procedure doIt;
            procedure toolDoIt(toolID : pointer);    { InterTool comm }
            destructor done; virtual;
            end;

        PaintToolPtr = ^PaintTool;
        PaintTool = object(pmoNode)
            doItDraw : boolean;
            constructor init(did : boolean);
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        TextToolPtr = ^TextTool;
        TextTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        LineToolPtr = ^LineTool;
        LineTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        RectToolPtr = ^RectTool;
        RectTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        EllipseToolPtr = ^EllipseTool;
        EllipseTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        FillToolPtr = ^FillTool;
        FillTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        ClearToolPtr = ^ClearTool;
        ClearTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        QuitToolPtr = ^QuitTool;
        QuitTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        ColorToolPtr = ^ColorTool;
        ColorTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;

        PaletteToolPtr = ^PaletteTool;
        PaletteTool = object(PaintTool)
            constructor init;
            procedure draw; virtual;
            procedure select; virtual;
            procedure doIt; virtual;
            destructor done; virtual;
            end;


    constructor Easel.init;
        begin
            pmoList.init;
            ique(new(TextToolPtr,init));
            ique(new(LineToolPtr,init));
            ique(new(RectToolPtr,init));
            ique(new(EllipseToolPtr,init));
            ique(new(FillToolPtr,init));
            ique(new(ClearToolPtr,init));
            ique(new(QuitToolPtr,init));
            ique(new(ColorToolPtr,init));
            ique(new(PaletteToolPtr,init));
            toolw := (GetMaxX + 1) div 8;
            toolx := GetMaxX - toolw + 1;
            toolh := (GetMaxY + 1)  div nodes;
            if GetMaxColor > 3 then begin
                { Readln mode, see graphtxt }
                InputWriteMode := XORPut;
                InputRewrite := true;
                toolsc := RED;
                toolscb := LIGHTGRAY;
                toolc := BLUE;
                toolcb := LIGHTGRAY
                end
            else if GetMaxColor > 1 then begin
                InputWriteMode := CopyPut;
                InputRewrite := false;
                toolsc := BLACK;
                toolscb := GetMaxColor;
                toolc := BLUE;
                toolcb := BLACK
                end
            else begin
                InputWriteMode := CopyPut;
                InputRewrite := false;
                toolsc := GetMaxColor;
                toolscb := BLACK;
                toolc := BLACK;
                toolcb := GetMaxColor
                end;
            color := toolc;
            background := toolcb;
            SetColor(background);
            SetBkColor(color);
            if (GetMaxX < 320) or (GetMaxY < 200) then
                SetTextStyle(SmallFont,HorizDir,4)
            else
                SetTextStyle(TriplexFont,HorizDir,3);
            SetTextJustify(CenterText,CenterText);
            quit := false
        end;

    procedure Easel.SelectTool(sx, sy : integer);
        var newTool, lastToolNum : word;
            y : integer;
        begin
            if sx > toolx then begin
                y := toolh;
                newTool := 1;
                while y < (sy + 1) do begin
                    inc(y,toolh);
                    inc(newTool)
                    end;
                if newTool <= nodes then begin
                    lastToolNum := curNum;
                    doItDrawID := TypeOf(current^);
                    color := toolc;
                    background := toolcb;
                    PaintToolPtr(current)^.draw;
                    mkcur(newTool);
                    if PaintToolPtr(current)^.doItDraw then
                        doItDrawID := TypeOf(current^);
                    color := toolsc;
                    background := toolscb;
                    PaintToolPtr(current)^.select;
                    if not PaintToolPtr(current)^.doItDraw then begin
                        mkcur(lastToolNum);
                        PaintToolPtr(current)^.select
                        end
                    end
                end
        end;

    procedure Easel.toolDraw(toolID : pointer;
                c, b : integer);
        var lastTool : word;
            finished : boolean;
            tmpc, tmpb : integer;
        begin
            lastTool := curNum;
            mkcur(0);
            finished := false;
            while not finished do
                if next then begin
                    if TypeOf(current^) = toolID then begin
                        tmpc := color;
                        color := c;
                        tmpb := background;
                        background := b;
                        PaintToolPtr(current)^.draw;
                        color := tmpc;
                        background := tmpb;
                        finished := true
                        end
                    end
                else
                    finished := true;
            mkcur(lastTool)
        end;

    procedure Easel.doIt;
        begin
            if not mouse.Present then exit;
            toolDoIt(TypeOf(ClearTool));
            color := toolc;
            while next do
                PaintToolPtr(current)^.draw;
            mkcur(1);
            color := toolsc;
            background := toolscb;
            doItDrawID := TypeOf(current^);
            PaintToolPtr(current)^.select;
            MoveTo(GetMaxX div 2, GetMaxY div 2);
            writeln('Easel is a primitive paint program');
            writeln('used to demostrate the omouse unit.');
            writeln('Press the left mouse button to select');
            writeln('a paint tool.  The right mouse button');
            writeln('selects the background color when the');
            writeln('mouse cursor is over the palette');
            writeln('colors.  Start off by clearing');
            writeln('this message.');
            mouse.reset;
            mouse.AutoEventUpdate;
            mouse.UserCount := mouse.EventCount;
            mouse.show;
            while not quit do begin
                while mouse.UserCount = mouse.EventCount do;
                if (mouse.x > toolx) then begin
                    if mouse.LeftPressed then
                        SelectTool(mouse.LastLeftPressX,
                            mouse.LastLeftPressY)
                    else if mouse.RightPressed then
                        SelectTool(mouse.LastRightPressX,
                            mouse.LastRightPressY)
                    end
                else if mouse.LeftPressed then begin
                    mouse.trap(0,0,toolx-1,GetMaxY);
                    SetViewPort(0,0,toolx-1,GetMaxY,ClipOn);
                    PaintToolPtr(current)^.doIt;
                    mouse.trap(0,0,GetMaxX,GetMaxY);
                    SetViewPort(0,0,GetMaxX,GetMaxY,ClipOff);
                    end;
                mouse.UserCount := mouse.EventCount;
                end;
        end;

    procedure Easel.toolDoIt(toolID : pointer);
        var lastTool : word;
            finished : boolean;
        begin
            lastTool := curNum;
            mkcur(0);
            finished := false;
            while not finished do
                if next then begin
                    if TypeOf(current^) = toolID then begin
                        PaintToolPtr(current)^.doIt;
                        finished := true
                        end
                    end
                else
                    finished := true;
            mkcur(lastTool)
        end;

    destructor Easel.done;
        begin
            pmoList.done
        end;




    constructor PaintTool.init(did : boolean);
        begin
            doItDraw := did
        end;

    procedure PaintTool.draw;
        var FS : FillSettingsType;
            LS : LineSettingsType;
            c, y : word;
        begin
            mouse.hide;
            with EaselPtr(list)^ do begin
                GetFillSettings(FS);
                SetFillStyle(SolidFill,background);
                GetLineSettings(LS);
                SetLineStyle(SolidLn,0,NormWidth);
                c := GetColor;
                SetColor(color);
                SetWriteMode(CopyPut);
                y := (curNum-1)*toolh;
                bar3d(toolx,y,toolx+toolw-1,y+toolh-1,
                    0,false);
                SetFillStyle(FS.Pattern,FS.Color);
                SetLineStyle(LS.LineStyle,LS.Pattern,
                    LS.Thickness);
                SetColor(c)
                end;
            mouse.show
        end;

    procedure PaintTool.select;
        begin
            draw
        end;

    procedure PaintTool.doIt;
        begin
        end;

    destructor PaintTool.done;
        begin
        end;


    constructor TextTool.init;
        begin
            PaintTool.init(true)
        end;

    procedure TextTool.draw;
        var c : word;
        begin
            mouse.hide;
            PaintTool.draw;
            c := GetColor;
            with EaselPtr(list)^ do begin
                SetColor(color);
                OutTextXY(toolx + toolw div 2,
                    (curNum-1)*toolh + toolh div 2,'T')
                end;
            SetColor(c);
            mouse.show
        end;

    procedure TextTool.select;
        begin
            draw
        end;

    procedure TextTool.doIt;
        begin
            MoveTo(mouse.LastLeftPressX,mouse.LastLeftPressY);
            while mouse.LeftPressed do;
            mouse.hide;
            readln;
            mouse.show;
        end;

    destructor TextTool.done;
        begin
        end;


    constructor LineTool.init;
        begin
            PaintTool.init(true)
        end;

    procedure LineTool.draw;
        var LS : LineSettingsType;
            c, y : word;
        begin
            mouse.hide;
            PaintTool.draw;
            GetLineSettings(LS);
            SetLineStyle(SolidLn,0,NormWidth);
            c := GetColor;
            with EaselPtr(list)^ do begin
                y := (curNum-1)*toolh;
                SetColor(color);
                line(toolx + toolw div 4 * 3, y + toolh div 4,
                    toolx + toolw div 4, y + toolh div 4 * 3)
                end;
            SetLineStyle(LS.LineStyle,LS.Pattern,
                LS.Thickness);
            SetColor(c);
            mouse.show
        end;

    procedure LineTool.select;
        begin
            draw
        end;

    procedure LineTool.doIt;
        begin
            SetWriteMode(XORPut);
            mouse.UserX := mouse.x;
            mouse.UserY := mouse.y;
            mouse.hide;
            line(mouse.LastLeftPressX,
                mouse.LastLeftPressY,
                mouse.UserX,mouse.UserY);
            mouse.show;
            mouse.EventMoved := 0;
            while (mouse.LeftPresses >
                mouse.LeftReleases) do begin;
                if mouse.EventMoved > 0 then begin
                    mouse.hide;
                    line(mouse.LastLeftPressX,
                        mouse.LastLeftPressY,
                        mouse.UserX,mouse.UserY);
                    mouse.UserX := mouse.x;
                    mouse.UserY := mouse.y;
                    line(mouse.LastLeftPressX,
                        mouse.LastLeftPressY,
                        mouse.UserX,mouse.UserY);
                    mouse.show;
                    mouse.EventMoved := 0;
                    end;
                end;
            SetWriteMode(CopyPut);
            mouse.hide;
            line(mouse.LastLeftPressX,
                mouse.LastLeftPressY,
                mouse.UserX,mouse.UserY);
            mouse.show;
        end;

    destructor LineTool.done;
        begin
        end;


    constructor RectTool.init;
        begin
            PaintTool.init(true)
        end;

    procedure RectTool.draw;
        var LS : LineSettingsType;
            c, y : word;
        begin
            mouse.hide;
            PaintTool.draw;
            GetLineSettings(LS);
            SetLineStyle(SolidLn,0,NormWidth);
            c := GetColor;
            with EaselPtr(list)^ do begin
                SetColor(color);
                y := (curNum-1)*toolh;
                rectangle(toolx + toolw div 4,
                    y + toolh div 4,
                    toolx + toolw div 4 * 3,
                    y + toolh div 4 * 3);
                end;
            SetLineStyle(LS.LineStyle,Ls.Pattern,
                LS.Thickness);
            SetColor(c);
            mouse.show
        end;

    procedure RectTool.select;
        begin
            draw
        end;


    procedure RectTool.doIt;
        begin
            SetWriteMode(XORPut);
            mouse.UserX := mouse.x;
            mouse.UserY := mouse.y;
            mouse.hide;
            Rectangle(mouse.LastLeftPressX,
                mouse.LastLeftPressY,
                mouse.UserX,mouse.UserY);
            mouse.show;
            mouse.EventMoved := 0;
            while (mouse.LeftPresses >
                mouse.LeftReleases) do begin;
                if mouse.EventMoved > 0 then begin
                    mouse.hide;
                    Rectangle(mouse.LastLeftPressX,
                        mouse.LastLeftPressY,
                        mouse.UserX,mouse.UserY);
                    mouse.UserX := mouse.x;
                    mouse.UserY := mouse.y;
                    Rectangle(mouse.LastLeftPressX,
                        mouse.LastLeftPressY,
                        mouse.UserX,mouse.UserY);
                    mouse.show;
                    mouse.EventMoved := 0;
                    end;
                end;
            SetWriteMode(CopyPut);
            mouse.hide;
            Rectangle(mouse.LastLeftPressX,
                mouse.LastLeftPressY,
                mouse.UserX,mouse.UserY);
            mouse.show;
        end;

    destructor RectTool.done;
        begin
        end;


    constructor EllipseTool.init;
        begin
            PaintTool.init(true)
        end;

    procedure EllipseTool.draw;
        var LS : LineSettingsType;
            c : word;
        begin
            mouse.hide;
            PaintTool.draw;
            GetLineSettings(LS);
            SetLineStyle(SolidLn,0,NormWidth);
            c := GetColor;
            with EaselPtr(list)^ do begin
                SetColor(color);
                ellipse(toolx + toolw div 2,
                    (curNum-1)*toolh + toolh div 2,
                    0,360,toolw div 4, toolh div 8)
                end;
            SetLineStyle(LS.LineStyle,LS.Pattern,
                LS.Thickness);
            SetColor(c);
            mouse.show
        end;

    procedure EllipseTool.select;
        begin
            draw
        end;

    procedure EllipseTool.doIt;
        begin
            SetWriteMode(XORPut);
            mouse.hide;
            mouse.UserX := abs(mouse.x -
                mouse.LastLeftPressX);
            mouse.UserY := abs(mouse.y -
                mouse.LastLeftPressY);
            Rectangle(mouse.LastLeftPressX - mouse.UserX,
                mouse.LastLeftPressY - mouse.UserY,
                mouse.LastLeftPressX + mouse.UserX,
                mouse.LastLeftPressY + mouse.UserY);
            mouse.show;
            mouse.EventMoved := 0;
            while (mouse.LeftPresses >
                mouse.LeftReleases) do begin;
                if mouse.EventMoved > 0 then begin
                    mouse.hide;
                    Rectangle(mouse.LastLeftPressX - mouse.UserX,
                        mouse.LastLeftPressY - mouse.UserY,
                        mouse.LastLeftPressX + mouse.UserX,
                        mouse.LastLeftPressY + mouse.UserY);
                    mouse.UserX := abs(mouse.x -
                        mouse.LastLeftPressX);
                    mouse.UserY := abs(mouse.y -
                        mouse.LastLeftPressY);
                    Rectangle(mouse.LastLeftPressX - mouse.UserX,
                        mouse.LastLeftPressY - mouse.UserY,
                        mouse.LastLeftPressX + mouse.UserX,
                        mouse.LastLeftPressY + mouse.UserY);
                    mouse.show;
                    mouse.EventMoved := 0;
                    end;
                end;
            mouse.hide;
            Rectangle(mouse.LastLeftPressX - mouse.UserX,
                mouse.LastLeftPressY - mouse.UserY,
                mouse.LastLeftPressX + mouse.UserX,
                mouse.LastLeftPressY + mouse.UserY);
            SetWriteMode(CopyPut);
            Ellipse(mouse.LastLeftPressX,mouse.LastLeftPressY,
                0,360,mouse.UserX,mouse.UserY);
            mouse.show;
        end;

    destructor EllipseTool.done;
        begin
        end;


    constructor FillTool.init;
        begin
            PaintTool.init(true)
        end;

    procedure FillTool.draw;
        var c : word;
        begin
            mouse.hide;
            PaintTool.Draw;
            c := GetColor;
            with EaselPtr(list)^ do begin
                SetColor(color);
                OutTextXY(toolx + toolw div 2,
                    (curNum-1)*toolh + toolh div 2,'Fill')
                end;
            SetColor(c);
            mouse.show
        end;

    procedure FillTool.select;
        var b, c : integer;
        begin
            with EaselPtr(list)^ do begin
                c := color;
                b := background;
                color := GetColor;
                background := GetBkColor;
                draw;
                color := c;
                background := b
                end
        end;

    procedure FillTool.doIt;
        begin
            mouse.hide;
            SetFillStyle(SolidFill,GetColor);
            FloodFill(mouse.LastLeftPressX,
                mouse.LastLeftPressY,GetColor);
            mouse.show;
            while mouse.LeftPressed or mouse.RightPressed
                do;
        end;

    destructor FillTool.done;
        begin
        end;


    constructor ClearTool.init;
        begin
            PaintTool.init(false)
        end;

    procedure ClearTool.draw;
        var c : word;
        begin
            mouse.hide;
            PaintTool.Draw;
            c := GetColor;
            with EaselPtr(list)^ do begin
                SetColor(color);
                OutTextXY(toolx + toolw div 2,
                    (curNum-1)*toolh + toolh div 2,'Clr')
                end;
            SetColor(c);
            mouse.show
        end;

    procedure ClearTool.select;
        begin
            mouse.hide;
            SetFillStyle(SolidFill,GetBkColor);
            bar(0,0,GetMaxX - EaselPtr(list)^.toolw,
                GetMaxY);
            mouse.show
        end;

    procedure ClearTool.doIt;
        begin
            select
        end;

    destructor ClearTool.done;
        begin
        end;

    constructor QuitTool.init;
        begin
            PaintTool.init(false)
        end;

    procedure QuitTool.draw;
        var c : word;
        begin
            mouse.hide;
            PaintTool.Draw;
            c := GetColor;
            with EaselPtr(list)^ do begin
                SetColor(color);
                OutTextXY(toolx + toolw div 2,
                    (curNum-1)*toolh + toolh div 2,'Quit')
                end;
            SetColor(c);
            mouse.show
        end;

    procedure QuitTool.select;
        begin
             EaselPtr(list)^.quit := true
        end;

    procedure QuitTool.doIt;
        begin
        end;

    destructor QuitTool.done;
        begin
        end;



    constructor ColorTool.init;
        begin
            PaintTool.init(false)
        end;

    procedure ColorTool.draw;
        var LS : LineSettingsType;
            FS : FillSettingsType;
            y : integer;
        begin
            mouse.hide;
            GetLineSettings(LS);
            SetLineStyle(SolidLn,0,NormWidth);
            GetFillSettings(FS);
            SetFillStyle(SolidFill,GetBkColor);
            with EaselPtr(list)^ do begin
                y := (curNum-1)*toolh;
                bar3d(toolx, y, toolx + toolw - 1,
                    y + toolh - 1, 0, false);
                SetFillStyle(SolidFill,GetColor);
                bar(toolx + toolw div 4, y + toolh div 4,
                    toolx + toolw div 4 * 3,
                    y + toolh div 4 * 3)
                end;
            SetLineStyle(LS.LineStyle,LS.Pattern,
                LS.Thickness);
            SetFillStyle(FS.Pattern,FS.Color);
            mouse.show
        end;

    procedure ColorTool.select;
        begin
        end;

    procedure ColorTool.doIt;
        begin
            draw
        end;

    destructor ColorTool.done;
        begin
        end;


    constructor PaletteTool.init;
        begin
            PaintTool.init(false)
        end;

    procedure PaletteTool.draw;
        var FS : FillSettingsType;
            y, h, w, c : integer;

        begin
            mouse.hide;
            with EaselPtr(list)^ do begin
                h := toolh div ((GetMaxColor + 1) div 2);
                w := toolw div 2;
                y := (curNum-1)*toolh;
                GetFillSettings(FS);
                for c := 0 to GetMaxColor do begin
                    SetFillStyle(SolidFill,c);
                    bar(toolx+(c mod 2) * w,
                        y+(c div 2) * h,
                        toolx+(c mod 2) * w + w,
                        y+(c div 2) * h + h)
                    end
                end;
            SetFillStyle(FS.Pattern,FS.Color);
            mouse.show
        end;

    procedure PaletteTool.select;
        var mx, my, y, w, h, c : integer;
        begin
            if mouse.LeftPressed then begin
                mx := mouse.LastLeftPressX;
                my := mouse.LastLeftPressY
                end
            else begin
                mx := mouse.LastRightPressX;
                my := mouse.LastRightPressY
                end;
            with EaselPtr(list)^ do begin
                y := (curNum-1)*toolh;
                h := toolh div ((GetMaxColor + 1) div 2);
                w := toolw div 2;
                c := 0;
                while (mx > (toolx + (c mod 2) * w + w)) or
                    (my > (y + (c div 2) * h + h)) do
                    inc(c);
                if c <= GetMaxColor then begin
                    if mouse.LeftPressed then
                        SetColor(c)
                    else
                        SetBkColor(c);
                    toolDraw(TypeOf(ColorTool),GetColor,GetBkColor);
                    if doItDrawID = TypeOf(FillTool) then
                       toolDraw(TypeOf(FillTool),GetColor,GetBkColor);
                    end
                end;
            while mouse.LeftPressed or mouse.RightPressed
                do;
        end;

    procedure PaletteTool.doIt;
        begin
        end;

    destructor PaletteTool.done;
        begin
        end;


    var E : Easel;
        driver, mode, error : integer;
        ch : char;

    begin
        if not mouse.present then begin
            clrscr;
            writeln('Mouse driver not installed or mouse not properly connected!');
            writeln('Press "enter" to halt.');
            halt;
            end;
        driver := detect;
        InitGraph(driver,mode,'');
        error := GraphResult;
        if error = grOk then begin
            InitGraphText;
            E.init;
            E.doIt;
            E.done;
            CloseGraph;
            CloseGraphText
            end
        else
            writeln('Graphics error: ',GraphErrorMsg(error));
        TextColor(LIGHTGRAY);
        TextBackground(BLACK);
        clrscr;
        writeln('Omouse operates in Turbo''s screen coordinates instead');
        writeln('of the more confusing mouse virtual coordinates.  Omouse');
        writeln('has an automatic mouse event interrupt handler so you don''t ');
        writeln('have to write your own.  All of the mouse driver functions');
        writeln('are supported as omouse methods.  Let''s look at the mouse');
        writeln('report while operating the mouse to see some of omouse''s');
        write('internal data fields.  Press "enter" to continue ...');
        readln;
        gotoxy(1,24);
        writeln('Move the mouse to see the automatic updating of omouse data.');
        write('Press any key to terminate omouse''s report.');
        window(10,4,60,22);
        TextColor(BLACK);
        TextBackground(LIGHTGRAY);
        clrscr;
        mouse.reset;
        mouse.trap(10,4,60,22);
        mouse.x := 54; mouse.y := 19;
        mouse.GotoXY;
        mouse.show;
        mouse.offtrap(10,4,53,18);
        mouse.AutoEventUpdate;
        while (not KeyPressed) do begin
            gotoxy(1,1);
            mouse.OffTrap(10,4,53,18);
            mouse.report;
            mouse.show;
            delay(500);
        end;
        if ReadKey = #0 then ch := ReadKey;
        mouse.reset;

        window(1,1,80,25);
        clrscr;
        writeln('If you find omouse useful and are using it in your');
        writeln('applications, a registration fee of $7 is requested.');
        writeln('Upon registration you will be sent source code and the');
        writeln('latest examples programs on a DOS formatted 5 1/4" disk.');
        writeln;
        writeln('PSW / Power SoftWare');
        writeln('P.O. Box 10072');
        writeln('McLean, Virginia 22102 8072');
        writeln('[phone]');
        writeln;
        writeln('That''s all folks!');
        writeln;
        writeln('Press enter to quit.');
        readln;
        TextColor(LIGHTGRAY);
        TextBackground(BLACK);
        clrscr
    end.