static IPTR mDispose(struct IClass *cl, Object *obj, Msg msg)
{
struct data *data = INST_DATA(cl,obj);
struct DiskObject *icon = data->icon;
IPTR res;
/*
** Because of users hate an app that saves on disc
** at any exit, we check if you must save something
*/
if (DoMethod(data->win,MUIM_App_CheckSave))
{
DoSuperMethod(cl,obj,MUIM_Application_Save,(IPTR)MUIV_Application_Save_ENV);
DoSuperMethod(cl,obj,MUIM_Application_Save,(IPTR)MUIV_Application_Save_ENVARC);
}
res = DoSuperMethodA(cl,obj,msg);
if (icon) FreeDiskObject(icon);
return res;
}
VOID ImageDecoderThread ()
{
LONG args[6];
struct RDArgs *readargs;
if(readargs = ReadArgs("/A/N,/A/N,/A/N,/A/N,/A/N,/A/F", args, NULL))
{
ULONG pageID = *((ULONG *)args[0]);
struct ImageList *images = *((struct ImageList **)args[1]);
Object *ipc = *((Object **)args[2]);
ULONG handle = *((ULONG *)args[3]);
struct Screen *scr = *((struct Screen **)args[4]);
STRPTR url = (STRPTR)args[5];
Object *dt = NULL;
if(dt = NewDTObject(url,
DTA_GroupID, GID_PICTURE,
PDTA_DestMode, MODE_V43,
PDTA_Remap, TRUE,
PDTA_FreeSourceBitMap, TRUE,
PDTA_Screen, scr,
PDTA_UseFriendBitMap, TRUE,
TAG_DONE))
{
DoMethod(dt, DTM_PROCLAYOUT);
}
struct IPCMsg ipcmsg(handle, IPCFlg_Unlock);
ipcmsg.MethodID = MUIM_IPC_DoMessage;
ipcmsg.PageID = pageID;
ipcmsg.Images = images;
ipcmsg.DTObject = dt;
ipcmsg.ImageDecoderThread = FindTask(NULL);
if(!DoMethodA(ipc, (Msg)&ipcmsg))
DisposeDTObject(dt);
UnlockPubScreen(NULL, scr);
}
}
static void HandleAll(void)
{
ULONG sigs = 0;
LONG returnid;
set (wnd, MUIA_Window_Open, TRUE);
for(;;)
{
returnid = (LONG) DoMethod(app, MUIM_Application_NewInput, (IPTR) &sigs);
if ((returnid == MUIV_Application_ReturnID_Quit) ||
(returnid == RETURNID_SAVE) || (returnid == RETURNID_USE)) break;
if (sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C);
if (sigs & SIGBREAKF_CTRL_C) break;
}
}
}
/*
* Create an object from a class.
*/
Object *
NewObjectA (struct IClass *classPtr,
ClassID classID,
struct TagItem *tagList)
{
Object * object;
struct _Object carrier;
/* No classPtr ? */
if (!classPtr)
{
/* Search for the class */
if (!(classPtr = GetPublicClass(classID)) )
{
/* I used to have a last-resort builtin class creation here,
* but I decided nobody should need it, because you
* dont have to call this function with a non-public class -dlc
*/
g_error("NewObjectA: null classPtr, and non public class %s\n"
"Perhaps you should try MUI_NewObjectA ?\n",
classID);
return (NULL); /* Nothing found */
}
}
/* Put the classPtr in our dummy object */
carrier.o_Class = classPtr;
/* Try to create a new object */
if ((object = (Object *) DoMethod (BASEOBJECT(&carrier), OM_NEW, (ULONG)tagList)))
{
OCLASS(object) = classPtr;
/* One more object */
classPtr->cl_ObjectCount ++;
}
return (object);
} /* NewObjectA */
static APTR build_drive_gui(void)
{
APTR app, ui, ok, cancel;
app = mui_get_app();
ui = GroupObject,
FILENAME(ui_to_from_drive[0].object, "2031", hook_object_drive[0])
FILENAME(ui_to_from_drive[1].object, "2030", hook_object_drive[1])
FILENAME(ui_to_from_drive[2].object, "3040", hook_object_drive[2])
FILENAME(ui_to_from_drive[3].object, "4040", hook_object_drive[3])
FILENAME(ui_to_from_drive[4].object, "1001", hook_object_drive[4])
OK_CANCEL_BUTTON
End;
if (ui != NULL) {
DoMethod(cancel,
MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(ok, MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_Application_ReturnID, BTN_OK);
DoMethod(hook_object_drive[0], MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_CallHook, &BrowseDrive0);
DoMethod(hook_object_drive[1], MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_CallHook, &BrowseDrive1);
DoMethod(hook_object_drive[2], MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_CallHook, &BrowseDrive2);
DoMethod(hook_object_drive[3], MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_CallHook, &BrowseDrive3);
DoMethod(hook_object_drive[4], MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_CallHook, &BrowseDrive4);
}
return ui;
}
///
/// US_OpenFunc
// Opens and initializes user list window
HOOKPROTONHNONP(US_OpenFunc, void)
{
ENTER();
if(G->US == NULL)
{
struct User *user = US_GetCurrentUser();
// if the first user doesn't have a real name yet then copy over the name from the configuration
if(G->Users.User[0].Name[0] == '\0')
{
struct UserIdentityNode *uin = GetUserIdentity(&C->userIdentityList, 0, TRUE);
if(uin != NULL)
strlcpy(G->Users.User[0].Name, uin->realname, sizeof(G->Users.User[0].Name));
}
if((G->US = US_New(!user->Limited)) != NULL)
{
if(SafeOpenWindow(G->US->GUI.WI))
{
int i;
// add the users to the listview
for(i = 0; i < G->Users.Num; i++)
DoMethod(G->US->GUI.LV_USERS, MUIM_NList_InsertSingle, &G->Users.User[i], MUIV_NList_Insert_Bottom);
set(G->US->GUI.LV_USERS, MUIA_NList_Active, 0);
set(G->US->GUI.BT_ADD, MUIA_Disabled, G->Users.Num == MAXUSERS);
set(G->US->GUI.BT_DEL, MUIA_Disabled, G->Users.Num == 0);
}
else
DisposeModulePush(&G->US);
}
}
LEAVE();
}
int main(void)
{
struct Library *MiamiBase;
if (Setup())
{
if (Port = CreateMsgPort())
{
struct Message *m;
Port->mp_Node.ln_Name = "SysLog";
Port->mp_Node.ln_Pri = 12;
AddPort(Port);
MiamiBase = OpenLibrary("miami.library",13);
if (MiamiBase) {
SetSysLogPort();
CloseLibrary(MiamiBase);
}
if (BuildGui())
{
DoMethod(App, MUIM_Application_Load, MUIV_Application_Load_ENV);
SetNotifications();
MainLoop(Win);
MUI_DisposeObject(App);
}
RemPort(Port);
MiamiBase = OpenLibrary("miami.library",13);
if (MiamiBase) {
SetSysLogPort();
CloseLibrary(MiamiBase);
}
while (m = GetMsg(Port)) ReplyMsg(m);
DeleteMsgPort(Port);
}
}
else Printf("Setup() failed.\n");
Cleanup();
return 0;
}
IPTR Poppen__MUIM_Poppen_CloseWindow(struct IClass *cl, Object *obj,
struct MUIP_Poppen_CloseWindow *msg)
{
struct Poppen_DATA *data = INST_DATA(cl, obj);
int ok = msg->ok;
set(data->wnd, MUIA_Window_Open, FALSE);
if (ok)
{
char *spec;
get(data->penadjust, MUIA_Penadjust_Spec, &spec);
set(obj, MUIA_Pendisplay_Spec, (IPTR)spec);
}
DoMethod(_app(obj), OM_REMMEMBER, (IPTR)data->wnd);
MUI_DisposeObject(data->wnd);
data->wnd = NULL;
data->penadjust = NULL;
return 1;
}
VOID RedrawPreview( FRAME *pwframe, EXTBASE *PPTBase )
{
D(bug("RedrawPreview( %08X, xb=%08X )\n",pwframe, PPTBase ));
if( pwframe->preview.pf_Hook ) {
CallHook( pwframe->preview.pf_Hook, (Object *)pwframe, ~0 );
} else {
/*
* Send message to the main window
*/
struct IBox *ibox;
GetAttr(AREA_AreaBox, pwframe->preview.pf_RenderArea, (ULONG *)&ibox );
QuickRender( pwframe, pwframe->preview.pf_win->RPort,
ibox->Top, ibox->Left,
ibox->Height, ibox->Width, PPTBase );
#if 0
DoMethod( pwframe->parent->disp->Win, WM_REPORT_ID, GID_DW_AREA,
WMRIF_TASK, globals->maintask, TAG_DONE );
#endif
}
}
IPTR Poppen__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Poppen_DATA *data;
struct TagItem *tag, *tags;
//Object *image;
obj = (Object *)DoSuperNewTags(cl, obj, NULL,
ButtonFrame,
InnerSpacing(4,4),
MUIA_Background, MUII_ButtonBack,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_Draggable, TRUE,
TAG_MORE, (IPTR)msg->ops_AttrList);
if (!obj) return FALSE;
data = INST_DATA(cl, obj);
data->wintitle = NULL;
/* parse initial taglist */
for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem**)&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Window_Title:
data->wintitle = (CONST_STRPTR)tag->ti_Data;
break;
}
}
DoMethod(obj, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)obj, 1,
MUIM_Poppen_OpenWindow);
return (IPTR)obj;
}
static void closeAllWindows(Object *app)
{
BOOL loop;
ENTER();
do
{
struct List *list;
Object *mstate;
Object *win;
loop = FALSE;
list = (struct List *)xget(app, MUIA_Application_WindowList);
mstate = (Object *)list->lh_Head;
while((win = NextObject(&mstate)) != NULL)
{
ULONG ok = FALSE;
ok = xget(win, MUIA_App_IsSubWin);
if(ok)
{
set(win, MUIA_Window_Open, FALSE);
DoMethod(app, OM_REMMEMBER, (IPTR)win);
MUI_DisposeObject(win);
loop = TRUE;
break;
}
}
}
while(loop == TRUE);
LEAVE();
}
VOID TextAreaClass::AppendGadget (struct AppendGadgetMessage &amsg)
{
if(Flags & FLG_AllElementsPresent)
{
if(!MUIGadget)
{
MUIGadget = TextEditorObject,
MUIA_TextEditor_Rows, Rows,
MUIA_TextEditor_Columns, Columns,
/* MUIA_FixWidth, 400,
MUIA_FixHeight, 200,
*/ MUIA_TextEditor_InVirtualGroup, TRUE,
MUIA_TextEditor_Contents, Contents,
MUIA_TextEditor_FixedFont, TRUE,
MUIA_TextEditor_ReadOnly, Flags & FLG_TextArea_ReadOnly,
MUIA_CycleChain, TRUE,
End;
if(MUIGadget)
DoMethod(amsg.Parent, OM_ADDMEMBER, (ULONG)MUIGadget);
else Flags |= FLG_Layouted;
}
}
}
static void GUINewSettings(void) {
Object *oldcycle;
Object *cycle = CycleObject,
CYC_Labels, Units,
CYC_Active, state.UnitSelected,
CYC_PopActive, PopUpMenus,
CYC_Popup, PopUpMenus,
GA_ID, ACTID_UNIT,
EndObject;
if(cycle) {
oldcycle = (Object *) DoMethod( vgroup, GRM_REPLACEMEMBER,
Window_Objs[ACTID_UNIT], cycle, FixMinHeight, TAG_DONE);
if(oldcycle) {
DisposeObject(oldcycle);
Window_Objs[ACTID_UNIT] = cycle;
}
else {
DisposeObject(cycle);
}
}
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_DEBUG], window, NULL,
CYC_Active, globalprefs.ahigp_DebugLevel, TAG_DONE);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_SURROUND], window, NULL,
CYC_Active, globalprefs.ahigp_DisableSurround, TAG_DONE);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_ECHO], window, NULL,
CYC_Active, (globalprefs.ahigp_DisableEcho ? 2 : 0) |
(globalprefs.ahigp_FastEcho ? 1 : 0), TAG_DONE);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_CLIPMV], window, NULL,
CYC_Active, globalprefs.ahigp_ClipMasterVolume, TAG_DONE);
SetGadgetAttrs((struct Gadget *) Window_Objs[ACTID_CPULIMIT], window, NULL,
SLIDER_Level, (globalprefs.ahigp_MaxCPU * 100 + 32768) >> 16, TAG_DONE);
GUINewUnit();
}
static void DisposeObj(Object *o, SW_IDATA *idata)
{
DoMethod(idata->SWA_NNews_GlobSel, SWM_NSFilter_HideUI);
DoMethod(idata->SWA_NNews_GlobHL, SWM_NSFilter_HideUI);
DoMethod(idata->SWA_NNews_GlobKill, SWM_NSFilter_HideUI);
DoMethod(idata->SWA_NNews_GlobDsp, SWM_NDFilter_HideUI);
DoMethod(idata->SWA_NNews_GlobAct, SWM_NAFilter_HideUI);
MUI_DisposeObject(idata->ArtLst);
// -- close all our windows ----------------------------------------------
CloseAll(o, idata, SWV_WinMax, TRUE);
ClrLists(idata);
DoMethod(idata->DTImg, SWM_DTImg_FreeImgCache, idata->SWA_NNews_DTImages);
MUI_DisposeObject(idata->DTImg);
// -- so objs don`t try to talk to the application object during dispose --
set(o, SWA_AppBase_App, NULL);
}
struct WCSScreenMode *ModeList_Choose(struct WCSScreenMode *This,
struct WCSScreenData *ScrnData)
{
static const char *Cycle_OSCAN[] = {"None", "Text", "Standard", "Max", "Video", NULL};
struct WCSScreenMode *Scan, *Selected;
APTR ModeSelWin, SM_Save, SM_Use, SM_Exit, SM_Width, SM_Height, SM_List, SM_Text, SM_OSCAN;
ULONG Signalz, Finished, ReturnID;
int CheckVal, Update;
char *ModeText, ModeInfo[255];
ModeSelWin = WindowObject,
MUIA_Window_Title, "World Construction Set Screenmode",
MUIA_Window_ID, "SCRN",
MUIA_Window_SizeGadget, TRUE,
WindowContents, VGroup,
Child, ColGroup(2), MUIA_Group_SameWidth, TRUE,
MUIA_Group_HorizSpacing, 4, MUIA_Group_VertSpacing, 3,
Child, VGroup, /* MUIA_HorizWeight, 150, */
Child, TextObject, MUIA_Text_Contents, "\33cDisplay Mode", End,
Child, SM_List = ListviewObject,
MUIA_Listview_Input, TRUE,
MUIA_Listview_List, ListObject, ReadListFrame, End,
End,
End,
Child, VGroup,
Child, TextObject, MUIA_Text_Contents, "\33cMode Information", End,
Child, SM_Text = FloattextObject, ReadListFrame,
MUIA_Floattext_Text, "Mode: \nRes : \nAuto: \nScan: \n\nAttributes\n\n\n", End,
End,
Child, HGroup,
Child, Label2("Overscan: "),
Child, SM_OSCAN = CycleObject, MUIA_Cycle_Entries, Cycle_OSCAN, End,
End,
Child, HGroup,
Child, RectangleObject, End,
Child, HGroup, MUIA_Group_HorizSpacing, 0,
Child, Label2("Width "), /* No End (in sight) */
Child, SM_Width = StringObject, StringFrame,
MUIA_String_Integer, 0,
MUIA_String_Accept, "0123456789",
MUIA_FixWidthTxt, "01234",
End,
End,
Child, RectangleObject, End,
Child, HGroup, MUIA_Group_HorizSpacing, 0,
Child, Label2("Height "), /* No End (in sight) */
Child, SM_Height = StringObject, StringFrame,
MUIA_String_Integer, 0,
MUIA_String_Accept, "0123456789",
MUIA_FixWidthTxt, "01234",
End,
End,
Child, RectangleObject, End,
End,
End,
Child, RectangleObject, MUIA_FixHeight, 4, End,
Child, HGroup, MUIA_HorizWeight, 1,
/* Button button button. Who's got the button? */
MUIA_Group_SameSize, TRUE,
Child, SM_Save = KeyButtonObject('s'), MUIA_Text_Contents, "\33cSave", MUIA_HorizWeight, 200, End,
Child, RectangleObject, MUIA_HorizWeight, 1, End,
Child, SM_Use = KeyButtonObject('u'), MUIA_Text_Contents, "\33cUse", MUIA_HorizWeight, 200, End,
Child, RectangleObject, MUIA_HorizWeight, 1, End,
Child, SM_Exit = KeyButtonObject('e'), MUIA_Text_Contents, "\33cExit", MUIA_HorizWeight, 200, End,
End,
End,
End;
if(ModeSelWin)
{
DoMethod(ModeSelWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
app, 2, MUIM_Application_ReturnID, ID_SM_EXIT);
MUI_DoNotiPresFal(app, SM_Exit, ID_SM_EXIT,
SM_Use, ID_SM_USE, SM_Save, ID_SM_SAVE, NULL);
DoMethod(SM_List, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
app, 2, MUIM_Application_ReturnID, ID_SM_LIST);
DoMethod(SM_OSCAN, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
app, 2, MUIM_Application_ReturnID, ID_SM_OSCAN);
DoMethod(SM_Width, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
app, 2, MUIM_Application_ReturnID, ID_SM_WIDTH);
DoMethod(SM_Height, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime,
app, 2, MUIM_Application_ReturnID, ID_SM_HEIGHT);
DoMethod(ModeSelWin, MUIM_Window_SetCycleChain,
SM_List, SM_Save, SM_Use, SM_Exit, SM_OSCAN, SM_Width, SM_Height, NULL);
set(ModeSelWin, MUIA_Window_ActiveObject, SM_Save);
for(Scan = This; Scan; Scan = Scan->Next)
{
DoMethod(SM_List, MUIM_List_InsertSingle, Scan->ModeName, MUIV_List_Insert_Sorted);
} /* for */
set(SM_List, MUIA_List_Active, MUIV_List_Active_Top);
DoMethod(app, OM_ADDMEMBER, ModeSelWin);
#ifdef WCS_MUI_2_HACK
/* This is not needed here, but will be when ScreenMode selection
** can be done from within the program. */
/* MUI2_MenuCheck_Hack(); */
#endif /* WCS_MUI_2_HACK */
set(ModeSelWin, MUIA_Window_Open, TRUE);
} /* if */
Selected = This;
for(Finished = NULL; !Finished;)
{
if(ReturnID = DoMethod(app, MUIM_Application_Input, &Signalz))
{
switch(ReturnID)
{
case ID_SM_OSCAN:
{
/* Do not break, fall through to below. */
} /* ID_SM_OSCAN */
case ID_SM_LIST:
{
get(SM_List, MUIA_List_Active, &CheckVal);
DoMethod(SM_List, MUIM_List_GetEntry, CheckVal, &ModeText);
for(Scan = This; Scan;)
{
Selected = Scan;
if((unsigned char *)&Scan->ModeName == ModeText)
{
Scan = NULL;
} /* if */
else
Scan = Scan->Next;
} /* for */
get(SM_OSCAN, MUIA_Cycle_Active, &CheckVal);
Update = 1;
if(Selected->UX != Selected->OX)
Update = 0;
if(Selected->UY != Selected->OY)
Update = 0;
if(CheckVal == 0)
{
Selected->OX = Selected->X;
Selected->OY = Selected->Y;
} /* if */
else
{
Selected->OX = Selected->OScans[CheckVal - 1].x;
Selected->OY = Selected->OScans[CheckVal - 1].y;
} /* else */
if(Update)
{
Selected->UX = Selected->OX;
Selected->UY = Selected->OY;
} /* if */
sprintf(ModeInfo, "Mode: 0x%08lx\nRes : %dx%d - %dx%d\nAuto: %dx%d\nScan: %dns\n\nAttributes\n",
Selected->ModeID, Selected->X, Selected->Y, Selected->OX, Selected->OY,
Selected->MaxX, Selected->MaxY, Selected->PixelSpeed);
if(Selected->PropertyFlags & DIPF_IS_LACE)
strcat(ModeInfo,"Laced ");
if(Selected->PropertyFlags & DIPF_IS_HAM)
strcat(ModeInfo,"HAM ");
if(Selected->PropertyFlags & DIPF_IS_ECS)
strcat(ModeInfo,"ECS ");
if(Selected->PropertyFlags & DIPF_IS_AA)
strcat(ModeInfo,"AGA ");
if(Selected->PropertyFlags & DIPF_IS_PAL)
strcat(ModeInfo,"PAL ");
if(Selected->PropertyFlags & DIPF_IS_GENLOCK)
strcat(ModeInfo,"Genlockable ");
if(Selected->PropertyFlags & DIPF_IS_DRAGGABLE)
strcat(ModeInfo,"Draggable ");
if(Selected->PropertyFlags & DIPF_IS_PANELLED)
strcat(ModeInfo,"Panelled ");
if(Selected->PropertyFlags & DIPF_IS_EXTRAHALFBRITE)
strcat(ModeInfo,"EHB ");
if(Selected->PropertyFlags & DIPF_IS_FOREIGN)
strcat(ModeInfo,"Foreign ");
set(SM_Text, MUIA_Floattext_Text, ModeInfo);
set(SM_Width, MUIA_String_Integer, Selected->UX);
set(SM_Height, MUIA_String_Integer, Selected->UY);
break;
} /* ID_SM_LIST */
case ID_SM_HEIGHT:
{
get(SM_Height, MUIA_String_Integer, &CheckVal);
if(CheckVal < Selected->OY)
{
CheckVal = Selected->OY;
set(SM_Height, MUIA_String_Integer, CheckVal);
set(ModeSelWin, MUIA_Window_ActiveObject, SM_Height);
} /* if */
else if(CheckVal > Selected->MaxY)
{
CheckVal = Selected->MaxY;
set(SM_Height, MUIA_String_Integer, CheckVal);
set(ModeSelWin, MUIA_Window_ActiveObject, SM_Height);
} /* else if */
else
set(ModeSelWin, MUIA_Window_ActiveObject, SM_Width);
Selected->UY = CheckVal;
break;
} /* ID_SM_HEIGHT */
case ID_SM_WIDTH:
{
get(SM_Width, MUIA_String_Integer, &CheckVal);
if(CheckVal < Selected->OX)
{
CheckVal = Selected->OX;
set(SM_Width, MUIA_String_Integer, CheckVal);
set(ModeSelWin, MUIA_Window_ActiveObject, SM_Width);
} /* if */
else if(CheckVal > Selected->MaxX)
{
CheckVal = Selected->MaxX;
set(SM_Width, MUIA_String_Integer, CheckVal);
set(ModeSelWin, MUIA_Window_ActiveObject, SM_Width);
} /* else if */
else
set(ModeSelWin, MUIA_Window_ActiveObject, SM_Height);
Selected->UX = CheckVal;
break;
} /* ID_SM_WIDTH */
case ID_SM_SAVE:
{
ScrnData->ModeID = Selected->ModeID;
ScrnData->Width = Selected->UX;
ScrnData->Height = Selected->UY;
/* Do something more here */
} /* ID_SM_SAVE */
case ID_SM_USE:
{
Finished = 1;
get(SM_Height, MUIA_String_Integer, &CheckVal);
if(CheckVal < Selected->OY)
{
CheckVal = Selected->OY;
set(SM_Height, MUIA_String_Integer, CheckVal);
Finished = 0;
} /* if */
if(CheckVal > Selected->MaxY)
{
CheckVal = Selected->MaxY;
set(SM_Height, MUIA_String_Integer, CheckVal);
Finished = 0;
} /* if */
Selected->UY = CheckVal;
get(SM_Width, MUIA_String_Integer, &CheckVal);
if(CheckVal < Selected->OX)
{
CheckVal = Selected->OX;
set(SM_Width, MUIA_String_Integer, CheckVal);
Finished = 0;
} /* if */
if(CheckVal > Selected->MaxX)
{
CheckVal = Selected->MaxX;
set(SM_Width, MUIA_String_Integer, CheckVal);
Finished = 0;
} /* if */
Selected->UX = CheckVal;
if(Finished)
{
DoMethod(app, OM_REMMEMBER, ModeSelWin);
MUI_DisposeObject(ModeSelWin);
return(Selected);
} /* if */
break;
} /* ID_SM_USE */
case ID_SM_EXIT:
{
return(NULL);
break;
} /* ID_SM_EXIT */
} /* switch */
} /* if */
else
{
if(!Finished)
{
Wait(Signalz);
} /* if */
} /* else */
} /* for */
#ifdef PRINTMODES_DEBUG
for(Scan = This; Scan; Scan = Scan->Next)
{
printf("%08lx: ", Scan->ModeID);
printf("\"%s\" ", Scan->ModeName);
printf("%ld x %ld - %ld x %ld.\n", Scan->X, Scan->Y, Scan->OX, Scan->OY);
printf("%dns ", Scan->PixelSpeed);
if(Scan->PropertyFlags & DIPF_IS_LACE)
printf("Laced ");
if(Scan->PropertyFlags & DIPF_IS_HAM)
printf("HAM ");
if(Scan->PropertyFlags & DIPF_IS_ECS)
printf("ECS ");
if(Scan->PropertyFlags & DIPF_IS_AA)
printf("AGA ");
if(Scan->PropertyFlags & DIPF_IS_PAL)
printf("PAL ");
if(Scan->PropertyFlags & DIPF_IS_GENLOCK)
printf("Genlockable ");
if(Scan->PropertyFlags & DIPF_IS_DRAGGABLE)
printf("Draggable ");
if(Scan->PropertyFlags & DIPF_IS_PANELLED)
printf("Panelled ");
if(Scan->PropertyFlags & DIPF_IS_EXTRAHALFBRITE)
printf("EHB ");
if(Scan->PropertyFlags & DIPF_IS_FOREIGN)
printf("Foreign ");
printf("\n");
} /* for */
#endif /* PRINTMODES_DEBUG */
} /* ModeList_Choose() */
/**
* Initialize the filter window.
*/
static void init_filter(void)
{
static struct Hook filter_construct_hook;
static struct Hook filter_destruct_hook;
static struct Hook filter_display_hook;
static struct Hook move_objstr_hook, move_strobj_hook;
Object *ok_button, *cancel_button, *save_button;
Object *filter_move_popobject, *filter_remote_label;
init_hook(&filter_construct_hook,(HOOKFUNC)filter_construct);
init_hook(&filter_destruct_hook,(HOOKFUNC)filter_destruct);
init_hook(&filter_display_hook,(HOOKFUNC)filter_display);
init_hook(&move_objstr_hook, (HOOKFUNC)move_objstr);
init_hook(&move_strobj_hook, (HOOKFUNC)move_strobj);
filter_wnd = WindowObject,
MUIA_Window_ID, MAKE_ID('F','I','L','T'),
MUIA_Window_Title, _("SimpleMail - Edit Filter"),
WindowContents, VGroup,
Child, VGroup,
Child, HGroup,
Child, VGroup,
MUIA_HorizWeight,40,
Child, VGroup,
MUIA_Group_Spacing, 0,
Child, NListviewObject,
MUIA_NListview_NList, filter_list = FilterListObject,
MUIA_NList_AutoVisible, 1, /* keep the active filter visible */
MUIA_NList_ConstructHook, &filter_construct_hook,
MUIA_NList_DestructHook, &filter_destruct_hook,
MUIA_NList_DisplayHook, &filter_display_hook,
End,
End,
Child, HGroup,
Child, filter_name_string = UTF8StringObject,
StringFrame,
End,
End,
End,
Child, ColGroup(2),
Child, filter_new_button = MakeButton(_("_New")),
Child, filter_remove_button = MakeButton(_("_Remove")),
Child, filter_moveup_button = MakeButton(_("Move up")),
Child, filter_movedown_button = MakeButton(_("Move Down")),
End,
End,
Child, BalanceObject, End,
Child, VGroup,
Child, HorizLineTextObject(_("Activity")),
Child, HGroup,
Child, RectangleObject,MUIA_Weight,25,End,
Child, ColGroup(5),
Child, MakeLabel(_("On request")),
Child, filter_request_check = MakeCheck(NULL,FALSE),
Child, RectangleObject,MUIA_Weight,200,End,
Child, MakeLabel(_("On sent mails")),
Child, filter_sent_check = MakeCheck(NULL,FALSE),
Child, filter_remote_label = MakeLabel(_("Remotly on POP3 server")),
Child, filter_remote_check = MakeCheck(NULL,FALSE),
Child, RectangleObject,MUIA_Weight,200,End,
Child, MakeLabel(_("On new mails")),
Child, filter_new_check = MakeCheck(NULL,FALSE),
End,
Child, RectangleObject,MUIA_Weight,25,End,
End,
Child, HorizLineTextObject(_("Rules")),
Child, VGroupV,
Child, filter_rule_group = ColGroup(2),
Child, HVSpace,
Child, HVSpace,
End,
End,
Child, HGroup,
Child, filter_add_rule_button = MakeButton(_("Add new rule")),
Child, filter_apply_now_button = MakeButton(_("Apply now")),
End,
Child, HorizLineTextObject(_("Action")),
Child, VGroup,
Child, ColGroup(3),
Child, MakeLabel(_("Move to Folder")),
Child, filter_move_check = MakeCheck(_("Move to Folder"),FALSE),
Child, filter_move_popobject = PopobjectObject,
MUIA_Disabled, TRUE,
MUIA_Popstring_Button, PopButton(MUII_PopUp),
MUIA_Popstring_String, filter_move_text = TextObject, TextFrame, MUIA_Background, MUII_TextBack, End,
MUIA_Popobject_ObjStrHook, &move_objstr_hook,
MUIA_Popobject_StrObjHook, &move_strobj_hook,
MUIA_Popobject_Object, NListviewObject,
MUIA_NListview_NList, filter_folder_list = FolderTreelistObject,
End,
End,
End,
Child, MakeLabel(_("Execute ARexx Script")),
Child, filter_arexx_check = MakeCheck(_("Execute ARexx Script"),FALSE),
Child, filter_arexx_popasl = PopaslObject,
MUIA_Disabled, TRUE,
MUIA_Popstring_Button, PopButton(MUII_PopFile),
MUIA_Popstring_String, filter_arexx_string = BetterStringObject,
StringFrame,
MUIA_CycleChain,1,
MUIA_String_Acknowledge, TRUE,
End,
End,
Child, MakeLabel(_("Play Sound")),
Child, filter_sound_check = MakeCheck(_("Play Sound"),FALSE),
Child, filter_sound_string = AudioSelectGroupObject, MUIA_Disabled, TRUE, End,
End,
End,
End,
End,
End,
Child, HorizLineObject,
Child, HGroup,
Child, save_button = MakeButton(Q_("?filter:_Save")),
Child, ok_button = MakeButton(_("_Use")),
Child, cancel_button = MakeButton(_("_Cancel")),
End,
End,
End;
if (filter_wnd)
{
char *short_help_txt = _("If activated the filter will be used remotly on POP3 servers\n"
"which support the TOP command. Mails which matches the filter\n"
"are presented to the user and automatically marked as to be ignored.");
set(filter_remote_label, MUIA_ShortHelp, short_help_txt);
set(filter_remote_check, MUIA_ShortHelp, short_help_txt);
DoMethod(App, OM_ADDMEMBER, (ULONG)filter_wnd);
DoMethod(filter_wnd, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_cancel);
DoMethod(ok_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_ok);
DoMethod(save_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_ok);
DoMethod(save_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)save_filter);
DoMethod(cancel_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_cancel);
DoMethod(filter_new_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_new);
DoMethod(filter_remove_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_remove);
DoMethod(filter_moveup_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_list, 3, MUIM_NList_Move, MUIV_NList_Move_Active, MUIV_NList_Move_Previous);
DoMethod(filter_movedown_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_list, 3, MUIM_NList_Move, MUIV_NList_Move_Active, MUIV_NList_Move_Next);
set(filter_name_string, MUIA_String_AttachedList, (ULONG)filter_list);
DoMethod(filter_list, MUIM_Notify, MUIA_NList_Active, MUIV_EveryTime, (ULONG)filter_list, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_active);
DoMethod(filter_name_string, MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime, (ULONG)filter_list, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_name);
DoMethod(filter_add_rule_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_add_rule_gui);
DoMethod(filter_apply_now_button, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)filter_wnd, 3, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)filter_apply);
DoMethod(filter_move_check, MUIM_Notify, MUIA_Selected, MUIV_EveryTime, (ULONG)filter_move_popobject, 3, MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
DoMethod(filter_sound_check, MUIM_Notify, MUIA_Selected, MUIV_EveryTime, (ULONG)filter_sound_string, 3, MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
DoMethod(filter_arexx_check, MUIM_Notify, MUIA_Selected, MUIV_EveryTime, (ULONG)filter_arexx_popasl, 3, MUIM_Set, MUIA_Disabled, MUIV_NotTriggerValue);
DoMethod(filter_folder_list, MUIM_Notify, MUIA_NList_DoubleClick, TRUE, (ULONG)filter_move_popobject, 2, MUIM_Popstring_Close, 1);
filter_update_folder_list();
}
}
/* /// "nHIDCtrlGUITask()" */
AROS_UFH0(void, GM_UNIQUENAME(nHIDCtrlGUITask))
{
AROS_USERFUNC_INIT
struct Task *thistask;
struct NepHidBase *nh;
struct NepClassHid *nch;
thistask = FindTask(NULL);
#undef ps
#define ps nch->nch_HCPsdBase
#undef IntuitionBase
#define IntuitionBase nch->nch_HCIntBase
#undef MUIMasterBase
#define MUIMasterBase nch->nch_HCMUIBase
nch = thistask->tc_UserData;
nch->nch_HCGUITask = thistask;
nh = nch->nch_ClsBase;
++nh->nh_Library.lib_OpenCnt;
NewList(&nch->nch_HCGUIItems);
if(!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME, MUIMASTER_VMIN)))
{
KPRINTF(10, ("Couldn't open muimaster.library.\n"));
GM_UNIQUENAME(nHIDCtrlGUITaskCleanup)(nch);
return;
}
if(!(IntuitionBase = OpenLibrary("intuition.library", 39)))
{
KPRINTF(10, ("Couldn't open intuition.library.\n"));
GM_UNIQUENAME(nHIDCtrlGUITaskCleanup)(nch);
return;
}
if(!(ps = OpenLibrary("poseidon.library", 4)))
{
KPRINTF(10, ("Couldn't open poseidon.library.\n"));
GM_UNIQUENAME(nHIDCtrlGUITaskCleanup)(nch);
return;
}
nch->nch_HCActionClass = MUI_CreateCustomClass(NULL, MUIC_Area , NULL, sizeof(struct ActionData), GM_UNIQUENAME(HCActionDispatcher));
if(!nch->nch_HCActionClass)
{
KPRINTF(10, ("Couldn't create ActionClass.\n"));
GM_UNIQUENAME(nHIDCtrlGUITaskCleanup)(nch);
return;
}
nch->nch_HCApp = ApplicationObject,
MUIA_Application_Title , (IPTR)nch->nch_CDC->cdc_HIDCtrlTitle,
MUIA_Application_Version , (IPTR)VERSION_STRING,
MUIA_Application_Copyright , (IPTR)"©2002-2009 Chris Hodges",
MUIA_Application_Author , (IPTR)"Chris Hodges <*****@*****.**>",
MUIA_Application_Description, (IPTR)"HID Device Output Control",
MUIA_Application_Base , (IPTR)nch->nch_CDC->cdc_HIDCtrlRexx,
MUIA_Application_HelpFile , (IPTR)"HELP:Poseidon.guide",
MUIA_Application_Menustrip , (IPTR)MenustripObject,
Child, (IPTR)MenuObjectT((IPTR)"Project"),
Child, (IPTR)(nch->nch_HCAboutMI = MenuitemObject,
MUIA_Menuitem_Title, (IPTR)"About...",
MUIA_Menuitem_Shortcut, (IPTR)"?",
End),
Child, (IPTR)MenuitemObject,
MUIA_Menuitem_Title, (IPTR)NM_BARLABEL,
End,
Child, (IPTR)(nch->nch_HCCloseMI = MenuitemObject,
MUIA_Menuitem_Title, (IPTR)"Hide",
MUIA_Menuitem_Shortcut, (IPTR)"H",
End),
End,
Child, (IPTR)MenuObjectT((IPTR)"Settings"),
Child, (IPTR)(nch->nch_HCMUIPrefsMI = MenuitemObject,
MUIA_Menuitem_Title, (IPTR)"MUI Settings",
MUIA_Menuitem_Shortcut, (IPTR)"M",
End),
End,
End,
SubWindow, (IPTR)(nch->nch_HCMainWindow = WindowObject,
MUIA_Window_ID , MAKE_ID('H','C','T','L'),
MUIA_Window_Title, (IPTR)nch->nch_CDC->cdc_HIDCtrlTitle,
MUIA_HelpNode, (IPTR)GM_UNIQUENAME(libname),
WindowContents, (IPTR)VGroup,
Child, (IPTR)(nch->nch_HCActionObj = NewObject(nch->nch_HCActionClass->mcc_Class, 0, MUIA_ShowMe, FALSE, TAG_END)),
Child, (IPTR)(nch->nch_HCGroupObj = ColGroup(4),
End),
Child, (IPTR)(nch->nch_HCCloseObj = TextObject, ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_CycleChain, 1,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_Text_Contents, (IPTR)"\33c Hide ",
End),
End,
End),
End;
if(!nch->nch_HCApp)
{
KPRINTF(10, ("Couldn't create application\n"));
GM_UNIQUENAME(nHIDCtrlGUITaskCleanup)(nch);
return;
}
{
struct ActionData *ad = INST_DATA(nch->nch_HCActionClass->mcc_Class, nch->nch_HCActionObj);
ad->ad_NCH = nch;
}
/* add items */
{
struct NepHidReport *nhr;
struct NepHidItem **nhiptr;
struct NepHidItem *nhi;
struct NepHidGItem *nhgi;
UWORD count;
Object *obj;
UWORD numobj = 0;
nhr = (struct NepHidReport *) nch->nch_HidReports.lh_Head;
while(nhr->nhr_Node.ln_Succ)
{
if((count = nhr->nhr_OutItemCount))
{
nhiptr = nhr->nhr_OutItemMap;
if(nhiptr)
{
do
{
nhi = *nhiptr++;
obj = NULL;
nhgi = NULL;
if(nhi->nhi_Flags & RPF_MAIN_VARIABLE)
{
if(nhi->nhi_Flags & RPF_MAIN_RELATIVE)
{
if((nhi->nhi_LogicalMin == 0) && (nhi->nhi_LogicalMax == 1))
{
if((nhgi = nAllocGHCItem(nch, nhi, NULL, nhi->nhi_Usage)))
{
/* one shot */
obj = VGroup,
Child, (IPTR)VSpace(0),
Child, (IPTR)(nhgi->nhgi_GUIObj = TextObject, ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_CycleChain, 1,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_Text_PreParse, (IPTR)"\33c",
MUIA_Text_Contents, (IPTR)nhgi->nhgi_Name,
End),
Child, (IPTR)VSpace(0),
End;
nhgi->nhgi_ObjType = NHGIOT_SHOTBUTTON;
}
}
else if(nhi->nhi_LogicalMin < 0)
{
if((nhgi = nAllocGHCItem(nch, nhi, NULL, nhi->nhi_Usage)))
{
/* Horizontal slider */
obj = VGroup,
Child, (IPTR)VSpace(0),
Child, (IPTR)HGroup,
Child, (IPTR)Label((IPTR)nhgi->nhgi_Name),
Child, (IPTR)(nhgi->nhgi_GUIObj = SliderObject, SliderFrame,
MUIA_Slider_Horiz, TRUE,
MUIA_CycleChain, 1,
MUIA_InputMode, MUIV_InputMode_Immediate,
MUIA_Numeric_Min, nhi->nhi_LogicalMin,
MUIA_Numeric_Max, nhi->nhi_LogicalMax,
MUIA_Numeric_Value, nhi->nhi_OldValue,
End),
End,
Child, (IPTR)VSpace(0),
End;
nhgi->nhgi_ObjType = NHGIOT_SLIDERIMM;
}
} else {
if((nhgi = nAllocGHCItem(nch, nhi, NULL, nhi->nhi_Usage)))
{
/* Vertical slider */
obj = HGroup,
Child, (IPTR)HSpace(0),
Child, (IPTR)VGroup,
Child, (IPTR)(nhgi->nhgi_GUIObj = SliderObject, SliderFrame,
MUIA_Slider_Horiz, FALSE,
MUIA_CycleChain, 1,
MUIA_InputMode, MUIV_InputMode_Immediate,
MUIA_Numeric_Min, nhi->nhi_LogicalMin,
MUIA_Numeric_Max, nhi->nhi_LogicalMax,
MUIA_Numeric_Value, nhi->nhi_OldValue,
End),
Child, (IPTR)Label((IPTR)nhgi->nhgi_Name),
End,
Child, (IPTR)HSpace(0),
End;
nhgi->nhgi_ObjType = NHGIOT_SLIDERIMM;
}
}
} else {
if((nhi->nhi_LogicalMin == 0) && (nhi->nhi_LogicalMax == 1))
{
if((nhgi = nAllocGHCItem(nch, nhi, NULL, nhi->nhi_Usage)))
{
/* toggle button */
obj = VGroup,
Child, (IPTR)VSpace(0),
Child, (IPTR)(nhgi->nhgi_GUIObj = TextObject, ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_CycleChain, 1,
MUIA_InputMode, MUIV_InputMode_Toggle,
MUIA_Text_PreParse, (IPTR)"\33c",
MUIA_Text_Contents, (IPTR)nhgi->nhgi_Name,
End),
Child, (IPTR)VSpace(0),
End;
nhgi->nhgi_ObjType = NHGIOT_TOGGLEBUTTON;
}
}
else if(nhi->nhi_LogicalMin < 0)
{
if((nhgi = nAllocGHCItem(nch, nhi, NULL, nhi->nhi_Usage)))
{
/* Horizontal slider */
obj = VGroup,
Child, (IPTR)VSpace(0),
Child, (IPTR)HGroup,
Child, (IPTR)Label((IPTR)nhgi->nhgi_Name),
Child, (IPTR)(nhgi->nhgi_GUIObj = SliderObject, SliderFrame,
MUIA_Slider_Horiz, TRUE,
MUIA_CycleChain, 1,
MUIA_Numeric_Min, nhi->nhi_LogicalMin,
MUIA_Numeric_Max, nhi->nhi_LogicalMax,
MUIA_Numeric_Value, nhi->nhi_OldValue,
End),
End,
Child, (IPTR)VSpace(0),
End;
nhgi->nhgi_ObjType = NHGIOT_SLIDER;
}
} else {
if((nhgi = nAllocGHCItem(nch, nhi, NULL, nhi->nhi_Usage)))
{
/* Vertical slider */
obj = HGroup,
Child, (IPTR)HSpace(0),
Child, (IPTR)VGroup,
Child, (IPTR)(nhgi->nhgi_GUIObj = SliderObject, SliderFrame,
MUIA_Slider_Horiz, FALSE,
MUIA_CycleChain, 1,
MUIA_Numeric_Min, nhi->nhi_LogicalMin,
MUIA_Numeric_Max, nhi->nhi_LogicalMax,
MUIA_Numeric_Value, nhi->nhi_OldValue,
End),
Child, (IPTR)Label(nhgi->nhgi_Name),
End,
Child, (IPTR)HSpace(0),
End;
nhgi->nhgi_ObjType = NHGIOT_SLIDER;
}
}
}
}
if(obj)
{
DoMethod(nch->nch_HCGroupObj, OM_ADDMEMBER, obj);
switch(nhgi->nhgi_ObjType)
{
case NHGIOT_SHOTBUTTON:
DoMethod(nhgi->nhgi_GUIObj, MUIM_Notify, MUIA_Pressed, FALSE,
nch->nch_HCActionObj, 2, MUIM_Action_UpdateHIDCtrl, nhgi);
break;
case NHGIOT_TOGGLEBUTTON:
DoMethod(nhgi->nhgi_GUIObj, MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
nch->nch_HCActionObj, 2, MUIM_Action_UpdateHIDCtrl, nhgi);
break;
case NHGIOT_SLIDERIMM:
DoMethod(nhgi->nhgi_GUIObj, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
nch->nch_HCActionObj, 2, MUIM_Action_UpdateHIDCtrl, nhgi);
break;
case NHGIOT_SLIDER:
DoMethod(nhgi->nhgi_GUIObj, MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
nch->nch_HCActionObj, 2, MUIM_Action_UpdateHIDCtrl, nhgi);
break;
}
numobj++;
}
} while(--count);
}
}
nhr = (struct NepHidReport *) nhr->nhr_Node.ln_Succ;
}
if(!numobj)
{
DoMethod(nch->nch_HCGroupObj, OM_ADDMEMBER, Label("No output items in this interface!"));
}
}
DoMethod(nch->nch_HCMainWindow, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
nch->nch_HCActionObj, 1, MUIM_Action_HideHIDControl);
DoMethod(nch->nch_HCCloseObj, MUIM_Notify, MUIA_Pressed, FALSE,
nch->nch_HCActionObj, 1, MUIM_Action_HideHIDControl);
DoMethod(nch->nch_HCAboutMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
nch->nch_HCActionObj, 1, MUIM_Action_About);
DoMethod(nch->nch_HCCloseMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
nch->nch_HCActionObj, 1, MUIM_Action_HideHIDControl);
DoMethod(nch->nch_HCMUIPrefsMI, MUIM_Notify, MUIA_Menuitem_Trigger, MUIV_EveryTime,
nch->nch_HCApp, 2, MUIM_Application_OpenConfigWindow, 0);
{
IPTR isopen = 0;
IPTR iconify = 0;
ULONG sigs;
ULONG sigmask;
LONG retid;
if(nch->nch_CDC->cdc_HIDCtrlOpen)
{
get(nch->nch_HCApp, MUIA_Application_Iconified, &iconify);
set(nch->nch_HCMainWindow, MUIA_Window_Open, TRUE);
get(nch->nch_HCMainWindow, MUIA_Window_Open, &isopen);
if(!(isopen || iconify))
{
GM_UNIQUENAME(nHIDCtrlGUITaskCleanup)(nch);
return;
}
}
sigmask = 0;
do
{
retid = DoMethod(nch->nch_HCApp, MUIM_Application_NewInput, &sigs);
if(sigs)
{
sigs = Wait(sigs | sigmask | SIGBREAKF_CTRL_C);
if(sigs & SIGBREAKF_CTRL_C)
{
break;
}
}
} while(retid != MUIV_Application_ReturnID_Quit);
set(nch->nch_HCMainWindow, MUIA_Window_Open, FALSE);
}
GM_UNIQUENAME(nHIDCtrlGUITaskCleanup)(nch);
AROS_USERFUNC_EXIT
}
/**
* Refreshes the folder list. It should be called, whenever the folder list
* has been changed.
*/
void filter_update_folder_list(void)
{
DoMethod(filter_folder_list, MUIM_FolderTreelist_Refresh, NULL);
}
/**
* Removes the currently selected filter.
*/
static void filter_remove(void)
{
filter_last_selected = NULL;
DoMethod(filter_list, MUIM_NList_Remove, MUIV_NList_Remove_Active);
}
void EventLoop(void) {
ULONG signal = NULL, rc;
WORD code;
BOOL running = TRUE;
GetAttr( WINDOW_SigMask, WO_Window, &signal );
if(signal) {
do {
if(Wait(signal | SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C ) {
running=FALSE;
}
while (( rc = CA_HandleInput( WO_Window, &code)) != WMHI_LASTMSG) {
switch(rc & WMHI_CLASSMASK) {
case WMHI_CLOSEWINDOW:
running=FALSE;
break;
case WMHI_GADGETUP:
case WMHI_MENUPICK:
{
if((rc & WMHI_CLASSMASK) == WMHI_MENUPICK) {
struct MenuItem *mi;
mi = ItemAddress(Menu, rc & WMHI_MENUMASK);
if(mi) {
rc = (ULONG) GTMENUITEM_USERDATA(mi);
}
}
switch( rc & WMHI_GADGETMASK) {
#if 0
case ACTID_OPEN:
{
if(DoMethod( openreq, FRM_DOREQUEST ) == FRQ_OK) {
char *file = NULL;
GetAttr( FRQ_Path, openreq, (ULONG *) &file);
NewSettings(file);
GUINewSettings();
}
break;
}
case ACTID_SAVEAS:
{
FillUnit();
if(DoMethod( savereq, FRM_DOREQUEST ) == FRQ_OK) {
char *file = NULL;
GetAttr( FRQ_Path, savereq, (ULONG *) &file);
SaveSettings(file, UnitList);
if(SaveIcons) {
WriteIcon(file);
}
}
break;
}
#endif
case ACTID_ABOUT:
Req( (char *) msgButtonOK,
(char *) msgTextCopyright,
"",(char *) msgTextProgramName,
"1996-2003 Martin Blom" );
break;
case ACTID_SAVE:
FillUnit();
SaveSettings(ENVFILE, UnitList);
SaveSettings(ENVARCFILE, UnitList);
running=FALSE;
break;
case ACTID_USE:
FillUnit();
SaveSettings(ENVFILE, UnitList);
running=FALSE;
break;
case ACTID_QUIT:
running=FALSE;
break;
case ACTID_DEFAULT:
SetAttrs( WO_Window, WA_BusyPointer, TRUE, TAG_DONE);
NewSettings(NULL); // This is VERY slow!!
SetAttrs( WO_Window, WA_BusyPointer, FALSE, TAG_DONE);
GUINewSettings();
break;
case ACTID_LASTSAVED:
NewSettings(ENVARCFILE);
GUINewSettings();
break;
case ACTID_RESTORE:
NewSettings(args.from);
GUINewSettings();
break;
case ACTID_ICONS:
{
struct MenuItem *item;
item = FindMenuItem(ACTID_ICONS);
if(item) {
if(item->Flags & CHECKED)
SaveIcons = TRUE;
else
SaveIcons = FALSE;
}
break;
}
#if 0
case ACTID_HELP: {
APTR lock = BGUI_LockWindow(Window);
if(!BGUI_Help( Window, HELPFILE, "AHI", NULL)) {
Req( (char *) msgButtonOK, (char *) msgTextNoFind, HELPFILE);
}
BGUI_UnlockWindow(lock);
break;
}
case ACTID_GUIDE: {
APTR lock = BGUI_LockWindow(Window);
if(!BGUI_Help( Window, HELPFILE, NULL, NULL)) {
Req( (char *) msgButtonOK, (char *) msgTextNoFind, HELPFILE);
}
BGUI_UnlockWindow(lock);
break;
}
case ACTID_HELPINDEX: {
APTR lock = BGUI_LockWindow(Window);
if(!BGUI_Help( Window, HELPFILE, "Concept Index", 0)) {
Req( (char *) msgButtonOK, (char *) msgTextNoFind, HELPFILE);
}
BGUI_UnlockWindow(lock);
break;
}
#endif
case ACTID_UNIT: {
FillUnit();
NewUnit(code);
GUINewUnit();
break;
}
case ACTID_MODE: {
FillUnit();
NewMode(code);
GUINewMode();
break;
}
case ACTID_DEBUG:
case ACTID_SURROUND:
case ACTID_ECHO:
case ACTID_CPULIMIT:
case ACTID_CLIPMV:
{
ULONG debug = AHI_DEBUG_NONE, surround = FALSE, echo = 0, cpu = 90;
ULONG clip = FALSE;
GetAttr( CHOOSER_Active, Window_Objs[ACTID_DEBUG], &debug);
GetAttr( CHOOSER_Active, Window_Objs[ACTID_SURROUND], &surround);
GetAttr( CHOOSER_Active, Window_Objs[ACTID_ECHO], &echo);
GetAttr( CHOOSER_Active, Window_Objs[ACTID_CLIPMV], &clip);
GetAttr( INTEGER_Number, Window_Objs[ACTID_CPULIMIT], &cpu);
globalprefs.ahigp_DebugLevel = debug;
globalprefs.ahigp_DisableSurround = surround;
globalprefs.ahigp_DisableEcho = (echo == 2);
globalprefs.ahigp_FastEcho = (echo == 1);
globalprefs.ahigp_MaxCPU = (cpu << 16) / 100;
globalprefs.ahigp_ClipMasterVolume= clip;
break;
}
} /* switch(GADGETMASK) */
}
} /* switch(CLASSMASK) */
} /* HandleInput */
} while(running);
}
}
int main(void)
{
Object *application, *window, *b1, *b2, *b3;
application = ApplicationObject,
SubWindow, window = WindowObject,
MUIA_Window_Title, (IPTR) "Hide & Show",
MUIA_Window_Activate, TRUE,
WindowContents, (IPTR) VGroup,
Child, (IPTR) HGroup,
Child, (IPTR) SimpleButton("Visible all the time"),
Child, (IPTR) (b1 = ImageButton("Click Hide or Show", "THEME:Images/Gadgets/Prefs/Test")),
Child, (IPTR) SimpleButton("Visible all the time too"),
End,
Child, (IPTR) HGroup,
Child, (IPTR) (b2 = SimpleButton("Hide")),
Child, (IPTR) (b3 = SimpleButton("Show")),
End,
End,
End,
End;
if (application)
{
ULONG sigs = 0;
DoMethod
(
window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
(IPTR) application, 2, MUIM_Application_ReturnID,
MUIV_Application_ReturnID_Quit
);
DoMethod
(
b2, MUIM_Notify, MUIA_Pressed, FALSE,
(IPTR) b1, 3, MUIM_Set, MUIA_ShowMe, FALSE
);
DoMethod
(
b3, MUIM_Notify, MUIA_Pressed, FALSE,
(IPTR) b1, 3, MUIM_Set, MUIA_ShowMe, TRUE
);
set(window,MUIA_Window_Open,TRUE);
while
(
DoMethod
(
application, MUIM_Application_NewInput, (IPTR) &sigs
) != MUIV_Application_ReturnID_Quit
)
{
if (sigs)
{
sigs = Wait(sigs | SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D);
if (sigs & SIGBREAKF_CTRL_C) break;
if (sigs & SIGBREAKF_CTRL_D) break;
}
}
MUI_DisposeObject(application);
}
return 0;
}
void main (int argc, char *argv[])
{
ULONG State = 0;
MUI_PenSpec ps[2];
Object *pp, *CT1, *CT2, *Win, *App, *vg, *b1, *CT3;
static STRPTR Lines1[] = {
"Foo bar test",
"dummy test " CTxtFont("times/24") "gqah de absoflipping" CTxtFont("") " blah",
"now is the time\n\n",
"for " CTxtFont("courier/15/U") "all" CTxtFont("//I") " good men "
CTxtFont("") "to come" CTxtFont("") " to the aid",
"(of their country)",
NULL,
};
static STRPTR Lines2 =
"This\tis lines 2 test\n"
"It's plain\t\t and boring.\n"
"But sometimes that's ok for\n"
"just testing purposes, eh?\n";
static STRPTR Lines3[] = {
CTxtFont("topaz/8")CTxtFont("courier/15/U") "BBB"
CTxtFont("//I") " CCCC ",
"Nonterm " CTxtFont("times/24") "gqah de absoflipping" CTxtFont("") " blah",
NULL,
};
static STRPTR Lines4[] = {
"wefwef " CTxtFont("") "boofar fwfw " CTxtFont("") "wefwfww",
NULL,
};
if (!(pp = PendisplayObject, End)) exit(0);
DoMethod(pp,MUIM_Pendisplay_SetMUIPen,MPEN_SHINE);
get(pp, MUIA_Pendisplay_Spec, &ps[0]);
DoMethod(pp,MUIM_Pendisplay_SetMUIPen,MPEN_HALFSHADOW);
get(pp, MUIA_Pendisplay_Spec, &ps[1]);
sprintf(Buff,
"abc\ndef \\033CV{%08lx}this\\033CV{} is a test\nghi\nwfwf\nawf\n",
&ps[0]);
App = ApplicationObject,
MUIA_Application_Title, "CText Test",
SubWindow, Win = WindowObject,
MUIA_Window_ID, 2,
WindowContents, VGroup,
Child, b1 = SimpleButton("Howdy"),
Child, ScrollgroupObject,
MUIA_Scrollgroup_Contents, vg = VirtgroupObject,
VirtualFrame,
MUIA_Group_Horiz, FALSE,
MUIA_Background, MUII_TextBack,
MUIA_Group_Spacing, 0,
MUIA_UserData, SWV_CText_ClickGrpRoot,
Child, CT1 = CTextObject,
MUIA_VertWeight, 1,
SWA_CText_Lines, Lines1,
End,
Child, CT2 = CTextObject,
MUIA_VertWeight, 1,
SWA_CText_PrevCText, CT1,
SWA_CText_Contents, Lines2,
End,
Child, CTextObject,
MUIA_VertWeight, 1,
SWA_CText_Contents, Buff,
End,
Child, CT3 = CTextObject,
MUIA_VertWeight, 1,
SWA_CText_Lines, Lines3,
End,
Child, CTextObject,
MUIA_VertWeight, 1,
SWA_CText_PrevCText, CT3,
SWA_CText_Lines, Lines4,
End,
Child, RectangleObject,
MUIA_VertWeight, 1000,
End,
End,
End,
End,
End,
End;
if (!App) exit(0);
DoMethod(Win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, App, 2,
MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
DoMethod(vg, SWM_ListSearch_Setup, &State);
DoMethod(b1, MUIM_Notify, MUIA_Pressed, FALSE,
vg, 1, SWM_CText_SelAll);
set(Win, MUIA_Window_Open, TRUE);
DoMethod(vg, MUIM_List_Jump, 10);
SWEventLoop(App, Win, NULL, TRUE);
DoMethod(CT1, SWM_CText_Clip);
MUI_DisposeObject(App);
MUI_DisposeObject(pp);
}
LONG PrintLine(LONG x, struct line_node *line, LONG line_nr, BOOL doublebuffer, struct InstData *data)
{
STRPTR text = line->line.Contents;
LONG length;
struct RastPort *rp = &data->doublerp;
ENTER();
length = LineCharsWidth(text+x, data);
if(doublebuffer == FALSE)
rp = &data->copyrp;
if((line_nr > 0) && (data->update) && !(data->flags & FLG_Quiet) && data->rport != NULL && data->shown == TRUE)
{
LONG c_length = length;
LONG startx = 0, stopx = 0;
LONG starty = 0, xoffset = ((data->height-rp->TxBaseline+1)>>1)+1;
LONG flow = 0;
UWORD *styles = line->line.Styles;
UWORD *colors = line->line.Colors;
struct marking block;
BOOL cursor = FALSE;
if(line->line.Color && x == 0 && line->line.Length == 1)
line->line.Color = FALSE;
if(doublebuffer == FALSE)
{
starty = data->ypos+(data->height * (line_nr-1));
xoffset = data->xpos;
}
flow = FlowSpace(line->line.Flow, text+x, data);
Move(rp, xoffset+flow, starty+rp->TxBaseline);
if(Enabled(data))
{
struct line_node *blkline;
NiceBlock(&data->blockinfo, &block);
blkline = block.startline->next;
if(block.startline == block.stopline)
{
if(block.startline == line)
{
startx = block.startx;
stopx = block.stopx;
}
}
else
{
if(block.startline == line)
{
startx = block.startx;
stopx = line->line.Length;
}
else
{
if(block.stopline == line)
{
stopx = block.stopx;
}
else
{
while((blkline != block.stopline) && (!stopx))
{
if(blkline == line)
{
stopx = line->line.Length;
}
blkline = blkline->next;
}
}
}
}
}
{
UWORD blockstart = 0;
UWORD blockwidth = 0;
struct RastPort *old = muiRenderInfo(data->object)->mri_RastPort;
if(startx < x+c_length && stopx > x)
{
if(startx > x)
blockstart = TextLength(&data->tmprp, text+x, startx-x);
else
startx = x;
blockwidth = ((stopx >= c_length+x) ? data->innerwidth-(blockstart+flow) : TextLength(&data->tmprp, text+startx, stopx-startx));
}
else if(!(data->flags & (FLG_ReadOnly | FLG_Ghosted)) &&
line == data->actualline && data->CPos_X >= x &&
data->CPos_X < x+c_length && !Enabled(data) &&
(data->flags & FLG_Active || data->inactiveCursor == TRUE))
{
cursor = TRUE;
blockstart = TextLength(&data->tmprp, text+x, data->CPos_X-x);
// calculate the cursor width
// if it is set to 6 then we should find out how the width of the current char is
if(data->CursorWidth == 6)
blockwidth = TextLength(&data->tmprp, (*(text+data->CPos_X) < ' ') ? (char *)" " : (char *)(text+data->CPos_X), 1);
else
blockwidth = data->CursorWidth;
}
SetDrMd(rp, JAM1);
muiRenderInfo(data->object)->mri_RastPort = rp;
// clear the background first
DoMethod(data->object, MUIM_DrawBackground, xoffset, starty,
flow+blockstart, data->height,
(data->flags & FLG_InVGrp) ? 0 : data->xpos,
(data->flags & FLG_InVGrp) ? data->height*(data->visual_y+line_nr-2) : data->realypos+data->height * (data->visual_y+line_nr-2),
0);
if(blockwidth)
{
ULONG color;
// in case the gadget is in inactive state we use a different background
// color for our selected area
if((data->flags & FLG_Active) == 0 && (data->flags & FLG_Activated) == 0 &&
(data->flags & FLG_ActiveOnClick) != 0)
{
color = data->inactivecolor;
}
else
color = data->markedcolor;
// if selectmode == 2 then a whole line should be drawn as being marked, so
// we have to start at xoffset instead of xoffset+flow+blockstart.
// Please note that the second part of the following "empiric" evaluation should
// prevent that centered or right aligned lines are not correctly marked right
// from the beginning of the line. However, it seems to be not cover 100% of all different
// cases so that the evaluation if a line should be completely marked should be probably
// moved elsewhere in future.
if(data->selectmode == 2 ||
(flow && data->selectmode != 1 && startx-x == 0 && cursor == FALSE &&
((data->blockinfo.startline != data->blockinfo.stopline) || x > 0)))
{
SetAPen(rp, color);
RectFill(rp, xoffset, starty, xoffset+flow+blockwidth-1, starty+data->height-1);
}
else
{
SetAPen(rp, cursor ? data->cursorcolor : color);
RectFill(rp, xoffset+flow+blockstart, starty, xoffset+flow+blockstart+blockwidth-1, starty+data->height-1);
// if the gadget is in inactive state we just draw a skeleton cursor instead
if(cursor == TRUE &&
(data->flags & FLG_Active) == 0 && (data->flags & FLG_Activated) == 0)
{
DoMethod(data->object, MUIM_DrawBackground, xoffset+flow+blockstart+1, starty+1,
blockwidth-2, data->height-2,
(data->flags & FLG_InVGrp) ? 0 : data->xpos,
(data->flags & FLG_InVGrp) ? data->height*(data->visual_y+line_nr-2) : data->realypos+data->height * (data->visual_y+line_nr-2),
0);
}
}
}
{
LONG x_start = xoffset+blockstart+blockwidth,
y_start = starty,
x_width = data->innerwidth-(blockstart+blockwidth),
y_width = data->height,
x_ptrn = blockstart+blockwidth,
y_ptrn = data->height*(data->visual_y+line_nr-2);
if(blockwidth)
{
x_start += flow;
x_width -= flow;
x_ptrn += flow;
}
if(!(data->flags & FLG_InVGrp))
{
x_ptrn += data->xpos;
y_ptrn += data->realypos;
}
DoMethod(data->object, MUIM_DrawBackground, x_start, y_start, x_width, y_width, x_ptrn, y_ptrn);
}
muiRenderInfo(data->object)->mri_RastPort = old;
}
if(doublebuffer == FALSE)
AddClipping(data);
SetAPen(rp, (line->line.Color ? data->highlightcolor : data->textcolor));
while(c_length)
{
LONG p_length = c_length;
SetSoftStyle(rp, convert(GetStyle(x, line)), AskSoftStyle(rp));
if(styles)
{
while(*styles-1 <= x)
{
styles += 2;
}
if(*styles-x-1 < p_length)
{
p_length = *styles-x-1;
}
}
if(colors)
{
while(*colors-1 <= x)
{
SetAPen(rp, ConvertPen(*(colors+1), line->line.Color, data));
colors += 2;
}
if(*colors-x-1 < p_length)
{
p_length = *colors-x-1;
}
}
/* if(stopx)
{
if((startx > x) && (startx-x < p_length))
{
p_length = startx-x;
SetAPen(rp, 3);
}
else
{
if((stopx > x) && (stopx-x < p_length))
{
p_length = stopx-x;
SetAPen(rp, 4);
}
else
SetAPen(rp, (line->color ? data->highlightcolor : data->textcolor));
}
}
*/
if(text[x+p_length-1] < ' ')
Text(rp, text+x, p_length-1);
else
Text(rp, text+x, p_length);
x += p_length;
c_length -= p_length;
}
SetSoftStyle(rp, FS_NORMAL, AskSoftStyle(rp));
if(line->line.Separator)
{
WORD LeftX, LeftWidth,
RightX, RightWidth,
Y, Height;
LeftX = xoffset;
LeftWidth = flow-3;
RightX = rp->cp_x+3;
RightWidth = xoffset+data->innerwidth - RightX;
Y = starty;
Height = (line->line.Separator & LNSF_Thick) ? 2 : 1;
if(line->line.Separator & LNSF_Middle)
Y += (data->height/2)-Height;
else
{
if(line->line.Separator & LNSF_Bottom)
Y += data->height-(2*Height);
}
if(line->line.Separator & LNSF_StrikeThru || line->line.Length == 1)
{
LeftWidth = data->innerwidth;
}
else
{
DrawSeparator(rp, RightX, Y, RightWidth, Height, data);
}
DrawSeparator(rp, LeftX, Y, LeftWidth, Height, data);
}
if(data->flags & FLG_Ghosted)
{
UWORD *oldPattern = (UWORD *)rp->AreaPtrn;
UBYTE oldSize = rp->AreaPtSz;
UWORD newPattern[] = {0x1111, 0x4444};
if(doublebuffer == TRUE)
{
ULONG ptrn1 = 0x11111111;
ULONG ptrn2 = 0x44444444;
ptrn1 = ptrn1>>((data->xpos-xoffset)%16);
ptrn2 = ptrn2>>((data->xpos-xoffset)%16);
if((data->height*(data->visual_y+line_nr-2))%2 == 0)
{
newPattern[0] = ptrn2;
newPattern[1] = ptrn1;
}
else
{
newPattern[0] = ptrn1;
newPattern[1] = ptrn2;
}
}
Object *CreatePrefs(struct Toolbar_DataP *data)
{
Object **objs = data->Gadgets;
Object *textgroup, *imagegroup;
Object *prefsgroup;
static STRPTR LookStrings[4];
static STRPTR BorderTypeStrings[4];
static STRPTR SelectionModeStrings[4];
static STRPTR PrecisionStrings[5];
static STRPTR GhostEffectStrings[5];
BorderTypeStrings[0] = LOCALE(MSG_BORDERTYPE_OLD, "Old");
BorderTypeStrings[1] = LOCALE(MSG_BORDERTYPE_OFF, "Off");
BorderTypeStrings[2] = LOCALE(MSG_BORDERTYPE_NEW, "New");
BorderTypeStrings[3] = NULL;
SelectionModeStrings[0] = LOCALE(MSG_SELECTIONMODE_OLD, "Old");
SelectionModeStrings[1] = LOCALE(MSG_SELECTIONMODE_OFF, "Off");
SelectionModeStrings[2] = LOCALE(MSG_SELECTIONMODE_NEW, "New");
SelectionModeStrings[3] = NULL;
LookStrings[0] = LOCALE(MSG_IMAGETEXT, "Image and Text");
LookStrings[1] = LOCALE(MSG_IMAGEONLY, "Image only");
LookStrings[2] = LOCALE(MSG_TEXTONLY, "Text only");
LookStrings[3] = NULL;
PrecisionStrings[0] = LOCALE(MSG_EXACT, "Exact");
PrecisionStrings[1] = LOCALE(MSG_IMAGE, "Image");
PrecisionStrings[2] = LOCALE(MSG_ICON, "Icon");
PrecisionStrings[3] = LOCALE(MSG_GUI, "GUI");
PrecisionStrings[4] = NULL;
// GhostEffectStrings[0] = LOCALE(MSG_DIMMMED, "Dimmed"); // Temporarily disabled - remember +-1
GhostEffectStrings[0] = LOCALE(MSG_LIGHT, "Light Grid");
GhostEffectStrings[1] = LOCALE(MSG_HEAVY, "Heavy Grid");
GhostEffectStrings[2] = LOCALE(MSG_SUPERLIGHT, "Superlight Grid");
GhostEffectStrings[3] = NULL;
prefsgroup =
VGroup,
Child, VGroup,
Child, HGroup,
// MUIA_Group_SameWidth, TRUE,
/********************************* General *********************************/
Child, HGroup,
MUIA_Background, MUII_GroupBack,
MUIA_Frame , MUIV_Frame_Group,
MUIA_FrameTitle, LOCALE(MSG_GENERAL, "General"),
Child, RectangleObject, End,
Child, VGroup,
Child, RectangleObject, End,
Child, objs[Look] = RadioObject,
// MUIA_FrameTitle, "Toolbar look",
MUIA_Radio_Entries, LookStrings,
End,
Child, RectangleObject, End,
End,
//ghosttype
Child, RectangleObject, End,
End,
/********************************* Image *********************************/
Child, imagegroup = HGroup,
MUIA_Background, MUII_GroupBack,
MUIA_Frame , MUIV_Frame_Group,
MUIA_FrameTitle, LOCALE(MSG_IMAGE, "Image"),
Child, RectangleObject, End,
Child, VGroup,
Child, RectangleObject, End,
Child, HGroup,
Child, RectangleObject, End,
Child, VGroup,
Child, Label(LOCALE(MSG_USEIMAGES1, "\33cUse ghosted/selected images")),
// Child, MUI_MakeObject(MUIO_Label, LOCALE(MSG_USEIMAGES2, "\33c(if they are available)"), MUIO_Label_Tiny),
Child, TextObject,
MUIA_Text_Contents, LOCALE(MSG_USEIMAGES2, "\33c(if they are available)"),
MUIA_Font, MUIV_Font_Tiny,
End,
End,
Child, objs[UseImages] = CheckMark(TRUE),
// Child, RectangleObject, End,
End,
Child, ColGroup(2),
// Child, HGroup,
Child, Label(LOCALE(MSG_REMAP, "Remap Precision")),
Child, objs[Precision] = Cycle(PrecisionStrings),
// End,
// Child, HGroup,
Child, Label(LOCALE(MSG_GHOSTEFFECT, "Ghosting effect")),
Child, objs[GhostEffect] = Cycle(GhostEffectStrings),
// End,
End,
Child, RectangleObject, End,
End,
Child, RectangleObject, End,
End,
End,
/********************************* Spacing *********************************/
Child, HGroup,
Child, HGroup,
MUIA_Background, MUII_GroupBack,
MUIA_Frame , MUIV_Frame_Group,
MUIA_FrameTitle, LOCALE(MSG_SPACING, "Spacing"),
Child, VGroup,
Child, RectangleObject, End,
Child, ColGroup(2),
Child, Label(LOCALE(MSG_GROUPSPACE, "Group Space")),
Child, objs[GroupSpace] = SliderObject,
MUIA_Slider_Min, -1,
MUIA_Slider_Max, 50,
End,
Child, Label(LOCALE(MSG_TOOLSPACE, "Tool Space")),
Child, objs[ToolSpace] = SliderObject,
MUIA_Slider_Min, -1,
MUIA_Slider_Max, 10,
End,
Child, VGroup,
Child, Label(LOCALE(MSG_INNERSPACE, "\33cInner Space")),
// Child, MUI_MakeObject(MUIO_Label,LOCALE(MSG_INNERSPACE_WITH, "\33c(with tooltext)"), MUIO_Label_Tiny),
Child, TextObject,
MUIA_Text_Contents, LOCALE(MSG_INNERSPACE_WITH, "\33c(with tooltext)"),
MUIA_Font, MUIV_Font_Tiny,
End,
End,
Child, objs[InnerSpace_Text] = SliderObject,
MUIA_Slider_Min, 0,
MUIA_Slider_Max, 10,
End,
Child, VGroup,
Child, Label(LOCALE(MSG_INNERSPACE, "\33cInner Space")),
// Child, MUI_MakeObject(MUIO_Label,LOCALE(MSG_INNERSPACE_WITHOUT, "\33c(without tooltext)"), MUIO_Label_Tiny),
Child, TextObject,
MUIA_Text_Contents, LOCALE(MSG_INNERSPACE_WITHOUT, "\33c(without tooltext)"),
MUIA_Font, MUIV_Font_Tiny,
End,
End,
Child, objs[InnerSpace_NoText] = SliderObject,
MUIA_Slider_Min, 0,
MUIA_Slider_Max, 10,
MUIA_Disabled, TRUE,
End,
// some kind of relative mode
// width: fixed/floating
End,
Child, RectangleObject, End,
End,
End,
/********************************* Text *********************************/
Child, textgroup = HGroup,
MUIA_Background, MUII_GroupBack,
MUIA_Frame , MUIV_Frame_Group,
MUIA_FrameTitle, LOCALE(MSG_TEXT, "Text"),
Child, VGroup,
Child, RectangleObject, End,
/* Child, HGroup,
Child, RectangleObject, End,
Child, Label(LOCALE(MSG_PLACEMENT, "Placement")),
Child, data->CY_Placement = Cycle(CY_textplacement),
// Child, RectangleObject, End,
End,
*/ Child, ColGroup(2),
// Child, VGroup,
Child, Label(LOCALE(MSG_COLOR, "Text Color")),
// End,
// Child, VGroup,
Child, objs[ToolPen] = PoppenObject,
MUIA_Window_Title, LOCALE(MSG_ADJUST, "Adjust Text Color"),
MUIA_Draggable, TRUE,
MUIA_ShortHelp, LOCALE(MSG_COLOR_HELP, "Color of the tool texts."),
End,
Child, Label2(LOCALE(MSG_FONT, "Text Font")),
Child, data->FontASL = PopaslObject,
MUIA_Popstring_String, objs[ToolFont] = String(0,35),
MUIA_Popstring_Button, PopButton(MUII_PopUp),
MUIA_Popasl_Type , ASL_FontRequest,
ASLFO_TitleText , LOCALE(MSG_SELECT, "Please select a text font..."),
End,
// End,
End,
Child, RectangleObject, End,
End,
End,
End,
// Sløringseffekt: Normal, 3D, ...
End,
/*
Child, HGroup,
Child, HGroup,
MUIA_Background, MUII_GroupBack,
MUIA_Frame , MUIV_Frame_Group,
MUIA_FrameTitle, LOCALE(MSG_BORDERTYPE, "Border Type"),
InnerSpacing(12, 12),
Child, objs[BorderType] = Cycle(BorderTypeStrings),
End,
Child, VGroup,
MUIA_Background, MUII_GroupBack,
MUIA_Frame , MUIV_Frame_Group,
MUIA_FrameTitle, LOCALE(MSG_SELECTIONMODE, "Selection Border"),
InnerSpacing(12, 12),
Child, objs[SelectionMode] = Cycle(SelectionModeStrings),
Child, HGroup,
Child, Label2(LOCALE(MSG_AUTOACTIVE, "Show Active on Mousehi")),
Child, objs[AutoActive] = CheckMark(TRUE),
End,
End,
End,
*/
Child, HGroup,
Child, HGroup,
MUIA_Background, MUII_GroupBack,
MUIA_Frame , MUIV_Frame_Group,
MUIA_FrameTitle, LOCALE(MSG_BORDERTYPE, "Border Type"),
Child, RectangleObject, End,
Child, VGroup,
Child, RectangleObject, End,
Child, objs[BorderType] = Cycle(BorderTypeStrings),
Child, RectangleObject, End,
End,
Child, RectangleObject, End,
End,
Child, HGroup,
MUIA_Background, MUII_GroupBack,
MUIA_Frame , MUIV_Frame_Group,
MUIA_FrameTitle, LOCALE(MSG_SELECTIONMODE, "Selection Border"),
Child, RectangleObject, End,
Child, VGroup,
Child, RectangleObject, End,
MUIA_Weight, 200,
Child, objs[SelectionMode] = Cycle(SelectionModeStrings),
Child, HGroup,
Child, Label2(LOCALE(MSG_AUTOACTIVE, "Show Active on Mousehit")),
Child, objs[AutoActive] = CheckMark(TRUE),
End,
Child, RectangleObject, End,
End,
Child, RectangleObject, End,
End,
End,
Child, TextObject,
TextFrame,
MUIA_Background, MUII_TextBack,
MUIA_FixHeightTxt, "\n\n",
MUIA_Text_Contents, ABOUTTEXT,
End,
End;
if(prefsgroup)
{
DoMethod(objs[Look], MUIM_Notify, MUIA_Radio_Active, 0, textgroup, 6, MUIM_MultiSet, MUIA_Disabled, FALSE, textgroup, imagegroup, objs[InnerSpace_Text]);
DoMethod(objs[Look], MUIM_Notify, MUIA_Radio_Active, 1, textgroup, 5, MUIM_MultiSet, MUIA_Disabled, TRUE, textgroup, objs[InnerSpace_Text]);
DoMethod(objs[Look], MUIM_Notify, MUIA_Radio_Active, 2, textgroup, 5, MUIM_MultiSet, MUIA_Disabled, FALSE, textgroup, objs[InnerSpace_Text]);
DoMethod(objs[Look], MUIM_Notify, MUIA_Radio_Active, 0, objs[InnerSpace_NoText], 3, MUIM_Set, MUIA_Disabled, TRUE);
DoMethod(objs[Look], MUIM_Notify, MUIA_Radio_Active, 1, imagegroup, 5, MUIM_MultiSet, MUIA_Disabled, FALSE, imagegroup, objs[InnerSpace_NoText]);
DoMethod(objs[Look], MUIM_Notify, MUIA_Radio_Active, 2, imagegroup, 5, MUIM_MultiSet, MUIA_Disabled, TRUE, imagegroup, objs[InnerSpace_NoText]);
}
return prefsgroup;
}
int main (int argc, char **argv)
{
Object *app;
Object *mainWin;
g_print("use '--gdk-debug all --sync' to debug events\n");
/*
* Zune needed this new call, for underlying libs.
*/
MUI_Init(&argc, &argv);
/*
* This big call uses macros from mui.h
* You may also create intermediate objects.
* Usually you will only create one window, which will be
* an instance of a custom Window subclass (remember to use
* subclasses as much as possible !)
*/
app = ApplicationObject,
MUIA_Application_Author, "Reez",
MUIA_Application_Title, "Application1",
MUIA_Application_Description, "A very simple test program",
SubWindow, mainWin = WindowObject,
MUIA_Window_Title, "My first MUI app !",
WindowContents, VGroup,
Child, HGroup,
Child, RectangleObject,
MUIA_Background, MUII_ButtonBack,
MUIA_Frame, MUIV_Frame_Button,
MUIA_Weight, 60,
MUIA_InnerLeft, 10,
MUIA_InnerRight, 10,
MUIA_InnerTop, 10,
MUIA_InnerBottom, 10,
/* MUIA_FixWidth, 30, */
End,
Child, RectangleObject,
MUIA_Background, MUII_FILL,
MUIA_Frame, MUIV_Frame_Button,
MUIA_FixWidth, 42,
End,
Child, RectangleObject,
MUIA_Background, MUII_FILLSHINE,
MUIA_Frame, MUIV_Frame_Button,
MUIA_Weight, 40,
End,
End,
Child, HGroup,
Child, RectangleObject,
MUIA_Background, MUII_SHADOWBACK,
MUIA_Frame, MUIV_Frame_Button,
MUIA_FixHeight, 30,
End,
Child, RectangleObject,
MUIA_Background, MUII_TextBack,
MUIA_Frame, MUIV_Frame_Button,
End,
End,
Child, HGroup,
MUIA_Weight, 50,
Child, RectangleObject,
MUIA_Background, MUII_FILLSHINE,
MUIA_Frame, MUIV_Frame_Button,
/* MUIA_FixWidth, 30, */
End,
Child, RectangleObject,
MUIA_Background, MUII_FILLBACK,
MUIA_Frame, MUIV_Frame_Button,
MUIA_Weight, 50,
End,
End,
End,
End,
End;
if (!app)
g_error("can't create application object.\n");
g_print("created Application object %p\n", app);
DoMethod(mainWin, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
/*
* 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");
}
/*
** This is the ideal input loop for an object oriented MUI application.
** Everything is encapsulated in classes, no return ids need to be used,
** we just check if the program shall terminate.
** Note that MUIM_Application_NewInput expects sigs to contain the result
** from Wait() (or 0). This makes the input loop significantly faster.
*/
{
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;
}
/// MimeTypeListOpenHook
// Sets the popup listview accordingly to the string gadget
HOOKPROTO(MimeTypeListOpenFunc, BOOL, Object *listview, Object *str)
{
BOOL isConfigWindow = (BOOL)(hook->h_Data != NULL);
char *s;
Object *list;
ENTER();
if((s = (char *)xget(str, MUIA_String_Contents)) != NULL &&
(list = (Object *)xget(listview, MUIA_Listview_List)) != NULL)
{
int i;
// we build the list totally from ground up.
DoMethod(list, MUIM_List_Clear);
// populate the list with the user's own defined MIME types but only if the source
// string isn't the one in the YAM config window.
if(isConfigWindow == FALSE)
{
struct MimeTypeNode *mt;
IterateList(&C->mimeTypeList, struct MimeTypeNode *, mt)
{
DoMethod(list, MUIM_List_InsertSingle, mt->ContentType, MUIV_List_Insert_Sorted);
}
}
// populate the MUI list with our internal MIME types but check that
// we don't add duplicate names
for(i=0; IntMimeTypeArray[i].ContentType != NULL; i++)
{
BOOL duplicateFound = FALSE;
if(isConfigWindow == FALSE)
{
struct MimeTypeNode *mt;
IterateList(&C->mimeTypeList, struct MimeTypeNode *, mt)
{
if(strcasecmp(mt->ContentType, IntMimeTypeArray[i].ContentType) == 0)
{
duplicateFound = TRUE;
break;
}
}
}
if(duplicateFound == FALSE)
DoMethod(list, MUIM_List_InsertSingle, IntMimeTypeArray[i].ContentType, MUIV_List_Insert_Sorted);
}
// make sure to make the current entry active
for(i=0;;i++)
{
char *c;
DoMethod(list, MUIM_List_GetEntry, i, &c);
if(c == NULL || s[0] == '\0')
{
set(list, MUIA_List_Active, MUIV_List_Active_Off);
break;
}
else if(strcasecmp(c, s) == 0)
{
set(list, MUIA_List_Active, i);
break;
}
}
}
IPTR Pendisplay__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Pendisplay_DATA *data;
const struct TagItem *tags;
struct TagItem *tag;
BOOL newcol = FALSE;
IPTR retval;
data = INST_DATA(cl, obj);
for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Pendisplay_Reference:
if (data->refobj)
{
DoMethod(data->refobj, MUIM_KillNotifyObj, MUIA_Pendisplay_Spec, (IPTR)obj);
}
data->refobj = (Object *)tag->ti_Data;
if (data->refobj)
{
DoMethod(data->refobj, MUIM_Notify, MUIA_Pendisplay_Spec, MUIV_EveryTime,
(IPTR)obj, 3, MUIM_Set, MUIA_Pendisplay_Spec, MUIV_TriggerValue);
}
newcol = TRUE;
break;
case MUIA_Pendisplay_RGBcolor:
{
struct MUI_RGBcolor *rgb = (struct MUI_RGBcolor *)tag->ti_Data;
snprintf(data->penspec.ps_buf, sizeof(data->penspec.ps_buf),
"%lc%08lx,%08lx,%08lx", (LONG)PST_RGB, rgb->red, rgb->green, rgb->blue);
}
newcol = TRUE;
break;
case MUIA_Pendisplay_Spec:
if (tag->ti_Data)
{
data->penspec = *(struct MUI_PenSpec *)tag->ti_Data;
newcol = TRUE;
}
break;
}
}
retval = DoSuperMethodA(cl, obj, (Msg)msg);
if (newcol && (_flags(obj) & MADF_SETUP))
{
if (data->pen != -1)
{
MUI_ReleasePen(muiRenderInfo(obj), data->pen);
data->pen = -1;
}
if (!data->refobj)
{
data->pen = MUI_ObtainPen(muiRenderInfo(obj), &data->penspec, 0);
}
MUI_Redraw(obj, MADF_DRAWUPDATE);
}
return retval;
}
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;
}
static APTR build_gui(void)
{
APTR app, ui, mode, start_server, connect_to, disconnect, cancel, bind_server;
app = mui_get_app();
ui = GroupObject,
Child, mode = StringObject,
MUIA_Frame, MUIV_Frame_String,
MUIA_FrameTitle, translate_text(IDS_CURRENT_MODE),
End,
Child, GroupObject,
MUIA_Frame, MUIV_Frame_Group,
MUIA_Group_Horiz, TRUE,
Child, ui_to_from[0].object = StringObject,
MUIA_Frame, MUIV_Frame_String,
MUIA_FrameTitle, translate_text(IDS_TCP_PORT),
MUIA_String_Accept, "0123456789",
MUIA_String_MaxLen, 5+1,
End,
Child, start_server = TextObject,
ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_Text_Contents, translate_text(IDS_START_SERVER),
MUIA_Text_PreParse, "\033c",
MUIA_InputMode, MUIV_InputMode_RelVerify,
End,
End,
Child, GroupObject,
MUIA_Frame, MUIV_Frame_Group,
MUIA_Group_Horiz, TRUE,
Child, bind_server = TextObject,
ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_Text_Contents, translate_text(IDS_SERVER_BIND),
MUIA_Text_PreParse, "\033c",
MUIA_InputMode, MUIV_InputMode_RelVerify,
End,
Child, ui_to_from[1].object = StringObject,
MUIA_Frame, MUIV_Frame_String,
MUIA_String_Accept, ".0123456789",
MUIA_String_MaxLen, 15+1,
End,
End,
Child, GroupObject,
MUIA_Frame, MUIV_Frame_Group,
MUIA_Group_Horiz, TRUE,
Child, connect_to = TextObject,
ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_Text_Contents, translate_text(IDS_CONNECT_TO),
MUIA_Text_PreParse, "\033c",
MUIA_InputMode, MUIV_InputMode_RelVerify,
End,
Child, ui_to_from[2].object = StringObject,
MUIA_Frame, MUIV_Frame_String,
MUIA_String_Accept, ".0123456789",
MUIA_String_MaxLen, 15+1,
End,
End,
Child, GroupObject,
MUIA_Frame, MUIV_Frame_Group,
MUIA_Group_Horiz, TRUE,
Child, disconnect = TextObject,
ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_Text_Contents, translate_text(IDS_DISCONNECT),
MUIA_Text_PreParse, "\033c",
MUIA_InputMode, MUIV_InputMode_RelVerify,
End,
Child, cancel = TextObject,
ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_Text_Contents, translate_text(IDS_CANCEL),
MUIA_Text_PreParse, "\033c",
MUIA_InputMode, MUIV_InputMode_RelVerify,
End,
End,
End;
if (ui != NULL) {
DoMethod(start_server, MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_Application_ReturnID, BTN_START_SERVER);
DoMethod(connect_to, MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_Application_ReturnID, BTN_CONNECT_TO);
DoMethod(disconnect, MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_Application_ReturnID, BTN_DISCONNECT);
DoMethod(cancel, MUIM_Notify, MUIA_Pressed, FALSE,
app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
switch(network_get_mode()) {
case NETWORK_IDLE:
set(mode, MUIA_String_Contents, translate_text(IDS_IDLE));
break;
case NETWORK_SERVER:
set(mode, MUIA_String_Contents, translate_text(IDS_SERVER_LISTENING));
break;
case NETWORK_SERVER_CONNECTED:
set(mode, MUIA_String_Contents, translate_text(IDS_CONNECTED_SERVER));
break;
case NETWORK_CLIENT:
set(mode, MUIA_String_Contents, translate_text(IDS_CONNECTED_CLIENT));
break;
}
}
return ui;
}
/**************************************************************************
MUIM_Draw
**************************************************************************/
IPTR Levelmeter__MUIM_Draw(struct IClass *cl, Object *obj, struct MUIP_Draw *msg)
{
struct Levelmeter_DATA *data = INST_DATA(cl, obj);
struct RastPort *rp;
WORD x1, y1, x2, y2;
DoSuperMethodA(cl,obj,(Msg)msg);
if (!(msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE)))
return FALSE;
x1 = _mleft(obj);
y1 = _mtop(obj);
x2 = _mright(obj);
y2 = _mbottom(obj);
rp = _rp(obj);
if (msg->flags & MADF_DRAWOBJECT)
{
/* Transparent edges */
DoMethod(obj, MUIM_DrawParentBackground, x1, y1, 2, 1, x1, y1, 0);
DoMethod(obj, MUIM_DrawParentBackground, x1, y1 + 1, 1, 1, x1, y1 + 1, 0);
DoMethod(obj, MUIM_DrawParentBackground, x2 - 1, y1, 2, 1, x2 - 1, y1, 0);
DoMethod(obj, MUIM_DrawParentBackground, x2, y1 + 1, 1, 1, x2, y1 + 1, 0);
DoMethod(obj, MUIM_DrawParentBackground, x1, y2, 2, 1, x1, y2, 0);
DoMethod(obj, MUIM_DrawParentBackground, x1, y2 - 1, 1, 1, x1, y2 - 1, 0);
DoMethod(obj, MUIM_DrawParentBackground, x2 - 1, y2, 2, 1, x2 - 1, y2, 0);
DoMethod(obj, MUIM_DrawParentBackground, x2, y2 - 1, 1, 1, x2, y2 - 1, 0);
/* Outer frame */
SetABPenDrMd(rp, _pens(obj)[MPEN_SHINE], 0, JAM1);
Move(rp, x1 + 1, y2 - 1);
Draw(rp, x1, y2 - 2);
Draw(rp, x1, y1 + 2);
Draw(rp, x1 + 2, y1);
Draw(rp, x2 - 2, y1);
Draw(rp, x2 - 1, y1 + 1);
SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
Move(rp, x2, y1 + 2);
Draw(rp, x2, y2 - 2);
Draw(rp, x2 - 2, y2);
Draw(rp, x1 + 2, y2);
SetAPen(rp, _pens(obj)[MPEN_HALFSHINE]);
Move(rp, x1 + 1, y2 - 2);
Draw(rp, x1 + 1, y1 + 2);
Draw(rp, x1 + 2, y1 + 1);
Draw(rp, x2 - 2, y1 + 1);
SetAPen(rp, _pens(obj)[MPEN_HALFSHADOW]);
Move(rp, x2 - 1, y1 + 2);
Draw(rp, x2 - 1, y2 - 2);
Draw(rp, x2 - 2, y2 - 1);
Draw(rp, x1 + 2, y2 - 1);
/* Border */
x1 += OUTERFRAME_X;
x2 -= OUTERFRAME_X;
y1 += OUTERFRAME_X;
y2 -= OUTERFRAME_Y;
SetAPen(rp, _pens(obj)[MPEN_HALFSHINE]);
RectFill(rp, x1, y1, x2, y1 + BORDERSIZE_Y - 1);
RectFill(rp, x1, y1 + BORDERSIZE_Y, x1 + BORDERSIZE_X - 1, y2);
RectFill(rp, x1 + BORDERSIZE_X - 1, y2 - BORDERSIZE_Y + 1, x2, y2);
RectFill(rp, x2 - BORDERSIZE_X + 1, y1 + BORDERSIZE_Y, x2, y2 - BORDERSIZE_Y);
/* Inner Frame */
x1 += BORDERSIZE_X;
x2 -= BORDERSIZE_X;
y1 += BORDERSIZE_Y;
y2 = y1 + LEVEL_HEIGHT + INNERFRAME_H - 1;
Move(rp, x1, y1);
Draw(rp, x1 + 2, y1);
Draw(rp, x1, y1 + 2);
Draw(rp, x1, y1 + 1);
Move(rp, x2, y1);
Draw(rp, x2 - 2, y1);
Draw(rp, x2, y1 + 2);
Draw(rp, x2, y1 + 1);
Move(rp, x1, y2);
Draw(rp, x1 + 2, y2);
Draw(rp, x1, y2 - 2);
Draw(rp, x1, y2 - 1);
Move(rp, x2, y2);
Draw(rp, x2 - 2, y2);
Draw(rp, x2, y2 - 2);
Draw(rp, x2, y2 - 1);
SetAPen(rp, _pens(obj)[MPEN_HALFSHADOW]);
Move(rp, x1 + 2, y2 - 1);
Draw(rp, x1, y2 - 3);
Draw(rp, x1, y1 + 3);
Draw(rp, x1 + 3, y1);
Draw(rp, x2 - 3, y1);
Draw(rp, x2 - 1, y1 + 2);
SetAPen(rp, _pens(obj)[MPEN_SHINE]);
Move(rp, x2, y1 + 3);
Draw(rp, x2, y2 - 3);
Draw(rp, x2 - 3, y2);
Draw(rp, x1 + 3, y2);
SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
Move(rp, x1 + 3, y1 + 1);
Draw(rp, x2 - 3, y1 + 1);
Move(rp, x1 + 1, y1 + 3);
Draw(rp, x1 + 1, y2 - 3);
Move(rp, x1 + 3, y2 - 1);
Draw(rp, x2 - 3, y2 - 1);
Move(rp, x2 - 1, y1 + 3),
Draw(rp, x2 - 1, y2 - 3);
/* Levelmeter bg */
x1 += INNERFRAME_X;
x2 -= INNERFRAME_X;
y1 += INNERFRAME_Y;
y2 -= INNERFRAME_Y;
SetAPen(rp, data->levelbgpen);
RectFill(rp, x1 + 1, y1, x2 - 1, y1);
RectFill(rp, x1, y1 + 1, x2, y2 - 1);
RectFill(rp, x1 + 1, y2, x2 - 1, y2);
SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
WritePixel(rp, x1, y1);
WritePixel(rp, x2, y1);
WritePixel(rp, x1, y2);
WritePixel(rp, x2, y2);
/* Levelmeter scale */
DrawScale(rp, x1, y1, x2, y2, _pens(obj)[MPEN_SHINE]);
/* Level-Label spacing */
x1 -= INNERFRAME_X;
x2 += INNERFRAME_X;
y1 = y2 + INNERFRAME_Y + 1;
SetAPen(rp, _pens(obj)[MPEN_HALFSHINE]);
RectFill(rp, x1, y1, x2, y1 + LEVEL_LABEL_SPACING - 1);
/* Label Frame */
y1 += LEVEL_LABEL_SPACING;
y2 = _mbottom(obj) - OUTERFRAME_Y - BORDERSIZE_Y;
SetAPen(rp, _pens(obj)[MPEN_HALFSHINE]);
Move(rp, x1, y1);
Draw(rp, x1 + 1, y1);
Draw(rp, x1, y1 + 1);
Move(rp, x2, y1);
Draw(rp, x2 - 1, y1);
Draw(rp, x2, y1 + 1);
Move(rp, x1, y2);
Draw(rp, x1 + 1, y2);
Draw(rp, x1, y2 - 1);
Move(rp, x2, y2);
Draw(rp, x2 - 1, y2);
Draw(rp, x2, y2 - 1);
SetAPen(rp, _pens(obj)[MPEN_HALFSHADOW]);
Move(rp, x1 + 1, y2 - 1);
Draw(rp, x1, y2 - 2);
Draw(rp, x1, y1 + 2);
Draw(rp, x1 + 2, y1);
Draw(rp, x2 - 2, y1);
Draw(rp, x2 - 1, y1 + 1);
SetAPen(rp, _pens(obj)[MPEN_SHINE]);
Move(rp, x2, y1 + 2);
Draw(rp, x2, y2 - 2);
Draw(rp, x2 - 2, y2);
Draw(rp, x1 + 2, y2);
SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
RectFill(rp, x1 + 1, y1 + 2, x1 + 1, y2 - 2);
RectFill(rp, x2 - 1, y1 + 2, x2 - 1, y2 - 2);
RectFill(rp, x1 + 2, y1 + 1, x2 - 2, y1 + 1);
RectFill(rp, x1 + 2, y2 - 1, x2 - 2, y2 - 1);
/* Label Bg */
RectFill(rp, x1 + 2, y1 +2, x2 - 2, y2 - 2);
}
x1 = _mleft(obj) + OUTERFRAME_X + BORDERSIZE_X + INNERFRAME_X;
x2 = _mright(obj) - OUTERFRAME_X - BORDERSIZE_X - INNERFRAME_X;
y1 = _mtop(obj) + OUTERFRAME_Y + BORDERSIZE_Y + INNERFRAME_Y;
y2 = y1 + LEVEL_HEIGHT - 1;
if (msg->flags & MADF_DRAWUPDATE)
{
DrawNeedle(rp, x1, y1, x2, y2, data->prevangle, data->levelbgpen);
}
data->prevangle = (double)DoMethod(obj, MUIM_Numeric_ValueToScale, 0, 180);
DrawNeedle(rp, x1, y1, x2, y2, data->prevangle, _pens(obj)[MPEN_SHINE]);
return TRUE;
}
