/**
* A new entry has been activated.
*/
static void filter_active(void)
{
struct filter *f;
DoMethod(filter_list, MUIM_NList_GetEntry, MUIV_NList_GetEntry_Active, (ULONG)&f);
if (f)
{
filter_accept_rule();
nnset(filter_name_string,MUIA_UTF8String_Contents, f->name);
filter_refresh_rules();
set(filter_move_text, MUIA_Text_Contents, f->dest_folder);
set(filter_move_check, MUIA_Selected, f->use_dest_folder);
set(filter_sound_string, MUIA_String_Contents, f->sound_file);
set(filter_sound_check, MUIA_Selected, f->use_sound_file);
set(filter_arexx_string, MUIA_String_Contents, f->arexx_file);
set(filter_arexx_check, MUIA_Selected, f->use_arexx_file);
set(filter_request_check, MUIA_Selected, !!(f->flags & FILTER_FLAG_REQUEST));
set(filter_new_check, MUIA_Selected, !!(f->flags & FILTER_FLAG_NEW));
set(filter_sent_check, MUIA_Selected, !!(f->flags & FILTER_FLAG_SENT));
set(filter_remote_check, MUIA_Selected, !!(f->flags & FILTER_FLAG_REMOTE));
} else
{
filter_refresh_rules();
}
filter_last_selected = f;
/* Update some disable states */
set(filter_apply_now_button,MUIA_Disabled,!filter_last_selected);
set(filter_add_rule_button,MUIA_Disabled,!filter_last_selected);
}
static ULONG
mSets(struct IClass *cl,Object *obj,struct opSet *msg)
{
struct TagItem *tag;
if (tag = FindTagItem(MUIA_Calendar_StartDay,msg->ops_AttrList))
{
struct data *data = INST_DATA(cl,obj);
ULONG wsd = tag->ti_Data;
int i;
if (wsd>6) wsd = 6;
for (i = 0; i<7; i++) if (i!=wsd) nnset(data->days[i],MUIA_Selected,FALSE);
nnset(data->days[wsd],MUIA_Selected,TRUE);
data->wsd = wsd;
}
return 0;
}
///
/// US_GetUSEntryFunc
// Fills form with data from selected list entry
HOOKPROTONHNONP(US_GetUSEntryFunc, void)
{
struct US_GUIData *gui;
int act;
ENTER();
gui = &G->US->GUI;
act = xget(gui->LV_USERS, MUIA_NList_Active);
if(act != MUIV_NList_Active_Off)
{
struct User *user;
BOOL notallowed;
BOOL iscurrent;
BOOL limited;
DoMethod(gui->LV_USERS, MUIM_NList_GetEntry, act, &user);
limited = !G->US->Supervisor;
iscurrent = (user->ID == G->Users.CurrentID);
notallowed = limited && !iscurrent;
nnset(gui->ST_USER, MUIA_String_Contents, user->Name);
nnset(gui->ST_MAILDIR, MUIA_String_Contents, user->MailDir);
nnset(gui->ST_PASSWD, MUIA_String_Contents, user->Password);
nnset(gui->CH_USEADDR, MUIA_Selected, user->UseAddr);
nnset(gui->CH_USEDICT, MUIA_Selected, user->UseDict);
nnset(gui->CH_ROOT, MUIA_Selected, !user->Limited);
nnset(gui->CH_CLONE, MUIA_Selected, user->Clone);
set(gui->ST_USER, MUIA_Disabled, notallowed);
set(gui->CH_USEDICT, MUIA_Disabled, notallowed || act == 0);
set(gui->CH_USEADDR, MUIA_Disabled, notallowed || act == 0);
set(gui->CH_CLONE, MUIA_Disabled, !user->IsNew || act == 0);
set(gui->PO_MAILDIR, MUIA_Disabled, limited);
set(gui->CH_ROOT, MUIA_Disabled, limited);
set(gui->ST_PASSWD, MUIA_Disabled, notallowed);
set(gui->BT_DEL, MUIA_Disabled, act == 0 || iscurrent);
}
else
DoMethod(G->App, MUIM_MultiSet, MUIA_Disabled, TRUE, gui->ST_USER,
gui->ST_PASSWD,
gui->PO_MAILDIR,
gui->CH_USEDICT,
gui->CH_USEADDR,
gui->CH_ROOT,
gui->CH_CLONE,
gui->BT_DEL,
NULL);
LEAVE();
}
IPTR ScreenModeProperties__OM_SET(Class *CLASS, Object *self, struct opSet *message)
{
struct ScreenModeProperties_DATA *data = INST_DATA(CLASS, self);
const struct TagItem *tags;
struct TagItem *tag;
struct TagItem noforward_tags[] =
{
{MUIA_Group_Forward , FALSE },
{TAG_MORE , (IPTR)message->ops_AttrList }
};
struct opSet noforward_message = *message;
noforward_message.ops_AttrList = noforward_tags;
ULONG id = INVALID_ID;
IPTR no_notify = TAG_IGNORE;
for (tags = message->ops_AttrList; (tag = NextTagItem(&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_NoNotify:
no_notify = MUIA_NoNotify;
break;
case MUIA_ScreenModeProperties_DisplayID:
{
struct TagItem width_tags[] =
{
{ no_notify, TRUE },
{ MUIA_Numeric_Min, 0 },
{ MUIA_Numeric_Max, 0 },
{ MUIA_Numeric_Default, 0 },
{ TAG_DONE, 0 }
};
struct TagItem height_tags[] =
{
{ no_notify, TRUE },
{ MUIA_Numeric_Min, 0 },
{ MUIA_Numeric_Max, 0 },
{ MUIA_Numeric_Default, 0 },
{ TAG_DONE, 0 }
};
struct TagItem depth_tags[] =
{
{ no_notify, TRUE },
{ MUIA_Numeric_Min, 0 },
{ MUIA_Numeric_Max, 0 },
{ MUIA_Numeric_Default, 0 },
{ TAG_DONE, 0 }
};
struct DimensionInfo dim;
BOOL autoscroll;
if (GetDisplayInfoData(NULL, (UBYTE *)&dim, sizeof(dim), DTAG_DIMS, tag->ti_Data))
{
width_tags[1].ti_Data = dim.MinRasterWidth;
height_tags[1].ti_Data = dim.MinRasterHeight;
depth_tags[1].ti_Data = 1;
width_tags[2].ti_Data = dim.MaxRasterWidth;
height_tags[2].ti_Data = dim.MaxRasterHeight;
depth_tags[2].ti_Data = dim.MaxDepth;
width_tags[3].ti_Data = dim.Nominal.MaxX - dim.Nominal.MinX + 1;
height_tags[3].ti_Data = dim.Nominal.MaxY - dim.Nominal.MinY + 1;
depth_tags[3].ti_Data = dim.MaxDepth;
id = tag->ti_Data;
}
/* Enable autoscroll only if the maximum sizes are bigger than
the resolution. */
autoscroll = width_tags[2].ti_Data > width_tags[3].ti_Data &&
height_tags[2].ti_Data > height_tags[3].ti_Data;
data->DisplayID = id;
nfset(self, MUIA_Disabled, id == INVALID_ID);
SetAttrsA(data->width, width_tags);
SetAttrsA(data->height, height_tags);
SetAttrsA(data->depth, depth_tags);
SetAttrs(data->autoscroll, no_notify, TRUE,
MUIA_Disabled, !autoscroll,
MUIA_Selected, autoscroll,
TAG_DONE);
break;
}
case MUIA_ScreenModeProperties_Width:
if (id != INVALID_ID)
{
WORD width = tag->ti_Data;
if (width != -1)
SetAttrs(data->width, no_notify, TRUE, MUIA_Numeric_Value, width, TAG_DONE);
else
DoMethod(data->width, MUIM_Numeric_SetDefault);
nnset(data->def_width, MUIA_Selected, width == -1);
}
break;
case MUIA_ScreenModeProperties_Height:
if (id != INVALID_ID)
{
WORD height = tag->ti_Data;
if (height != -1)
SetAttrs(data->height, no_notify, TRUE, MUIA_Numeric_Value, height, TAG_DONE);
else
DoMethod(data->height, MUIM_Numeric_SetDefault);
nnset(data->def_height, MUIA_Selected, height == -1);
}
break;
case MUIA_ScreenModeProperties_Depth:
if (id != INVALID_ID)
{
WORD depth = tag->ti_Data;
if (depth != -1)
SetAttrs(data->depth, no_notify, TRUE, MUIA_Numeric_Value, depth, TAG_DONE);
else
DoMethod(data->depth, MUIM_Numeric_SetDefault);
}
break;
case MUIA_ScreenModeProperties_Autoscroll:
if (id != INVALID_ID && !XGET(data->autoscroll, MUIA_Disabled))
SetAttrs(data->autoscroll, no_notify, TRUE, MUIA_Selected, tag->ti_Data != 0);
break;
}
}
return DoSuperMethodA(CLASS, self, (Msg)&noforward_message);
}
IPTR SMEditor__MUIM_PrefsEditor_ImportFH
(
Class *CLASS, Object *self,
struct MUIP_PrefsEditor_ImportFH *message
)
{
SETUP_INST_DATA;
struct ContextNode *context;
struct IFFHandle *handle;
struct ScreenModePrefs smp;
BOOL success = TRUE;
LONG error;
if (!(handle = AllocIFF()))
return FALSE;
handle->iff_Stream = (IPTR) message->fh;
InitIFFasDOS(handle);
if ((error = OpenIFF(handle, IFFF_READ)) == 0)
{
BYTE i;
// FIXME: We want some sanity checking here!
for (i = 0; i < 1; i++)
{
if ((error = StopChunk(handle, ID_PREF, ID_SCRM)) == 0)
{
if ((error = ParseIFF(handle, IFFPARSE_SCAN)) == 0)
{
context = CurrentChunk(handle);
error = ReadChunkBytes
(
handle, &smp, sizeof(struct ScreenModePrefs)
);
if (error < 0)
{
printf("Error: ReadChunkBytes() returned %ld!\n", error);
}
}
else
{
printf("ParseIFF() failed, returncode %ld!\n", error);
success = FALSE;
break;
}
}
else
{
printf("StopChunk() failed, returncode %ld!\n", error);
success = FALSE;
}
}
CloseIFF(handle);
}
else
{
//ShowError(_(MSG_CANT_OPEN_STREAM));
}
FreeIFF(handle);
if (success)
{
SMPByteSwap(&smp);
nnset(data->selector, MUIA_ScreenModeSelector_Active, smp.smp_DisplayID);
SetAttrs
(
data->properties,
MUIA_NoNotify, TRUE,
MUIA_ScreenModeProperties_DisplayID, smp.smp_DisplayID,
MUIA_ScreenModeProperties_Width, smp.smp_Width,
MUIA_ScreenModeProperties_Height, smp.smp_Height,
MUIA_ScreenModeProperties_Depth, smp.smp_Depth,
MUIA_ScreenModeProperties_Autoscroll, smp.smp_Control & AUTOSCROLL,
TAG_DONE
);
}
return success;
}
