IPTR Poppen__MUIM_Poppen_OpenWindow(struct IClass *cl, Object *obj, Msg msg)
{
struct Poppen_DATA *data = INST_DATA(cl, obj);
if (!data->wnd)
{
Object *ok_button, *cancel_button;
char *penspec;
get(obj,MUIA_Pendisplay_Spec, &penspec);
data->wnd = (Object *)(WindowObject,
MUIA_Window_Title, (IPTR)data->wintitle,
MUIA_Window_Activate, TRUE,
WindowContents, (IPTR)VGroup,
Child, (IPTR)(data->penadjust = (Object *)PenadjustObject,
MUIA_CycleChain, 1,
MUIA_Penadjust_Spec, (IPTR)penspec,
End),
Child, (IPTR)HGroup,
Child, (IPTR)(ok_button = MUI_MakeObject(MUIO_Button,(IPTR)"_Ok")),
Child, (IPTR)(cancel_button = MUI_MakeObject(MUIO_Button,(IPTR)"_Cancel")),
End,
End,
End);
if (data->wnd)
{
set(ok_button, MUIA_CycleChain, 1);
set(cancel_button, MUIA_CycleChain, 1);
DoMethod(_app(obj),OM_ADDMEMBER,(IPTR)data->wnd);
DoMethod(ok_button, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)_app(obj), 5,
MUIM_Application_PushMethod, (IPTR)obj, 2,
MUIM_Poppen_CloseWindow, TRUE);
DoMethod(cancel_button, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)_app(obj), 5,
MUIM_Application_PushMethod, (IPTR)obj, 2,
MUIM_Poppen_CloseWindow, FALSE);
DoMethod(data->wnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (IPTR)_app(obj), 5,
MUIM_Application_PushMethod, (IPTR)obj, 2,
MUIM_Poppen_CloseWindow, FALSE);
}
}
if (data->wnd)
{
IPTR opened;
set(data->wnd, MUIA_Window_Open,TRUE);
get(data->wnd, MUIA_Window_Open, &opened);
if (!opened)
{
DoMethod(obj, MUIM_Poppen_CloseWindow, FALSE);
}
}
return 1;
}
Object *opopbutton(ULONG img, ULONG help)
{
Object *obj;
if((obj = MUI_MakeObject(MUIO_PopButton, img)) != NULL)
SetAttrs(obj,MUIA_CycleChain,TRUE,_HELP(help),TAG_DONE);
return obj;
}
STATIC APTR MakeString(LONG str_id, ULONG maxlen, ULONG object_id)
{
APTR obj;
if ((obj = MUI_MakeObject(MUIO_String, (IPTR)GSI(str_id), maxlen)))
SetAttrs(obj, MUIA_CycleChain, TRUE, MUIA_ObjectID, object_id, TAG_DONE);
return obj;
}
Object *obutton(ULONG text, ULONG help)
{
Object *obj;
if((obj = MUI_MakeObject(MUIO_Button, (ULONG)getString(text))) != NULL)
SetAttrs(obj,MUIA_CycleChain,TRUE,_HELP(help),TAG_DONE);
return obj;
}
STATIC APTR MakeCycle(LONG label, CONST CONST_STRPTR *entries, ULONG id)
{
APTR obj = MUI_MakeObject(MUIO_Cycle, (IPTR)GSI(label), (IPTR)entries);
if (obj)
SetAttrs(obj, MUIA_CycleChain, 1, MUIA_ObjectID, id, TAG_DONE);
return obj;
}
Object *CreateGUI(struct IClass *cl, Object *obj, struct ObjStore *os, struct DnetcLibrary *LibBase)
{
UBYTE about[512];
ULONG array[] =
{
(ULONG) LibBase->Version,
LibBase->Library.lib_Version,
LibBase->Library.lib_Revision
};
//#define SysBase LibBase->MySysBase
RawDoFmt(
"\33cdistributed.net client - a product of distributed.net\n"
"%s\n"
"Copyright 1997-2011 distributed.net\n"
"\n"
"\n"
"MorphOS client maintained by\n"
"Harry Sintonen\n"
"<*****@*****.**>\n"
"\n"
"\n"
"MUI GUI module (v%ld.%ld) maintained by\n"
"Ilkka Lehtoranta\n"
"<*****@*****.**>",
array, NULL, about);
//#undef SysBase
return (Object*)DoSuperNew(cl, obj,
MUIA_Application_DiskObject, (IPTR)LibBase->dobj,
MUIA_Application_Commands, (IPTR)commands,
MUIA_Application_Version, (IPTR)&VerString[1],
MUIA_Application_Copyright, (IPTR)"distributed.net",
MUIA_Application_Author, (IPTR)"Ilkka Lehtoranta",
MUIA_Application_Base, (IPTR)"DNETC",
MUIA_Application_UsedClasses, (IPTR)ClassList,
MUIA_Application_Title, (IPTR)"dnetc",
MUIA_Application_Description, (IPTR)"GUI for distributed.net client",
MUIA_Application_Window, (IPTR)(os->wnd = MUI_NewObject(MUIC_Window,
MUIA_Window_Title, (IPTR)"distributed.net client",
MUIA_Window_ID, MAKE_ID('M','A','I','N'),
MUIA_Window_Width, MUIV_Window_Width_Visible(55),
MUIA_Window_Height, MUIV_Window_Height_Visible(45),
MUIA_Window_Menustrip, (IPTR)MUI_MakeObject(MUIO_MenustripNM, (IPTR)&Menus, 0),
MUIA_Window_RootObject, (IPTR)MUI_NewObject(MUIC_Group,
MUIA_Group_Child, (IPTR)(os->lst = NewObject(LibBase->ListMCC->mcc_Class, NULL,
MUIA_Background, MUII_ReadListBack,
MUIA_Frame, MUIV_Frame_ReadList,
MUIA_CycleChain, TRUE,
TAG_END)),
TAG_END),
TAG_END)),
MUIA_Application_Window, (IPTR)(os->req = MUI_NewObject(MUIC_Aboutbox,
MUIA_Aboutbox_Credits, (IPTR)about,
TAG_END)),
TAG_END);
}
STATIC APTR MakeButton(LONG str_id)
{
APTR obj;
if ((obj = MUI_MakeObject(MUIO_Button, GSI(str_id))))
SetAttrs(obj, MUIA_CycleChain, TRUE, TAG_DONE);
return obj;
}
Object *ocheckmark(ULONG key, ULONG help)
{
Object *obj;
if((obj = MUI_MakeObject(MUIO_Checkmark, (ULONG)getString(key))) != NULL)
SetAttrs(obj,MUIA_CycleChain,TRUE,_HELP(help),TAG_DONE);
return obj;
}
Object *
ocheck(ULONG key,ULONG help)
{
register Object *obj;
if (obj = MUI_MakeObject(MUIO_Checkmark,(ULONG)getString(key)))
SetAttrs(obj,MUIA_CycleChain,TRUE,MUIA_ShortHelp,(ULONG)getString(help),TAG_DONE);
return obj;
}
Object * CheckMarkObj( STRPTR ShortHelp, ULONG ObjectID )
{
Object *obj;
if((obj = MUI_MakeObject(MUIO_Checkmark, NULL)))
{
SetAttrs(obj,
MUIA_CycleChain , TRUE,
MUIA_ShortHelp , (ULONG)ShortHelp,
MUIA_ObjectID , ObjectID,
TAG_DONE);
}
return(obj);
}
STATIC APTR MakeSlider(LONG str_id, LONG fmt_id, LONG min, LONG max, ULONG object_id)
{
APTR obj;
if ((obj = MUI_MakeObject(MUIO_Slider, (IPTR)GSI(str_id), min, max)))
{
SetAttrs(obj,
MUIA_CycleChain , TRUE,
MUIA_ObjectID , object_id,
MUIA_Numeric_Format , (IPTR)GSI(fmt_id),
TAG_DONE);
}
return obj;
}
STATIC APTR MakeCheck(LONG str_id, ULONG check, ULONG object_id)
{
APTR obj;
obj = MUI_MakeObject(MUIO_Checkmark, (IPTR)GSI(str_id));
if (obj)
SetAttrs(obj,
MUIA_CycleChain, TRUE,
MUIA_ObjectID , object_id,
MUIA_Selected , check,
TAG_DONE);
return (obj);
}
Object * ButtonObj( STRPTR label, LONG FixWidth, STRPTR ShortHelp )
{
Object *obj;
if((obj = MUI_MakeObject(MUIO_Button, label )))
{
SetAttrs(obj,
MUIA_CycleChain , 1,
MUIA_FixWidth , FixWidth,
MUIA_ShortHelp , (ULONG) ShortHelp,
TAG_DONE);
}
return(obj);
}
Object * CycleObj( char **array, STRPTR ShortHelp, ULONG ObjectID )
{
Object *obj;
if((obj = MUI_MakeObject(MUIO_Cycle, NULL, array)))
{
SetAttrs(obj,
MUIA_CycleChain , TRUE,
MUIA_ShortHelp , (ULONG) ShortHelp,
MUIA_ObjectID , ObjectID,
TAG_DONE);
}
return(obj);
}
Object * SliderObj( LONG min, LONG max, LONG Current, STRPTR ShortHelp, ULONG ObjectID)
{
Object *obj;
if((obj = MUI_MakeObject(MUIO_Slider, NULL, min, max)))
{
SetAttrs(obj,
MUIA_CycleChain , TRUE,
MUIA_ShortHelp , (ULONG) ShortHelp,
MUIA_Slider_Level , Current,
MUIA_ObjectID , ObjectID,
TAG_DONE);
}
return(obj);
}
Object *
opop(ULONG type,ULONG key)
{
register Object *obj;
if (!(lib_flags & BASEFLG_MUI4) && (type==MUII_PopFont))
type = MUII_PopUp;
if (obj = MUI_MakeObject(MUIO_PopButton,type))
{
set(obj,MUIA_CycleChain,TRUE);
if (key)
{
ULONG k;
if (k = getKeyChar(getString(key)))
set(obj,MUIA_ControlChar,ToLower(k));
}
}
return obj;
}
BOOL BuildGUI(char *screenname)
{
Object *MUISave, *MUIUse, *MUICancel;
Object *page1,*page2;
Object *MUITFreq,*MUITChannels,*MUITOutvol,*MUITMonvol,*MUITGain,*MUITInput,*MUITOutput,*MUITDebug,*MUITEcho,*MUITSurround,*MUITClipvol,*MUITCpu,*MUITACTime,*MUITScalemode;
UpdateStrings();
MUIMasterBase = (void *)OpenLibrary("muimaster.library", MUIMASTER_VLATEST);
if(MUIMasterBase == NULL)
{
Printf((char *) msgTextNoOpen, (ULONG) "muimaster.library", MUIMASTER_VLATEST);
Printf("\n");
return FALSE;
}
page1 = HGroup,
Child, VGroup,
Child, MUIUnit = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, Units,
MUIA_Cycle_Active, state.UnitSelected,
End,
Child, ListviewObject,
MUIA_CycleChain, 1,
MUIA_Listview_List, MUIList = ListObject,
InputListFrame,
MUIA_List_AutoVisible, TRUE,
End,
End,
Child, HGroup,
ReadListFrame,
MUIA_Background, MUII_TextBack,
Child, TextObject,
MUIA_Text_Contents, msgProperties,
MUIA_Text_SetMax, TRUE,
End,
Child, MUIInfos = TextObject,
MUIA_Text_Contents, "\n\n\n\n\n\n",
MUIA_Text_SetMin, FALSE,
End,
End,
End,
Child, BalanceObject,
End,
Child, VGroup,
Child, HVSpace,
Child, ColGroup(3),
GroupFrameT(msgOptions),
Child, MUITFreq = SpecialButton((STRPTR)msgOptFrequency),
Child, MUIFreq = SpecialSlider(0,max(state.Frequencies-1,0),state.FreqSelected),
Child, MUILFreq = SpecialLabel(getFreq()),
Child, MUITChannels = SpecialButton((STRPTR)msgOptChannels),
Child, MUIChannels = SpecialSlider(1,state.Channels,state.ChannelsSelected),
Child, MUILChannels = SpecialLabel(getChannels()),
Child, MUITOutvol = SpecialButton((STRPTR)msgOptVolume),
Child, MUIOutvol = SpecialSlider(0,max(state.OutVols-1,0),state.OutVolSelected),
Child, MUILOutvol = SpecialLabel(getOutVol()),
Child, MUITMonvol = SpecialButton((STRPTR)msgOptMonitor),
Child, MUIMonvol = SpecialSlider(0,max(state.MonVols-1,1),state.MonVolSelected),
Child, MUILMonvol = SpecialLabel(getMonVol()),
Child, MUITGain = SpecialButton((STRPTR)msgOptGain),
Child, MUIGain = SpecialSlider(0,max(state.Gains-1,0),state.GainSelected),
Child, MUILGain = SpecialLabel(getGain()),
Child, MUITInput = SpecialButton((STRPTR)msgOptInput),
Child, MUIInput = SpecialSlider(0,max(state.Inputs-1,0),state.InputSelected),
Child, MUILInput = SpecialLabel(getInput()),
Child, MUITOutput = SpecialButton((STRPTR)msgOptOutput),
Child, MUIOutput = SpecialSlider(0,max(state.Outputs-1,0),state.OutputSelected),
Child, MUILOutput = SpecialLabel(getOutput()),
End,
Child, MUIPlay = SimpleButton(msgButtonPlay),
Child, HVSpace,
End,
End;
page2 = VGroup,
Child, HVSpace,
Child, HGroup,
Child, HVSpace,
Child, ColGroup(2),
GroupFrameT(msgGlobalOptions),
Child, MUITDebug = SpecialButton((STRPTR)msgGlobOptDebugLevel),
Child, MUIDebug = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, DebugLabels,
MUIA_Cycle_Active, globalprefs.ahigp_DebugLevel,
End,
Child, MUITEcho = SpecialButton((STRPTR)msgGlobOptEcho),
Child, MUIEcho = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, EchoLabels,
MUIA_Cycle_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) | (globalprefs.ahigp_FastEcho ? 1 : 0),
MUIA_Disabled, AHIBase->lib_Version >= 5,
End,
Child, MUITSurround = SpecialButton((STRPTR)msgGlobOptSurround),
Child, MUISurround = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, SurroundLabels,
MUIA_Cycle_Active, globalprefs.ahigp_DisableSurround,
MUIA_Disabled, AHIBase->lib_Version >= 5,
End,
Child, MUITClipvol = SpecialButton((STRPTR)msgGlobOptMasterVol),
Child, MUIClipvol = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, ClipMVLabels,
MUIA_Cycle_Active, globalprefs.ahigp_ClipMasterVolume,
MUIA_Disabled, AHIBase->lib_Version >= 5,
End,
Child, MUITCpu = SpecialButton((STRPTR)msgGlobOptCPULimit),
Child, MUICpu = SliderObject,
MUIA_CycleChain, 1,
MUIA_Slider_Horiz, TRUE,
MUIA_Numeric_Min, 0,
MUIA_Numeric_Max, 100,
MUIA_Numeric_Value,(globalprefs.ahigp_MaxCPU * 100 + 32768) / 65536,
MUIA_Numeric_Format,"%ld%%",
End,
Child, MUITACTime = SpecialButton((STRPTR)msgGlobOptACTime),
Child, MUIACTime = SliderObject,
MUIA_CycleChain, 1,
MUIA_Slider_Horiz, TRUE,
MUIA_Numeric_Min, 0,
MUIA_Numeric_Max, 100,
MUIA_Numeric_Value,(globalprefs.ahigp_AntiClickTime * 1000 + 32768) >> 16,
MUIA_Numeric_Format,"%ld ms",
MUIA_Disabled, AHIBase->lib_Version <= 4,
End,
Child, MUITScalemode = SpecialButton((STRPTR)msgOptScalemode),
Child, MUIScalemode = CycleObject,
MUIA_CycleChain, 1,
MUIA_Cycle_Entries, ScaleLabels,
MUIA_Cycle_Active, globalprefs.ahigp_ScaleMode,
MUIA_Disabled, AHIBase->lib_Version <= 4,
End,
End,
Child, HVSpace,
End,
Child, HVSpace,
End;
MUIApp = ApplicationObject,
MUIA_Application_Title, (char *) msgTextProgramName,
MUIA_Application_Version, Version,
MUIA_Application_Copyright, "©1996-2004 Martin Blom",
MUIA_Application_Author, "Stéphane Barbaray/Martin Blom",
MUIA_Application_Base, "AHI",
MUIA_Application_HelpFile, HELPFILE,
MUIA_Application_Menustrip, MUIMenu = MUI_MakeObject(MUIO_MenustripNM,Menus,0),
MUIA_Application_SingleTask, TRUE,
SubWindow, MUIWindow = WindowObject,
MUIA_Window_Title, (char *) msgTextProgramName,
MUIA_Window_ID , MAKE_ID('M','A','I','N'),
MUIA_HelpNode, "AHI",
WindowContents, VGroup,
Child, RegisterGroup(PageNames),
MUIA_CycleChain, 1,
Child, page1,
Child, page2,
End,
Child, HGroup,
Child, MUISave = SimpleButton(msgButtonSave),
Child, MUIUse = SimpleButton(msgButtonUse),
Child, MUICancel = SimpleButton(msgButtonCancel),
End,
End,
End,
End;
if( MUIApp != NULL )
{
APTR item = (APTR)DoMethod(MUIMenu,MUIM_FindUData,ACTID_ICONS);
if(item)
{
set(item, MUIA_Menuitem_Checked, SaveIcons);
}
DoMethod(MUIWindow, MUIM_MultiSet, MUIA_Text_PreParse,"\033l",MUILFreq,MUILChannels,MUILOutvol,MUILMonvol,MUILGain,MUILInput,MUILOutput,NULL);
DoMethod(MUIWindow, MUIM_MultiSet, MUIA_CycleChain, 1, MUISave,MUIUse,MUICancel,NULL);
DoMethod(MUITFreq, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIFreq);
DoMethod(MUITChannels, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIChannels);
DoMethod(MUITOutvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIOutvol);
DoMethod(MUITMonvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIMonvol);
DoMethod(MUITGain, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIGain);
DoMethod(MUITInput, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIInput);
DoMethod(MUITOutput, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIOutput);
DoMethod(MUIPlay, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_PLAY);
DoMethod(MUITDebug, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIDebug);
DoMethod(MUITEcho, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIEcho);
DoMethod(MUITSurround, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUISurround);
DoMethod(MUITClipvol, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIClipvol);
DoMethod(MUITCpu, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUICpu);
DoMethod(MUITACTime, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIACTime);
DoMethod(MUITScalemode, MUIM_Notify, MUIA_Pressed, TRUE, MUIWindow, 3, MUIM_Set, MUIA_Window_ActiveObject, MUIScalemode);
DoMethod(MUIWindow, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(MUISave, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SAVE);
DoMethod(MUIUse, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, ACTID_USE);
DoMethod(MUICancel, MUIM_Notify, MUIA_Pressed, FALSE, MUIApp, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(MUIUnit, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_UNIT);
DoMethod(MUIList, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_MODE);
DoMethod(MUIDebug, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_DEBUG);
DoMethod(MUISurround, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SURROUND);
DoMethod(MUIEcho, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_ECHO);
DoMethod(MUICpu, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_CPULIMIT);
DoMethod(MUIClipvol, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_CLIPMV);
DoMethod(MUIACTime, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_ACTIME);
DoMethod(MUIScalemode, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, MUIApp, 2, MUIM_Application_ReturnID, ACTID_SCALEMODE);
DoMethod(MUIFreq, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIChannels, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIOutvol, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIMonvol, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIGain, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIInput, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
DoMethod(MUIOutput, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, MUIV_Notify_Self, 3, MUIM_CallHook, &hookSlider, MUIV_TriggerValue);
set(MUIWindow, MUIA_Window_Open, TRUE);
GUINewUnit();
return TRUE;
}
return FALSE;
}
int main(void)
{
if((DiskfontBase = OpenLibrary("diskfont.library", 38)) &&
GETINTERFACE(IDiskfont, DiskfontBase))
if((GfxBase = OpenLibrary("graphics.library", 38)) &&
GETINTERFACE(IGraphics, GfxBase))
if((IntuitionBase = (APTR)OpenLibrary("intuition.library", 38)) &&
GETINTERFACE(IIntuition, IntuitionBase))
if((KeymapBase = OpenLibrary("keymap.library", 37)) &&
GETINTERFACE(IKeymap, KeymapBase))
if((LocaleBase = OpenLibrary("locale.library", 38)) &&
GETINTERFACE(ILocale, LocaleBase))
if((LayersBase = OpenLibrary("layers.library", 38)) &&
GETINTERFACE(ILayers, LayersBase))
if((UtilityBase = (APTR)OpenLibrary("utility.library", 38)) &&
GETINTERFACE(IUtility, UtilityBase))
if((MUIMasterBase = OpenLibrary("muimaster.library", MUIMASTER_VMIN)) &&
GETINTERFACE(IMUIMaster, MUIMasterBase))
if((IFFParseBase = OpenLibrary("iffparse.library", 36)) &&
GETINTERFACE(IIFFParse, IFFParseBase))
{
struct MUI_CustomClass *mcc;
Object *a1, *a2, *app, *window, *bstring, *bstring2, *bpos, *ssize, *button, *numbutton;
Object *menu;
const char *classes[] = {"BetterString.mcp", NULL};
#if defined(DEBUG)
SetupDebug();
#endif
mcc = MUI_CreateCustomClass(NULL, "Area.mui", NULL, sizeof(struct InstData), ENTRY(_Dispatcher));
/*
menu = MenustripObject,
MUIA_Family_Child, MenuObject, MUIA_Menu_Title, "Test",
MUIA_Family_Child, MenuitemObject,
MUIA_Menuitem_Title, "Dummy",
MUIA_Menuitem_Enabled, TRUE,
MUIA_Menuitem_Shortcut, "V",
End,
End,
End,
*/
app = ApplicationObject,
MUIA_Application_Author, "BetterString.mcc Open Source Team",
MUIA_Application_Base, "BetterString-Test",
MUIA_Application_Copyright, "(C) 2005-2009 by BetterString.mcc Open Source Team",
MUIA_Application_Description, "BetterString.mcc demonstration program",
MUIA_Application_Title, "BetterString-Test",
MUIA_Application_Version, "$VER: BetterString-Demo V1.0 (18.05.2007)",
MUIA_Application_UsedClasses, classes,
MUIA_Application_Window, window = WindowObject,
MUIA_Window_Title, "BetterString-Test",
MUIA_Window_ID, MAKE_ID('M','A','I','N'),
//MUIA_Window_Menustrip, menu,
MUIA_Window_RootObject, VGroup,
Child, PopaslObject,
MUIA_Popstring_String, NewObject(mcc->mcc_Class, NULL, StringFrame, MUIA_BetterString_NoInput, TRUE, MUIA_CycleChain, TRUE, End,
MUIA_Popstring_Button, MUI_MakeObject(MUIO_PopButton, MUII_PopUp),
MUIA_Popasl_Type, ASL_FontRequest,
End,
Child, ColGroup(2), StringFrame,
MUIA_Background, MUII_GroupBack,
Child, TextObject,
MUIA_Weight, 0,
MUIA_Text_Contents, "\33rName:",
End,
Child, a1 = (Object *)NewObject(mcc->mcc_Class, NULL,
MUIA_CycleChain, TRUE,
MUIA_Background, MUII_GroupBack,
MUIA_String_AdvanceOnCR, TRUE,
MUIA_String_MaxLen, 10,
MUIA_ObjectID, MAKE_ID('N','A','M','E'),
End,
Child, TextObject,
MUIA_Weight, 0,
MUIA_Text_Contents, "\33rStreet:",
End,
Child, a2 = (Object *)NewObject(mcc->mcc_Class, NULL,
MUIA_CycleChain, TRUE,
MUIA_Background, MUII_GroupBack,
MUIA_String_AdvanceOnCR, TRUE,
MUIA_ObjectID, MAKE_ID('S','T','R','T'),
End,
Child, TextObject,
MUIA_Weight, 0,
MUIA_Text_Contents, "\33rZip, City:",
End,
Child, NewObject(mcc->mcc_Class, NULL,
MUIA_CycleChain, TRUE,
MUIA_Background, MUII_GroupBack,
MUIA_String_AdvanceOnCR, TRUE,
MUIA_ObjectID, MAKE_ID('C','I','T','Y'),
End,
End,
Child, TextObject,
MUIA_Font, MUIV_Font_Tiny,
MUIA_Text_Contents, "\33cBetterString.mcc",
End,
Child, NewObject(mcc->mcc_Class, NULL,
StringFrame,
MUIA_CycleChain, TRUE,
MUIA_String_Secret, TRUE,
// MUIA_String_MaxLen, 20,
MUIA_String_AdvanceOnCR, TRUE,
MUIA_BetterString_StayActive, TRUE,
// MUIA_String_Accept, "0123456789",
MUIA_String_Contents, "This is a wonderful example string!",
End,
Child, NewObject(mcc->mcc_Class, NULL,
StringFrame,
MUIA_CycleChain, TRUE,
MUIA_BetterString_InactiveContents, "This is a wonderful example string!",
End,
Child, NewObject(mcc->mcc_Class, NULL,
StringFrame,
MUIA_CycleChain, TRUE,
MUIA_String_Secret, TRUE,
MUIA_BetterString_InactiveContents, "This is a wonderful example string!",
End,
Child, TextObject,
MUIA_Font, MUIV_Font_Tiny,
MUIA_Text_Contents, "\33cCentered",
End,
Child, bstring = (Object *)NewObject(mcc->mcc_Class, NULL,
ButtonFrame,
MUIA_Font, MUIV_Font_Big,
// StringFrame,
MUIA_String_AdvanceOnCR, TRUE,
MUIA_String_Format, MUIV_String_Format_Center,
MUIA_String_Contents, "This is a wonderful example string!",
MUIA_CycleChain, TRUE,
End,
Child, TextObject,
MUIA_Font, MUIV_Font_Tiny,
MUIA_Text_Contents, "\33cRight-Aligned",
End,
Child, bstring2 = NewObject(mcc->mcc_Class, NULL,
MUIA_CycleChain, TRUE,
// StringFrame,
MUIA_String_AdvanceOnCR, TRUE,
MUIA_String_Contents, "This is a wonderful example string!",
MUIA_String_Format, MUIV_String_Format_Right,
End,
Child, TextObject,
MUIA_Font, MUIV_Font_Tiny,
MUIA_Text_Contents, "\33cStringObject",
End,
Child, StringObject,
StringFrame,
MUIA_String_AdvanceOnCR, TRUE,
MUIA_String_Contents, "This is a standard StringObject",
MUIA_String_Format, MUIV_String_Format_Right,
MUIA_String_MaxLen, 1024,
MUIA_CycleChain, TRUE,
End,
Child, HGroup,
Child, button = SimpleButton("Insert"),
Child, bpos = SliderObject,
MUIA_Slider_Horiz, TRUE,
MUIA_Numeric_Max, 60,
End,
Child, ssize = SliderObject,
MUIA_Slider_Horiz, TRUE,
MUIA_Numeric_Min, -30,
MUIA_Numeric_Max, 30,
MUIA_Numeric_Value, 0,
End,
Child, numbutton = NumericbuttonObject,
MUIA_Numeric_Min, -30,
MUIA_Numeric_Max, 30,
MUIA_Numeric_Value, 0,
MUIA_Disabled, TRUE,
End,
End,
End,
End,
End;
if(app)
{
ULONG sigs;
DoMethod(app, MUIM_Application_Load, MUIV_Application_Load_ENV);
DoMethod(a1, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime, a2, 3, MUIM_Set, MUIA_String_Contents, MUIV_TriggerValue);
DoMethod(a2, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime, a1, 3, MUIM_Set, MUIA_String_Contents, MUIV_TriggerValue);
DoMethod(ssize, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, numbutton, 3, MUIM_Set, MUIA_Numeric_Value, MUIV_TriggerValue);
DoMethod(bpos, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, bstring, 3, MUIM_Set, MUIA_String_BufferPos, MUIV_TriggerValue);
DoMethod(ssize, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime, bstring, 3, MUIM_Set, MUIA_BetterString_SelectSize, MUIV_TriggerValue);
DoMethod(button, MUIM_Notify, MUIA_Pressed, FALSE, bstring, 3, MUIM_BetterString_Insert, "*Test*", MUIV_BetterString_Insert_BufferPos);
DoMethod(window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, MUIV_Notify_Application, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
set(bstring, MUIA_BetterString_KeyDownFocus, bstring2);
set(bstring2, MUIA_BetterString_KeyUpFocus, bstring);
set(window, MUIA_Window_ActiveObject, bstring);
set(window, MUIA_Window_DefaultObject, bstring);
set(window, MUIA_Window_Open, TRUE);
while((LONG)DoMethod(app, MUIM_Application_NewInput, &sigs) != MUIV_Application_ReturnID_Quit)
{
if(sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if(sigs & SIGBREAKF_CTRL_C)
break;
}
}
DoMethod(app, MUIM_Application_Save, MUIV_Application_Save_ENV);
MUI_DisposeObject(app);
if(mcc)
MUI_DeleteCustomClass(mcc);
}
DROPINTERFACE(IMUIMaster);
CloseLibrary(MUIMasterBase);
MUIMasterBase = NULL;
}
if(IFFParseBase)
{
DROPINTERFACE(IIFFParse);
CloseLibrary(IFFParseBase);
IFFParseBase = NULL;
}
if(UtilityBase)
{
DROPINTERFACE(IUtility);
CloseLibrary((struct Library *)UtilityBase);
}
if(LayersBase)
{
DROPINTERFACE(ILayers);
CloseLibrary(LayersBase);
}
if(LocaleBase)
{
DROPINTERFACE(ILocale);
CloseLibrary(LocaleBase);
}
if(KeymapBase)
{
DROPINTERFACE(IKeymap);
CloseLibrary(KeymapBase);
}
if(IntuitionBase)
{
DROPINTERFACE(IIntuition);
CloseLibrary((struct Library *)IntuitionBase);
}
if(GfxBase)
{
DROPINTERFACE(IGraphics);
CloseLibrary(GfxBase);
}
if(DiskfontBase)
{
DROPINTERFACE(IDiskfont);
CloseLibrary(DiskfontBase);
}
return 0;
}
int main(void)
{
Object *app, *win, *iconCon, *vert, *horiz;
Object *strip;
struct MUI_CustomClass *iconContainerClass;
BOOL running=TRUE;
ULONG signals=0;
struct Screen *screen;
struct NewMenu *menuDat;
struct TagItem icTags[6];
ULONG inputResult;
MUIMasterBase=OpenLibrary("muimaster.library", 0);
if(!MUIMasterBase)
printf("could not open muimaster.library\n");
DesktopBase=OpenLibrary("desktop.library", 0);
if(!DesktopBase)
printf("could not open desktop.library\n");
menuDat=BuildDesktopMenus();
if(!menuDat)
kprintf("EEK! EEKK! Menu ERROR!!!\n");
screen=LockPubScreen(NULL);
horiz=PropObject,
MUIA_Prop_Horiz, TRUE,
MUIA_Prop_Entries, 0,
MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Bottom,
End;
vert=PropObject,
MUIA_Prop_Horiz, FALSE,
MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Right,
End;
icTags[0].ti_Tag=MUIA_InnerLeft;
icTags[0].ti_Data=0;
icTags[1].ti_Tag=MUIA_InnerTop;
icTags[1].ti_Data=0;
icTags[2].ti_Tag=MUIA_InnerBottom;
icTags[2].ti_Data=0;
icTags[3].ti_Tag=MUIA_InnerRight;
icTags[3].ti_Data=0;
icTags[4].ti_Tag=MUIA_FillArea;
icTags[4].ti_Data=FALSE;
// icTags[1].ti_Tag=ICOA_Directory;
// icTags[1].ti_Data="C:";
// icTags[2].ti_Tag=ICA_VertScroller;
// icTags[2].ti_Data=vert;
// icTags[3].ti_Tag=ICA_HorizScroller;
// icTags[3].ti_Data=horiz;
icTags[5].ti_Tag=TAG_END;
icTags[5].ti_Data=0;
kprintf("here1\n");
app=ApplicationObject,
SubWindow, win=WindowObject,
MUIA_Window_Backdrop, TRUE,
MUIA_Window_Borderless, TRUE,
MUIA_Window_CloseGadget, FALSE,
MUIA_Window_DepthGadget, FALSE,
MUIA_Window_SizeGadget, FALSE,
MUIA_Window_DragBar, FALSE,
MUIA_Window_LeftEdge, 0,
MUIA_Window_TopEdge, screen->BarHeight+1,
MUIA_Window_Width, screen->Width,
MUIA_Window_Height, screen->Height-screen->BarHeight-1,
MUIA_Window_Menustrip, strip=MUI_MakeObject(MUIO_MenustripNM, menuDat, 0),
// MUIA_Window_UseBottomBorderScroller, TRUE,
// MUIA_Window_UseRightBorderScroller, TRUE,
MUIA_Window_EraseArea, FALSE,
WindowContents, iconCon=CreateDesktopObjectA(CDO_Desktop, icTags),
End,
End;
if(app)
{
DoMethod(win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
// these are here temporarily..
DoMethod(vert, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, iconCon, 3, MUIM_Set, ICA_ScrollToVert, MUIV_TriggerValue);
DoMethod(horiz, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, iconCon, 3, MUIM_Set, ICA_ScrollToHoriz, MUIV_TriggerValue);
SetAttrs(win, MUIA_Window_Open, TRUE, TAG_DONE);
while(running)
{
inputResult=DoMethod(app, MUIM_Application_Input, &signals);
switch(inputResult)
{
case MUIV_Application_ReturnID_Quit:
running=FALSE;
break;
case 2:
running=FALSE;
break;
default:
{
// a menuitem was selected...
struct MinList *subjects=NULL;
Object *member, *ostate;
Tag activeSubjectsTag;
struct TagItem args[2];
if(inputResult & DOC_DESKTOPOP)
{
args[0].ti_Tag=DDO_Target;
args[0].ti_Data=iconCon;
args[1].ti_Tag=TAG_END;
args[1].ti_Data=0;
DoDesktopOperation(inputResult, args);
}
else if(inputResult & DOC_ICONOP)
{
GetAttr(AICA_SelectedIcons, iconCon, &subjects);
ostate=subjects->mlh_Head;
while((member=NextObject(&ostate)))
{
args[0].ti_Tag=DDO_Target;
args[0].ti_Data=member;
args[1].ti_Tag=TAG_END;
args[1].ti_Data=0;
DoDesktopOperation(inputResult, args);
}
}
else if(inputResult & DOC_WINDOWOP)
{
GetAttr(DA_ActiveWindow, iconCon, &subjects);
args[0].ti_Tag=DDO_Target;
args[0].ti_Data=subjects;
args[1].ti_Tag=TAG_END;
args[1].ti_Data=0;
DoDesktopOperation(inputResult, args);
}
}
}
if(running && signals)
Wait(signals);
}
SetAttrs(win, MUIA_Window_Open, FALSE, TAG_DONE);
DisposeObject(app);
}
else
kprintf("could not create app\n");
CloseLibrary(DesktopBase);
CloseLibrary(MUIMasterBase);
return 0;
}
int
main(UNUSED int argc,char **argv)
{
int res;
if ((IntuitionBase = (APTR)OpenLibrary("intuition.library",39)) != NULL &&
GETINTERFACE("main", IIntuition, IntuitionBase))
{
if ((MUIMasterBase = OpenLibrary("muimaster.library",19)) != NULL &&
GETINTERFACE("main", IMUIMaster, MUIMasterBase))
{
Object *app, *win, *sb, *appearance, *labelPos, *borderless, *sunny, *raised, *scaled, *update;
if ((app = ApplicationObject,
MUIA_Application_Title, "TheBar Demo4",
MUIA_Application_Version, "$VER: TheBarDemo4 1.0 (24.6.2003)",
MUIA_Application_Copyright, "Copyright 2003 by Alfonso Ranieri",
MUIA_Application_Author, "Alfonso Ranieri <*****@*****.**>",
MUIA_Application_Description, "TheBar example",
MUIA_Application_Base, "THEBAREXAMPLE",
MUIA_Application_UsedClasses, usedClasses,
SubWindow, win = WindowObject,
MUIA_Window_ID, MAKE_ID('M','A','I','N'),
MUIA_Window_Title, "TheBar Demo4",
WindowContents, VGroup,
Child, sb = TheBarObject,
MUIA_Group_Horiz, TRUE,
MUIA_TheBar_IgnoreAppearance, TRUE,
MUIA_TheBar_EnableKeys, TRUE,
MUIA_TheBar_Buttons, buttons,
MUIA_TheBar_StripBrush, &cbrush,
MUIA_TheBar_StripCols, 16,
MUIA_TheBar_StripRows, 3,
MUIA_TheBar_StripHSpace, 0,
MUIA_TheBar_StripVSpace, 0,
End,
Child, VGroup,
GroupFrameT("Settings"),
Child, HGroup,
Child, Label2("Appearance"),
Child, appearance = MUI_MakeObject(MUIO_Cycle,NULL,appearances),
Child, Label2("Label pos"),
Child, labelPos = MUI_MakeObject(MUIO_Cycle,NULL,labelPoss),
End,
Child, HGroup,
Child, HSpace(0),
Child, Label1("Borderless"),
Child, borderless = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, HSpace(0),
Child, Label1("Sunny"),
Child, sunny = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, HSpace(0),
Child, Label1("Raised"),
Child, raised = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, HSpace(0),
Child, Label1("Scaled"),
Child, scaled = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, HSpace(0),
End,
End,
Child, update = MUI_MakeObject(MUIO_Button,"_Update"),
End,
End,
End) != NULL)
{
ULONG sigs = 0;
LONG id;
DoMethod(win,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,MUIV_Notify_Application,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
DoMethod(update,MUIM_Notify,MUIA_Pressed,FALSE,app,2,MUIM_Application_ReturnID,TAG_USER);
set(win,MUIA_Window_Open,TRUE);
while ((id = DoMethod(app,MUIM_Application_NewInput,&sigs))!=MUIV_Application_ReturnID_Quit)
{
if (id==(LONG)TAG_USER)
{
IPTR appearanceV = 0,
labelPosV = 0,
borderlessV = 0,
sunnyV = 0,
raisedV = 0,
scaledV = 0;
get(appearance,MUIA_Cycle_Active,&appearanceV);
get(labelPos,MUIA_Cycle_Active,&labelPosV);
get(borderless,MUIA_Selected,&borderlessV);
get(sunny,MUIA_Selected,&sunnyV);
get(raised,MUIA_Selected,&raisedV);
get(scaled,MUIA_Selected,&scaledV);
SetAttrs(sb,MUIA_TheBar_ViewMode, appearanceV,
MUIA_TheBar_LabelPos, labelPosV,
MUIA_TheBar_Borderless, borderlessV,
MUIA_TheBar_Sunny, sunnyV,
MUIA_TheBar_Raised, raisedV,
MUIA_TheBar_Scaled, scaledV,
TAG_DONE);
}
if (sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if (sigs & SIGBREAKF_CTRL_C) break;
}
}
MUI_DisposeObject(app);
res = RETURN_OK;
}
else
{
printf("%s: can't create application\n",argv[0]);
res = RETURN_FAIL;
}
CLOSELIB(MUIMasterBase, IMUIMaster);
}
else
{
printf("%s: Can't open muimaster.library ver 19 or higher\n",argv[0]);
res = RETURN_ERROR;
}
CLOSELIB(IntuitionBase, IIntuition);
}
else
{
printf("%s: Can't open intuition.library ver 39 or higher\n",argv[0]);
res = RETURN_ERROR;
}
return res;
}
Object *CreatePrefsGroup(struct InstData_MCP *data)
{
Object *example;
Object **objs = data->Objects;
Object *group;
static const char *key01[2];
static const char *key02[2];
static const char *key03[2];
static const char *key04[2];
static const char *key05[2];
static const char *key06[2];
static const char *key07[2];
static const char *key08[2];
static const char *key09[2];
static const char *key10[2];
static const char *key11[2];
static const char *key12[2];
static const char *key13[2];
static const char *key14[2];
static const char *key15[2];
static const char *key16[2];
static const char *key17[2];
static const char *key18[2];
static const char infotext1[] = "\033bBetterString.mcp " LIB_REV_STRING "\033n (" LIB_DATE ")\n"
"Copyright (C) 1997-2000 Allan Odgaard\n"
LIB_COPYRIGHT;
static const char infotext2[] = "\n"
"Distributed under the terms of the LGPL2.\n"
"\n"
"For the latest version, check out:\n"
"http://www.sf.net/projects/bstring-mcc/\n"
"\n";
static const char **keyinfo[] =
{
key01, key02, key03, key04, key05, key06, key07, key08, key09, key10,
key11, key12, key13, key14, key15, key16, key17, key18,
NULL
};
key01[0] = GetStr(MSG_Help_Copy_Shortcut); key01[1] = GetStr(MSG_Help_Copy);
key02[0] = GetStr(MSG_Help_Cut_Shortcut); key02[1] = GetStr(MSG_Help_Cut);
key03[0] = GetStr(MSG_Help_Paste_Shortcut); key03[1] = GetStr(MSG_Help_Paste);
key04[0] = GetStr(MSG_Help_Undo_Shortcut); key04[1] = GetStr(MSG_Help_Undo);
key05[0] = GetStr(MSG_Help_Redo_Shortcut); key05[1] = GetStr(MSG_Help_Redo);
key06[0] = GetStr(MSG_Help_ToggleBuffer_Shortcut); key06[1] = GetStr(MSG_Help_ToggleBuffer);
key07[0] = GetStr(MSG_Help_ToggleCaseChar_Shortcut); key07[1] = GetStr(MSG_Help_ToggleCaseChar);
key08[0] = GetStr(MSG_Help_ToggleCaseWord_Shortcut); key08[1] = GetStr(MSG_Help_ToggleCaseWord);
key09[0] = GetStr(MSG_Help_IncreaseNumber_Shortcut); key09[1] = GetStr(MSG_Help_IncreaseNumber);
key10[0] = GetStr(MSG_Help_DecreaseNumber_Shortcut); key10[1] = GetStr(MSG_Help_DecreaseNumber);
key11[0] = GetStr(MSG_Help_HexToDecimal_Shortcut); key11[1] = GetStr(MSG_Help_HexToDecimal);
key12[0] = GetStr(MSG_Help_DecimalToHex_Shortcut); key12[1] = GetStr(MSG_Help_DecimalToHex);
key13[0] = GetStr(MSG_Help_FilenameCompletition_Shortcut); key13[1] = GetStr(MSG_Help_FilenameCompletition);
key14[0] = GetStr(MSG_Help_Mark_Shortcut); key14[1] = GetStr(MSG_Help_Mark);
key15[0] = GetStr(MSG_Help_GotoToStartEndOfLine_Shortcut); key15[1] = GetStr(MSG_Help_GotoToStartEndOfLine);
key16[0] = GetStr(MSG_Help_DeleteToStartEndOfLine_Shortcut); key16[1] = GetStr(MSG_Help_DeleteToStartEndOfLine);
key17[0] = GetStr(MSG_Help_GotoToPrevNextWord_Shortcut); key17[1] = GetStr(MSG_Help_GotoToPrevNextWord);
key18[0] = GetStr(MSG_Help_DeleteToPrevNextWord_Shortcut); key18[1] = GetStr(MSG_Help_DeleteToPrevNextWord);
group = VGroup,
Child, PopobjectObject,
MUIA_Popstring_String, example = BetterStringObject, StringFrame,
MUIA_String_Contents, GetStr(MSG_String_TestString),
MUIA_String_Format, MUIV_String_Format_Center,
MUIA_CycleChain, TRUE,
End,
MUIA_Popstring_Button, PopButton(MUII_PopUp),
MUIA_Popobject_Object, ListviewObject,
MUIA_Listview_Input, FALSE,
MUIA_Listview_List, ListObject, ReadListFrame,
MUIA_List_DisplayHook, &DisplayHook,
MUIA_List_Format, ",,",
MUIA_List_SourceArray, keyinfo,
End,
End,
End,
Child, VSpace(4),
Child, ColGroup(2),
Child, HSpace(-1),
Child, HGroup,
MUIA_Group_SameWidth, TRUE,
Child, TextObject,
MUIA_Font, MUIV_Font_Tiny,
MUIA_Text_Contents, GetStr(MSG_Label_Background),
MUIA_Text_PreParse, "\33c",
End,
Child, TextObject,
MUIA_Font, MUIV_Font_Tiny,
MUIA_Text_Contents, GetStr(MSG_Label_Text),
MUIA_Text_PreParse, "\33c",
End,
End,
Child, TxtLabel(GetStr(MSG_Label_Inactive)),
Child, HGroup,
Child, objs[InactiveBack] = PopimageObject,
MUIA_Imageadjust_Type, 2,
MUIA_CycleChain, TRUE,
MUIA_FixHeight, 0,
End,
Child, objs[InactiveText] = PoppenObject,
MUIA_CycleChain, TRUE,
MUIA_FixHeight, 0,
End,
End,
Child, TxtLabel(GetStr(MSG_Label_Active)),
Child, HGroup,
Child, objs[ActiveBack] = PopimageObject,
MUIA_Imageadjust_Type, 2,
MUIA_CycleChain, TRUE,
MUIA_FixHeight, 0,
End,
Child, objs[ActiveText] = PoppenObject,
MUIA_CycleChain, TRUE,
MUIA_FixHeight, 0,
End,
End,
Child, HSpace(-1),
Child, RectangleObject,
MUIA_Rectangle_HBar, TRUE,
MUIA_VertWeight, 0,
End,
Child, TxtLabel(GetStr(MSG_Label_Cursor)),
Child, objs[Cursor] = PoppenObject,
MUIA_CycleChain, TRUE,
MUIA_FixHeight, 0,
End,
Child, TxtLabel(GetStr(MSG_Label_Marked)),
Child, HGroup,
Child, objs[MarkedBack] = PoppenObject,
MUIA_CycleChain, TRUE,
MUIA_FixHeight, 0,
End,
Child, objs[MarkedText] = PoppenObject,
MUIA_CycleChain, TRUE,
MUIA_FixHeight, 0,
End,
End,
Child, HSpace(-1),
Child, RectangleObject,
MUIA_Rectangle_HBar, TRUE,
MUIA_VertWeight, 0,
End,
Child, HSpace(-1),
Child, HGroup,
MUIA_Weight, 0,
Child, objs[SelectOnActive] = MUI_MakeObject(MUIO_Checkmark, NULL),
Child, TxtLLabel(GetStr(MSG_SelectOnActive)),
Child, HSpace(-1),
End,
Child, HSpace(-1),
Child, HGroup,
MUIA_Weight, 0,
Child, objs[SelectPointer] = MUI_MakeObject(MUIO_Checkmark, NULL),
Child, TxtLLabel(GetStr(MSG_SelectPointer)),
Child, HSpace(-1),
End,
End,
Child, CrawlingObject,
TextFrame,
MUIA_FixHeightTxt, infotext1,
MUIA_Background, "m1",
Child, TextObject,
MUIA_Text_Copy, FALSE,
MUIA_Text_PreParse, "\033c",
MUIA_Text_Contents, infotext1,
End,
Child, TextObject,
MUIA_Text_Copy, FALSE,
MUIA_Text_PreParse, "\033c",
MUIA_Text_Contents, infotext2,
End,
Child, TextObject,
MUIA_Text_Copy, FALSE,
MUIA_Text_PreParse, "\033c",
MUIA_Text_Contents, infotext1,
End,
End,
End;
// the inactive background will be the same as for String.mui on MUI4
if(objs[InactiveBack] != NULL)
set(objs[InactiveBack], MUIA_Disabled, data->mui4x);
// the active background will be the same as for String.mui on MUI4
if(objs[ActiveBack] != NULL)
set(objs[ActiveBack], MUIA_Disabled, data->mui4x);
if(objs[SelectOnActive] != NULL)
set(objs[SelectOnActive], MUIA_ShortHelp, GetStr(MSG_HELP_SelectOnActive));
// disable the pointer checkmark in case MUI already handles custom pointer types
if(objs[SelectPointer] != NULL)
{
SetAttrs(objs[SelectPointer],
MUIA_ShortHelp, GetStr(MSG_HELP_SelectPointer),
MUIA_Disabled, xget(example, MUIA_PointerType) != MUIV_PointerType_Normal,
TAG_DONE);
}
return group;
}
Object *ScreenModeProperties__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
{
struct ScreenModeProperties_DATA *data;
Object *width, *height, *depth,
*def_width, *def_height;
Object *autoscroll;
ULONG id;
self = (Object *)DoSuperNewTags
(
CLASS, self, NULL,
MUIA_Group_Horiz, TRUE,
Child, (IPTR)ColGroup(4),
Child, (IPTR)Label1(__(MSG_WIDTH)),
Child, HLeft(width = (Object *)NumericbuttonObject, End),
Child, (IPTR)(def_width = (Object *)CheckMarkObject, End),
Child, (IPTR)Label1(__(MSG_DEFAULT)),
Child, (IPTR)Label1(__(MSG_HEIGHT)),
Child, HLeft(height = (Object *)NumericbuttonObject, End),
Child, (IPTR)(def_height = (Object *)CheckMarkObject, End),
Child, (IPTR)Label1(__(MSG_DEFAULT)),
Child, (IPTR)Label1(__(MSG_DEPTH)),
Child, HLeft(depth = (Object *)NumericbuttonObject, End),
Child, (IPTR)RectangleObject, End,
Child, (IPTR)RectangleObject, End,
End,
Child, (IPTR)MUI_MakeObject(MUIO_VBar, 20),
Child, (IPTR)HCenter(HGroup,
Child, (IPTR)Label1(__(MSG_AUTOSCROLL)),
Child, (IPTR)(autoscroll = (Object *)CheckMarkObject, End),
End),
TAG_MORE, (IPTR)message->ops_AttrList
);
if (!self)
goto err;
data = INST_DATA(CLASS, self);
data->width = width;
data->height = height;
data->depth = depth;
data->def_width = def_width;
data->def_height = def_height;
data->autoscroll = autoscroll;
DoMethod
(
width, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
(IPTR)self, 3,
MUIM_Set, MUIA_ScreenModeProperties_Width, MUIV_TriggerValue
);
DoMethod
(
height, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
(IPTR)self, 3,
MUIM_Set, MUIA_ScreenModeProperties_Height, MUIV_TriggerValue
);
DoMethod
(
depth, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
(IPTR)self, 3,
MUIM_Set, MUIA_ScreenModeProperties_Depth, MUIV_TriggerValue
);
DoMethod
(
def_width, MUIM_Notify, MUIA_Selected, TRUE,
(IPTR)width, 1,
MUIM_Numeric_SetDefault
);
DoMethod
(
width, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
(IPTR)def_width, 3,
MUIM_Set, MUIA_Selected, FALSE
);
DoMethod
(
def_height, MUIM_Notify, MUIA_Selected, TRUE,
(IPTR)height, 1,
MUIM_Numeric_SetDefault
);
DoMethod
(
height, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
(IPTR)def_height, 3,
MUIM_Set, MUIA_Selected, FALSE
);
id = GetTagData(MUIA_ScreenModeProperties_DisplayID, INVALID_ID, message->ops_AttrList);
set(self, MUIA_ScreenModeProperties_DisplayID, id);
return self;
err:
CoerceMethod(CLASS, self, OM_DISPOSE);
return NULL;
}
int main (int argc, char **argv)
{
Object *app;
Object *mainWin;
Object *radio1;
Object *radio2;
MUI_Init(&argc, &argv);
app = ApplicationObject,
SubWindow, mainWin = WindowObject,
MUIA_Window_Title, "Input modes",
WindowContents, VGroup,
Child, MUI_MakeObject(MUIO_BarTitle, _U("MUIV_InputMode_RelVerify")),
Child, SimpleChainedButton("Hello world, \33u\33iyo\n"
/* "\33l\33iHello \33bworld\33n, yo\n" */
/* "\33iHello world, yo\n" */
"_Hello \33uwo\0331r\33bl\33n\33ud\33n, \33iyo\n"
/* "\33cI \33ilove MUI\n" */
"HelloH \33b\33ihello\33nH"),
Child, MUI_MakeObject(MUIO_BarTitle, _U("MUIV_InputMode_Toggle")),
/* Child, VSpace(0), */
Child, HGroup,
MUIA_Frame, MUIV_Frame_Group,
MUIA_FrameTitle, "The quick brown fox jumps over the lazy dog",
MUIA_Background, MUII_GroupBack,
Child, ChainedCheckmark("My first checkmark"),
End,
Child, MUI_MakeObject(MUIO_BarTitle, _U("MUIV_InputMode_Immediate")),
Child, HGroup,
MUIA_Frame, MUIV_Frame_Group,
/* MUIA_FrameTitle, "Radio", */
MUIA_FixHeight, 30,
Child, radio1 = RectangleObject,
MUIA_CycleChain, TRUE,
MUIA_ControlChar, 'i',
MUIA_InputMode, MUIV_InputMode_Immediate,
MUIA_Background, MUII_ButtonBack,
MUIA_Frame, MUIV_Frame_Button,
End,
Child, radio2 = RectangleObject,
MUIA_CycleChain, TRUE,
MUIA_ControlChar, 'o',
MUIA_InputMode, MUIV_InputMode_Immediate,
MUIA_Background, MUII_ButtonBack,
MUIA_Frame, MUIV_Frame_Button,
End,
End,
End,
End,
End;
if (!app)
g_error("can't create application object.\n");
DoMethod(mainWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
_U(app), 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
set(radio1, MUIA_Selected, TRUE);
DoMethod(radio1, MUIM_Notify, MUIA_Selected, TRUE,
_U(radio2), 3, MUIM_Set, MUIA_Selected, FALSE);
DoMethod(radio2, MUIM_Notify, MUIA_Selected, TRUE,
_U(radio1), 3, MUIM_Set, MUIA_Selected, FALSE);
/*
* Open window and ALWAYS check.
*/
set(mainWin, MUIA_Window_Open, TRUE);
if (!xget(mainWin, MUIA_Window_Open))
{
MUI_DisposeObject(app);
g_printerr("%s : can't open main window.\n", argv[0]);
return 5;
}
{
ULONG sigs = 0;
while (DoMethod(app, MUIM_Application_NewInput, _U(&sigs))
!= MUIV_Application_ReturnID_Quit)
{
}
}
set(mainWin, MUIA_Window_Open, FALSE);
MUI_DisposeObject(app);
return 0;
}
/*
** Here we go
*/
static IPTR mNew(struct IClass *cl, Object *obj, struct opSet *msg)
{
Object *strip, *win;
if((obj = (Object *)DoSuperNew(cl,obj,
MUIA_Application_Title, "OpenURL-Prefs",
MUIA_Application_Version, "$VER: OpenURL-Prefs " LIB_REV_STRING " [" SYSTEMSHORT "/" CPU "] (" LIB_DATE ") " LIB_COPYRIGHT,
MUIA_Application_Author, APPAUTHOR,
MUIA_Application_Copyright, getString(MSG_App_Copyright),
MUIA_Application_Description, getString(MSG_App_Description),
MUIA_Application_HelpFile, APPHELP,
MUIA_Application_Base, APPBASENAME,
MUIA_Application_Menustrip, strip = MUI_MakeObject(MUIO_MenustripNM,(IPTR)menu,MUIO_MenustripNM_CommandKeyCheck),
MUIA_Application_UsedClasses, usedClasses,
MUIA_Application_Window, win = winObject, End,
TAG_MORE,msg->ops_AttrList)) != NULL)
{
struct data *data = INST_DATA(cl,obj);
/*
** Setup data
*/
data->win = win;
if((data->icon = GetDiskObject((STRPTR)"PROGDIR:OpenURL")) != NULL)
superset(cl,obj,MUIA_Application_DiskObject,data->icon);
/* Menus */
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_About),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,1,MUIM_App_About);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_AboutMUI),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)MUIV_Notify_Application,2,MUIM_Application_AboutMUI,(IPTR)win);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Hide),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,3,MUIM_Set,MUIA_Application_Iconified,TRUE);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Quit),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Save),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)win,2,MUIM_Win_StorePrefs,MUIV_Win_StorePrefs_Save);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Use),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)win,2,MUIM_Win_StorePrefs,MUIV_Win_StorePrefs_Use);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_LastSaved),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_App_GetPrefs,MUIV_App_GetPrefs_LastSaveds);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Restore),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_App_GetPrefs,MUIV_App_GetPrefs_Restore);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Defaults),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_App_GetPrefs,MUIV_App_GetPrefs_Defaults);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_MUI),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_Application_OpenConfigWindow,0);
/* Menus help */
DoSuperMethod(cl,obj,MUIM_Notify,MUIA_Application_MenuHelp,MUIV_EveryTime,MUIV_Notify_Self,
5,MUIM_Application_ShowHelp,(IPTR)win,(IPTR)APPHELP,(IPTR)"MENUS",0);
/*
** Load list formats
*/
DoSuperMethod(cl,obj,MUIM_Application_Load,(IPTR)MUIV_Application_Load_ENV);
/*
** Try to get OpenURL prefs and open window
*/
if (!DoMethod(win,MUIM_Win_GetPrefs,MUIV_Win_GetPrefs_Restore) || !openWindow(obj,win))
{
CoerceMethod(cl,obj,OM_DISPOSE);
return 0;
}
}
return (IPTR)obj;
}
int
main(UNUSED int argc,char **argv)
{
int res;
if ((IntuitionBase = (APTR)OpenLibrary("intuition.library",39)) != NULL &&
GETINTERFACE("main", IIntuition, IntuitionBase))
{
if ((MUIMasterBase = OpenLibrary("muimaster.library",19)) != NULL &&
GETINTERFACE("main", IMUIMaster, MUIMasterBase))
{
Object *app, *win, *mg, *sb, *viewMode, *buttonsPos, *labelPos, *borderless, *sunny,
*raised, *scaled, *keys, *bspacer, *fixed, *free, *update, *rows, *cols, *s4, *h0,
*rb, *rs, *ri;
if ((app = ApplicationObject,
MUIA_Application_Title, "TheBar Demo3",
MUIA_Application_Version, "$VER: TheBarDemo3 1.0 (24.6.2003)",
MUIA_Application_Copyright, "Copyright 2003 by Alfonso Ranieri",
MUIA_Application_Author, "Alfonso Ranieri <*****@*****.**>",
MUIA_Application_Description, "TheBar example",
MUIA_Application_Base, "THEBAREXAMPLE",
MUIA_Application_UsedClasses, usedClasses,
SubWindow, win = WindowObject,
MUIA_Window_ID, MAKE_ID('M','A','I','N'),
MUIA_Window_Title, "TheBar Demo3",
WindowContents, mg = VGroup,
Child, sb = TheBarObject,
MUIA_Group_Horiz, TRUE,
MUIA_TheBar_IgnoreAppearance, TRUE,
MUIA_TheBar_ViewMode, MUIV_TheBar_ViewMode_Gfx,
MUIA_TheBar_Buttons, buttons,
MUIA_TheBar_PicsDrawer, "PROGDIR:Pics",
MUIA_TheBar_Pics, pics,
MUIA_TheBar_SelPics, spics,
MUIA_TheBar_DisPics, dpics,
End,
Child, VGroup,
GroupFrameT("Appearance"),
Child, ColGroup(2),
Child, Label2("Rows"),
Child, HGroup,
Child, rows = MUI_MakeObject(MUIO_Radio,NULL,rowss),
Child, HSpace(0),
End,
Child, Label2("Columns"),
Child, HGroup,
Child, cols = MUI_MakeObject(MUIO_Radio,NULL,colss),
Child, HSpace(0),
End,
Child, Label2("ViewMode"),
Child, viewMode = MUI_MakeObject(MUIO_Cycle,NULL,viewModes),
Child, Label2("Buttons position"),
Child, buttonsPos = MUI_MakeObject(MUIO_Cycle,NULL,buttonsPoss),
Child, Label2("Label position"),
Child, labelPos = MUI_MakeObject(MUIO_Cycle,NULL,labelPoss),
End,
Child, ScrollgroupObject,
MUIA_Scrollgroup_FreeHoriz, FALSE,
MUIA_Scrollgroup_Contents, VirtgroupObject,
MUIA_Frame, MUIV_Frame_Virtual,
Child, HGroup,
Child, ColGroup(2),
Child, borderless = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel1("Borderless"),
Child, sunny = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel1("Sunny"),
Child, raised = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel1("Raised"),
Child, scaled = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel1("Scaled"),
Child, keys = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel1("Enable keys"),
Child, bspacer = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel1("Bar spacer"),
Child, fixed = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel("Fixed"),
Child, free = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel("Disable 0"),
Child, h0 = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel("Hide 0"),
Child, s4 = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel("Sleep 4"),
Child, RectangleObject, MUIA_FixHeightTxt,"a",End,
Child, RectangleObject, MUIA_FixHeightTxt,"a",End,
Child, rb = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel("Remove Bars"),
Child, rs = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel("Remove Spaces"),
Child, ri = MUI_MakeObject(MUIO_Checkmark,NULL),
Child, LLabel("Remove Images"),
End,
Child, HSpace(0),
End,
Child, VSpace(0),
End,
End,
Child, update = MUI_MakeObject(MUIO_Button,"_Update"),
End,
End,
End,
End) != NULL)
{
ULONG sigs = 0;
LONG id;
set(rows,MUIA_Group_Horiz,TRUE);
set(cols,MUIA_Group_Horiz,TRUE);
set(viewMode,MUIA_Cycle_Active,1);
set(s4,MUIA_Selected,TRUE);
DoMethod(sb,MUIM_TheBar_SetAttr,4,MUIA_TheBar_Attr_Sleep,TRUE);
DoMethod(win,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,MUIV_Notify_Application,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
DoMethod(update,MUIM_Notify,MUIA_Pressed,FALSE,app,2,MUIM_Application_ReturnID,TAG_USER);
set(win,MUIA_Window_Open,TRUE);
while ((id = DoMethod(app,MUIM_Application_NewInput,&sigs))!=MUIV_Application_ReturnID_Quit)
{
if (id==(LONG)TAG_USER)
{
IPTR c = 0,
r = 0,
vm = 0,
bp = 0,
lp = 0,
br = 0,
su = 0,
ra = 0,
sc = 0,
k = 0,
bs = 0,
fi = 0,
fr = 0,
hl0 = 0,
sl4 = 0,
rbl = 0,
rsl = 0,
ril = 0,
rem = 0;
get(rows,MUIA_Radio_Active,&r);
if (r==4) r = 6;
get(cols,MUIA_Radio_Active,&c);
get(viewMode,MUIA_Cycle_Active,&vm);
get(buttonsPos,MUIA_Cycle_Active,&bp);
get(labelPos,MUIA_Cycle_Active,&lp);
get(borderless,MUIA_Selected,&br);
get(sunny,MUIA_Selected,&su);
get(raised,MUIA_Selected,&ra);
get(scaled,MUIA_Selected,&sc);
get(keys,MUIA_Selected,&k);
get(bspacer,MUIA_Selected,&bs);
get(fixed,MUIA_Selected,&fi);
get(free,MUIA_Selected,&fr);
get(h0,MUIA_Selected,&hl0);
get(s4,MUIA_Selected,&sl4);
get(rb,MUIA_Selected,&rbl);
get(rs,MUIA_Selected,&rsl);
get(ri,MUIA_Selected,&ril);
rem = 0;
if (rbl) rem |= MUIV_TheBar_RemoveSpacers_Bar;
if (rsl) rem |= MUIV_TheBar_RemoveSpacers_Button;
if (ril) rem |= MUIV_TheBar_RemoveSpacers_Image;
DoMethod(mg,MUIM_Group_InitChange);
DoMethod(sb,MUIM_Group_InitChange);
SetAttrs(sb,MUIA_TheBar_Columns, c,
MUIA_TheBar_Rows, r,
MUIA_TheBar_ViewMode, vm,
MUIA_TheBar_Borderless, br,
MUIA_TheBar_Sunny, su,
MUIA_TheBar_Raised, ra,
MUIA_TheBar_Scaled, sc,
MUIA_TheBar_EnableKeys, k,
MUIA_TheBar_BarSpacer, bs,
MUIA_TheBar_RemoveSpacers,rem,
MUIA_TheBar_LabelPos, lp,
TAG_DONE);
DoMethod(sb,MUIM_TheBar_SetAttr,0,MUIA_TheBar_Attr_Hide,hl0);
DoMethod(sb,MUIM_TheBar_SetAttr,4,MUIA_TheBar_Attr_Sleep,sl4);
DoMethod(sb,MUIM_TheBar_SetAttr,6,MUIA_TheBar_Attr_Disabled,fr);
DoMethod(sb,MUIM_Group_ExitChange);
DoMethod(mg,MUIM_Group_ExitChange);
}
if (sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if (sigs & SIGBREAKF_CTRL_C) break;
}
}
MUI_DisposeObject(app);
res = RETURN_OK;
}
else
{
printf("%s: can't create application\n",argv[0]);
res = RETURN_FAIL;
}
CLOSELIB(MUIMasterBase, IMUIMaster);
}
else
{
printf("%s: Can't open muimaster.library ver 19 or higher\n",argv[0]);
res = RETURN_ERROR;
}
CLOSELIB(IntuitionBase, IIntuition);
}
else
{
printf("%s: Can't open intuition.library ver 39 or higher\n",argv[0]);
res = RETURN_ERROR;
}
return res;
}
/*** Methods ****************************************************************/
Object * NetPEditor__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
{
Object *deviceString, *IPString, *maskString, *gateString,
*DNSString[2], *hostString, *domainString, *DHCPState, *autostart;
DHCPCycle[0] = _(MSG_IP_MODE_MANUAL);
DHCPCycle[1] = _(MSG_IP_MODE_DHCP);
NetworkTabs[0] = _(MSG_TAB_IP_CONFIGURATION);
NetworkTabs[1] = _(MSG_TAB_COMPUTER_NAME);
self = (Object *)DoSuperNewTags
(
CLASS, self, NULL,
MUIA_PrefsEditor_Name, __(MSG_NAME),
MUIA_PrefsEditor_Path, (IPTR)"AROSTCP/arostcp.prefs",
Child, RegisterGroup((IPTR)NetworkTabs),
Child, (IPTR)ColGroup(2),
Child, (IPTR)Label2(__(MSG_DEVICE)),Child, (IPTR)PopaslObject,
MUIA_Popasl_Type, ASL_FileRequest,
ASLFO_MaxHeight, 100,
MUIA_Popstring_String, (IPTR)(deviceString = (Object *)StringObject, TextFrame, MUIA_Background, MUII_TextBack, End),
MUIA_Popstring_Button, (IPTR)PopButton(MUII_PopUp),
End,
Child, (IPTR)Label2(__(MSG_IP_MODE)), Child, (IPTR)(DHCPState = (Object *)CycleObject, MUIA_Cycle_Entries, (IPTR)DHCPCycle, End),
Child, (IPTR)Label2(__(MSG_IP)), Child, (IPTR)(IPString = (Object *)StringObject, TextFrame, MUIA_String_Accept, (IPTR)"0123456789.", End),
Child, (IPTR)Label2(__(MSG_MASK)),Child, (IPTR)(maskString = (Object *)StringObject, TextFrame, MUIA_String_Accept, (IPTR)"0123456789.", End),
Child, (IPTR)Label2(__(MSG_GATE)),Child, (IPTR)(gateString = (Object *)StringObject, TextFrame, MUIA_String_Accept, (IPTR)"0123456789.", End),
Child, (IPTR)Label2(__(MSG_DNS1)),Child, (IPTR)(DNSString[0] = (Object *)StringObject, TextFrame, MUIA_String_Accept, (IPTR)"0123456789.", End),
Child, (IPTR)Label2(__(MSG_DNS2)),Child, (IPTR)(DNSString[1] = (Object *)StringObject, TextFrame, MUIA_String_Accept, (IPTR)"0123456789.", End),
Child, (IPTR)Label2(__(MSG_AUTOSTART_STACK)),
Child, (IPTR)HGroup,
Child, (IPTR)(autostart = MUI_MakeObject(MUIO_Checkmark, NULL)),
Child, (IPTR)HVSpace,
End,
End,
Child, (IPTR)ColGroup(2),
Child, (IPTR)Label2(__(MSG_HOST_NAME)), Child, (IPTR)(hostString = (Object *)StringObject, TextFrame, MUIA_String_Accept, (IPTR)"0123456789abcdefghijklmnopqrstuvwxyz-", End),
Child, (IPTR)Label2(__(MSG_DOMAIN_NAME)), Child, (IPTR)(domainString = (Object *)StringObject, TextFrame, MUIA_String_Accept, (IPTR)"0123456789abcdefghijklmnopqrstuvwxyz-.", End),
End,
End, // register
TAG_DONE
);
if (self != NULL) {
struct NetPEditor_DATA *data = INST_DATA(CLASS, self);
data->netped_deviceString = deviceString;
data->netped_IPString = IPString;
data->netped_maskString = maskString;
data->netped_gateString = gateString;
data->netped_DNSString[0] = DNSString[0];
data->netped_DNSString[1] = DNSString[1];
data->netped_hostString = hostString;
data->netped_domainString = domainString;
data->netped_DHCPState = DHCPState;
data->netped_Autostart = autostart;
/*-- Setup notifications -------------------------------------------*/
DoMethod
(
deviceString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
IPString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
maskString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
gateString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
DNSString[0], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
DNSString[1], MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
hostString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
domainString, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
autostart, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
(IPTR)self, 3, MUIM_Set, MUIA_PrefsEditor_Changed, TRUE
);
DoMethod
(
DHCPState, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
(IPTR)self, 1, MUIM_NetPEditor_IPModeChanged
);
}
return self;
}
BOOPSI_DISPATCHER_END
int main(void) {
SetTaskPri(FindTask(NULL), 15);
struct MUI_CustomClass *mcc;
if((ps = OpenLibrary("poseidon.library", 4))) {
if((mcc = MUI_CreateCustomClass(NULL, "Area.mui", NULL, sizeof(struct InstData), classdispatcher))) {
mybug(-1,("mui custon class at %p\n", mcc));
Object *app, *window, *tick1, *custom;
app = ApplicationObject,
SubWindow, window = WindowObject,
MUIA_Window_Title, "PS3Eye",
MUIA_Window_Activate, TRUE,
WindowContents, HGroup,
Child, HGroup,
MUIA_Weight, 100,
Child, custom = NewObject(mcc->mcc_Class, NULL, TAG_DONE),
End,
Child, VGroup,
MUIA_Weight, 1,
MUIA_Group_SameWidth, TRUE,
GroupFrameT("Configuration"),
Child, HGroup,
Child, tick1 = MUI_MakeObject(MUIO_Checkmark, NULL),
Child, MUI_MakeObject(MUIO_Label,"640x480", 0),
End,
Child, (IPTR) VSpace(0),
End,
End,
End,
End;
if(app) {
ULONG sigs = 0;
DoMethod(tick1, MUIM_Notify, MUIA_Selected, TRUE, (IPTR)custom, 3, MUIM_Set, MUIA_Resolution, TRUE);
DoMethod(tick1, MUIM_Notify, MUIA_Selected, FALSE, (IPTR)custom, 3, MUIM_Set, MUIA_Resolution, FALSE);
DoMethod(window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
set(window, MUIA_Window_Open, TRUE);
while((LONG)DoMethod(app, MUIM_Application_NewInput, &sigs) != (LONG)MUIV_Application_ReturnID_Quit) {
if(sigs) {
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if(sigs & SIGBREAKF_CTRL_C)
break;
}
}
MUI_DisposeObject(app);
}
MUI_DeleteCustomClass(mcc);
}
CloseLibrary(ps);
}
mybug(-1,("Exiting\n"));
return 0;
}
IPTR Popimage__MUIM_Popimage_OpenWindow(struct IClass *cl, Object *obj, Msg msg)
{
struct Popimage_DATA *data = INST_DATA(cl, obj);
if (!data->wnd)
{
Object *ok_button, *cancel_button;
char *img_spec;
ULONG x = 0, y = 0;
get(_win(obj), MUIA_Window_LeftEdge, &x);
get(_win(obj), MUIA_Window_TopEdge, &y);
get(obj,MUIA_Imagedisplay_Spec, &img_spec);
data->wnd = (Object *)WindowObject,
MUIA_Window_Title, (IPTR) data->wintitle,
MUIA_Window_Activate, TRUE,
MUIA_Window_IsSubWindow, TRUE,
MUIA_Window_LeftEdge, _left(obj) + x,
MUIA_Window_TopEdge, _bottom(obj) + y + 1,
WindowContents, (IPTR) VGroup,
Child, (IPTR) (data->imageadjust = MUI_NewObject
(
MUIC_Imageadjust,
MUIA_CycleChain, 1,
MUIA_Imageadjust_Spec, (IPTR) img_spec,
MUIA_Imageadjust_Type, data->adjust_type,
MUIA_Imageadjust_Originator, (IPTR) obj,
TAG_DONE
)),
Child, (IPTR) HGroup,
MUIA_Group_SameWidth, TRUE,
Child, (IPTR) (ok_button = MUI_MakeObject
(
MUIO_Button, (IPTR) "_Ok"
)),
Child, (IPTR) HVSpace,
Child, (IPTR) HVSpace,
Child, (IPTR) (cancel_button = MUI_MakeObject
(
MUIO_Button, (IPTR) "_Cancel"
)),
End,
End,
End;
if (data->wnd)
{
set(ok_button, MUIA_CycleChain, 1);
set(cancel_button, MUIA_CycleChain, 1);
DoMethod(_app(obj),OM_ADDMEMBER,(IPTR)data->wnd);
DoMethod
(
ok_button, MUIM_Notify, MUIA_Pressed, FALSE,
(IPTR) _app(obj), 5, MUIM_Application_PushMethod,
(IPTR) obj, 2, MUIM_Popimage_CloseWindow, TRUE
);
DoMethod
(
cancel_button, MUIM_Notify, MUIA_Pressed, FALSE,
(IPTR) _app(obj), 5, MUIM_Application_PushMethod,
(IPTR) obj, 2, MUIM_Popimage_CloseWindow, FALSE
);
DoMethod
(
data->wnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
(IPTR) _app(obj), 5, MUIM_Application_PushMethod,
(IPTR) obj, 2, MUIM_Popimage_CloseWindow, FALSE
);
}
}
if (data->wnd)
{
ULONG opened;
set(data->wnd, MUIA_Window_Open,TRUE);
get(data->wnd, MUIA_Window_Open, &opened);
if (!opened)
{
DoMethod(obj, MUIM_Popimage_CloseWindow, FALSE);
}
}
return 1;
}
int main (int argc, char **argv)
{
Object *app;
Object *mainWin;
Object *pages;
Object *stepb[2];
Object *b[3];
int i;
g_print("use '--gdk-debug all --sync' to debug events\n");
MUI_Init(&argc, &argv);
app = ApplicationObject,
SubWindow, mainWin = WindowObject,
MUIA_Window_Title, "Pages",
WindowContents, VGroup,
Child, VGroup,
GroupFrame,
Child, HGroup,
Child, stepb[0] = RectangleObject,
MUIA_CycleChain, TRUE,
MUIA_InnerLeft, 20,
MUIA_FixHeight, 20,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
Child, stepb[1] = RectangleObject,
MUIA_CycleChain, TRUE,
MUIA_InnerLeft, 20,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
End,
Child, MUI_MakeObject(MUIO_HBar, 4),
Child, HGroup,
Child, b[0] = RectangleObject,
MUIA_CycleChain, TRUE,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_FixHeight, 20,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
Child, b[1] = RectangleObject,
MUIA_CycleChain, TRUE,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_FixHeight, 20,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
Child, b[2] = RectangleObject,
MUIA_CycleChain, TRUE,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_FixHeight, 20,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
End,
End,
Child, pages = HGroup,
MUIA_Group_PageMode, TRUE,
InputListFrame,
MUIA_Background, MUII_PageBack,
Child, RectangleObject,
MUIA_FixWidth, 50,
MUIA_Background, MUII_SHADOW,
End,
Child, RectangleObject,
MUIA_FixWidth, 30,
MUIA_FixHeight, 30,
MUIA_Background, MUII_SHINE,
End,
Child, RectangleObject,
MUIA_FixHeight, 50,
MUIA_Background, MUII_FILL,
End,
End,
End,
End,
End;
if (!app)
g_error("can't create application object.\n");
DoMethod(mainWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
app, 2,
MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(stepb[0], MUIM_Notify, MUIA_Timer, MUIV_EveryTime,
pages, 3, MUIM_Set,
MUIA_Group_ActivePage, MUIV_Group_ActivePage_Prev);
DoMethod(stepb[1], MUIM_Notify, MUIA_Timer, MUIV_EveryTime,
pages, 3, MUIM_Set,
MUIA_Group_ActivePage, MUIV_Group_ActivePage_Next);
for (i = 0; i < 3; i++)
{
DoMethod(b[i], MUIM_Notify, MUIA_Pressed, FALSE,
pages, 3, MUIM_Set, MUIA_Group_ActivePage, i);
}
/*
* Open window and ALWAYS check.
*/
set(mainWin, MUIA_Window_Open, TRUE);
if (!xget(mainWin, MUIA_Window_Open))
{
MUI_DisposeObject(app);
g_error("can't open main window.\n");
}
{
ULONG sigs = 0;
while (DoMethod(app, MUIM_Application_NewInput, &sigs)
!= MUIV_Application_ReturnID_Quit)
{
}
}
set(mainWin, MUIA_Window_Open, FALSE);
MUI_DisposeObject(app);
return 0;
}
int main (int argc, char **argv)
{
Object *app;
Object *mainWin;
Object *pages;
Object *stepb[2];
Object *b[3];
int i;
if (!openmuimaster()) return 20;
app = ApplicationObject,
SubWindow, mainWin = WindowObject,
MUIA_Window_Title, "Pages",
WindowContents, VGroup,
Child, VGroup,
GroupFrame,
Child, HGroup,
Child, stepb[0] = RectangleObject,
MUIA_Rectangle_BarTitle, "prev",
MUIA_CycleChain, TRUE,
MUIA_InnerLeft, 20,
MUIA_FixHeight, 20,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
Child, stepb[1] = RectangleObject,
MUIA_Rectangle_BarTitle, "next",
MUIA_CycleChain, TRUE,
MUIA_InnerLeft, 20,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
End,
Child, MUI_MakeObject(MUIO_HBar, 4),
Child, HGroup,
Child, b[0] = RectangleObject,
MUIA_Rectangle_BarTitle, "1",
MUIA_CycleChain, TRUE,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_FixHeight, 20,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
Child, b[1] = RectangleObject,
MUIA_Rectangle_BarTitle, "2",
MUIA_CycleChain, TRUE,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_FixHeight, 20,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
Child, b[2] = RectangleObject,
MUIA_Rectangle_BarTitle, "3",
MUIA_CycleChain, TRUE,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_FixHeight, 20,
MUIA_Background, MUII_ButtonBack,
ButtonFrame,
End,
End,
End,
Child, pages = HGroup,
MUIA_Group_PageMode, TRUE,
InputListFrame,
MUIA_Background, MUII_PageBack,
Child, RectangleObject,
MUIA_FixWidth, 50,
MUIA_Background, MUII_SHADOW,
MUIA_Rectangle_BarTitle, "Rect1",
End,
Child, RectangleObject,
MUIA_FixWidth, 30,
MUIA_FixHeight, 30,
MUIA_Background, MUII_SHINE,
MUIA_Rectangle_BarTitle, "Rect2",
End,
Child, RectangleObject,
MUIA_FixHeight, 50,
MUIA_Background, MUII_FILL,
MUIA_Rectangle_BarTitle, "Rect3",
End,
End,
End,
End,
End;
if (!app)
{
fprintf(stderr, "can't create application object.\n");
goto error;
}
DoMethod(mainWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
(IPTR)app, 2,
MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(stepb[0], MUIM_Notify, MUIA_Timer, MUIV_EveryTime,
(IPTR)pages, 3, MUIM_Set,
MUIA_Group_ActivePage, MUIV_Group_ActivePage_Prev);
DoMethod(stepb[1], MUIM_Notify, MUIA_Timer, MUIV_EveryTime,
(IPTR)pages, 3, MUIM_Set,
MUIA_Group_ActivePage, MUIV_Group_ActivePage_Next);
for (i = 0; i < 3; i++)
{
DoMethod(b[i], MUIM_Notify, MUIA_Pressed, FALSE,
(IPTR)pages, 3, MUIM_Set, MUIA_Group_ActivePage, i);
}
/*
* Open window and ALWAYS check.
*/
set(mainWin, MUIA_Window_Open, TRUE);
if (!XGET(mainWin, MUIA_Window_Open))
{
MUI_DisposeObject(app);
fprintf(stderr, "can't open main window.\n");
goto error;
}
{
ULONG sigs = 0;
while (DoMethod(app, MUIM_Application_NewInput, (IPTR)&sigs)
!= MUIV_Application_ReturnID_Quit)
{
if (sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if (sigs & SIGBREAKF_CTRL_C) break;
}
}
}
set(mainWin, MUIA_Window_Open, FALSE);
MUI_DisposeObject(app);
error:
closemuimaster();
return 0;
}
