The CDPD Public Domain Collection for CDTV 3/CDPDIII.bin/pd/programming/utils/mui-demo/mui-demo.c

C/C++ Source or Header | 1993-04-26 | 32KB | 701 lines

/*
**          C Source Code For The MUI Demo Program
**          --------------------------------------
**
**               written 1993 by Stefan Stuntz
**
** Even if it doesn't look so, all of the code below is pure C,
** just a little bit enhanced with some MUI specific macros.
**
** Note: You won't be able to recompile this program unless
**       you have the MUI include files, which are *not* part
**       of the demo release!
*/

#include "demos.h"


/*
** Convetional GadTools NewMenu structures. Since I was
** too lazy to construct my own, object oriented menu
** system for now, this is the only part of MUI that needs
** "gadtools.library". Well, GadTools menus aren't that bad,
** at least not as bad as the other GadTools crap :-)
** Nevertheless, object oriented menus will come soon.
*/

#define ID_ABOUT     1
#define ID_FRAMES    2
#define ID_IMAGES    3
#define ID_BROADCAST 4
#define ID_GROUPS    5
#define ID_BACKFILL  6
#define ID_LISTVIEWS 7
#define ID_CYCLE     8
#define ID_STRING    9
#define ID_DATATYPE  10
#define ID_NEWVOL    11
#define ID_NEWBRI    12

static const struct NewMenu Menu[] =
{
    { NM_TITLE, "Project"  , 0 ,0,0,(APTR)0            },
    { NM_ITEM , "About..." ,"?",0,0,(APTR)ID_ABOUT     },
    { NM_ITEM , NM_BARLABEL, 0 ,0,0,(APTR)0            },
    { NM_ITEM , "Frames"   ,"F",0,0,(APTR)ID_FRAMES    },
    { NM_ITEM , "Images"   ,"I",0,0,(APTR)ID_IMAGES    },
    { NM_ITEM , "Broadcast","B",0,0,(APTR)ID_BROADCAST },
    { NM_ITEM , "Groups"   ,"G",0,0,(APTR)ID_GROUPS    },
    { NM_ITEM , "Backfill" ,"A",0,0,(APTR)ID_BACKFILL  },
    { NM_ITEM , "Listviews","L",0,0,(APTR)ID_LISTVIEWS },
    { NM_ITEM , "Strings"  ,"S",0,0,(APTR)ID_STRING    },
    { NM_ITEM , "Datatypes","D",0,0,(APTR)ID_DATATYPE  },
    { NM_ITEM , "Cycle"    ,"C",0,0,(APTR)ID_CYCLE     },
    { NM_ITEM , NM_BARLABEL, 0 ,0,0,(APTR)0            },
    { NM_ITEM , "Quit"     ,"Q",0,0,(APTR)MUIV_Application_ReturnID_Quit },
    { NM_END  , NULL       , 0 ,0,0,(APTR)0            },
};


/*
** Here are all the little info texts
** that appear at the top of each demo window.
*/

static const char IN_Master[]    = "\tWelcome to the MUI demonstration program. This little toy will show you, how easy it is to create graphical user interfaces with MUI and how powerful the results are.\n\tMUI is based on BOOPSI, Amiga's basic object oriented programming system. For details about programming, see the 'ReadMe' file and the documented source code of this demo. Only one thing so far: it's really easy!\n\tNow go on, click around and watch this demo. Or use your keyboard (TAB, Return, Cursor-Keys) if you like that better. Hint: play around with the MUI preferences program and customize every pixel to fit your personal taste.";
static const char IN_Broadcast[] = "\tMUI objects communicate with each other with the aid of a broadcasting system. This system is frequently used in every MUI application. Binding an up and a down arrow to a prop gadget e.g. makes up a scrollbar, binding a scrollbar to a list makes up a listview. You can also bind windows to buttons, thus the window will be opened when the button is pressed.\n\tRemember: The main loop of this demo program simply consists of a Wait(). Once set up, MUI handles all user actions concerning the GUI automatically.";
static const char IN_Frames[]    = "\tEvery MUI object can have a surrounding frame. Several types are available, each of them either normal or inverted. The border thickness is adjustable via MUI's preferences program.";
static const char IN_Images[]    = "\tMUI offers a vector image class, that allows images to be zoomed to any dimension. Every MUI image is transformed to match the current screens colors before displaying.\n\tThere are several standard images for often used GUI components (e.g. Arrows). These standard images can be defined via the preferences program.";
static const char IN_Groups[]    = "\tGroups are very important for MUI. Their combinations determine how the GUI will look. A group may contain any number of child objects, which are positioned either horizontal or vertical.\n\tWhen a group is layouted, the available space is distributed between all of its childs, depending on their minimum and maximum dimensions and on their weight.\n\tOf course, the childs of a group may be other groups. There are no restrictions.";
static const char IN_Backfill[]  = "\tEvery object can have his own background, if it wants to. MUI offers several standard backgrounds (e.g. one of the DrawInfo pens or one of the rasters below). Additionally, a program can specify custom backfill hooks as shown at the bottom of this little window.";
static const char IN_Listviews[] = "\tMUI's list class is very flexible. A list can be made up of any number of columns containing formatted text or even images. Several subclasses of list class (e.g. a directory class and a volume class) are available. All MUI lists have the capability of multi selection, just by setting a single flag.\n\tThe small info texts at the top of each demo window are made with floattext class. This one just needs a character string as input and formats the text according to its width.";
static const char IN_Cycle[]     = "\tCycle gadgets, radios buttons and simple lists can be used to let the user pick exactly one selection from a list of choices. In this example, all three possibilities are shown. Of course they are connected via broadcasting, so every object will immediately be notified and updated when necessary.";
static const char IN_String[]    = "\tOf course, MUI offers a standard string gadget class for text input. The gadget in this example is attached to the list, you can control the list cursor from within the gadget.";
static const char IN_Datatype[]  = "";


/*
** This are the entries for the cycle gadgets and radio buttons.
*/

static const char *CYA_Computer[] = { "Amiga 500","Amiga 600","Amiga 1000 :)","Amiga 1200","Amiga 2000","Amiga 3000","Amiga 4000", "Amiga 4000T", "Atari ST :(", NULL };
static const char *CYA_Printer[]  = { "HP Deskjet","NEC P6","Okimate 20",NULL };
static const char *CYA_Display[]  = { "A1081","NEC 3D","A2024","Eizo T660i",NULL };
static const char *LVT_Brian[48]; /* this secret text is hidden at the end of this file :) */


/*
** Some Macros to make my life easier and the actual source
** code more readable.
*/

#define List(ftxt)             ListviewObject, MUIA_Weight, 50, MUIA_Listview_Input, FALSE, MUIA_Listview_List, FloattextObject, RaisedFrame, MUIA_Floattext_Text, ftxt, MUIA_Floattext_TabSize, 4, MUIA_List_CursorType, MUIV_List_CursorType_Bar, End, End
#define DemoWindow(name,info)  WindowObject, MUIA_Window_Name, name, WindowContents, VChilds, MUIA_InnerWindow, TRUE, Child, List(info)
#define ImageLine(name,nr)     HChilds, Child, TextObject, TextEntry, name, MUIA_FixWidthTxt, "RadioButton:", MUIA_Text_Format, MUIV_Text_Format_Right, End, Child, VChilds, Child, VSpace(0), Child, ImageObject, MUIA_Image_Type, nr, End, Child, VSpace(0), End, End
#define ScaledImage(nr,s,x,y)  ImageObject, MUIA_Image_Type, nr, MUIA_FixWidth, x, MUIA_FixHeight, y, MUIA_Image_Scalable, TRUE, MUIA_Image_State, s, End
#define Cycle(p,name,max,e)    HChilds, Child, VChilds, GroupSpacing(0), Child, VSpace(0), Child, TextObject, TextEntry, name, MUIA_FixWidthTxt, max, MUIA_Text_Format, MUIV_Text_Format_Right, End, Child, VSpace(0), End, Child, p = CycleObject, MUIA_Cycle_Entries, e, End, End
#define HProp                  PropObject, MUIA_Prop_Horiz, TRUE, MUIA_FixHeight, 8, MUIA_Prop_Entries, 8, MUIA_Prop_Visible, 1, End
#define VProp                  PropObject, MUIA_Prop_Horiz, FALSE, MUIA_FixWidth , 8, MUIA_Prop_Entries, 8, MUIA_Prop_Visible, 1, End


/*
** For every object we want to refer later (e.g. for broadcasting purposes)
** we need a pointer. These pointer do not need to be static, but this
** saves stack space.
*/

static APTR AP_Demo;
static APTR WI_Master,WI_Frames,WI_Images,WI_Broadcast,WI_Listviews,WI_Groups,WI_Backfill,WI_Cycle,WI_String,WI_Datatype;
static APTR BT_Broadcast,BT_Frames,BT_Images,BT_Groups,BT_Backfill,BT_Listviews,BT_Cycle,BT_String,BT_Datatype;
static APTR PR_PropA,PR_PropH,PR_PropV,PR_PropL,PR_PropR,PR_PropT,PR_PropB;
static APTR LV_Volumes,LV_Directory,LV_Computer,LV_Brian;
static APTR CY_Computer,CY_Printer,CY_Display;
static APTR MT_Computer,MT_Printer,MT_Display;
static APTR ST_Brian,ST_Datatype;
static APTR DT_Datatype;


/*
** Here we have the custom background hook for the backfill demo.
** This is the only part where the programmer actually draws,
** all other rendering is done by MUI.
*/

SAVEDS ASM LONG CustomBackgroundFunc(REG(a0) struct Hook *hook,REG(a2) struct RastPort *rp,REG(a1) struct MUIP_BackgroundPacket *p)
{
    USHORT pattern[]={0x1111,0x1111<<1,0x1111<<2,0x1111<<3};
    SetDrMd(rp,JAM2);
    SetAPen(rp,p->DrawInfo->dri_Pens[SHADOWPEN]);
    SetBPen(rp,p->DrawInfo->dri_Pens[FILLPEN]);
    SetAfPt(rp,pattern,2);
    RectFill(rp,p->left,p->top,p->left+p->width-1,p->top+p->height-1);
    SetAfPt(rp,NULL,-1);
    return(0);
}
static const struct Hook CustomBackgroundHook = { { NULL,NULL },CustomBackgroundFunc,NULL,NULL };


/*
** This is where all begins...
*/

int main(int argc,char *argv[])
{

/*
** The init() functions is define in demos.h and does nothing
** but open "muimaster.library".
*/

    init();


/*
** Every MUI application needs an application object,
** which will hold general informations and serve as
** anchor for user input, ARexx functions,
** commodities interface, etc.
*/

    AP_Demo = ApplicationObject,
        MUIA_Application_Title      , "MUI-Demo",
        MUIA_Application_Version    , "$VER: MUI-Demo 3.318 (26.04.93)",
        MUIA_Application_Copyright  , "Copyright ©1993, Stefan Stuntz",
        MUIA_Application_Author     , "Stefan Stuntz",
        MUIA_Application_Description, "Demonstrate the features of MUI.",
        MUIA_Application_Base       , "MUIDEMO",
        MUIA_Application_Menu       , Menu,
        End;


/*
** Now we will create all the nice demo windows. This is
** what makes up the GUI. Note that we do not need any
** error control for the sub objects since every error
** will automatically be forwarded to the parent object
** and cause this one to fail too.
**
** Creating the window does not mean to display it instantly.
** This is done later by a call to the applications AddWindow method.
*/

    WI_String =
        DemoWindow("String",IN_String),
            Child, LV_Brian = ListviewObject,
                MUIA_Listview_Input, TRUE,
                MUIA_Listview_List, ListObject, RaisedFrame, MUIA_List_CursorType, MUIV_List_CursorType_Bar, End,
                End,
            Child, ST_Brian = StringObject, StringFrame, End,
            End,
        End;

    WI_Datatype =
        DemoWindow("Datatype",IN_Datatype),
            Child, ST_Datatype = StringObject, StringFrame, End,
            Child, DT_Datatype = DatatypeObject, RecessedFrame, End,
            End,
        End;

    WI_Cycle =
        DemoWindow("Cycle Gadgets & RadioButtons",IN_Cycle),
            Child, HChilds,
                Child, MT_Computer = Mutex("Computer:",CYA_Computer),
                Child, VChilds,
                    Child, MT_Printer = Mutex("Printer:",CYA_Printer),
                    Child, VSpace(0),
                    Child, MT_Display = Mutex("Display:",CYA_Display),
                    End,
                Child, VChilds,
                    Child, VChilds, GroupFrame("Cycle Gadgets"),
                        Child, Cycle(CY_Computer,"Computer:","Computer:",CYA_Computer),
                        Child, Cycle(CY_Printer ,"Printer:" ,"Computer:",CYA_Printer ),
                        Child, Cycle(CY_Display ,"Display:" ,"Computer:",CYA_Display ),
                        End,
                    Child, LV_Computer =    ListviewObject,
                        MUIA_Listview_Input, TRUE,
                        MUIA_Listview_List, ListObject, RaisedFrame, MUIA_List_CursorType, MUIV_List_CursorType_Bar, End,
                        End,
                    End,
                End,
            End,
        End;

    WI_Listviews =
        DemoWindow("Listviews",IN_Listviews),
            Child, HChilds, GroupFrame("Dir & Volume List"),
                Child, LV_Directory = ListviewObject,
                    MUIA_Listview_Input, TRUE,
                    MUIA_Listview_MultiSelect, TRUE,
                    MUIA_Listview_List, DirlistObject, RaisedFrame, MUIA_Dirlist_DirName, "ram:", MUIA_List_CursorType, MUIV_List_CursorType_Bar, End,
                    End,
                Child, LV_Volumes = ListviewObject,
                    MUIA_Weight, 20,
                    MUIA_Listview_Input, TRUE,
                    MUIA_Listview_List, VolumelistObject, RaisedFrame, MUIA_Dirlist_DirName, "ram:", MUIA_List_CursorType, MUIV_List_CursorType_Bar, End,
                    End,
                End,
            End,
        End;

    WI_Broadcast =
        DemoWindow("Broadcasting",IN_Broadcast),
            Child, HChilds, GroupFrame("Connections"),
                Child, PR_PropL = VProp,
                Child, PR_PropR = VProp,
                Child, VChilds,
                    Child, VSpace(0),
                    Child, PR_PropA = HProp,
                    Child, HChilds,
                        Child, PR_PropH = HProp,
                        Child, PR_PropV = HProp,
                        End,
                    Child, VSpace(0),
                    End,
                Child, PR_PropT = VProp,
                Child, PR_PropB = VProp,
                End,
            End,
        End;

    WI_Backfill =
        DemoWindow("Backfill",IN_Backfill),
            Child, VChilds, GroupFrame("Standard Backgrounds"),
                Child, HChilds,
                    Child, RectangleObject, RecessedFrame, MUIA_Background, BACKGROUNDPEN              , End,
                 Child, RectangleObject, RecessedFrame, MUIA_Background, FILLPEN                    , End,
                 Child, RectangleObject, RecessedFrame, MUIA_Background, TEXTPEN                    , End,
                    End,
                Child, HChilds,
                 Child, RectangleObject, RecessedFrame, MUIA_Background, MUIV_Background_ShadowBack , End,
                 Child, RectangleObject, RecessedFrame, MUIA_Background, MUIV_Background_ShadowFill , End,
                 Child, RectangleObject, RecessedFrame, MUIA_Background, MUIV_Background_ShadowShine, End,
                    End,
                Child, HChilds,
                 Child, RectangleObject, RecessedFrame, MUIA_Background, MUIV_Background_FillBack   , End,
                 Child, RectangleObject, RecessedFrame, MUIA_Background, MUIV_Background_ShineBack  , End,
                 Child, RectangleObject, RecessedFrame, MUIA_Background, MUIV_Background_FillShine  , End,
                    End,
                End,
            Child, VChilds, GroupFrame("Custom Background"),
                Child, VChilds, RecessedFrame, MUIA_Background, &CustomBackgroundHook,
                    Child, TextObject, TextEntry, "Custom"    , MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Left  , MUIA_Text_FrontPen, SHINEPEN, End,
                    Child, TextObject, TextEntry, "Background", MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Center, MUIA_Text_FrontPen, SHINEPEN, End,
                    Child, TextObject, TextEntry, "Hook"      , MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Right , MUIA_Text_FrontPen, SHINEPEN, End,
                    End,
                End,
            End,
        End;

    WI_Groups =
        DemoWindow("Groups",IN_Groups),
            Child, HChilds, GroupFrame("Two Basic Group Types"),
                Child, HChilds, GroupFrame("Horizontal"),
                    Child, RectangleObject, RecessedFrame, End,
                    Child, RectangleObject, RecessedFrame, End,
                    Child, RectangleObject, RecessedFrame, End,
                    End,
                Child, VChilds, GroupFrame("Vertical"),
                    Child, RectangleObject, RecessedFrame, End,
                    Child, RectangleObject, RecessedFrame, End,
                    Child, RectangleObject, RecessedFrame, End,
                    End,
                End,
            Child, HChilds, GroupFrame("Different Weights"),
                Child, TextObject, RecessedFrame, TextEntry, "25 kg" , MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Center, MUIA_Weight,  25, End,
                Child, TextObject, RecessedFrame, TextEntry, "50 kg" , MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Center, MUIA_Weight,  50, End,
                Child, TextObject, RecessedFrame, TextEntry, "75 kg" , MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Center, MUIA_Weight,  75, End,
                Child, TextObject, RecessedFrame, TextEntry, "100 kg", MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Center, MUIA_Weight, 100, End,
                End,
            Child, HChilds, GroupFrame("Fixed & Variable Sizes"),
                Child, TextObject, RecessedFrame, TextEntry, "fixed" , MUIA_Text_SetMin, TRUE, MUIA_Text_SetMax, TRUE , MUIA_Text_Format, MUIV_Text_Format_Center, End,
                Child, TextObject, RecessedFrame, TextEntry, "free"  , MUIA_Text_SetMin, TRUE, MUIA_Text_SetMax, FALSE, MUIA_Text_Format, MUIV_Text_Format_Center, End,
                Child, TextObject, RecessedFrame, TextEntry, "fixed" , MUIA_Text_SetMin, TRUE, MUIA_Text_SetMax, TRUE , MUIA_Text_Format, MUIV_Text_Format_Center, End,
                Child, TextObject, RecessedFrame, TextEntry, "free"  , MUIA_Text_SetMin, TRUE, MUIA_Text_SetMax, FALSE, MUIA_Text_Format, MUIV_Text_Format_Center, End,
                Child, TextObject, RecessedFrame, TextEntry, "fixed" , MUIA_Text_SetMin, TRUE, MUIA_Text_SetMax, TRUE , MUIA_Text_Format, MUIV_Text_Format_Center, End,
                End,
            End,
        End;

    WI_Frames =
        DemoWindow("Frames",IN_Frames),
            Child, HChilds,
                Child, VChilds,
                    Child, CenterText("Normal"),
                    Child, VSpace(2),
                    Child, HChilds, BoringFrame   , Child, CenterText("Boring Frame"), End,
                    Child, HChilds, RaisedFrame   , Child, CenterText("Raised Frame"), End,
                    Child, HChilds, StringFrame   , Child, CenterText("String Frame"), End,
                    Child, HChilds, DoubleFrame   , Child, CenterText("Double Frame"), End,
                    Child, HChilds, OvalFrame     , Child, CenterText("Oval Frame"  ), End,
                    End,
                Child, VChilds,
                    Child, CenterText("Reverse"),
                    Child, VSpace(2),
                    Child, HChilds, InvBoringFrame, Child, CenterText("InvBoring Frame"), End,
                    Child, HChilds, RecessedFrame , Child, CenterText("Recessed Frame"), End,
                    Child, HChilds, NeXTFrame     , Child, CenterText("NeXT Frame"), End,
                    Child, HChilds, InvDoubleFrame, Child, CenterText("InvDouble Frame"), End,
                    Child, HChilds, InvOvalFrame  , Child, CenterText("InvOval Frame"), End,
                    End,
                End,
            End,
        End;

    WI_Images =
        DemoWindow("Images",IN_Images),
            Child, HChilds,
                Child, VChilds, GroupFrame("Standard Images"),
                    Child, ImageLine("ArrowUp:"    ,MUIV_Image_Type_ArrowUp    ),
                    Child, ImageLine("ArrowDown:"  ,MUIV_Image_Type_ArrowDown  ),
                    Child, ImageLine("ArrowLeft:"  ,MUIV_Image_Type_ArrowLeft  ),
                    Child, ImageLine("ArrowRight:" ,MUIV_Image_Type_ArrowRight ),
                    Child, ImageLine("RadioButton:",MUIV_Image_Type_RadioButton),
                    Child, ImageLine("PopUp:"      ,MUIV_Image_Type_PopUp      ),
                    Child, ImageLine("HardDisk:"   ,MUIV_Image_Type_HardDisk   ),
                    Child, ImageLine("Disk:"       ,MUIV_Image_Type_Disk       ),
                    Child, ImageLine("Chip:"       ,MUIV_Image_Type_Chip       ),
                    Child, ImageLine("Volume:"     ,MUIV_Image_Type_Volume     ),
                    Child, ImageLine("Drawer:"     ,MUIV_Image_Type_Drawer     ),
                    End,
                Child, VChilds, GroupFrame("Scale Engine"),
                    Child, VSpace(0),
                    Child, HChilds,
                        Child, ScaledImage(MUIV_Image_Type_RadioButton,1,17, 9),
                        Child, ScaledImage(MUIV_Image_Type_RadioButton,1,20,12),
                        Child, ScaledImage(MUIV_Image_Type_RadioButton,1,23,15),
                        Child, ScaledImage(MUIV_Image_Type_RadioButton,1,26,18),
                        Child, ScaledImage(MUIV_Image_Type_RadioButton,1,29,21),
                        End,
                    Child, VSpace(0),
                    Child, HChilds,
                        Child, ScaledImage(MUIV_Image_Type_CheckMark,1,13, 7),
                        Child, ScaledImage(MUIV_Image_Type_CheckMark,1,16,10),
                        Child, ScaledImage(MUIV_Image_Type_CheckMark,1,19,13),
                        Child, ScaledImage(MUIV_Image_Type_CheckMark,1,22,16),
                        Child, ScaledImage(MUIV_Image_Type_CheckMark,1,25,19),
                        Child, ScaledImage(MUIV_Image_Type_CheckMark,1,28,22),
                        End,
                    Child, VSpace(0),
                    Child, HChilds,
                        Child, ScaledImage(MUIV_Image_Type_PopUp,0,12,10),
                        Child, ScaledImage(MUIV_Image_Type_PopUp,0,15,13),
                        Child, ScaledImage(MUIV_Image_Type_PopUp,0,18,16),
                        Child, ScaledImage(MUIV_Image_Type_PopUp,0,21,19),
                        Child, ScaledImage(MUIV_Image_Type_PopUp,0,24,22),
                        Child, ScaledImage(MUIV_Image_Type_PopUp,0,27,25),
                        End,
                    Child, VSpace(0),
                    End,
                End,
            End,
        End;

    WI_Master = WindowObject,
        MUIA_Window_Name, "MUI-Demo",
        WindowContents, VChilds, MUIA_InnerWindow,TRUE,
            Child, VChilds, NeXTFrame, MUIA_Background, MUIV_Background_ShadowFill,
                Child, TextObject, TextEntry, "MUI - MagicUserInterface"     , MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Center, MUIA_Text_FrontPen, SHINEPEN, End,
                Child, TextObject, TextEntry, "written 1993 by Stefan Stuntz", MUIA_Text_SetMin, TRUE, MUIA_Text_Format, MUIV_Text_Format_Center, MUIA_Text_FrontPen, SHINEPEN, End,
                End,
            Child, List(IN_Master),
            Child, VChilds, GroupFrame("Available Demos"),
                Child, HIChilds,
                    Child, BT_Groups    = SimpleButton("Groups"),
                    Child, BT_Frames    = SimpleButton("Frames"),
                    Child, BT_Backfill  = SimpleButton("Backfill"),
                    End,
                Child, HIChilds,
                    Child, BT_Broadcast = SimpleButton("Broadcast"),
                    Child, BT_Listviews = SimpleButton("Listviews"),
                    Child, BT_Cycle     = SimpleButton("Cycle"),
                    End,
                Child, HIChilds,
                    Child, BT_Images    = SimpleButton("Images"),
                    Child, BT_String    = SimpleButton("String"),
                    Child, BT_Datatype  = SimpleButton("Datatype"),
                    End,
                End,
            End,
        End;


/*
** See if all the windows are created. The fail function
** is defined in demos.h, it deletes every created object
** and closes "muimaster.library".
*/

    if (!WI_Master   ) fail("Failed to create master window.");
    if (!WI_Frames   ) fail("Failed to create frames window.");
    if (!WI_Images   ) fail("Failed to create images window.");
    if (!WI_Broadcast) fail("Failed to create broadcasts window.");
    if (!WI_Listviews) fail("Failed to create listviews window.");
    if (!WI_Groups   ) fail("Failed to create groups window.");
    if (!WI_Backfill ) fail("Failed to create backfill window.");
    if (!WI_Cycle    ) fail("Failed to create cycle window.");
    if (!WI_String   ) fail("Failed to create String window.");
    if (!AP_Demo     ) fail("Failed to create application.");


/*
** Here comes the broadcast magic. Broadcasting means:
** When an attribute of an object changes, then please change
** another attribute of another object (accordingly) or send
** a method to another object.
*/

/*
** Lets bind the sub windows to the corresponding button
** of the master window.
*/

    DoMethod(BT_Frames   ,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_Frames);
    DoMethod(BT_Images   ,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_Images);
    DoMethod(BT_Broadcast,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_Broadcast);
    DoMethod(BT_Listviews,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_Listviews);
    DoMethod(BT_Groups   ,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_Groups);
    DoMethod(BT_Backfill ,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_Backfill);
    DoMethod(BT_Cycle    ,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_Cycle);
    DoMethod(BT_String   ,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_String);
    if (WI_Datatype)
        DoMethod(BT_Datatype,MUIM_Broadcast_Add,MUIA_Released,AP_Demo,2,MUIM_Application_AddWindow,WI_Datatype);
    else
        set(BT_Datatype,MUIA_Disabled,TRUE);


/*
** Automagically remove a window when the user hits the close gadget.
*/

    DoMethod(WI_Images   ,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_Images   );
    DoMethod(WI_Frames   ,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_Frames   );
    DoMethod(WI_Broadcast,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_Broadcast);
    DoMethod(WI_Listviews,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_Listviews);
    DoMethod(WI_Groups   ,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_Groups   );
    DoMethod(WI_Backfill ,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_Backfill );
    DoMethod(WI_Cycle    ,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_Cycle    );
    DoMethod(WI_String   ,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_String   );
    if (WI_Datatype)
        DoMethod(WI_Datatype ,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_RemoveWindow,WI_Datatype );


/*
** Closing the master window forces a complete shutdown of the application.
*/

    DoMethod(WI_Master,MUIM_Broadcast_Add,MUIA_Window_CloseRequest,AP_Demo,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);


/*
** This connects the prop gadgets in the broadcast demo window.
*/

    DoMethod(PR_PropA,MUIM_Broadcast_Add,MUIA_Prop_First,PR_PropH,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Prop_First,0);
    DoMethod(PR_PropA,MUIM_Broadcast_Add,MUIA_Prop_First,PR_PropV,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Prop_First,0);
    DoMethod(PR_PropH,MUIM_Broadcast_Add,MUIA_Prop_First,PR_PropL,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Prop_First,0);
    DoMethod(PR_PropH,MUIM_Broadcast_Add,MUIA_Prop_First,PR_PropR,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Prop_First,0);
    DoMethod(PR_PropV,MUIM_Broadcast_Add,MUIA_Prop_First,PR_PropT,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Prop_First,0);
    DoMethod(PR_PropV,MUIM_Broadcast_Add,MUIA_Prop_First,PR_PropB,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Prop_First,0);


/*
** And here we connect cycle gadgets, radio buttons and the list in the
** cycle & radio window.
*/

    DoMethod(CY_Computer,MUIM_Broadcast_Add,MUIA_Cycle_Active,MT_Computer,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Mutex_Active,0);
    DoMethod(CY_Printer ,MUIM_Broadcast_Add,MUIA_Cycle_Active,MT_Printer ,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Mutex_Active,0);
    DoMethod(CY_Display ,MUIM_Broadcast_Add,MUIA_Cycle_Active,MT_Display ,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Mutex_Active,0);
    DoMethod(MT_Computer,MUIM_Broadcast_Add,MUIA_Mutex_Active,CY_Computer,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Cycle_Active,0);
    DoMethod(MT_Printer ,MUIM_Broadcast_Add,MUIA_Mutex_Active,CY_Printer ,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Cycle_Active,0);
    DoMethod(MT_Display ,MUIM_Broadcast_Add,MUIA_Mutex_Active,CY_Display ,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Cycle_Active,0);
    DoMethod(MT_Computer,MUIM_Broadcast_Add,MUIA_Mutex_Active,LV_Computer,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_List_Active ,0);
    DoMethod(LV_Computer,MUIM_Broadcast_Add,MUIA_List_Active ,MT_Computer,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Mutex_Active,0);


/*
** This one makes us receive input ids from several list views.
*/

    DoMethod(LV_Volumes ,MUIM_Broadcast_Add,MUIA_Listview_DoubleClick,AP_Demo,2,MUIM_Application_ReturnID,ID_NEWVOL);
    DoMethod(LV_Brian   ,MUIM_Broadcast_Add,MUIA_List_Active,AP_Demo,2,MUIM_Application_ReturnID,ID_NEWBRI);


/*
** Now lets set the TAB cycle chain for some of our windows.
*/

    DoMethod(WI_Master   ,MUIM_Window_SetCycleChain,BT_Groups,BT_Frames,BT_Backfill,BT_Broadcast,BT_Listviews,BT_Cycle,BT_Images,BT_String,BT_Datatype,NULL);
    DoMethod(WI_Listviews,MUIM_Window_SetCycleChain,LV_Directory,LV_Volumes,NULL);
    DoMethod(WI_Cycle    ,MUIM_Window_SetCycleChain,MT_Computer,MT_Printer,MT_Display,CY_Computer,CY_Printer,CY_Display,LV_Computer,NULL);
    DoMethod(WI_String   ,MUIM_Window_SetCycleChain,ST_Brian,NULL);
    if (WI_Datatype)
        DoMethod(WI_Datatype ,MUIM_Window_SetCycleChain,ST_Datatype,NULL);


/*
** Set some start values for some objects.
*/

    DoMethod(ST_Datatype,MUIM_Broadcast_Add,MUIA_String_Final,DT_Datatype,2+MUIP_Broadcast_Add_AppendTriggered,MUIM_SET,MUIA_Datatype_Name,0);

    DoMethod(LV_Computer,MUIM_List_Insert,CYA_Computer,-1,MUIV_List_Insert_Last);
    DoMethod(LV_Brian   ,MUIM_List_Insert,LVT_Brian,-1,MUIV_List_Insert_Last);
    set(LV_Computer,MUIA_List_Active,0);
    set(LV_Brian   ,MUIA_List_Active,0);
    set(ST_Brian   ,MUIA_String_AttachedList,LV_Brian);


/*
** Everything's ready, lets launch the application. We will
** open the master window now.
*/

    DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Master);


/*
** This is the main loop. As you can see, it does just nothing.
** Everything is handled by MUI, no work for the programmer.
**
** The only thing we do here is to react on a double click
** in the volume list (which causes an ID_NEWVOL) by setting
** a new directory name for the directory list. If you want
** to see a real file requester with MUI, wait for the
** next release of MFR :-)
**
** Since MUI currently has no object oriented menu system
** that could send broadcast messages itself, we have also
** to check for the menu ids and open the appropriate
** windows by hand.
*/

    {
        ULONG signal;
        BOOL running = TRUE;
        char *buf;

        while (running)
        {
            switch (DoMethod(AP_Demo,MUIM_Application_Input,&signal))
            {
                case MUIV_Application_ReturnID_Quit:
                    running = FALSE;
                    break;

                case ID_NEWVOL:
                    DoMethod(LV_Volumes,MUIM_Volumelist_GetVol,-1,&buf);
                    set(LV_Directory,MUIA_Dirlist_DirName,buf);
                    break;

                case ID_NEWBRI:
                    get(LV_Brian,MUIA_List_Active,&buf);
                    set(ST_Brian,MUIA_String_Contents,LVT_Brian[(int)buf]);
                    break;

                case ID_ABOUT:
                    MUI_Request(AP_Demo, MUIR_Text, "\\appversion\n\\appcopyright", MUIR_Responses, "OK", TAG_DONE);
                    break;

                case ID_FRAMES   : DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Frames   ); break;
                case ID_IMAGES   : DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Images   ); break;
                case ID_BROADCAST: DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Broadcast); break;
                case ID_GROUPS   : DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Groups   ); break;
                case ID_BACKFILL : DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Backfill ); break;
                case ID_LISTVIEWS: DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Listviews); break;
                case ID_CYCLE    : DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Cycle    ); break;
                case ID_STRING   : DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_String   ); break;
                case ID_DATATYPE : if (WI_Datatype) DoMethod(AP_Demo,MUIM_Application_AddWindow,WI_Datatype ); break;
            }
            if (signal) Wait(signal);
        }
    }


/*
** Shut down the application, remove all windows.
*/

    DoMethod(AP_Demo,MUIM_Application_RemoveWindow,NULL);


/*
** Call the fail function in demos.h, this will dispose all
** objects and close "muimaster.library".
*/

    fail(NULL);
}


/*
** This is the end...
*/












/*
** expect for a little array definition:
*/

static const char *LVT_Brian[48] =
{
"Cheer up, Brian. You know what they say.",
"Some things in life are bad,",
"They can really make you mad.",
"Other things just make you swear and curse.",
"When you're chewing on life's grissle,",
"Don't grumble, give a whistle.",
"And this'll help things turn out for the best,",
"And...",
"",
"Always look on the bright side of life",
"Always look on the light side of life",
"",
"If life seems jolly rotten,",
"There's something you've forgotten,",
"And that's to laugh, and smile, and dance, and sing.",
"When you're feeling in the dumps,",
"Don't be silly chumps,",
"Just purse your lips and whistle, that's the thing.",
"And...",
"",
"Always look on the bright side of life, come on!",
"Always look on the right side of life",
"",
"For life is quite absurd,",
"And death's the final word.",
"You must always face the curtain with a bow.",
"Forget about your sin,",
"Give the audience a grin.",
"Enjoy it, it's your last chance anyhow,",
"So...",
"",
"Always look on the bright side of death",
"Just before you draw your terminal breath.",
"",
"Life's a piece of shit,",
"When you look at it.",
"Life's a laugh, and death's a joke, it's true.",
"You'll see it's all a show,",
"Keep 'em laughing as you go,",
"Just remember that the last laugh is on you.",
"And...",
"",
"Always look on the bright side of life !",
"",
"...",
"",
"[Thanx to [e-mail] and to Mr. M. Python]",
NULL,
};