Aminet 18/aminetcdnumber181997.iso/Aminet/dev/misc/Gfx4PCQ.lha/WindowLib/Examples/WindowDemo/WindowDemo.p

Text File | 1997-02-09 | 10.8 KB | 348 lines

Program WindowDemo;
{This is a program that demonstrates some features of THOR's windowlib.
 For more information on how this works read the include file
 utils/windowlib.i
 © 1997 THOR - Software}

{Include some useful stuff, and the windowlib itself}
{$I "include:utils/windowlib.i"}
{$I "include:utils/stringlib.i"}

{This is the demonstration part...}
PROCEDURE Demo;

CONST
    {Setup a menu bar in an simple way. The menu is created out of them.
     The entries in this array are of a structure called MenuCommand,
     each of them describing one menu item, a menu bar or controlling
     the generation. The structure itself consists of:
        1) the type of entry to be created:
            a MC_MENU (menubar), an MC_ITEM (an item of the menu)
            or an MC_SUBITEM (subitem of an item).
            The last item or subitem of a menu must be a
            MC_LASTSUBITEM/MC_LASTITEM or MC_LASTMENU resp.
            to tell windowlib that one element of the menu is
            now complete.
        2)    some flags describing how this should look like.
            They are either MC_NORMALMENU (ordinary menu bar)
            or MC_NORMAL for a select-action menu item, or
            MC_CHECKABLE to get a menu item that can be turned
            on or off. MC_BAR is special in the sense that it
            creates a separation bar.
        3)    One character consisting of a shortcut (Amiga + key)
        4)    A string to be appear in the menu itself.}

    menubar : ARRAY[1..8] OF MenuCommand=(
        (MC_MENU,MC_NORMALMENU,'\0',0,"Menu 1"),
         (MC_ITEM,MC_NORMAL,'\0',0,"Item 1"),
         (MC_ITEM,MC_NORMAL,'\0',0,"Item 2"),
         (MC_ITEM,MC_CHECKABLE,'\0',0,"Onoff"),
         (MC_ITEM,MC_BAR,'\0',0,""),
         (MC_ITEM,MC_NORMAL,'Q',0,"Exit"),
         (MC_LASTITEM,0,'\0',0,""),
        (MC_LASTMENU,0,'\0',0,""));

VAR
    x,y    :    SHORT;
    i    :    SHORT;
    s    :    ScreenPtr;
    w    :    WindowPtr;
    g1,g2,g3,g4,g5:    GadgetPtr;
    t    :    INTEGER;
    b    :    BOOLEAN;
    buf    :    ARRAY[0..15] OF CHAR;
    ex    :    BOOLEAN;
    menu,item,subitem : SHORT;


BEGIN
    InitGraphics;        {setup gfx system}

    {open a custom screen. Arguments are:
        left and top edge of the screen, width, height and
        depth of bitplanes (2^depth=# of colors)
        the monitor ID - here plain NTSC in HIRES
        and a title}
    s:=OpenAScreen(0,0,640,300,2,MON_NTSC OR MON_HIRES,"Test screen");

    {choose the pen 3 to be fire-brigade red. Arguments are
     the screen, the number of the pen and the red,green and blue
     components of the new color, on a range from 0 (min) to 15 (max).
     The windowlib does not support 16 bit colors...}
    SetColor(s,3,15,0,0);
    {please note that this is bad style since we haven't tested if the
     screen did open. Sigh}

    {open a window on this screen. The arguments are
     the screen, the position (left/top coordinates) the
     width and heights and some flags which should be left to
     14 for almost all reasons, and a string giving the title.}
    w:=OpenScreenWindow(s,0,20,640,240,2+4+8,"A Test");

    IF w<>NIL THEN BEGIN
        {setup a font to be used in this window. In this case,
         it's topaz.9. Choose something better if you like...}
        b:=SetWindowFont(w,"topaz.font",9);

        SetStyle(w,4);    {Set the style for the text to be printed:
            1 is underlined, 2 is bold, 4 is italic.
            Add the values for style combinations}

        Color(w,1);    {chose a pen to be used}

        {draw a nifty graphics}
        FOR i:=0 TO 10 DO BEGIN
            Plot(w,0,i*24);        {plot a point}
            DrawTo(w,i*64,240);    {draw a line from it to this position}
        END;

        {wait until the user clicks into the window}
        WaitForClick(w);

        {clear the window}
        ClearWindow(w);

        {draw an ellipse. Arguments are the center and the two
         radii}
        Ellipse(w,320,120,300,150);

        {fill it in a different color}
        Color(w,2);
        Fill(w,320,120);


        {wait until the user clicks into the window}
        WaitForClick(w);
        ClearWindow(w);        {clear it}

        Color(w,1);        {choose pen}
        {another nice gfx with ellipses}
        FOR i:=0 TO 10 DO
            Ellipse(w,320,120,i*20,100-i*10);

        WaitForClick(w);
        ClearWindow(w);        {wait and clear}

        {turn on boundary drawing. This affects filled boxes
         and ellipses.}
        Boundary(w,TRUE);
        OlColor(w,1);            {choose the pen for the boundary}
        FOR i:=0 TO 10 DO BEGIN
            Color(w,i);        {choose the pen for the interiour}
            PBox(w,i*32,i*12,640-i*32,240-i*12);    {draw a filled, framed rectangle}
        END;

        Boundary(w,FALSE);        {turn off boundary drawing again}
        WaitForClick(w);        {wait until the user clicks into the window}
        ClearWindow(w);            {clear it}

        {draw the same, but not filled}
        FOR i:=0 TO 10 DO BEGIN
            Color(w,i);        {chose color}
            Box(w,i*32,i*12,640-i*32,240-i*12);    {draw a frame}
        END;

        WaitForClick(w);
        ClearWindow(w);        {wait and clear}

        Boundary(w,TRUE);    {again boundary mode}
        OlColor(w,1);        {color for the boundary}

        FOR i:=0 TO 10 DO BEGIN
            Color(w,i);    {color for the interiour}
            PEllipse(w,320,120,i*20,100-i*10);    {draw a filled, framed ellipse}
        END;

        {some interactive selection functions}

        {let the user select one point of the window with a cross}
        SelectPoint(w,x,y);

        {let the user select a region of the window by "dragging" it}
        DragBox(w,x,y,x,y);

        {we do actually nothing with them, just for demonstration}


        {tell the windowlib we want to hear if the user presses a
         mouse button}
        RequestStart(w,MOUSEBUTTONS_F);
        REPEAT
            Mouse(w,x,y);    {read the mouse position}
            Plot(w,x,y);    {plot a point at this position}
        UNTIL NextRequest(w)=MOUSEBUTTONS_F;    {until the mouse button gets pressed}
        {turn off notification}
        RequestEnd(w,MOUSEBUTTONS_F);

        {create some gadgets. A text button is just a button with
         some text in it. It is called a "bool gadget" in intution
         terms. The user can press it to force some action.
         Arguments are: the window, the x and y coordinates of its
         position, the width and height - beeing zero here to tell
         the windowlib to calculate them by the text they should
         contain and the text itself}
        g1:=CreateTextButton(w,4,04,0,0,"Demo gadget");
        g2:=CreateTextButton(w,4,20,0,0,"Another one");

        {create a string field: This is a rectangular area where
         the user may insert text. These are called "string gadgets"
         by the intuition part of the OS.
         The arguments are the window, the position x and y and the
         width and height. The height is set to zero to tell window
         lib to fiddle this out by itself - the window's font is
         used here.}
        g3:=CreateStringField(w,4,40,100,0);

        {create a slider. They are called "prop gadgets" in intuition
         language and let users select a choise out of a list of
         items. Arguments are the window, the position x,y, the
         width and height, and a flag beeing FALSE for horizontal and
         TRUE for vertical movement. The size of the list = the number
         of choices is setup later.}
        g4:=CreateSlider(w,4,60,100,8,FALSE);

        {create a toggle gadget. This is also a "bool gadget" in
         intuition notation. This is a gadget that can be toggled
         "on" or "off" by the user by pressing it.}
        g5:=CreateTextToggle(w,4,80,0,0,"Toggle");

        {note that we did some bad style above since we never
         checked if the gadgets could have been created}

        {create a menu and attach it to the window. The definition
         of the menu is done by a structure you see on top of this
         procedure}
        CreateMenu(w,@menubar);

        {setup the slider g4 to describe a list of 16 items (=16
         possible choices), one beeing visible at a time, with 0
         beeing the initial choice. The choices returned by window-
         lib are numbered from 0 to 16}
        SetSlider(g4,16,1,0);

        {display the cursor in the string field created on top
         and let the user enter something}
        b:=ActivateField(g3);


        {tell the windowlib we want to get informed if:
            the user wants to close the window
            the user releases a gadget,i.e. the sliders, the buttons
            or the text field
            the user presses a mouse button.
            the user selected a menu.
            the user pressed a key}
        RequestStart(w,CLOSEWINDOW_f OR GADGETUP_f OR MOUSEBUTTONS_F OR MENUPICK_f OR RAWKEY_f);

        Color(w,1);    {choose the pen}
        ex:=FALSE;    {flag if we should exit}
        REPEAT
            {if the mouse button is pressed, read the
             mouse position and draw a point at it.
             read the next event in this case}
            IF MouseButton(w) THEN BEGIN
                Mouse(w,x,y);
                Plot(w,x,y);
                t:=NextRequest(w);
            END ELSE BEGIN
                {else redraw the gadgets since the
                 user might have drawn over them}
                RefreshButton(g1);
                RefreshButton(g2);
                RefreshButton(g3);
                RefreshButton(g4);
                RefreshButton(g5);
                {and wait for something to be happen}
                t:=WaitRequest(w);
            END;

            {now look what has happend, if at all}

            IF t=GADGETUP_f THEN BEGIN
                {a gadget has been released}

                {setup a drawing position}
                Position(w,50,120);

                {get the number of the gadget that has been
                 pressed. They are numbered from one
                 in increasing order of their creation}
                CASE LastGadgetID(w) OF
                1:    {draw some text if one of the buttons has been released}
                    DrawText(w,"Gadget 1");
                2:
                    DrawText(w,"Gadget 2");
                3:    {get the contents of the string field and draw it}
                    DrawText(w,BufferFromField(g3));
                4:    BEGIN    {read the position of the slider, convert it to text and draw it}
                        t:=IntToStr(@buf,FirstFromSlider(g4));
                        DrawText(w,@buf);
                    END;
                5:    BEGIN    {the on/off gadget has changed its state. Read it and display it}
                        IF GetToggle(g5) THEN BEGIN
                            DrawText(w,"On ");
                        END ELSE
                            DrawText(w,"Off");
                    END;
                END;
            END;
            IF t=CLOSEWINDOW_f THEN
                {if we got the message that the user wants to
                 shutdown, set a flag}
                ex:=TRUE;
            IF t=RAWKEY_f THEN BEGIN
                {read the key that has been pressed into a buffer,
                 and print this buffer.}
                LastKey(w,@buf,i);
                Position(w,50,90);
                DrawText(w,@buf);
            END;
            IF t=MENUPICK_f THEN BEGIN
                {a menu has been selected, read which one.
                 The number returned is the menu number, the item
                 number and the subitem number resp.
                  They are numbered from 0 increasing in the
                 order in the menu bar or menu. The item or
                 subitem is -1 if it has not been selected}
                LastMenu(w,menu,item,subitem);
                IF item=4 THEN
                    ex:=TRUE;    {"exit" choosen?}
                IF item=2 THEN BEGIN
                    {check the state of the checkmark item.
                     The numbers given here are again the
                     number of the menu, of the item and of
                     the subitem as described above. -1 means
                     that this item has no subitem}
                    IF CheckMarkOfMenu(w,0,2,-1) THEN BEGIN
                        {enable the menu item #1, i.e.
                         make it selectable}
                        OnMenuPoint(w,0,1,-1);
                    END ELSE
                        {disable menu item #1 in the first
                         menu, i.e. forbid selection}
                        OffMenuPoint(w,0,1,-1);
                    {set the state of the toggle gadget by the
                     state of this gadget}
                    SetToggle(g5,CheckMarkOfMenu(w,0,2,-1));
                END;
            END;
        UNTIL ex;        {repeat until the user had enough}

        {tell windowlib we no longer want to receive messages
         from this window}
        RequestEnd(w,CLOSEWINDOW_f OR GADGETUP_f);

        {close this window}
        CloseAWindow(w);
    END;
    {close the screen}
    CloseAScreen(s);
    {quit the gfx system}
    ExitGraphics;
END;

{a tiny main program}
BEGIN
    Demo;
END.