SAVEDS ULONG mSet(struct IClass *cl,Object *obj,struct opSet *msg)
{
struct FloatIntData *data = INST_DATA(cl,obj);
struct TagItem *tags,*tag;
ULONG Temp;
signed long int Limit;
double *D;
for (tags=msg->ops_AttrList;tag=NextTagItem(&tags);)
{
switch (tag->ti_Tag)
{
case MUIA_FloatInt_IncDecInt:
{
Temp = tag->ti_Data;
Limit = *(signed long int *)(&Temp);
data->IncDecAmount = Limit;
/* No reason to Sync */
break;
} /* IncDecInt */
case MUIA_FloatInt_IncDecDouble:
{
D = (double *)tag->ti_Data;
if(D) /* prevent enforcer hits from stupidity */
{
data->IncDecAmount = *D;
data->FIFlags &= ~FIOFlag_Frac;
} /* if */
/* No reason to Sync */
break;
} /* IncDecDouble */
case MUIA_FloatInt_IDFracDouble:
{
D = (double *)tag->ti_Data;
if(D) /* prevent enforcer hits from stupidity */
{
data->IncDecAmount = *D;
data->FIFlags |= FIOFlag_Frac;
} /* if */
/* No reason to Sync */
break;
} /* IDFracDouble */
case MUIA_FloatInt_MaxValDouble:
{
D = (double *)tag->ti_Data;
if(D) /* prevent enforcer hits from stupidity */
{
data->MaxAmount = *D;
if(!GetTagData(MUIV_FloatInt_InhibitAutoSync, NULL, msg->ops_AttrList))
{
mSync(cl, obj, msg);
} /* if */
} /* if */
break;
} /* MaxValDouble */
case MUIA_FloatInt_MinValDouble:
{
D = (double *)tag->ti_Data;
if(D) /* prevent enforcer hits from stupidity */
{
data->MinAmount = *D;
if(!GetTagData(MUIV_FloatInt_InhibitAutoSync, NULL, msg->ops_AttrList))
{
mSync(cl, obj, msg);
} /* if */
} /* if */
break;
} /* MinValDouble */
case MUIA_FloatInt_MaxValInt:
{
Temp = tag->ti_Data;
Limit = *(signed long int *)(&Temp);
data->MaxAmount = Limit;
if(!GetTagData(MUIV_FloatInt_InhibitAutoSync, NULL, msg->ops_AttrList))
{
mSync(cl, obj, msg);
} /* if */
break;
} /* MaxValInt */
case MUIA_FloatInt_MinValInt:
{
Temp = tag->ti_Data;
Limit = *(signed long int *)(&Temp);
data->MinAmount = Limit;
if(!GetTagData(MUIV_FloatInt_InhibitAutoSync, NULL, msg->ops_AttrList))
{
mSync(cl, obj, msg);
} /* if */
break;
} /* MinValInt */
case MUIA_FloatInt_VarPtr:
{
data->MasterVariable = (void *)tag->ti_Data;
if(!GetTagData(MUIV_FloatInt_InhibitAutoSync, NULL, msg->ops_AttrList))
{
mSync(cl, obj, msg);
} /* if */
break;
} /* VarPtr */
case MUIA_FloatInt_VarType:
{
Temp = tag->ti_Data;
if(Temp & FI_TypeMask)
{
data->FIFlags &= ~FI_TypeMask;
data->FIFlags |= Temp;
if(!GetTagData(MUIV_FloatInt_InhibitAutoSync, NULL, msg->ops_AttrList))
{
mSync(cl, obj, msg);
} /* if */
} /* if */
break;
} /* VarType */
case MUIA_FloatInt_Contents:
{
if(data->MasterVariable)
{
*((long *)(data->MasterVariable)) = (long)tag->ti_Data;
if(!GetTagData(MUIV_FloatInt_InhibitAutoSync, NULL, msg->ops_AttrList))
{
mSync(cl, obj, msg);
} /* if */
} /* if */
break;
} /* VarPtr */
}
}
return(DoSuperMethodA(cl,obj,(Msg)msg));
}
Thread *threadSelf0(Object *vmThread) {
return (Thread*)(INST_DATA(vmThread)[vmData_offset]);
}
void detachThread(Thread *thread) {
Object *group, *excep;
//ExecEnv *ee = thread->ee;
//Object *jThread = ee->thread;
Object *jThread = thread->thread;
Object *vmthread = (Object*)INST_DATA(jThread)[vmthread_offset];
/* Get the thread's group */
group = (Object *)INST_DATA(jThread)[group_offset];
/* If there's an uncaught exception, call uncaughtException on the thread's
exception handler, or the thread's group if this is unset */
if((excep = exceptionOccurred())) {
FieldBlock *fb = findField(thread_class, SYMBOL(exceptionHandler),
SYMBOL(sig_java_lang_Thread_UncaughtExceptionHandler));
Object *thread_handler = fb == NULL ? NULL : (Object *)INST_DATA(jThread)[fb->offset];
Object *handler = thread_handler == NULL ? group : thread_handler;
MethodBlock *uncaught_exp = lookupMethod(handler->classobj, SYMBOL(uncaughtException),
SYMBOL(_java_lang_Thread_java_lang_Throwable__V));
if(uncaught_exp) {
clearException();
DummyFrame dummy;
executeMethod(&dummy, handler, uncaught_exp, jThread, excep);
} else
printException();
}
/* remove thread from thread group */
DummyFrame dummy;
executeMethod(&dummy, group, (CLASS_CB(group->classobj))->method_table[rmveThrd_mtbl_idx], jThread);
/* set VMThread ref in Thread object to null - operations after this
point will result in an IllegalThreadStateException */
INST_DATA(jThread)[vmthread_offset] = 0;
/* Remove thread from the ID map hash table */
deleteThreadFromHash(thread);
/* Disable suspend to protect lock operation */
disableSuspend(thread);
/* Grab global lock, and update thread structures protected by
it (thread list, thread ID and number of daemon threads) */
pthread_mutex_lock(&lock);
/* remove from thread list... */
if((thread->prev->next = thread->next))
thread->next->prev = thread->prev;
/* One less live thread */
threads_count--;
/* Recycle the thread's thread ID */
freeThreadID(thread->id);
/* Handle daemon thread status */
if(!INST_DATA(jThread)[daemon_offset])
non_daemon_thrds--;
pthread_mutex_unlock(&lock);
/* notify any threads waiting on VMThread object -
these are joining this thread */
objectLock(vmthread);
objectNotifyAll(vmthread);
objectUnlock(vmthread);
/* It is safe to free the thread's ExecEnv and stack now as these are
only used within the thread. It is _not_ safe to free the native
thread structure as another thread may be concurrently accessing it.
However, they must have a reference to the VMThread -- therefore, it
is safe to free during GC when the VMThread is determined to be no
longer reachable. */
// sysFree(ee->stack);
//sysFree(ee);
/* If no more daemon threads notify the main thread (which
may be waiting to exit VM). Note, this is not protected
by lock, but main thread checks again */
if(non_daemon_thrds == 0) {
/* No need to bother with disabling suspension
* around lock, as we're no longer on thread list */
pthread_mutex_lock(&exit_lock);
pthread_cond_signal(&exit_cv);
pthread_mutex_unlock(&exit_lock);
}
TRACE("Thread 0x%x id: %d detached from VM\n", thread, thread->id);
}
/**************************************************************************
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;
}
IPTR GTSlider__OM_SET(Class * cl, Object * o, struct opSet * msg)
{
IPTR retval = 0UL;
const struct TagItem *tstate;
struct TagItem *tag, *dosuper_tags, tags[] =
{
{PGA_Total , 0 },
{PGA_Top , 0 },
{TAG_MORE , 0 }
};
struct SliderData *data = INST_DATA(cl, o);
BOOL val_set = FALSE;
EnterFunc(bug("Slider::Set(attrlist=%p)\n", msg->ops_AttrList));
dosuper_tags = msg->ops_AttrList;
tstate = msg->ops_AttrList;
while ((tag = NextTagItem(&tstate)))
{
IPTR tidata = tag->ti_Data;
switch (tag->ti_Tag)
{
case GTSL_Min:
data->min = (WORD)tidata;
val_set = TRUE;
break;
case GTSL_Max:
data->max = (WORD)tidata;
val_set = TRUE;
break;
case GTSL_Level: /* [ISN] */
if (tidata != data->level)
{
data->level = data->freedom==FREEHORIZ?(WORD)tidata:data->max-(WORD)tidata+data->min;
notifylevel(cl, o, data->level, msg->ops_GInfo, GadToolsBase);
val_set = TRUE;
}
break;
} /* switch () */
} /* while (iterate taglist) */
if (val_set)
{
tags[0].ti_Data = data->max - data->min + 1;
tags[1].ti_Data = data->level - data->min;
tags[2].ti_Data = (IPTR)msg->ops_AttrList;
dosuper_tags = tags;
retval = 1UL;
}
ReturnInt ("Slider::Set", IPTR, DoSuperMethod(cl, o, OM_SET, (IPTR) dosuper_tags, (IPTR) msg->ops_GInfo));
}
int getStringLen(Object *string) {
return INST_DATA(string)[count_offset];
}
/**************************************************************************
MUIM_HandleEvent
**************************************************************************/
IPTR Numeric__MUIM_HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
{
struct MUI_NumericData *data = INST_DATA(cl, obj);
if (msg->muikey != MUIKEY_NONE)
{
LONG step;
if (data->max - data->min < 10)
step = 1;
else
step = 10;
switch(msg->muikey)
{
case MUIKEY_PRESS:
return MUI_EventHandlerRC_Eat;
case MUIKEY_TOGGLE:
DoMethod(obj, MUIM_Numeric_SetDefault);
return MUI_EventHandlerRC_Eat;
case MUIKEY_RELEASE:
return MUI_EventHandlerRC_Eat;
case MUIKEY_BOTTOM:
case MUIKEY_LINEEND:
if (data->flags & NUMERIC_REVUPDOWN)
set(obj, MUIA_Numeric_Value, data->min);
else
set(obj, MUIA_Numeric_Value, data->max);
return MUI_EventHandlerRC_Eat;
case MUIKEY_TOP:
case MUIKEY_LINESTART:
if (data->flags & NUMERIC_REVUPDOWN)
set(obj, MUIA_Numeric_Value, data->max);
else
set(obj, MUIA_Numeric_Value, data->min);
return MUI_EventHandlerRC_Eat;
case MUIKEY_LEFT:
if (data->flags & NUMERIC_REVLEFTRIGHT)
DoMethod(obj, MUIM_Numeric_Increase, 1);
else
DoMethod(obj, MUIM_Numeric_Decrease, 1);
return MUI_EventHandlerRC_Eat;
case MUIKEY_RIGHT:
if (data->flags & NUMERIC_REVLEFTRIGHT)
DoMethod(obj, MUIM_Numeric_Decrease, 1);
else
DoMethod(obj, MUIM_Numeric_Increase, 1);
return MUI_EventHandlerRC_Eat;
case MUIKEY_UP:
if (data->flags & NUMERIC_REVUPDOWN)
DoMethod(obj, MUIM_Numeric_Increase, 1);
else
DoMethod(obj, MUIM_Numeric_Decrease, 1);
return MUI_EventHandlerRC_Eat;
case MUIKEY_DOWN:
if (data->flags & NUMERIC_REVUPDOWN)
DoMethod(obj, MUIM_Numeric_Decrease, 1);
else
DoMethod(obj, MUIM_Numeric_Increase, 1);
return MUI_EventHandlerRC_Eat;
case MUIKEY_PAGEDOWN:
case MUIKEY_WORDRIGHT:
if (data->flags & NUMERIC_REVUPDOWN)
DoMethod(obj, MUIM_Numeric_Decrease, step);
else
DoMethod(obj, MUIM_Numeric_Increase, step);
return MUI_EventHandlerRC_Eat;
case MUIKEY_PAGEUP:
case MUIKEY_WORDLEFT:
if (data->flags & NUMERIC_REVUPDOWN)
DoMethod(obj, MUIM_Numeric_Increase, step);
else
DoMethod(obj, MUIM_Numeric_Decrease, step);
return MUI_EventHandlerRC_Eat;
default:
return 0;
}
}
return 0;
}
STATIC ULONG transwnd_New(struct IClass *cl, Object *obj, struct opSet *msg)
{
Object *gauge1,/* *gauge2,*/*status,*abort,*mail_listview, *mail_list, *mail_group, *start, *ignore, *down, *del, *downdel, *ignore_check,*all,*none, *skip;
Object *head;
obj = (Object *) DoSuperNew(cl, obj,
WindowContents, VGroup,
Child, head = TextObject,End,
Child, RectangleObject, MUIA_Weight, 1, End,
Child, mail_group = VGroup,
MUIA_ShowMe, FALSE,
Child, mail_listview = NListviewObject,
MUIA_NListview_NList, mail_list = NListObject,
MUIA_NList_Title, TRUE,
MUIA_NList_Format, "P=\033r,,,",
End,
End,
Child, HGroup,
Child, ignore = MakeButton(_("Ignore")),
Child, down = MakeButton(_("Download")),
Child, del = MakeButton(_("Delete")),
Child, downdel = MakeButton(_("Download & Delete")),
Child, start = MakeButton(_("_Start")),
End,
Child, HGroup,
Child, all = MakeButton(_("Select All")),
Child, none = MakeButton(_("Select None")),
Child, MakeLabel(_("Ignore not listed mails")),
Child, ignore_check = MakeCheck(_("Ignore not listed mails"),FALSE),
Child, HVSpace,
End,
End,
Child, gauge1 = GaugeObject,
GaugeFrame,
MUIA_Gauge_InfoText, _("Waiting..."),
MUIA_Gauge_Horiz, TRUE,
End,
/* Child, gauge2 = GaugeObject,
GaugeFrame,
MUIA_Gauge_InfoText, _("Waiting..."),
MUIA_Gauge_Horiz, TRUE,
End,*/
Child, HGroup,
Child, status = TextObject, TextFrame, MUIA_Text_Contents, "", MUIA_Background, MUII_TextBack, End,
Child, skip = MakeButton(_("_Skip")),
Child, abort = MakeButton(_("_Abort")),
End,
End,
TAG_MORE, msg->ops_AttrList);
if (obj != NULL)
{
struct transwnd_Data *data = (struct transwnd_Data *) INST_DATA(cl, obj);
data->gauge1 = gauge1;
/* data->gauge2 = gauge2; */
data->status = status;
data->abort = abort;
data->skip = skip;
data->head = head;
data->mail_listview = mail_listview;
data->mail_list = mail_list;
data->mail_group = mail_group;
data->start = start;
data->ignore_check = ignore_check;
data->status_download = PictureButtonObject, MUIA_PictureButton_Directory, gui_get_images_directory(), MUIA_PictureButton_Filename, "status_download", End;
data->status_trashcan = PictureButtonObject, MUIA_PictureButton_Directory, gui_get_images_directory(), MUIA_PictureButton_Filename, "status_trashcan", End;
init_hook_with_data(&data->construct_hook, (HOOKFUNC)mail_construct, data);
init_hook_with_data(&data->destruct_hook, (HOOKFUNC)mail_destruct, data);
init_hook_with_data(&data->display_hook, (HOOKFUNC)mail_display, data);
SetAttrs(mail_list,
MUIA_NList_ConstructHook, &data->construct_hook,
MUIA_NList_DestructHook, &data->destruct_hook,
MUIA_NList_DisplayHook, &data->display_hook,
MUIA_NList_MultiSelect, MUIV_NList_MultiSelect_Default,
TAG_DONE);
set(skip, MUIA_Weight, 0);
set(abort, MUIA_Weight, 0);
DoMethod(abort, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)obj, 3, MUIM_Set, MUIA_transwnd_Aborted, TRUE);
DoMethod(skip, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)obj, 3, MUIM_Set, MUIA_transwnd_Skipped, TRUE);
DoMethod(start, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)App, 3, MUIM_WriteLong, (1<<0), (ULONG)&data->start_pressed);
DoMethod(obj, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, (ULONG)obj, 3, MUIM_Set, MUIA_transwnd_Aborted, TRUE);
DoMethod(ignore, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)App, 5, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)transwnd_set_mail_flags, (ULONG)data, 0);
DoMethod(down, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)App, 5, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)transwnd_set_mail_flags, (ULONG)data, MAILF_DOWNLOAD);
DoMethod(del, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)App, 5, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)transwnd_set_mail_flags, (ULONG)data, MAILF_DELETE);
DoMethod(downdel, MUIM_Notify, MUIA_Pressed, FALSE, (ULONG)App, 5, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)transwnd_set_mail_flags, (ULONG)data, MAILF_DOWNLOAD|MAILF_DELETE);
DoMethod(all,MUIM_Notify,MUIA_Pressed, FALSE, (ULONG)mail_list, 4, MUIM_NList_Select, MUIV_NList_Select_All, MUIV_NList_Select_On, NULL);
DoMethod(none,MUIM_Notify,MUIA_Pressed, FALSE, (ULONG)mail_list, 4, MUIM_NList_Select, MUIV_NList_Select_All, MUIV_NList_Select_Off, NULL);
}
return((ULONG) obj);
}
STATIC ULONG transwnd_Set(struct IClass *cl, Object *obj, struct opSet *msg)
{
int close = 0;
ULONG rc;
struct transwnd_Data *data;
struct TagItem *tags, *tag;
char *gauge1_str = NULL;
int gauge1_max = -1;
int gauge1_val = -1;
int gauge1_div = 1;
data = (struct transwnd_Data *) INST_DATA(cl, obj);
for ((tags = msg->ops_AttrList); (tag = NextTagItem((APTR)&tags));)
{
switch (tag->ti_Tag)
{
case MUIA_transwnd_Status:
set(data->status, MUIA_Text_Contents, tag->ti_Data);
break;
case MUIA_transwnd_Gauge1_Str:
gauge1_str = (char*)tag->ti_Data;
break;
case MUIA_transwnd_Gauge1_Max:
gauge1_max = tag->ti_Data;
/* 16bit only */
while (gauge1_max > 65535)
{
gauge1_max >>= 1;
gauge1_div <<= 1;
}
SM_DEBUGF(20,("Gauge_Max: real=%ld mui=%ld div=%ld\n",tag->ti_Data, gauge1_max, gauge1_div));
break;
case MUIA_transwnd_Gauge1_Val:
gauge1_val = tag->ti_Data;
break;
case MUIA_transwnd_Head:
set(data->head,MUIA_Text_Contents, tag->ti_Data);
break;
case MUIA_transwnd_Gauge2_Str:
/* set(data->gauge2, MUIA_Gauge_InfoText, tag->ti_Data); */
break;
case MUIA_transwnd_Gauge2_Max:
/* set(data->gauge2, MUIA_Gauge_Max, tag->ti_Data); */
break;
case MUIA_transwnd_Gauge2_Val:
/* set(data->gauge2, MUIA_Gauge_Current, tag->ti_Data); */
break;
case MUIA_transwnd_QuietList:
set(data->mail_list, MUIA_NList_Quiet, tag->ti_Data);
break;
case MUIA_Window_Open:
if (!tag->ti_Data) close = 1;
break;
}
}
if (gauge1_str || gauge1_max != -1 || gauge1_val != -1)
{
SetAttrs(data->gauge1,
gauge1_str==NULL?TAG_IGNORE:MUIA_Gauge_InfoText, gauge1_str,
gauge1_max==-1?TAG_IGNORE:MUIA_Gauge_Max, gauge1_max,
gauge1_max==-1?TAG_IGNORE:MUIA_Gauge_Divide, gauge1_div==1?0:gauge1_div,
gauge1_val==-1?TAG_IGNORE:MUIA_Gauge_Current, gauge1_val,
TAG_DONE);
}
rc = DoSuperMethodA(cl, obj, (Msg)msg);
if (close)
{
if (data->mail_group_shown)
{
set(data->mail_group, MUIA_ShowMe, FALSE);
data->mail_group_shown = 0;
}
DoMethod(data->mail_list, MUIM_NList_Clear);
SetAttrs(obj,
/* MUIA_Window_Title,"SimpleMail", */
MUIA_transwnd_Status, _("Waiting..."),
MUIA_transwnd_Gauge1_Str, _("Waiting..."),
MUIA_transwnd_Gauge1_Max, 1,
MUIA_transwnd_Gauge1_Val, 0,
MUIA_transwnd_Gauge2_Str, _("Waiting..."),
MUIA_transwnd_Gauge2_Max, 1,
MUIA_transwnd_Gauge2_Val, 0,
TAG_DONE);
}
return rc;
}
IPTR AROSCycle__OM_SET(Class *cl, Object *o, struct opSet *msg)
{
struct CycleData *data = INST_DATA(cl, o);
const struct TagItem *tag, *taglist = msg->ops_AttrList;
STRPTR *mylabels;
BOOL rerender = FALSE;
IPTR result;
result = DoSuperMethodA(cl, o, (Msg)msg);
while((tag = NextTagItem(&taglist)))
{
switch(tag->ti_Tag)
{
case AROSCYCLE_Labels:
data->labels = (STRPTR *)tag->ti_Data;
data->numlabels = 0;
data->active = 0;
mylabels = data->labels;
if (mylabels)
{
while (mylabels[0])
{
data->numlabels++;
mylabels++;
}
}
rerender = TRUE;
break;
case AROSCYCLE_Active:
data->active = tag->ti_Data;
rerender = TRUE;
break;
case GA_Disabled:
rerender = TRUE;
break;
}
}
/* SDuvan: Removed test (cl == OCLASS(o)) */
if(rerender)
{
struct RastPort *rport;
if(data->active > data->numlabels-1)
data->active = 0;
//kprintf("Rerendering\n");
rport = ObtainGIRPort(msg->ops_GInfo);
if(rport)
{
DoMethod(o, GM_RENDER, (IPTR)msg->ops_GInfo, (IPTR)rport, GREDRAW_UPDATE);
ReleaseGIRPort(rport);
result = FALSE;
}
}
return result;
}
IPTR AROSCycle__GM_HANDLEINPUT(Class *cl, Object *o, struct gpInput *msg)
{
struct RastPort *rport;
struct CycleData *data;
IPTR retval = GMR_MEACTIVE;
data = INST_DATA(cl, o);
if (msg->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
{
if (msg->gpi_IEvent->ie_Code == SELECTUP)
{
if (G(o)->Flags & GFLG_SELECTED)
{
/* mouse is over gadget */
data->active++;
if (data->active == data->numlabels)
data->active = 0;
*msg->gpi_Termination = data->active;
retval = GMR_NOREUSE | GMR_VERIFY;
} else
/* mouse is not over gadget */
retval = GMR_NOREUSE;
/*
G(o)->Flags &= ~GFLG_SELECTED;
rport = ObtainGIRPort(msg->gpi_GInfo);
if (rport)
{
struct gpRender rmsg =
{ GM_RENDER, msg->gpi_GInfo, rport, GREDRAW_UPDATE };
DoMethodA(o, (Msg)&rmsg);
ReleaseGIRPort(rport);
}*/
} else if (msg->gpi_IEvent->ie_Code == IECODE_NOBUTTON)
{
struct gpHitTest htmsg =
{ GM_HITTEST, msg->gpi_GInfo,
{ msg->gpi_Mouse.X, msg->gpi_Mouse.Y },
}, *p_htmsg = &htmsg;
if (DoMethodA(o, (Msg)p_htmsg) != GMR_GADGETHIT)
{
if (EG(o)->Flags & GFLG_SELECTED)
{
G(o)->Flags &= ~GFLG_SELECTED;
rport = ObtainGIRPort(msg->gpi_GInfo);
if (rport)
{
struct gpRender rmsg =
{ GM_RENDER, msg->gpi_GInfo, rport, GREDRAW_UPDATE }, *p_rmsg = &rmsg;
DoMethodA(o, (Msg)p_rmsg);
ReleaseGIRPort(rport);
}
}
} else
{
if (!(EG(o)->Flags & GFLG_SELECTED))
{
EG(o)->Flags |= GFLG_SELECTED;
rport = ObtainGIRPort(msg->gpi_GInfo);
if (rport)
{
struct gpRender rmsg =
{ GM_RENDER, msg->gpi_GInfo, rport, GREDRAW_UPDATE }, *p_rmsg = &rmsg;
DoMethodA(o, (Msg)p_rmsg);
ReleaseGIRPort(rport);
}
}
}
} else if (msg->gpi_IEvent->ie_Code == MENUDOWN)
retval = GMR_REUSE;
}
return retval;
}
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;
}
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);
}
SAVEDS ULONG mSync(struct IClass *cl,Object *obj,Msg msg)
{
struct FloatIntData *data;
double DConv;
unsigned long int ULConv;
signed long int LConv;
data = INST_DATA(cl,obj);
Scratch[0] = NULL;
if(data->FIFlags & FIOFlag_Float)
{
DConv = *(float *)data->MasterVariable;
sprintf(Scratch, "%f", DConv);
} /* if */
else if(data->FIFlags & FIOFlag_Double)
{
DConv = *(double *)data->MasterVariable;
sprintf(Scratch, "%f", DConv);
} /* if */
else if(data->FIFlags & FIOFlag_Char)
{
if(data->FIFlags && FIOFlag_Unsigned)
{
ULConv = *(unsigned char *)data->MasterVariable;
sprintf(Scratch, "%u", ULConv);
} /* if */
else
{
LConv = *(char *)data->MasterVariable;
sprintf(Scratch, "%d", LConv);
} /* else */
} /* if */
else if(data->FIFlags & FIOFlag_Short)
{
if(data->FIFlags && FIOFlag_Unsigned)
{
ULConv = *(unsigned short *)data->MasterVariable;
sprintf(Scratch, "%u", ULConv);
} /* if */
else
{
LConv = *(short *)data->MasterVariable;
sprintf(Scratch, "%d", LConv);
} /* else */
} /* if */
else if(data->FIFlags & FIOFlag_Long)
{
if(data->FIFlags && FIOFlag_Unsigned)
{
ULConv = *(unsigned long *)data->MasterVariable;
sprintf(Scratch, "%u", ULConv);
} /* if */
else
{
LConv = *(long *)data->MasterVariable;
sprintf(Scratch, "%d", LConv);
} /* else */
} /* if */
set(data->string, MUIA_String_Contents, Scratch);
/* No-op to invoke triggers, if any */
ULConv = *(unsigned long *)data->MasterVariable;
/* The following results in infinite recursion:
** set(obj, MUIA_FloatInt_Contents, ULConv);
**
** Use this instead: */
SetAttrs(obj,MUIV_FloatInt_InhibitAutoSync,TRUE,MUIA_FloatInt_Contents, ULConv,TAG_DONE);
return(0);
}
Object *getStringCharsArray(Object *string) {
return (Object*)INST_DATA(string)[value_offset];
}
STATIC ULONG transwnd_Clear (struct IClass *cl, Object *obj, Msg msg)
{
struct transwnd_Data *data = (struct transwnd_Data *) INST_DATA(cl, obj);
DoMethod(data->mail_list, MUIM_NList_Clear);
return 0;
}
unsigned short *getStringChars(Object *string) {
Object *array = (Object*)INST_DATA(string)[value_offset];
int offset = INST_DATA(string)[offset_offset];
return ((unsigned short*)ARRAY_DATA(array))+offset;
}
/**************************************************************************
Render one item
**************************************************************************/
static void RenderRegisterTabItem(struct IClass *cl, Object *obj, WORD item)
{
struct Register_DATA *data = INST_DATA(cl, obj);
struct RegisterTabItem *ri = &data->items[item];
struct TextExtent extent;
WORD fitlen; /* text len fitting in alloted space */
WORD fitpix; /* text pixels fitting in alloted space */
WORD x, y;
WORD top_item_bar_y;
WORD bottom_item_bar_y;
WORD left_item_bar_x;
WORD right_item_bar_x;
WORD item_bar_width;
WORD text_y;
WORD item_bg_height;
WORD fitwidth;
if ((item < 0) || (item >= data->numitems)) return;
y = data->top + ri->y1;
if (data->active == item)
{
top_item_bar_y = _top(obj) + ri->y1;
bottom_item_bar_y = _top(obj) + ri->y2 - 2;
left_item_bar_x = _left(obj) + ri->x1 - 1;
right_item_bar_x = _left(obj) + ri->x2 + 1;
item_bg_height = data->tab_height;
text_y = y + data->ty;
item_bar_width = right_item_bar_x - left_item_bar_x + 1;
/* fill tab with register background */
DoMethod(obj,MUIM_DrawBackground, left_item_bar_x, top_item_bar_y + 4,
item_bar_width, item_bg_height - 4,
left_item_bar_x, top_item_bar_y + 4, 0);
DoMethod(obj,MUIM_DrawBackground, left_item_bar_x + 2, top_item_bar_y + 2,
item_bar_width - (2 * 2), 2,
left_item_bar_x + 2, top_item_bar_y + 2, 0);
DoMethod(obj,MUIM_DrawBackground, left_item_bar_x + 4, top_item_bar_y + 1,
item_bar_width - (2 * 4), 1,
left_item_bar_x + 4, top_item_bar_y + 1, 0);
}
else
{
top_item_bar_y = _top(obj) + ri->y1 + 2;
bottom_item_bar_y = _top(obj) + ri->y2 - 1;
left_item_bar_x = _left(obj) + ri->x1;
right_item_bar_x = _left(obj) + ri->x2;
item_bg_height = data->tab_height - 3;
text_y = y + data->ty + 1;
item_bar_width = right_item_bar_x - left_item_bar_x + 1;
SetAPen(_rp(obj), _pens(obj)[MPEN_BACKGROUND]);
RectFill(_rp(obj), left_item_bar_x, top_item_bar_y + 4,
right_item_bar_x, bottom_item_bar_y);
RectFill(_rp(obj), left_item_bar_x + 2, top_item_bar_y + 2,
right_item_bar_x - 2, top_item_bar_y + 3);
RectFill(_rp(obj), left_item_bar_x + 4, top_item_bar_y + 1,
right_item_bar_x - 4, top_item_bar_y + 1);
}
/* top horiz bar */
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
RectFill(_rp(obj), left_item_bar_x + 4, top_item_bar_y, right_item_bar_x - 4, top_item_bar_y);
/* left vert bar */
RectFill(_rp(obj), left_item_bar_x, top_item_bar_y + 4, left_item_bar_x, bottom_item_bar_y);
WritePixel(_rp(obj), left_item_bar_x + 1, top_item_bar_y + 3);
WritePixel(_rp(obj), left_item_bar_x + 1, top_item_bar_y + 2);
WritePixel(_rp(obj), left_item_bar_x + 2, top_item_bar_y + 1);
WritePixel(_rp(obj), left_item_bar_x + 3, top_item_bar_y + 1);
SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHINE]);
WritePixel(_rp(obj), left_item_bar_x + 3, top_item_bar_y);
WritePixel(_rp(obj), left_item_bar_x + 4, top_item_bar_y + 1);
WritePixel(_rp(obj), left_item_bar_x + 2, top_item_bar_y + 2);
WritePixel(_rp(obj), left_item_bar_x + 3, top_item_bar_y + 2);
WritePixel(_rp(obj), left_item_bar_x + 2, top_item_bar_y + 3);
WritePixel(_rp(obj), left_item_bar_x, top_item_bar_y + 3);
WritePixel(_rp(obj), left_item_bar_x + 1, top_item_bar_y + 4);
if (data->active == item)
{
/* bottom horiz bar */
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
WritePixel(_rp(obj), left_item_bar_x - 1, bottom_item_bar_y + 1);
SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
WritePixel(_rp(obj), right_item_bar_x + 1, bottom_item_bar_y + 1);
DoMethod(obj,MUIM_DrawBackground, left_item_bar_x - 1, bottom_item_bar_y + 2,
item_bar_width + (2 * 1), 1,
left_item_bar_x - 1, bottom_item_bar_y + 2, 0);
}
/* right vert bar */
SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
WritePixel(_rp(obj), right_item_bar_x - 1, top_item_bar_y + 2);
RectFill(_rp(obj), right_item_bar_x, top_item_bar_y + 4, right_item_bar_x, bottom_item_bar_y);
SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHADOW]);
WritePixel(_rp(obj), right_item_bar_x - 2, top_item_bar_y + 1);
WritePixel(_rp(obj), right_item_bar_x - 1, top_item_bar_y + 3);
WritePixel(_rp(obj), right_item_bar_x, top_item_bar_y + 3);
SetAPen(_rp(obj), _pens(obj)[MPEN_BACKGROUND]);
WritePixel(_rp(obj), right_item_bar_x - 3, top_item_bar_y + 1);
/* text */
fitwidth = item_bar_width - TEXTSPACING;
fitlen = TextFit(_rp(obj), ri->text, ri->textlen, &extent, NULL, 1, fitwidth, data->tab_height);
fitpix = extent.te_Width;
/* D(bug("extent for %s (len=%d) in %d pix = %d chars, %d pix [%x,%x,%x]\n", */
/* ri->text, ri->textlen, fitwidth, fitlen, fitpix, _rp(obj), _rp(obj)->Font, _font(obj))); */
x = left_item_bar_x + (item_bar_width - fitpix) / 2;
SetDrMd(_rp(obj), JAM1);
SetAPen(_rp(obj), _pens(obj)[MPEN_TEXT]);
Move(_rp(obj), x, text_y);
Text(_rp(obj), ri->text, fitlen);
}
/**************************************************************************
OM_SET
**************************************************************************/
IPTR Numeric__OM_SET(struct IClass *cl, Object * obj, struct opSet *msg)
{
struct MUI_NumericData *data = INST_DATA(cl, obj);
struct TagItem *tags, *tag;
LONG oldval, oldmin, oldmax;
STRPTR oldfmt;
IPTR ret;
BOOL values_changed = FALSE;
oldval = data->value;
oldfmt = data->format;
oldmin = data->min;
oldmax = data->max;
for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags));)
{
switch (tag->ti_Tag)
{
case MUIA_Numeric_CheckAllSizes:
_handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_CHECKALLSIZES);
break;
case MUIA_Numeric_Default:
/* data->defvalue = CLAMP(tag->ti_Data, data->min, data->max); */
data->defvalue = tag->ti_Data;
break;
case MUIA_Numeric_Format:
data->format = (STRPTR)tag->ti_Data;
break;
case MUIA_Numeric_Max:
data->max = tag->ti_Data;
break;
case MUIA_Numeric_Min:
data->min = tag->ti_Data;
break;
case MUIA_Numeric_Reverse:
_handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVERSE);
break;
case MUIA_Numeric_RevLeftRight:
_handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVLEFTRIGHT);
break;
case MUIA_Numeric_RevUpDown:
_handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVUPDOWN);
break;
case MUIA_Numeric_Value:
tag->ti_Data = CLAMP((LONG)tag->ti_Data, data->min, data->max);
if (data->value == (LONG)tag->ti_Data)
tag->ti_Tag = TAG_IGNORE;
else
data->value = (LONG)tag->ti_Data;
break;
}
}
/* If the max, min or format values changed, then the minimum and maximum sizes
of the string output by MUIM_Numeric_Strigify maye have changed, so
give the subclass a chance to recalculate them and relayout the group
accordingly. Basically, the subclass will have to react on changes to
these values as well (by setting a notification on them, or by overriding
OM_SET) and then recalculate the minimum and maximum sizes for the object. */
if (data->format != oldfmt || data->min != oldmin || data->max != oldmax)
{
values_changed = TRUE;
DoMethod(_parent(obj), MUIM_Group_InitChange);
DoMethod(_parent(obj), MUIM_Group_ExitChange);
}
ret = DoSuperMethodA(cl, obj, (Msg)msg);
if (data->value != oldval || values_changed)
{
MUI_Redraw(obj, MADF_DRAWUPDATE);
}
return ret;
}
/**************************************************************************
Render tab bar
**************************************************************************/
static void RenderRegisterTab(struct IClass *cl, Object *obj, ULONG flags)
{
struct Register_DATA *data = INST_DATA(cl, obj);
WORD tabx;
/*
* Erase / prepare for drawing
*/
if (flags & MADF_DRAWOBJECT)
{
DoMethod(obj, MUIM_DrawParentBackground, data->left, data->top,
data->framewidth, data->tab_height - 1, data->left, data->top, 0);
}
else
{
/* draw parent bg over oldactive */
IPTR method;
WORD old_left, old_top, old_width, old_height;
struct RegisterTabItem *ri = &data->items[data->oldactive];
if (data->oldactive >= data->columns) method = MUIM_DrawBackground;
else method = MUIM_DrawParentBackground;
old_left = _left(obj) + ri->x1 - 2;
old_top = _top(obj) + ri->y1;
old_width = ri->x2 - ri->x1 + 5;
old_height = data->tab_height - 1;
DoMethod(obj, method, old_left, old_top,
old_width, old_height, old_left, old_top, 0);
SetDrMd(_rp(obj), JAM1);
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
RectFill(_rp(obj), old_left, old_top + old_height, old_left + old_width, old_top + old_height);
}
SetDrMd(_rp(obj), JAM1);
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
SetFont(_rp(obj), _font(obj));
SetSoftStyle(_rp(obj), FS_NORMAL, AskSoftStyle(_rp(obj)));
/*
* Draw new graphics
*/
/* register frame */
if (flags & MADF_DRAWOBJECT || (data->active / data->columns != data->oldactive / data->columns))
{
int i,y,tabs_on_bottom = 0;
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
RectFill(_rp(obj), data->left,
data->top + data->tab_height - 1,
data->left,
data->top + data->tab_height + data->frameheight - 1);
y = data->top + data->tab_height - 1;
for (i=0; i<data->rows; i++)
{
if (!tabs_on_bottom && (i > data->active/data->columns))
{
y = _bottom(obj) - muiAreaData(obj)->mad_InnerBottom + data->tab_height;
tabs_on_bottom = 1;
}
RectFill(_rp(obj), data->left + 1, y, data->left + data->framewidth - 2, y);
y += data->tab_height;
}
SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
RectFill(_rp(obj), data->left + data->framewidth - 1,
data->top + data->tab_height - 1,
data->left + data->framewidth - 1,
data->top + data->tab_height + data->frameheight - 1);
RectFill(_rp(obj), data->left + 1,
data->top + data->tab_height + data->frameheight - 1,
data->left + data->framewidth - 2,
data->top + data->tab_height + data->frameheight - 1);
for(i = 0, tabx = 0; i < data->numitems; i++)
{
RenderRegisterTabItem(cl, obj, i);
}
}
else
{
/* If active register has been changed and is on same row we simply draw both registers only */
RenderRegisterTabItem(cl, obj, data->active);
RenderRegisterTabItem(cl, obj, data->oldactive);
}
}
/// mSearch()
IPTR mSearch(UNUSED struct IClass *cl, Object *obj, struct MUIP_TextEditor_Search *msg)
{
struct InstData *data = INST_DATA(cl, obj);
STRPTR str = msg->SearchString;
LONG len = strlen(str), step = 0;
ENTER();
if(len > 0 && len <= 120)
{
BYTE map[256];
LONG (*StrCmp)(STRPTR, STRPTR, LONG);
LONG cursor;
struct line_node *line;
// if the FromTop flag is set we start the search right from the top
if(isFlagSet(msg->Flags, MUIF_TextEditor_Search_FromTop))
{
cursor = 0;
line = GetFirstLine(&data->linelist);
}
else
{
cursor = data->CPos_X;
line = data->actualline;
}
memset(map, len, 256);
// if a casesensitive search is requested we use a different
// compare function.
if(isFlagSet(msg->Flags, MUIF_TextEditor_Search_CaseSensitive))
{
StrCmp = Native_strncmp;
while(*str)
map[(int)*str++] = step--;
}
else
{
StrCmp = Utility_strnicmp;
while(*str)
{
map[ToLower(*str)] = step;
map[ToUpper(*str++)] = step--;
}
}
if(isFlagSet(msg->Flags, MUIF_TextEditor_Search_Backwards))
{
//D(DBF_STARTUP, "MUIF_TextEditor_Search_Backwards search=%s\n", msg->SearchString);
if(Enabled(data))
cursor -= len;
while(line != NULL)
{
LONG lenTmp = len;
STRPTR contents = line->line.Contents + cursor - lenTmp+1;
STRPTR lower = line->line.Contents;
while(contents >= lower)
{
//D(DBF_STARTUP, "MUIF_TextEditor_Search_Backwards previous=%ld, contents=%s\n",line, contents);
if(!StrCmp(contents, msg->SearchString, len))
{
LONG startx = contents - line->line.Contents;
//D(DBF_STARTUP, "MUIF_TextEditor_Search_Backwards found\n");
SimpleMarkText(data, startx, line, startx+len, line);
RETURN(TRUE);
return TRUE;
}
contents -= 1;
lenTmp += 1;
}
line = GetPrevLine(line);
if(line != NULL)
cursor = line->line.Length;
}
}
else
{
while(line)
{
LONG skip;
STRPTR contents = line->line.Contents + cursor + len-1;
STRPTR upper = line->line.Contents + line->line.Length;
while(contents < upper)
{
skip = map[(int)(*contents)];
contents += skip;
if(skip <= 0)
{
if(!StrCmp(contents, msg->SearchString, len))
{
LONG startx = contents - line->line.Contents;
SimpleMarkText(data, startx, line, startx+len, line);
RETURN(TRUE);
return TRUE;
}
contents += len;
}
}
cursor = 0;
line = GetNextLine(line);
}
}
}
RETURN(FALSE);
return FALSE;
}
IPTR Register__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Register_DATA *data;
int i;
IPTR tmp;
obj = (Object *)DoSuperNewTags(cl, obj, NULL, MUIA_Group_PageMode, TRUE,
MUIA_Background, MUII_RegisterBack,
TAG_MORE, (IPTR) msg->ops_AttrList);
if (!obj) return (IPTR)NULL;
data = INST_DATA(cl, obj);
data->frame = GetTagData(MUIA_Register_Frame, 0, msg->ops_AttrList);
data->labels = (char**)GetTagData(MUIA_Register_Titles, 0, msg->ops_AttrList);
if (!data->labels)
{
CoerceMethod(cl, obj, OM_DISPOSE);
return (IPTR)NULL;
}
for(data->numitems = 0; data->labels[data->numitems]; data->numitems++)
;
if (data->numitems <= 0)
{
CoerceMethod(cl, obj, OM_DISPOSE);
return (IPTR)NULL;
}
data->columns = (WORD)GetTagData(MUIA_Register_Columns, data->numitems, msg->ops_AttrList);
if (data->columns <= 0) data->columns = 1;
data->rows = (data->numitems + data->columns - 1)/data->columns;
get(obj, MUIA_Group_ActivePage, &tmp);
data->active = (WORD)tmp;
if (data->active < 0 || data->active >= data->numitems)
{
data->active = 0;
}
data->oldactive = data->active;
data->items = (struct RegisterTabItem *)AllocVec(data->numitems * sizeof(struct RegisterTabItem),
MEMF_PUBLIC | MEMF_CLEAR);
if (!data->items)
{
CoerceMethod(cl, obj, OM_DISPOSE);
return (IPTR)NULL;
}
for(i = 0; i < data->numitems; i++)
{
data->items[i].text = data->labels[i];
}
data->ehn.ehn_Events = IDCMP_MOUSEBUTTONS | IDCMP_RAWKEY;
data->ehn.ehn_Priority = 0;
data->ehn.ehn_Flags = 0;
data->ehn.ehn_Object = obj;
data->ehn.ehn_Class = cl;
return (IPTR)obj;
}
/**************************************************************************
MUIM_Semaphore_AttemptShared
**************************************************************************/
IPTR Semaphore__MUIM_AttemptShared(struct IClass *cl, Object *obj, struct MUIP_Semaphore_AttemptShared *msg)
{
struct MUI_SemaphoreData *data = INST_DATA(cl, obj);
return (IPTR)AttemptSemaphoreShared(&data->sem);
}
IPTR Register__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
{
struct Register_DATA *data = INST_DATA(cl, obj);
WORD i, h = 0;
if (!DoSuperMethodA(cl, obj, (Msg)msg))
{
return FALSE;
}
_font(obj) = zune_font_get(obj, MUIV_Font_Title);
data->fonth = _font(obj)->tf_YSize;
data->fontb = _font(obj)->tf_Baseline;
h = 0;
i = data->fonth + REGISTERTAB_EXTRA_HEIGHT;
h = (i > h) ? i : h;
data->tab_height = h;
data->ty = data->fontb + 1 + (data->tab_height - data->fonth) / 2;
/* D(bug("Register_Setup : data->height=%d\n", data->tab_height)); */
for(i = 0; i < data->numitems; i++)
{
data->items[i].textlen = strlen(data->items[i].text);
}
data->total_hspacing = (data->columns + 1) * INTERTAB - 2;
/* D(bug("Register_AskMinMax : data->total_hspacing = %d\n", data->total_hspacing)); */
data->min_width = data->total_hspacing * 3;
data->def_width = data->total_hspacing;
if (!(muiGlobalInfo(obj)->mgi_Prefs->register_truncate_titles))
{
struct RastPort temprp;
int i;
WORD textpixmax;
InitRastPort(&temprp);
SetFont(&temprp, _font(obj));
textpixmax = 0;
for(i = 0; i < data->numitems; i++)
{
WORD textpix = TextLength(&temprp, data->items[i].text, data->items[i].textlen);
textpixmax = MAX(textpix, textpixmax);
}
data->def_width += (textpixmax + TEXTSPACING + 1) * data->numitems;
data->def_width = MAX(data->min_width, data->def_width);
DeinitRastPort(&temprp);
}
SetHardCoord(obj,data);
muiAreaData(obj)->mad_Flags |= (MADF_INNERLEFT | MADF_INNERTOP | MADF_INNERRIGHT | MADF_INNERBOTTOM);
DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
return TRUE;
}
void initialiseThreadStage2(InitArgs *args) {
Object *java_thread;
Class *thrdGrp_class;
MethodBlock *run, *remove_thread;
FieldBlock *group, *priority, *root, *threadId;
FieldBlock *vmThread = NULL, *thread = NULL;
FieldBlock *vmData, *daemon, *name;
/* Load thread class and register reference for compaction threading */
thread_class = findSystemClass0(SYMBOL(java_lang_Thread));
registerStaticClassRef(&thread_class);
if(thread_class != NULL) {
vmThread = findField(thread_class, SYMBOL(vmThread), SYMBOL(sig_java_lang_VMThread));
daemon = findField(thread_class, SYMBOL(daemon), SYMBOL(Z));
name = findField(thread_class, SYMBOL(name), SYMBOL(sig_java_lang_String));
group = findField(thread_class, SYMBOL(group), SYMBOL(sig_java_lang_ThreadGroup));
priority = findField(thread_class, SYMBOL(priority), SYMBOL(I));
threadId = findField(thread_class, SYMBOL(threadId), SYMBOL(J));
init_mb = findMethod(thread_class, SYMBOL(object_init),
SYMBOL(_java_lang_VMThread_java_lang_String_I_Z__V));
run = findMethod(thread_class, SYMBOL(run), SYMBOL(___V));
vmthread_class = findSystemClass0(SYMBOL(java_lang_VMThread));
CLASS_CB(vmthread_class)->flags |= VMTHREAD;
/* Register class reference for compaction threading */
registerStaticClassRef(&vmthread_class);
if(vmthread_class != NULL) {
thread = findField(vmthread_class, SYMBOL(thread), SYMBOL(sig_java_lang_Thread));
vmData = findField(vmthread_class, SYMBOL(vmData), SYMBOL(I));
}
}
/* findField and findMethod do not throw an exception... */
if((init_mb == NULL) || (vmData == NULL) || (run == NULL) || (daemon == NULL) ||
(name == NULL) || (group == NULL) || (priority == NULL) || (vmThread == NULL) ||
(thread == NULL) || (threadId == NULL))
goto error;
vmthread_offset = vmThread->offset;
thread_offset = thread->offset;
vmData_offset = vmData->offset;
daemon_offset = daemon->offset;
group_offset = group->offset;
priority_offset = priority->offset;
threadId_offset = threadId->offset;
name_offset = name->offset;
run_mtbl_idx = run->method_table_index;
/* Initialise the Java-level thread objects for the main thread */
java_thread = initJavaThread(&main_thread, FALSE, "main");
/* Main thread is now sufficiently setup to be able to run the thread group
initialiser. This is essential to create the root thread group */
thrdGrp_class = findSystemClass(SYMBOL(java_lang_ThreadGroup));
root = findField(thrdGrp_class, SYMBOL(root), SYMBOL(sig_java_lang_ThreadGroup));
addThread_mb = findMethod(thrdGrp_class, SYMBOL(addThread),
SYMBOL(_java_lang_Thread_args__void));
remove_thread = findMethod(thrdGrp_class, SYMBOL(removeThread),
SYMBOL(_java_lang_Thread_args__void));
/* findField and findMethod do not throw an exception... */
if((root == NULL) || (addThread_mb == NULL) || (remove_thread == NULL))
goto error;
rmveThrd_mtbl_idx = remove_thread->method_table_index;
/* Add the main thread to the root thread group */
INST_DATA(java_thread)[group_offset] = root->static_value;
{
DummyFrame dummy;
executeMethod(&dummy, ((Object*)root->static_value), addThread_mb, java_thread);
}
// dyn
INST_DATA(java_thread)[vmthread_offset] = 0;
/* Setup signal handling. This will be inherited by all
threads created within Java */
initialiseSignals();
/* Create the signal handler thread. It is responsible for
catching and handling SIGQUIT (thread dump) and SIGINT
(user-termination of the VM, e.g. via Ctrl-C). Note it
must be a valid Java-level thread as it needs to run the
shutdown hooks in the event of user-termination */
createVMThread("Signal Handler", dumpThreadsLoop);
return;
error:
jam_fprintf(stderr, "Error initialising VM (initialiseMainThread)\nCheck "
"the README for compatible versions of GNU Classpath\n");
printException();
exitVM(1);
}
IPTR Register__MUIM_HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
{
struct Register_DATA *data = INST_DATA(cl, obj);
WORD i, x, y;
if (msg->muikey != MUIKEY_NONE)
{
switch (msg->muikey)
{
case MUIKEY_PRESS:
case MUIKEY_RIGHT:
case MUIKEY_TOGGLE:
nfset(obj, MUIA_Group_ActivePage, MUIV_Group_ActivePage_Next);
return MUI_EventHandlerRC_Eat;
case MUIKEY_LEFT:
nfset(obj, MUIA_Group_ActivePage, MUIV_Group_ActivePage_Prev);
return MUI_EventHandlerRC_Eat;
case MUIKEY_WORDLEFT:
case MUIKEY_LINESTART:
nfset(obj, MUIA_Group_ActivePage, MUIV_Group_ActivePage_First);
return MUI_EventHandlerRC_Eat;
case MUIKEY_WORDRIGHT:
case MUIKEY_LINEEND:
nfset(obj, MUIA_Group_ActivePage, MUIV_Group_ActivePage_Last);
return MUI_EventHandlerRC_Eat;
}
}
if (msg->imsg)
{
if ((msg->imsg->Class == IDCMP_MOUSEBUTTONS) &&
(msg->imsg->Code == SELECTDOWN))
{
x = msg->imsg->MouseX - data->left;
y = msg->imsg->MouseY - data->top;
/* D(bug("Register_HandleEvent : %d,%d,%d -- %d,%d,%d\n", 0, x, _width(obj), 0, y, data->tab_height)); */
if (_between(0, x, _width(obj)))
{
/* D(bug("Register_HandleEvent : in tab, %d,%d\n", x, y)); */
for(i = 0; i < data->numitems; i++)
{
if (_between(data->items[i].x1, x, data->items[i].x2) &&
_between(data->items[i].y1, y, data->items[i].y2))
{
if (data->active != i)
{
nfset(obj, MUIA_Group_ActivePage, i);
return MUI_EventHandlerRC_Eat;
}
break;
}
}
}
}
}
return 0;
}
long long javaThreadId(Thread *thread) {
//return *(long long*)&(INST_DATA(thread->ee->thread)[threadId_offset]);
return *(long long*)&(INST_DATA(thread->thread)[threadId_offset]);
}
char *String2Buff(Object *string, char *buff, int buff_len) {
int str_len = INST_DATA(string)[count_offset];
int len = buff_len-1 < str_len ? buff_len-1 : str_len;
return String2Buff0(string, buff, len);
}
void dumpThreadsLoop(Thread *self) {
//return; // do nothing for now
//assert(false);
char buffer[256];
Thread *thread;
sigset_t mask;
int sig;
sigemptyset(&mask);
sigaddset(&mask, SIGQUIT);
sigaddset(&mask, SIGINT);
disableSuspend0(self, &self);
for(;;) {
sigwait(&mask, &sig);
/* If it was an interrupt (e.g. Ctrl-C) terminate the VM */
if(sig == SIGINT)
exitVM(0);
/* It must be a SIGQUIT. Do a thread dump */
suspendAllThreads(self);
jam_printf("\n------ JamVM version %s Full Thread Dump -------\n", VERSION);
for(thread = &main_thread; thread != NULL; thread = thread->next) {
//uintptr_t *thr_data = INST_DATA(thread->ee->thread);
uintptr_t *thr_data = INST_DATA(thread->thread);
int priority = thr_data[priority_offset];
int daemon = thr_data[daemon_offset];
assert(false);
//Frame *last = thread->ee->last_frame;
Frame* last = threadSelf()->get_current_spmt_thread()->get_current_mode()->frame;
/* Get thread name; we don't use String2Cstr(), as this mallocs memory
and may deadlock with a thread suspended in malloc/realloc/free */
String2Buff((Object*)thr_data[name_offset], buffer, sizeof(buffer));
jam_printf("\n\"%s\"%s %p priority: %d tid: %p id: %d state: %s (%d)\n",
buffer, daemon ? " (daemon)" : "", thread, priority, thread->tid,
thread->id, getThreadStateString(thread), thread->state);
while(last->prev != NULL) {
for(; last->mb != NULL; last = last->prev) {
MethodBlock *mb = last->mb;
ClassBlock *cb = CLASS_CB(mb->classobj);
/* Convert slashes in class name to dots. Similar to above,
we don't use slash2dots(), as this mallocs memory */
slash2dots2buff(cb->name, buffer, sizeof(buffer));
jam_printf("\tat %s.%s(", buffer, mb->name);
if(mb->is_native())
jam_printf("Native method");
else
if(cb->source_file_name == NULL)
jam_printf("Unknown source");
else {
int line = mapPC2LineNo(mb, last->last_pc);
jam_printf("%s", cb->source_file_name);
if(line != -1)
jam_printf(":%d", line);
}
jam_printf(")\n");
}
last = last->prev;
}
}
resumeAllThreads(self);
}
}
SAVEDS ULONG mStr(struct IClass *cl,Object *obj,Msg msg)
{
struct FloatIntData *data;
char ReSync = 0;
double *D;
float *F;
char *C, *Str;
unsigned char *UC;
short *S;
unsigned short *US;
long *L;
unsigned long *UL;
data = INST_DATA(cl,obj);
get(data->string, MUIA_String_Contents, &Str);
if(data->FIFlags & FIOFlag_Float)
{
F = (float *)data->MasterVariable;
*F = atof(Str);
} /* if */
else if(data->FIFlags & FIOFlag_Double)
{
D = (double *)data->MasterVariable;
*D = atof(Str);
} /* if */
else if(data->FIFlags & FIOFlag_Char)
{
if(data->FIFlags && FIOFlag_Unsigned)
{
C = (char *)data->MasterVariable;
*C = (char)atoi(Str);
if(*C > data->MaxAmount) {*C = (char)data->MaxAmount; ReSync = 1;}
if(*C < data->MinAmount) {*C = (char)data->MinAmount; ReSync = 1;}
} /* if */
else
{
UC = (unsigned char *)data->MasterVariable;
*UC = (unsigned char)atoi(Str);
if(*UC > data->MaxAmount) {*UC = (unsigned char)data->MaxAmount; ReSync = 1;}
if(*UC < data->MinAmount) {*UC = (unsigned char)data->MinAmount; ReSync = 1;}
} /* else */
} /* if */
else if(data->FIFlags & FIOFlag_Short)
{
if(data->FIFlags && FIOFlag_Unsigned)
{
S = (short *)data->MasterVariable;
*S = (short)atoi(Str);
if(*S > data->MaxAmount) {*S = (short)data->MaxAmount; ReSync = 1;}
if(*S < data->MinAmount) {*S = (short)data->MinAmount; ReSync = 1;}
} /* if */
else
{
US = (unsigned short *)data->MasterVariable;
*US = (unsigned short)atoi(Str);
if(*US > data->MaxAmount) {*US = (unsigned short)data->MaxAmount; ReSync = 1;}
if(*US < data->MinAmount) {*US = (unsigned short)data->MinAmount; ReSync = 1;}
} /* else */
} /* if */
else if(data->FIFlags & FIOFlag_Long)
{
if(data->FIFlags && FIOFlag_Unsigned)
{
L = (long *)data->MasterVariable;
*L = (long)atol(Str);
if(*L > data->MaxAmount) {*L = (long)data->MaxAmount; ReSync = 1;}
if(*L < data->MinAmount) {*L = (long)data->MinAmount; ReSync = 1;}
} /* if */
else
{
UL = (unsigned long *)data->MasterVariable;
*UL = (unsigned long)atol(Str);
if(*UL > data->MaxAmount) {*UL = (unsigned long)data->MaxAmount; ReSync = 1;}
if(*UL < data->MinAmount) {*UL = (unsigned long)data->MinAmount; ReSync = 1;}
} /* else */
} /* if */
if(ReSync)
{
/* Update string gadget to reflect max/min limiting */
/* This will trigger notifies */
mSync(cl, obj, msg);
} /* if */
else
{
/* No-op to invoke triggers, if any */
UL = (unsigned long *)data->MasterVariable;
/* set(obj, MUIA_FloatInt_Contents, *(UL)); */
SetAttrs(obj,MUIV_FloatInt_InhibitAutoSync,TRUE,MUIA_FloatInt_Contents, *(UL),TAG_DONE);
} /* else */
return(0);
}
