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); }