static int WBInit(LIBBASETYPEPTR LIBBASE)
{
/* Make sure that the libraries are opened in L_OpenLib() --------------*/
WorkbenchBase->wb_Initialized = FALSE;
/* Initialize our private lists ----------------------------------------*/
NEWLIST(&(WorkbenchBase->wb_AppWindows));
NEWLIST(&(WorkbenchBase->wb_AppIcons));
NEWLIST(&(WorkbenchBase->wb_AppMenuItems));
NEWLIST(&(WorkbenchBase->wb_HiddenDevices));
/* Initialize our semaphores -------------------------------------------*/
InitSemaphore(&(WorkbenchBase->wb_WorkbenchPortSemaphore));
InitSemaphore(&(WorkbenchBase->wb_InitializationSemaphore));
InitSemaphore(&(WorkbenchBase->wb_BaseSemaphore));
/* Initialize handler message port -------------------------------------*/
WorkbenchBase->wb_HandlerPort.mp_SigBit = SIGBREAKB_CTRL_F;
WorkbenchBase->wb_HandlerPort.mp_SigTask = NULL;
WorkbenchBase->wb_HandlerPort.mp_Flags = PA_IGNORE;
NEWLIST(&(WorkbenchBase->wb_HandlerPort.mp_MsgList));
#warning "TODO: DefaultStackSize should differ depending on the platform AROS is compiled for"
/* Initialize miscellanous variables -----------------------------------*/
WorkbenchBase->wb_DefaultStackSize = 1024 * 32; /* 32kiB */ // FIXME: also read from preferences */
D(bug("[WBLIB] WBInit: Using %d Bytes for DefaultStackSize\n", WorkbenchBase->wb_DefaultStackSize));
return TRUE;
}
struct MidiCluster *NewCluster(char *name,struct CamdBase *CamdBase){
struct MyMidiCluster *mymidicluster;
struct MidiCluster *midicluster;
mymidicluster=AllocMem(sizeof(struct MyMidiCluster),MEMF_ANY | MEMF_CLEAR | MEMF_PUBLIC);
if(mymidicluster==NULL) return NULL;
InitSemaphore(&mymidicluster->semaphore);
midicluster=&mymidicluster->cluster;
midicluster->mcl_Node.ln_Name=AllocVec(mystrlen(name) + 1,MEMF_ANY|MEMF_PUBLIC);
if(midicluster->mcl_Node.ln_Name==NULL){
FreeMem(midicluster,sizeof(struct MyMidiCluster));
return NULL;
}
mysprintf(CamdBase,midicluster->mcl_Node.ln_Name,"%s",name);
NEWLIST(&midicluster->mcl_Receivers);
NEWLIST(&midicluster->mcl_Senders);
AddTail(&CB(CamdBase)->midiclusters,&midicluster->mcl_Node);
return midicluster;
}
static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR LIBBASE)
{
/* Setup the timer.device data */
LIBBASE->tb_CurrentTime.tv_secs = 0;
LIBBASE->tb_CurrentTime.tv_micro = 0;
LIBBASE->tb_VBlankTime.tv_secs = 0;
LIBBASE->tb_VBlankTime.tv_micro = 1000000 / (SysBase->VBlankFrequency * SysBase->PowerSupplyFrequency);
LIBBASE->tb_Elapsed.tv_secs = 0;
LIBBASE->tb_Elapsed.tv_micro = 0;
D(kprintf("Timer period: %ld secs, %ld micros\n",
LIBBASE->tb_VBlankTime.tv_secs, LIBBASE->tb_VBlankTime.tv_micro));
LIBBASE->tb_MiscFlags = TF_GO;
/* Initialise the lists */
NEWLIST( &LIBBASE->tb_Lists[0] );
NEWLIST( &LIBBASE->tb_Lists[1] );
NEWLIST( &LIBBASE->tb_Lists[2] );
NEWLIST( &LIBBASE->tb_Lists[3] );
NEWLIST( &LIBBASE->tb_Lists[4] );
/* Start the timer2 */
outb((inb(0x61) & 0xfd) | 1, 0x61); /* Enable the timer (set GATE on) */
outb(0xb6, 0x43); /* Binary mode on Timer2, count mode 3? */
outb(0x00, 0x42); /* We're counting whole range */
outb(0x00, 0x42);
LIBBASE->tb_prev_tick = 0xffff;
/* Start up the interrupt server. This is shared between us and the
HIDD that deals with the vblank */
LIBBASE->tb_VBlankInt.is_Node.ln_Pri = 0;
LIBBASE->tb_VBlankInt.is_Node.ln_Type = NT_INTERRUPT;
LIBBASE->tb_VBlankInt.is_Node.ln_Name = (STRPTR)MOD_NAME_STRING;
LIBBASE->tb_VBlankInt.is_Code = (APTR)&VBlankInt;
LIBBASE->tb_VBlankInt.is_Data = LIBBASE;
AddIntServer(INTB_TIMERTICK, &LIBBASE->tb_VBlankInt);
/* VBlank EMU */
LIBBASE->tb_vblank_timerequest.tr_node.io_Command = TR_ADDREQUEST;
LIBBASE->tb_vblank_timerequest.tr_node.io_Device = (struct Device *)TimerBase;
LIBBASE->tb_vblank_timerequest.tr_node.io_Unit = (struct Unit *)UNIT_MICROHZ;
LIBBASE->tb_vblank_timerequest.tr_time.tv_secs = 0;
LIBBASE->tb_vblank_timerequest.tr_time.tv_micro = 1000000 / SysBase->VBlankFrequency;
SendIO(&LIBBASE->tb_vblank_timerequest.tr_node);
return TRUE;
}
static int thylacine_Init(struct ThylacineBase *tb)
{
struct Library *ExpansionBase;
int unit = 0;
InitSemaphore(&tb->tb_UnitLock);
NEWLIST(&tb->tb_Units);
if ((ExpansionBase = OpenLibrary("expansion.library", 36))) {
struct ConfigDev *cd = NULL;
while ((cd = FindConfigDev(cd, THYLACINE_VENDOR, THYLACINE_PRODUCT))) {
struct sl811hs *sl;
ULONG addr = (ULONG)(IPTR)cd->cd_BoardAddr;
ULONG data = addr + 0x4000;
// ULONG reset = addr + 0x100;
sl = sl811hs_Attach(addr, data, INTB_EXTER);
if (sl) {
((struct Node *)sl)->ln_Pri = unit++;
((struct Node *)sl)->ln_Name = "thylacine.device";
AddTail(&tb->tb_Units, (struct Node *)sl);
}
}
CloseLibrary(ExpansionBase);
}
return IsListEmpty(&tb->tb_Units) ? 0 : 1;
}
static struct TrackedResources * CopyResourcesState(const struct TrackedResources *src)
{
struct TrackedResources *tr;
struct OpenedResourceNode *orn;
tr = get_tr();
if (!tr)
return NULL;
/* opencount-based stuff */
NEWLIST(&tr->opened);
for(orn=(struct OpenedResourceNode *)src->opened.lh_Head;
orn->node.ln_Succ!=NULL;
orn=(struct OpenedResourceNode *)orn->node.ln_Succ)
{
struct OpenedResourceNode *nc;
nc = CopyResourcesNode(orn);
Enqueue(&tr->opened, (struct Node *)nc);
}
/* memory */
tr->freeMem = src->freeMem;
return tr;
}
void MH2Int_MakeMenusInactive(struct Window *win, UWORD menupick, struct IntuitionBase *IntuitionBase)
{
struct InputEvent ie;
struct IOStdReq ior;
struct MsgPort replyport;
memset( &replyport, 0, sizeof( replyport ) );
ie.ie_NextEvent = 0;
ie.ie_Class = IECLASS_MENU;
ie.ie_SubClass = IESUBCLASS_MENUSTOP;
ie.ie_Code = menupick;
ie.ie_EventAddress = win;
replyport.mp_Node.ln_Type = NT_MSGPORT;
replyport.mp_Flags = PA_SIGNAL;
replyport.mp_SigBit = SIGB_INTUITION;
replyport.mp_SigTask = FindTask(NULL);
NEWLIST(&replyport.mp_MsgList);
ior = *(GetPrivIBase(IntuitionBase)->InputIO);
ior.io_Message.mn_ReplyPort = &replyport;
ior.io_Command = IND_WRITEEVENT;
ior.io_Data = &ie;
ior.io_Length = sizeof(struct InputEvent);
DoIO((struct IORequest *)&ior);
}
static void _Init_Semaphore(void)
{
DB2(bug("%s()\n", __FUNCTION__));
InitSemaphore(&sema_sem);
NEWLIST(&semaphores);
}
void *timer_init(void)
{
struct timer_s *timer;
timer = lib_AllocMem(sizeof(*timer), MEMF_PUBLIC);
if (timer) {
timer->TimerBase = NULL;
timer->TimerMP.mp_SigBit = AllocSignal(-1);
if ((BYTE)timer->TimerMP.mp_SigBit != -1) {
timer->TimerMP.mp_Node.ln_Type = NT_MSGPORT;
timer->TimerMP.mp_Flags = PA_SIGNAL;
timer->TimerMP.mp_SigTask = FindTask(NULL);
NEWLIST(&timer->TimerMP.mp_MsgList);
timer->TimerIO.tr_node.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
timer->TimerIO.tr_node.io_Message.mn_ReplyPort = &timer->TimerMP;
timer->TimerIO.tr_node.io_Message.mn_Length = sizeof(timer->TimerIO);
if (OpenDevice(TIMERNAME, UNIT_MICROHZ, (struct IORequest *)&timer->TimerIO, 0) == 0) {
timer->TimerBase = &timer->TimerIO.tr_node.io_Device->dd_Library;
return timer;
}
}
timer_exit(timer);
}
return NULL;
}
void dotimer(ULONG unit,ULONG timercmd,struct timeval *t)
{
struct PortIO {
struct timerequest treq;
struct MsgPort port;
} *portio;
if ((portio = lib_AllocMem(sizeof(*portio), MEMF_CLEAR | MEMF_PUBLIC))) {
portio->port.mp_Node.ln_Type = NT_MSGPORT;
if ((BYTE)(portio->port.mp_SigBit = AllocSignal(-1)) >= 0) {
portio->port.mp_SigTask = FindTask(NULL);
NEWLIST(&portio->port.mp_MsgList);
portio->treq.tr_node.io_Message.mn_Node.ln_Type = NT_REPLYMSG;
portio->treq.tr_node.io_Message.mn_ReplyPort = &portio->port;
if (!(OpenDevice(TIMERNAME, unit, &portio->treq.tr_node, 0))) {
portio->treq.tr_node.io_Command = timercmd;
portio->treq.tr_time.tv_secs = t->tv_secs;
portio->treq.tr_time.tv_micro = t->tv_micro;
if (!DoIO(&portio->treq.tr_node)) {
t->tv_secs = portio->treq.tr_time.tv_secs;
t->tv_micro = portio->treq.tr_time.tv_micro;
}
CloseDevice(&portio->treq.tr_node);
}
FreeSignal(portio->port.mp_SigBit);
}
lib_FreeMem(portio,sizeof(struct PortIO));
}
}
static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR LIBBASE)
{
D(bug("[SiS900] Init()\n"));
UBYTE tmpbuff[100];
sprintf((char *)tmpbuff, SiS900_TASK_NAME, "sis900.0");
if (FindTask(tmpbuff) != NULL)
{
D(bug("[SiS900] device already up and running.\n"));
return FALSE;
}
NEWLIST(&LIBBASE->sis900b_Units);
LIBBASE->sis900b_PCIDeviceAttrBase = OOP_ObtainAttrBase(IID_Hidd_PCIDevice);
if (LIBBASE->sis900b_PCIDeviceAttrBase != 0)
{
D(bug("[SiS900] HiddPCIDeviceAttrBase @ %p\n", LIBBASE->sis900b_PCIDeviceAttrBase));
LIBBASE->sis900b_PCI = OOP_NewObject(NULL, CLID_Hidd_PCI, NULL);
if (LIBBASE->sis900b_PCI)
{
D(bug("[SiS900] PCI Subsystem HIDD object @ %p\n", LIBBASE->sis900b_PCI));
struct Hook FindHook = {
h_Entry: (IPTR (*)())PCI_Enumerator,
h_Data: LIBBASE,
};
void DoSyncAction(void (*func)(struct IntuiActionMsg *, struct IntuitionBase *),
struct IntuiActionMsg *msg,
struct IntuitionBase *IntuitionBase)
{
struct IIHData *iihd = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
struct Task *me = FindTask(NULL);
if (me == iihd->InputDeviceTask)
{
func(msg, IntuitionBase);
}
else
{
#ifdef __MORPHOS__
struct IOStdReq req;
struct MsgPort port;
struct InputEvent ie;
#endif
msg->handler = func;
msg->task = me;
msg->done = FALSE;
ObtainSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
AddTail((struct List *)GetPrivIBase(IntuitionBase)->IntuiActionQueue, (struct Node *)msg);
ReleaseSemaphore(&GetPrivIBase(IntuitionBase)->IntuiActionLock);
#ifdef __MORPHOS__
port.mp_Flags = PA_SIGNAL;
port.mp_SigTask = me;
port.mp_SigBit = SIGB_INTUITION;
NEWLIST(&port.mp_MsgList);
req.io_Message.mn_ReplyPort = &port;
req.io_Device = GetPrivIBase(IntuitionBase)->InputIO->io_Device;
req.io_Unit = GetPrivIBase(IntuitionBase)->InputIO->io_Unit;
req.io_Command = IND_WRITEEVENT;
req.io_Length = sizeof(ie);
req.io_Data = &ie;
ie.ie_Class = IECLASS_NULL;
#endif
if (!msg->done)
{
#ifdef __MORPHOS__
DoIO((APTR)&req);
#else
AddNullEvent();
#endif
while (!msg->done)
{
Wait(SIGF_INTUITION);
}
}
}
}
static int GM_UNIQUENAME(Init)(LIBBASETYPEPTR hdskBase)
{
HostLibBase = OpenResource("hostlib.resource");
D(bug("hostdisk: HostLibBase: 0x%p\n", HostLibBase));
if (!HostLibBase)
return FALSE;
InitSemaphore(&hdskBase->sigsem);
NEWLIST(&hdskBase->units);
D(bug("hostdisk: in libinit func. Returning %x (success) :-)\n", hdskBase));
return TRUE;
}
IPTR ModelClass__OM_NEW(Class *cl, Object *o, Msg msg)
{
struct ModelData *data;
if ((o = (Object *)DoSuperMethodA(cl, o, msg)))
{
data = INST_DATA(cl, o);
NEWLIST(&data->memberlist);
};
return (IPTR)o;
}
static struct Task *create_inputtask( struct inputtask_params *params)
{
struct Task *task;
APTR stack;
task = AllocMem(sizeof (struct Task), MEMF_PUBLIC|MEMF_CLEAR);
if (NULL != task)
{
NEWLIST(&task->tc_MemEntry);
task->tc_Node.ln_Type=NT_TASK;
task->tc_Node.ln_Name= INPUTTASK_NAME;
task->tc_Node.ln_Pri = INPUTTASK_PRIORITY;
stack=AllocMem(INPUTTASK_STACKSIZE, MEMF_PUBLIC);
if(NULL != stack)
{
task->tc_SPLower=stack;
task->tc_SPUpper=(BYTE *)stack + INPUTTASK_STACKSIZE;
task->tc_UserData=params;
#if AROS_STACK_GROWS_DOWNWARDS
task->tc_SPReg=(BYTE *)task->tc_SPUpper-SP_OFFSET-sizeof(APTR);
#else
task->tc_SPReg=(BYTE *)task->tc_SPLower-SP_OFFSET+sizeof(APTR);
#endif
/* You have to clear signals first. */
SetSignal(0, params->ok_signal | params->nok_signal);
if(AddTask(task, inputtask_entry, NULL) != NULL)
{
/* Everything went OK. Wait for task to initialize */
ULONG sigset;
D(bug("WAITING FOR SIGNAL\n"));
sigset = Wait( params->ok_signal | params->nok_signal );
D(bug("GOT SIGNAL\n"));
if (sigset & params->ok_signal)
return task;
}
FreeMem(stack, INPUTTASK_STACKSIZE);
}
FreeMem(task,sizeof(struct Task));
}
return NULL;
}
static int devInit(LIBBASETYPEPTR base) {
KPRINTF(10, ("devInit base: 0x%p SysBase: 0x%p\n", base, SysBase));
base->hd_MemPool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR | MEMF_SEM_PROTECTED, 16384, 4096);
if(base->hd_MemPool) {
NEWLIST(&base->hd_Units);
KPRINTF(10, ("devInit: Ok\n"));
} else {
KPRINTF(10, ("devInit: CreatePool() failed!\n"));
return FALSE;
}
KPRINTF(10, ("devInit: openCnt = %ld\n", base->hd_Library.lib_OpenCnt));
return TRUE;
}
ULONG TellWBTaskToCloseWindows(struct IntuitionBase *IntuitionBase)
{
DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: currenttask <%s>\n",
FindTask(NULL)->tc_Node.ln_Name));
if
(
GetPrivIBase(IntuitionBase)->WorkBenchMP != NULL
&& GetPrivIBase(IntuitionBase)->WorkBenchMP->mp_SigTask != FindTask(NULL)
)
{
struct MsgPort replymp;
struct IntuiMessage imsg;
/* Setup our reply port. By doing this manually, we can use SIGB_SINGLE
* and thus avoid allocating a signal (which may fail). */
memset( &replymp, 0, sizeof( replymp ) );
replymp.mp_Node.ln_Type = NT_MSGPORT;
replymp.mp_Flags = PA_SIGNAL;
replymp.mp_SigBit = SIGB_SINGLE;
replymp.mp_SigTask = FindTask( NULL );
NEWLIST( &replymp.mp_MsgList );
/* Setup our message */
imsg.ExecMessage.mn_ReplyPort = &replymp;
imsg.Class = IDCMP_WBENCHMESSAGE;
imsg.Code = WBENCHCLOSE;
SetSignal(0, SIGF_SINGLE);
DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: Send Msg\n"));
/* Sends it to the handler and wait for the reply */
PutMsg( GetPrivIBase(IntuitionBase)->WorkBenchMP,
(struct Message *) &imsg );
WaitPort( &replymp );
/* After leaving this block imsg and repymp will be automagically freed,
* so we don't have to deallocate them ourselves. */
DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: done\n"));
return(TRUE);
}
else
{
DEBUG_WORKBENCH(dprintf("TellWBTaskToCloseWindows: no Workbench port\n"));
}
return(FALSE);
}
static int __init_timerbase(void)
{
__timeport.mp_Node.ln_Type = NT_MSGPORT;
__timeport.mp_Node.ln_Pri = 0;
__timeport.mp_Node.ln_Name = NULL;
__timeport.mp_Flags = PA_IGNORE;
__timeport.mp_SigTask = FindTask(NULL);
__timeport.mp_SigBit = 0;
NEWLIST(&__timeport.mp_MsgList);
__timereq.tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
__timereq.tr_node.io_Message.mn_Node.ln_Pri = 0;
__timereq.tr_node.io_Message.mn_Node.ln_Name = NULL;
__timereq.tr_node.io_Message.mn_ReplyPort = &__timeport;
__timereq.tr_node.io_Message.mn_Length = sizeof (__timereq);
struct Locale *locale = OpenLocale(NULL);
if (locale)
{
__gmtoffset = locale->loc_GMTOffset;
CloseLocale(locale);
}
else
__gmtoffset = 0;
if
(
OpenDevice
(
"timer.device",
UNIT_VBLANK,
(struct IORequest *)&__timereq,
0
)
==
0
)
{
TimerBase = (struct Device *)__timereq.tr_node.io_Device;
return 1;
}
else
{
return 0;
}
}
IPTR observerNew(Class * cl, Object * obj, struct opSet * msg)
{
IPTR retval = 0;
struct ObserverClassData *data;
struct TagItem *tstate = msg->ops_AttrList,
*tag;
Object *presentation = NULL,
*parent = NULL;
while ((tag = NextTagItem(&tstate)) != NULL)
{
switch (tag->ti_Tag)
{
case OA_Presentation:
presentation = (Object *) tag->ti_Data;
break;
case OA_Parent:
parent = (Object *) tag->ti_Data;
break;
default:
continue; /* Don't supress non-processed tags */
}
tag->ti_Tag = TAG_IGNORE;
}
retval = DoSuperMethodA(cl, obj, (Msg) msg);
if (retval)
{
obj = (Object *) retval;
data = INST_DATA(cl, obj);
data->presentation = presentation;
data->parent = parent;
NEWLIST((struct List *) &data->freeList);
data->inTree = FALSE;
DoMethod(presentation, MUIM_Notify, PA_InTree, MUIV_EveryTime, (IPTR) obj, 3,
MUIM_Set, OA_InTree, TRUE);
}
return retval;
}
/*
* createPrime创建一个新的list, 其中的bound是上限
* 这里由于是判断一批数是否为素数, 故使用埃拉托斯特尼筛法
*/
void createPrime(long bound) {
int i, j;
FILE *fin = fopen(FILENAME, "wb");
printf("NONE prime.dat exits, Generating new one...\n");
/* bound值可能不能整除bits值, 这时应该适当放宽上限, 保证所有数都可以存储进去 */
long len = (bound % bits == 0? bound / bits : bound / bits + 1);
bound = len * bits;
/* 创建list */
NEWLIST(len);
/* 0和1不是素数 */
SETLIST(0);SETLIST(1);
/*
* 以下是埃拉托斯特尼筛法
* 具体详见[[http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes]]
*/
for (i = 2; i * i < bound; i++ ) {
if (LIST(i)!=0) {continue;}
for (j = i * i; j < bound; j+= i) {
SETLIST(j);
}
}
/*
* 将信息存储进文件中方便多次调用
* 文件中的第一个数为数组长度, 之后每行为一个元素值
*/
fprintf(fin, "%ld\n", len);
for (i = 0; i < len; i++) {
fprintf(fin, "%ld\n", primeList[i]);
}
list_len = len;
fclose(fin);
printf("Generating DONE\n");
return;
}
static int Irq_Init(LIBBASETYPEPTR LIBBASE)
{
int i;
struct irq_staticdata *isd = &LIBBASE->isd;
D(bug("[IRQ] IRQ: Initializing\n"));
/* Initialize IRQ lists */
for (i = 0; i < 16; i++)
{
NEWLIST(&isd->irqlist[i]);
}
Disable();
//init_Servers(isd); /* Initialize all known IRQ servers */
Enable(); /* Turn interrupts on */
D(bug("[IRQ] Init OK\n"));
return TRUE;
}
/* Get a snapshot of current resources */
static struct TrackedResources *NewResourcesState(void)
{
struct TrackedResources *tr;
tr = get_tr();
if (!tr)
return NULL;
/* flush */
FreeVec(AllocVec(~0ul/2, MEMF_ANY));
/* opencount-based stuff */
NEWLIST(&tr->opened);
if (!AddOpenedResources(&tr->opened))
return NULL;
/* memory */
tr->freeMem = AvailMem(MEMF_ANY);
return tr;
}
struct Task *CreateTask(STRPTR name, LONG pri, APTR initpc, ULONG stacksize)
{ struct Library *SysBase = *(struct Library **)4L;
struct newMemList nml;
struct MemList *ml;
struct Task *newtask;
APTR task2;
stacksize=(stacksize+3)&~3;
{ long *p1,*p2;
int i;
for (p1=(long *)&nml,p2=(long*)&MemTemplate,i=7; i; *p1++=*p2++,i--) ;
*p1=stacksize;
}
if (!(((unsigned int)ml=AllocEntry((struct MemList *)&nml)) & (1<<31))) {
newtask=ml->ml_ME[0].me_Addr;
newtask->tc_Node.ln_Type = NT_TASK;
newtask->tc_Node.ln_Pri = pri;
newtask->tc_Node.ln_Name = name;
newtask->tc_SPReg = (APTR)((ULONG)ml->ml_ME[1].me_Addr+stacksize);
newtask->tc_SPLower = ml->ml_ME[1].me_Addr;
newtask->tc_SPUpper = newtask->tc_SPReg;
NEWLIST(&newtask->tc_MemEntry);
AddHead(&newtask->tc_MemEntry,&ml->ml_Node);
task2=AddTask(newtask,initpc,0);
if (SysBase->lib_Version>36 && !task2) {
FreeEntry(ml); newtask = NULL;
}
}
else
newtask = NULL;
return newtask;
}
struct MsgPort *CreatePort(CONST_STRPTR name,LONG pri)
{ APTR SysBase = *(APTR *)4L;
struct MsgPort *port = NULL;
UBYTE portsig;
if ((BYTE)(portsig=AllocSignal(-1)) >= 0) {
if (!(port=AllocMem(sizeof(*port),MEMF_CLEAR|MEMF_PUBLIC)))
FreeSignal(portsig);
else {
port->mp_Node.ln_Type = NT_MSGPORT;
port->mp_Node.ln_Pri = pri;
port->mp_Node.ln_Name = name;
/* done via AllocMem
port->mp_Flags = PA_SIGNAL;
*/
port->mp_SigBit = portsig;
port->mp_SigTask = FindTask(NULL);
NEWLIST(&port->mp_MsgList);
if (port->mp_Node.ln_Name)
AddPort(port);
}
}
return port;
}
/*
* 初始化素数信息, 其中bound表示大致估计的需要判断素数的一个范围
*/
void initPrime(long bound) {
FILE *fin = fopen(FILENAME, "rb");
FILE *fout;
long i, j, k, length;
long len, num;
printf("Initializing New Prime_List...\n");
if (fin == NULL) {
/* 若文件不存在, 则创建一个新的 */
createPrime(bound);
}
else {
/* 否则从文件中读取信息 */
fscanf(fin, "%ld", &length);
/* 开辟数组空间 */
len = (bound % bits == 0? bound / bits : bound / bits + 1);
NEWLIST(len);
/*
* 从文件中读取信息
* 这里出现两种情况:
* 1. 文件中的信息大于给定的上限, 只需要读取即可
* 2. 文件给出的信息小于上线, 除了需要读取文件信息外, 还需要将对未给出的信息进行初始化判断
*/
for (i = 0; i < SMALL(length,len); i++) {
fscanf(fin, "%ld", &primeList[i]);
}
fclose(fin);
list_len = length;
/* 若文件给出信息不足, 则继续进行初始化判断 */
if (len > length) {
for (;i < len; i++) {
for (j = 0; j < bits; j++) {
num = i * bits + j;
if (!checkPrime(num))
SETLIST(num);
}
}
/* 将新的信息写入文件 */
fout = fopen("prime.dat", "wb");
fprintf(fout, "%ld\n", len);
for (i = 0; i < len; i++) {
fprintf(fout, "%ld\n", primeList[i]);
}
fclose(fout);
list_len = len;
}
}
printf("Initializing DONE\n");
return;
}
static int OOPInit(LIBBASETYPEPTR LIBBASE)
{
D(bug("Enter OOPInit\n"));
LIBBASE->ob_UtilityBase = OpenLibrary("utility.library",36);
if (!LIBBASE->ob_UtilityBase)
return FALSE;
NEWLIST(&LIBBASE->ob_ClassList);
InitSemaphore(&LIBBASE->ob_ClassListLock);
NEWLIST(&LIBBASE->ob_ServerList);
InitSemaphore(&LIBBASE->ob_ServerListLock);
InitSemaphore(&LIBBASE->ob_IIDTableLock);
SDInit();
LIBBASE->ob_IIDTable = NewHash(NUM_IDS, HT_STRING, LIBBASE);
if (LIBBASE->ob_IIDTable)
{
struct IDDescr intern_ids[] =
{
/* We must make sure that Root gets ID 0 and Meta gets ID 1 */
{ IID_Root, &__IRoot },
{ IID_Meta, &__IMeta },
#if 0
{ IID_Method, &__IMethod },
{ IID_Server, &__IServer },
{ IID_Proxy, &__IProxy },
{ IID_Interface, &__IInterface },
#endif
{ NULL, NULL }
};
/* Get some IDs that are used internally */
if (GetIDs(intern_ids, LIBBASE))
{
if (init_rootclass(LIBBASE))
{
if (init_basemeta(LIBBASE))
{
if (init_ifmetaclass(LIBBASE))
{
LIBBASE->ob_HIDDMetaClass
= init_hiddmetaclass(LIBBASE);
if (LIBBASE->ob_HIDDMetaClass)
{
if (InitUtilityClasses(LIBBASE))
{
D(bug("OOPInit all OK\n"));
return (TRUE);
}
}
}
}
}
}
}
D(bug("OOPInit failed\n"));
return (FALSE);
}
static int InitBase(LIBBASETYPEPTR LIBBASE)
{
NEWLIST(&LIBBASE->clients);
return TRUE;
}
STATIC BOOL FOGadInit(struct LayoutData *ld, struct AslBase_intern *AslBase)
{
struct FOUserData *udata = ld->ld_UserData;
struct IntFontReq *iforeq = (struct IntFontReq *)ld->ld_IntReq;
STRPTR str[6];
#if USE_SHARED_COOLIMAGES
struct ButtonInfo bi[NUMBUTS] =
{
{ ID_BUTOK , GetIR(iforeq)->ir_PositiveText , MSG_FONTREQ_POSITIVE_GAD, COOL_USEIMAGE_ID , &udata->OKBut },
{ ID_BUTCANCEL , GetIR(iforeq)->ir_NegativeText , MSG_FONTREQ_NEGATIVE_GAD, COOL_CANCELIMAGE_ID , &udata->CancelBut }
};
#else
struct ButtonInfo bi[NUMBUTS] =
{
{ ID_BUTOK , GetIR(iforeq)->ir_PositiveText , MSG_FONTREQ_POSITIVE_GAD, &cool_useimage , &udata->OKBut },
{ ID_BUTCANCEL , GetIR(iforeq)->ir_NegativeText , MSG_FONTREQ_NEGATIVE_GAD, &cool_cancelimage , &udata->CancelBut }
};
#endif
Object *gad;
LONG error;
WORD gadrows, x, y, w, h, i, y2;
WORD sizelvwidth, labelwidth = 0, maxgadcolwidth = 0;
NEWLIST(&udata->NameListviewList);
udata->SizeListviewRenderHook.h_Entry = (APTR)AROS_ASMSYMNAME(SizeListviewRenderFunc);
udata->SizeListviewRenderHook.h_SubEntry = NULL;
udata->SizeListviewRenderHook.h_Data = AslBase;
udata->StringEditHook.h_Entry = (APTR)AROS_ASMSYMNAME(StringEditFunc);
udata->StringEditHook.h_SubEntry = NULL;
udata->StringEditHook.h_Data = AslBase;
FOGetFonts(ld, AslBase);
error = ERROR_NO_FREE_STORE;
/* calc. min. size */
w = 0;
for(i = 0; i < NUMBUTS; i++)
{
if(!bi[i].text) bi[i].text = GetString(bi[i].deftextid, GetIR(iforeq)->ir_Catalog, AslBase);
x = TextLength(&ld->ld_DummyRP, bi[i].text, strlen(bi[i].text));
#if FOREQ_COOL_BUTTONS
#if USE_SHARED_COOLIMAGES
if (CoolImagesBase)
{
bi[i].coolimage = (const struct CoolImage *)COOL_ObtainImageA(bi[i].coolid, NULL);
}
if (CoolImagesBase)
#endif
if (ld->ld_TrueColor)
{
x += IMAGEBUTTONEXTRAWIDTH + bi[i].coolimage->width;
}
#endif
if (x > w) w = x;
}
udata->ButWidth = w + BUTTONEXTRAWIDTH;
ld->ld_ButWidth = udata->ButWidth;
ld->ld_NumButtons = 4;
#if FOREQ_COOL_BUTTONS
#if USE_SHARED_COOLIMAGES
if (CoolImagesBase)
{
#endif
y = BUTTONEXTRAHEIGHT + ld->ld_Font->tf_YSize;
if (ld->ld_TrueColor)
{
y2 = IMAGEBUTTONEXTRAHEIGHT + DEF_COOLIMAGEHEIGHT;
} else {
y2 = 0;
}
udata->ButHeight = (y > y2) ? y : y2;
#if USE_SHARED_COOLIMAGES
}
else
{
udata->ButHeight = BUTTONEXTRAHEIGHT + ld->ld_Font->tf_YSize;
}
#endif
#else
udata->ButHeight = BUTTONEXTRAHEIGHT + ld->ld_Font->tf_YSize;
#endif
gadrows = 2; /* button row + string gadgets under listviews */
if (iforeq->ifo_Flags & FOF_DODRAWMODE) gadrows++;
if (iforeq->ifo_Flags & FOF_DOSTYLE) gadrows++;
if (iforeq->ifo_Flags & (FOF_DOFRONTPEN | FOF_DOBACKPEN)) gadrows++;
ld->ld_MinWidth = OUTERSPACINGX * 2 +
GADGETSPACINGX * 1 +
udata->ButWidth * NUMBUTS;
ld->ld_MinHeight = OUTERSPACINGY * 2 +
(GADGETSPACINGY + udata->ButHeight) * gadrows +
BORDERLVSPACINGY * 2 +
(ld->ld_Font->tf_YSize + BORDERLVITEMSPACINGY * 2) * FOREQ_MIN_VISIBLELINES +
FONTPREVIEWHEIGHT + GADGETSPACINGY -
GADGETSPACINGY; /* because the string gadgets are attached to listview gadgets */
/* make listview gadgets */
sizelvwidth = PROPSIZE +
FOREQ_VISIBILE_SIZE_CHARS * ld->ld_Font->tf_XSize +
BORDERLVSPACINGX * 2 +
BORDERLVITEMSPACINGX * 2;
x = ld->ld_WBorLeft + OUTERSPACINGX;
y = ld->ld_WBorTop + OUTERSPACINGY;
w = -ld->ld_WBorRight - ld->ld_WBorLeft - OUTERSPACINGX * 2 - PROPSIZE - GADGETSPACINGX - sizelvwidth;
h = -ld->ld_WBorBottom - ld->ld_WBorTop - OUTERSPACINGY * 2 -
udata->ButHeight * gadrows -
GADGETSPACINGY * gadrows -
(FONTPREVIEWHEIGHT + GADGETSPACINGY) +
GADGETSPACINGY; /* because the string gadgets are attached to listview gadgets */
{
struct TagItem lv_tags[] =
{
{GA_Left , x },
{GA_Top , y },
{GA_RelWidth , w },
{GA_RelHeight , h },
{GA_UserData , (IPTR)ld },
{GA_ID , ID_NAMELISTVIEW },
{GA_RelVerify , TRUE },
{ASLLV_Labels , (IPTR)&udata->NameListviewList },
{TAG_IGNORE , 0 },
{TAG_IGNORE , (IPTR)&udata->SizeListviewRenderHook },
{ASLLV_Font , (IPTR)ld->ld_Font },
{TAG_DONE }
};
udata->NameListview = gad = NewObjectA(AslBase->asllistviewclass, NULL, lv_tags);
if (!gad) goto failure;
lv_tags[0].ti_Tag = GA_RelRight;
lv_tags[0].ti_Data = -ld->ld_WBorRight - OUTERSPACINGX - sizelvwidth + 1;
lv_tags[2].ti_Tag = GA_Width;
lv_tags[2].ti_Data = sizelvwidth - PROPSIZE;
lv_tags[5].ti_Data = ID_SIZELISTVIEW;
lv_tags[7].ti_Data = 0;
lv_tags[8].ti_Tag = GA_Previous;
lv_tags[8].ti_Data = (IPTR)gad;
lv_tags[9].ti_Tag = ASLLV_CallBack;
udata->SizeListview = gad = NewObjectA(AslBase->asllistviewclass, NULL, lv_tags);
if (!gad) goto failure;
}
/* make scroller gadgets for listviews */
x = -ld->ld_WBorRight - OUTERSPACINGX - PROPSIZE - sizelvwidth - GADGETSPACINGX + 1;
y = ld->ld_WBorTop + OUTERSPACINGY;
w = PROPSIZE;
h = -ld->ld_WBorBottom - ld->ld_WBorTop - OUTERSPACINGY * 2 -
udata->ButHeight * gadrows -
GADGETSPACINGY * gadrows -
(FONTPREVIEWHEIGHT + GADGETSPACINGY) +
GADGETSPACINGY;
{
struct TagItem scroller_tags[] =
{
{GA_RelRight , x },
{GA_Top , y },
{GA_Width , w },
{GA_RelHeight , h },
{GA_ID , ID_NAMELISTVIEW },
{PGA_NewLook , TRUE },
{PGA_Borderless , TRUE },
{PGA_Freedom , FREEVERT },
{PGA_Top , 0 },
{PGA_Total , 20 },
{PGA_Visible , 1 },
{GA_Previous , (IPTR)gad },
{TAG_DONE }
};
if (!makescrollergadget(&udata->NameScrollGad, ld, scroller_tags, AslBase)) goto failure;
gad = udata->NameScrollGad.arrow2;
scroller_tags[0].ti_Data = x + sizelvwidth + GADGETSPACINGX;
scroller_tags[1].ti_Data = y;
scroller_tags[2].ti_Data = w;
scroller_tags[3].ti_Data = h;
scroller_tags[4].ti_Data = ID_SIZELISTVIEW;
scroller_tags[11].ti_Data = (IPTR)gad;
if (!makescrollergadget(&udata->SizeScrollGad, ld, scroller_tags, AslBase)) goto failure;
gad = udata->SizeScrollGad.arrow2;
}
connectscrollerandlistview(&udata->NameScrollGad, udata->NameListview, AslBase);
connectscrollerandlistview(&udata->SizeScrollGad, udata->SizeListview, AslBase);
/* make preview gadget */
x = ld->ld_WBorLeft + OUTERSPACINGX;
y = -ld->ld_WBorBottom - OUTERSPACINGY - udata->ButHeight -
GADGETSPACINGY - FONTPREVIEWHEIGHT;
w = -ld->ld_WBorRight - ld->ld_WBorLeft - OUTERSPACINGX * 2;
{
struct TagItem preview_tags[] =
{
{GA_Left , x },
{GA_RelBottom , y },
{GA_RelWidth , w },
{GA_Height , FONTPREVIEWHEIGHT },
{GA_Previous , (IPTR)gad },
{GA_ID , ID_PREVIEW },
{ASLFP_SampleText , (IPTR)iforeq->ifo_SampleText },
{ASLFP_APen , iforeq->ifo_FrontPen },
{ASLFP_BPen , iforeq->ifo_BackPen },
{TAG_DONE }
};
udata->Preview = gad = NewObjectA(AslBase->aslfontpreviewclass, NULL, preview_tags);
if (!gad) goto failure;
}
/* make string gadgets */
x = ld->ld_WBorLeft + OUTERSPACINGX;
y = -ld->ld_WBorBottom - OUTERSPACINGY - udata->ButHeight -
(udata->ButHeight + GADGETSPACINGY) * (gadrows - 1) -
(FONTPREVIEWHEIGHT + GADGETSPACINGY) + 1;
w = -ld->ld_WBorRight - ld->ld_WBorLeft - OUTERSPACINGX * 2 - GADGETSPACINGX - sizelvwidth;
{
struct TagItem string_tags[] =
{
{GA_Left , x },
{GA_RelBottom , y },
{GA_RelWidth , w },
{GA_Height , udata->ButHeight },
{GA_Previous , (IPTR)gad },
{STRINGA_TextVal , (IPTR)"" },
{STRINGA_MaxChars , MAXFONTNAME },
{STRINGA_EditHook , (IPTR)&udata->StringEditHook },
{GA_ID , ID_NAMESTRING },
{GA_RelVerify , TRUE },
{GA_UserData , (IPTR)ld },
{GA_TabCycle , TRUE },
{STRINGA_Font , (IPTR)ld->ld_Font },
{TAG_DONE }
};
udata->NameString = gad = NewObjectA(AslBase->aslstringclass, NULL, string_tags);
if (!gad) goto failure;
string_tags[0].ti_Tag = GA_RelRight;
string_tags[0].ti_Data = -ld->ld_WBorRight - OUTERSPACINGX - sizelvwidth + 1;
string_tags[2].ti_Tag = GA_Width;
string_tags[2].ti_Data = sizelvwidth;
string_tags[4].ti_Data = (IPTR)gad;
string_tags[5].ti_Tag = STRINGA_LongVal;
string_tags[5].ti_Data = iforeq->ifo_TextAttr.ta_YSize;
string_tags[6].ti_Data = 6;
string_tags[8].ti_Data = ID_SIZESTRING;
udata->SizeString = gad = NewObjectA(AslBase->aslstringclass, NULL, string_tags);
if (!gad) goto failure;
}
/* make button row */
y = -ld->ld_WBorBottom - OUTERSPACINGY - udata->ButHeight + 1;
{
struct TagItem button_tags[] =
{
{GA_Text , 0 },
{GA_Previous , 0 },
{GA_ID , 0 },
#if FOREQ_COOL_BUTTONS
{ASLBT_CoolImage , 0 },
#else
{TAG_IGNORE , 0 },
#endif
{GA_UserData , (IPTR)ld },
{GA_Left , 0 },
{GA_RelBottom , y },
{GA_Width , udata->ButWidth },
{GA_Height , udata->ButHeight },
{GA_RelVerify , TRUE },
{GA_Image , 0 }, /* means we want a frame */
{TAG_DONE }
};
for(i = 0; i < NUMBUTS; i++)
{
button_tags[0].ti_Data = (IPTR)bi[i].text;
button_tags[1].ti_Data = (IPTR)gad;
button_tags[2].ti_Data = bi[i].gadid;
#if USE_SHARED_COOLIMAGES
if (CoolImagesBase == NULL) button_tags[3].ti_Tag = TAG_IGNORE;
#endif
button_tags[3].ti_Data = (IPTR)bi[i].coolimage;
*(bi[i].objvar) = gad = NewObjectA(AslBase->aslbuttonclass, NULL, button_tags);
if (!gad) goto failure;
}
}
/* make labels */
i = 0;
x = ld->ld_WBorLeft + OUTERSPACINGX;
y = -ld->ld_WBorBottom - OUTERSPACINGY - udata->ButHeight -
(udata->ButHeight + GADGETSPACINGY) * (gadrows - 2) -
(FONTPREVIEWHEIGHT + GADGETSPACINGY) + 1;
if (iforeq->ifo_Flags & (FOF_DODRAWMODE | FOF_DOSTYLE | FOF_DOFRONTPEN | FOF_DOBACKPEN))
{
#define FSET(x) ((iforeq->ifo_Flags & x) ? TRUE : FALSE)
struct LabelInfo
{
BOOL doit;
char *text;
Object **objvar;
} li [] =
{
{FSET(FOF_DOSTYLE) , (STRPTR)MSG_FONTREQ_STYLE_LABEL , &udata->StyleLabel },
{FALSE , (STRPTR)MSG_FONTREQ_COLOR_LABEL_FG, &udata->ColorLabel },
{FSET(FOF_DODRAWMODE) , (STRPTR)MSG_FONTREQ_MODE_LABEL , &udata->DrawModeLabel }
};
#undef FSET
struct TagItem label_tags[] =
{
{GA_Left , 0 },
{GA_RelBottom , y },
{GA_Width , 0 },
{GA_Height , udata->ButHeight },
{GA_Text , 0 },
{GA_Previous , (IPTR)gad },
{GA_UserData , (IPTR)ld },
{GA_Disabled , TRUE },
{TAG_DONE }
};
WORD i2;
if (iforeq->ifo_Flags & (FOF_DOFRONTPEN | FOF_DOBACKPEN))
{
li[1].doit = TRUE;
switch(iforeq->ifo_Flags & (FOF_DOFRONTPEN | FOF_DOBACKPEN))
{
case FOF_DOFRONTPEN:
break;
case FOF_DOBACKPEN:
li[1].text = (STRPTR)MSG_FONTREQ_COLOR_LABEL_BG;
break;
case FOF_DOFRONTPEN | FOF_DOBACKPEN:
li[1].text = (STRPTR)MSG_FONTREQ_COLOR_LABEL_FGBG;
break;
}
} /* if (iforeq->ifo_Flags & (FOF_DOFRONTPEN | FOF_DOBACKPEN)) */
for(i = 0, i2 = 0; i < 3; i++)
{
if (li[i].doit)
{
if ((i == 2) && (iforeq->ifo_ModeList))
{
li[i].text = iforeq->ifo_ModeList[0];
}
else
{
li[i].text = GetString((LONG)li[i].text, GetIR(iforeq)->ir_Catalog, AslBase);
}
str[i2++] = li[i].text;
}
}
w = labelwidth = BiggestTextLength(str, i2, &(ld->ld_DummyRP), AslBase);
for(i = 0; i < 3;i++)
{
if (!li[i].doit) continue;
label_tags[2].ti_Data = TextLength(&ld->ld_DummyRP, li[i].text, strlen(li[i].text));
label_tags[0].ti_Data = x + w - label_tags[2].ti_Data;
label_tags[4].ti_Data = (IPTR)li[i].text;
label_tags[5].ti_Data = (IPTR)gad;
*(li[i].objvar) = gad = NewObjectA(AslBase->aslbuttonclass, NULL, label_tags);
if (!gad) goto failure;
y += udata->ButHeight + GADGETSPACINGY;
label_tags[1].ti_Data = y;
}
y = -ld->ld_WBorBottom - OUTERSPACINGY - udata->ButHeight -
(udata->ButHeight + GADGETSPACINGY) * (gadrows - 2) -
(FONTPREVIEWHEIGHT + GADGETSPACINGY) + 1;
x = ld->ld_WBorLeft + OUTERSPACINGX + w + LABELSPACINGX;
/* Make Style gadget */
if (iforeq->ifo_Flags & FOF_DOSTYLE)
{
STRPTR stylestrings[3];
struct TagItem style_tags[] =
{
{GA_Previous , (IPTR)gad },
{GA_Left , x },
{GA_RelBottom , y },
{GA_Width , 0 },
{GA_Height , udata->ButHeight },
{GA_RelVerify , TRUE },
{GA_UserData , (IPTR)ld },
{GA_ID , ID_STYLE },
{ASLFS_LabelArray , (IPTR)stylestrings },
{ASLFS_Style , iforeq->ifo_TextAttr.ta_Style },
{TAG_DONE }
};
stylestrings[0] = GetString(MSG_FONTREQ_STYLE_BOLD, GetIR(iforeq)->ir_Catalog, AslBase);
stylestrings[1] = GetString(MSG_FONTREQ_STYLE_ITALIC, GetIR(iforeq)->ir_Catalog, AslBase);
stylestrings[2] = GetString(MSG_FONTREQ_STYLE_UNDERLINED, GetIR(iforeq)->ir_Catalog, AslBase);
w = BiggestTextLength(stylestrings, 3, &(ld->ld_DummyRP), AslBase);
w *= 2;
w *= 3;
style_tags[3].ti_Data = w;
if (w > maxgadcolwidth) maxgadcolwidth = w;
udata->StyleGadget = gad = NewObjectA(AslBase->aslfontstyleclass, NULL, style_tags);
if (!gad) goto failure;
y += udata->ButHeight + GADGETSPACINGY;
}
w = udata->ButHeight * 12 / 10 + 19; /* CYCLEIMAGEWIDTH = 19 */
/* Make FrontPen gadget */
if (iforeq->ifo_Flags & FOF_DOFRONTPEN)
{
struct TagItem cp_tags[] =
{
{GA_Previous , (IPTR)gad },
{GA_Left , x },
{GA_RelBottom , y },
{GA_Width , w },
{GA_Height , udata->ButHeight },
{GA_RelVerify , TRUE },
{GA_UserData , (IPTR)ld },
{GA_ID , ID_FRONTPEN },
{ASLCP_Color , iforeq->ifo_FrontPen },
{ASLCP_ColorTable , (IPTR)iforeq->ifo_FrontPens },
{ASLCP_NumColors , iforeq->ifo_MaxFrontPen },
{TAG_DONE }
};
udata->FGColorGadget = gad = NewObjectA(AslBase->aslcolorpickerclass, NULL, cp_tags);
if (!gad) goto failure;
x += w + GADGETSPACINGX;
}
/* Make BackPen gadget */
if (iforeq->ifo_Flags & FOF_DOBACKPEN)
{
struct TagItem cp_tags[] =
{
{GA_Previous , (IPTR)gad },
{GA_Left , x },
{GA_RelBottom , y },
{GA_Width , w },
{GA_Height , udata->ButHeight },
{GA_RelVerify , TRUE },
{GA_UserData , (IPTR)ld },
{GA_ID , ID_BACKPEN },
{ASLCP_Color , iforeq->ifo_BackPen },
{ASLCP_ColorTable , (IPTR)iforeq->ifo_BackPens },
{ASLCP_NumColors , iforeq->ifo_MaxBackPen },
{TAG_DONE }
};
udata->BGColorGadget = gad = NewObjectA(AslBase->aslcolorpickerclass, NULL, cp_tags);
if (!gad) goto failure;
}
if (iforeq->ifo_Flags & (FOF_DOFRONTPEN | FOF_DOBACKPEN))
{
if ((iforeq->ifo_Flags & (FOF_DOFRONTPEN | FOF_DOBACKPEN)) == (FOF_DOFRONTPEN | FOF_DOBACKPEN))
{
w += GADGETSPACINGX + w;
}
if (w > maxgadcolwidth) maxgadcolwidth = w;
y += udata->ButHeight + GADGETSPACINGY;
}
/* Make DrawMode gadget */
x = ld->ld_WBorLeft + OUTERSPACINGX + labelwidth + LABELSPACINGX;
w = -ld->ld_WBorLeft - ld->ld_WBorRight - OUTERSPACINGX * 2 -
labelwidth - LABELSPACINGX;
if (iforeq->ifo_Flags & FOF_DODRAWMODE)
{
struct TagItem cycle_tags[] =
{
{GA_Previous , (IPTR)gad },
{GA_Left , x },
{GA_RelBottom , y },
{GA_RelWidth , w },
{GA_Height , udata->ButHeight },
{GA_RelVerify , TRUE },
{GA_UserData , (IPTR)ld },
{GA_ID , ID_DRAWMODE },
{ASLCY_Labels , 0 },
{ASLCY_Active , iforeq->ifo_DrawMode },
{ASLCY_Font , (IPTR)ld->ld_Font },
{TAG_DONE }
};
static LONG labelids[] =
{
MSG_FONTREQ_MODE_TEXT,
MSG_FONTREQ_MODE_TEXTANDFIELD,
MSG_FONTREQ_MODE_COMPLEMENT,
};
STRPTR *labels;
if (iforeq->ifo_ModeList)
{
labels = &iforeq->ifo_ModeList[1];
}
else
{
labels = (STRPTR *)&iforeq->ifo_DrawModeJAM1Text;
for(i = 0; i < 3; i++)
{
labels[i] = GetString(labelids[i], GetIR(iforeq)->ir_Catalog, AslBase);
}
}
cycle_tags[8].ti_Data = (IPTR)labels;
i = CYCLEEXTRAWIDTH + BiggestTextLength(labels,
0x7FFF,
&(ld->ld_DummyRP),
AslBase);
if (i > maxgadcolwidth) maxgadcolwidth = i;
udata->DrawModeGadget = gad = NewObjectA(AslBase->aslcycleclass, NULL, cycle_tags);
if (!gad) goto failure;
y += udata->ButHeight + GADGETSPACINGY;
} /* if (iforeq->ifo_Flags & FOF_DODRAWMODE) */
} /* if (iforeq->ifo_Flags & (FOF_DODRAWMODE | FOF_DOSTYLE | FOF_DOFRONTPEN | FOF_DOBACKPEN)) */
#if AVOID_FLICKER
{
struct TagItem eraser_tags[] =
{
{GA_Previous, (IPTR)gad},
{TAG_DONE}
};
udata->EraserGadget = gad = NewObjectA(AslBase->asleraserclass, NULL, eraser_tags);
/* Doesn't matter if this failed */
}
#endif
w = OUTERSPACINGX + labelwidth + LABELSPACINGX + maxgadcolwidth + OUTERSPACINGX;
if (w > ld->ld_MinWidth) ld->ld_MinWidth = w;
ld->ld_GList = (struct Gadget *)udata->NameListview;
/* Menus */
{
struct NewMenu nm[] =
{
{NM_TITLE, (STRPTR)MSG_FONTREQ_MEN_CONTROL },
{NM_ITEM, (STRPTR)MSG_FONTREQ_MEN_CONTROL_LASTFONT , 0, 0, 0, (APTR)FOMEN_LASTFONT },
{NM_ITEM, (STRPTR)MSG_FONTREQ_MEN_CONTROL_NEXTFONT , 0, 0, 0, (APTR)FOMEN_NEXTFONT },
{NM_ITEM, NM_BARLABEL },
{NM_ITEM, (STRPTR)MSG_FONTREQ_MEN_CONTROL_RESTORE , 0, 0, 0, (APTR)FOMEN_RESTORE },
{NM_ITEM, (STRPTR)MSG_FONTREQ_MEN_CONTROL_RESCAN , 0, 0, 0, (APTR)FOMEN_RESCAN },
{NM_ITEM, NM_BARLABEL },
{NM_ITEM, (STRPTR)MSG_FONTREQ_MEN_CONTROL_OK , 0, 0, 0, (APTR)FOMEN_OK },
{NM_ITEM, (STRPTR)MSG_FONTREQ_MEN_CONTROL_CANCEL , 0, 0, 0, (APTR)FOMEN_CANCEL },
{NM_END }
};
struct TagItem menu_tags[] =
{
{GTMN_NewLookMenus , TRUE },
{GTMN_TextAttr , (IPTR)GetIR(iforeq)->ir_TextAttr },
{TAG_DONE }
};
if (menu_tags[1].ti_Data == 0) menu_tags[1].ti_Tag = TAG_IGNORE;
LocalizeMenus(nm, GetIR(iforeq)->ir_Catalog, AslBase);
/* Don't fail, if menus cannot be created/layouted, because a requester
without menus is still better than no requester at all */
if ((ld->ld_Menu = CreateMenusA(nm, NULL)))
{
if (!LayoutMenusA(ld->ld_Menu, ld->ld_VisualInfo, menu_tags))
{
FreeMenus(ld->ld_Menu);ld->ld_Menu = NULL;
}
}
}
FORestore(ld, iforeq->ifo_TextAttr.ta_Name, iforeq->ifo_TextAttr.ta_YSize, AslBase);
SetIoErr(0);
ReturnBool ("FOGadInit", TRUE);
failure:
SetIoErr(error);
D(bug("failure\n"));
FOGadCleanup(ld, ASLB(AslBase));
ReturnBool ("FOGadInit", FALSE);
}
int
main ()
{
int a;
short b;
APTR ptr;
WORD c;
struct List l;
ListPtr lptr;
struct Node n;
/* Store an int in a BE 16bit data type */
c = 15;
a = c; // Check if all conversions work
b = c;
// Try to print the data
printf ("Must be 15 15 15: %d %d %d\n", a, b, (int)c);
putchar ('\n');
// Same with a pointer
ptr = &lptr;
// Note that the pointer must be casted but the compiler will print
// a warning if the cast is missing:
// warning: cannot pass objects of type `APTR' through `...'
// These three lines must print the same values.
printf ("APTR %p %p\n", &lptr, (void *)ptr);
hexdump (&ptr, sizeof (ptr));
ptr.print (); putchar ('\n');
putchar ('\n');
// Same with a pointer
char * p1;
STRPTR p2;
p1 = "hello";
p2 = p1;
// Note that the pointer must be casted but the compiler will print
// a warning if the cast is missing:
// warning: cannot pass objects of type `STRPTR' through `...'
// The first line must print two equal pointers and the second line
// must print two times "hello".
printf ("string %p %p\n", p1, (void *)p2);
printf ("%s %s\n", p1, (UBYTE *)p2);
putchar ('\n');
// Show the contents of the memory (to prove that the actual data is BE)
printf ("Contents of p1 (host endianess) and p2 (big endian):\n");
hexdump (&p1, sizeof (p1));
hexdump (&p2, sizeof (p2));
putchar ('\n');
// Same with a structure
lptr = &l;
// Print address of list header
printf ("&lptr %p\n", &lptr);
// Print list pointers (host and BE) which must be equal (otherwise the
// BE pointer is not converted correctly).
printf ("List %p %p\n", &l, (void *)lptr);
// Show that it's really a BE pointer
hexdump (&lptr, sizeof (lptr));
// Print the real contents of the variable in host endianess
lptr.print ();
putchar ('\n');
putchar ('\n');
// Try some functions on the list
NEWLIST(lptr);
printf ("NewList %p %p %p\n", (void *)(l.lh_Head), (void *)l.lh_Tail, (void *)l.lh_TailPred);
printf ("NewList %p %p %p\n", (void *)(lptr->lh_Head), (void *)lptr->lh_Tail, (void *)lptr->lh_TailPred);
hexdump (&l, sizeof (struct List));
putchar ('\n');
ADDHEAD(lptr, &n);
printf ("&Node %p\n", &n);
printf ("AddHead %p %p %p\n", (void *)l.lh_Head, (void *)l.lh_Tail, (void *)l.lh_TailPred);
putchar ('\n');
return 0;
}
/******* TapUnit::New() ***********************************/
OOP_Object *UXTapUnit__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
{
struct HIDDTapUnitData * data;
static const struct TagItem tags[] = {{ TAG_END, 0}};
struct TagItem *tag, *tstate;
ULONG unitnum = 0;
EnterFunc(bug("TapUnit::New()\n"));
tstate = msg->attrList;
while ((tag = NextTagItem((const struct TagItem **)&tstate))) {
ULONG idx;
if (IS_HIDDTAPUNIT_ATTR(tag->ti_Tag, idx)) {
switch (idx) {
case aoHidd_TapUnit_Unit:
unitnum = (ULONG)tag->ti_Data;
break;
}
}
} /* while (tags to process) */
D(bug("!!!!Request for unit number %d\n",unitnum));
obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
if (obj) {
data = OOP_INST_DATA(cl, obj);
data->unitnum = unitnum;
D(bug("Creating network device %s.\n",unitname[data->unitnum]));
data->filedescriptor = unix_open_nonblock("/dev/net/tun");
if (data->filedescriptor < 0)
data->filedescriptor = unix_open_nonblock("/dev/tap");
D(bug("Opened %s on handle %d\n",unitname[data->unitnum], data->filedescriptor));
if (-1 != data->filedescriptor) {
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
strncpy(ifr.ifr_name, unitname[data->unitnum], IFNAMSIZ);
/*
** Configure the tty driver ?!?!?!
*/
{
data->replyport_read = AllocMem(sizeof(struct MsgPort), MEMF_PUBLIC|MEMF_CLEAR);
data->replyport_write= AllocMem(sizeof(struct MsgPort), MEMF_PUBLIC|MEMF_CLEAR);
if (data->replyport_read && data->replyport_write) {
/*
** Init the msg ports. They don't need a signal to be allocated
*/
NEWLIST(&data->replyport_read->mp_MsgList);
data->replyport_read ->mp_Node.ln_Type = NT_MSGPORT;
NEWLIST(&data->replyport_write->mp_MsgList);
data->replyport_write->mp_Node.ln_Type = NT_MSGPORT;
data->softint_read = AllocMem(sizeof(struct Interrupt), MEMF_CLEAR);
data->softint_write = AllocMem(sizeof(struct Interrupt), MEMF_CLEAR);
if (data->softint_read && data->softint_write) {
data->softint_read->is_Data = data;
data->softint_read->is_Code = tapunit_receive_data;
data->softint_write->is_Data = data;
data->softint_write->is_Code = tapunit_write_more_data;
data->replyport_read->mp_Flags = PA_SOFTINT;
data->replyport_read->mp_SoftInt = data->softint_read;
data->replyport_write->mp_Flags = PA_SOFTINT;
data->replyport_write->mp_SoftInt = data->softint_write;
data->unixio_read = OOP_NewObject(NULL, CLID_Hidd_UnixIO, (struct TagItem *)tags);
data->unixio_write = OOP_NewObject(NULL, CLID_Hidd_UnixIO, (struct TagItem *)tags);
if (NULL != data->unixio_read && NULL != data->unixio_write)
{
Hidd_UnixIO_IOControlFile(data->unixio_read,
data->filedescriptor,
TUNSETIFF,
&ifr,
NULL);
ULONG error;
D(bug("Creating UnixIO AsyncIO command!\n"));
error = Hidd_UnixIO_AsyncIO(data->unixio_read,
data->filedescriptor,
vHidd_UnixIO_Terminal,
data->replyport_read,
vHidd_UnixIO_Read | vHidd_UnixIO_Keep,
SysBase);
error = Hidd_UnixIO_AsyncIO(data->unixio_write,
data->filedescriptor,
vHidd_UnixIO_Terminal,
data->replyport_write,
vHidd_UnixIO_Write | vHidd_UnixIO_Keep,
SysBase);
goto exit;
}
if (NULL != data->unixio_read)
OOP_DisposeObject(data->unixio_read);
if (NULL != data->unixio_write)
OOP_DisposeObject(data->unixio_write);
}
if (data->softint_read)
FreeMem(data->softint_read, sizeof(struct Interrupt));
if (data->softint_write)
FreeMem(data->softint_write, sizeof(struct Interrupt));
}
if (data->replyport_read)
FreeMem(data->replyport_read , sizeof(struct MsgPort));
if (data->replyport_write)
FreeMem(data->replyport_write, sizeof(struct MsgPort));
}
close(data->filedescriptor);
}
OOP_DisposeObject(obj);
obj = NULL;
} /* if (obj) */
D(bug("%s - an error occurred!\n",__FUNCTION__));
exit:
ReturnPtr("TapUnit::New()", OOP_Object *, obj);
}
/* Compute the delta between 2 resources snapshots.
* the ResourceDiff can have dangling pointers in old and nu, so dont clear
* them before being done with rd in the processing loop
*/
static struct ResourceDiff *NewStateDiff(const struct TrackedResources *old,
const struct TrackedResources *nu)
{
/* FIXME */
struct OpenedResourceNode *orn;
struct ResourceDiff *rd;
rd = get_rd();
if (!rd)
return NULL;
NEWLIST(&rd->modifiedOpened);
for(orn=(struct OpenedResourceNode *)nu->opened.lh_Head;
orn->node.ln_Succ!=NULL;
orn=(struct OpenedResourceNode *)orn->node.ln_Succ)
{
struct OpenedResourceNode *other;
BOOL seen = FALSE;
for(other=(struct OpenedResourceNode *)old->opened.lh_Head;
other->node.ln_Succ!=NULL;
other=(struct OpenedResourceNode *)other->node.ln_Succ)
{
if (orn->addr == other->addr)
{
if (!strcmp(orn->name, other->name))
{
seen = TRUE;
if (orn->count != other->count)
{
struct ModifiedResource *mr = get_mr();
if (!mr)
return NULL;
mr->type = other->type;
mr->name = other->name;
mr->addr = other->addr;
mr->before_count = other->count;
mr->after_count = orn->count;
Enqueue(&rd->modifiedOpened, (struct Node *)mr);
}
}
}
}
if (!seen)
{
struct ModifiedResource *mr = get_mr();
if (!mr)
return NULL;
mr->type = orn->type;
mr->name = orn->name;
mr->addr = orn->addr;
mr->before_count = 0;
mr->after_count = orn->count;
Enqueue(&rd->modifiedOpened, (struct Node *)mr);
}
}
rd->memLost = old->freeMem - nu->freeMem;
return rd;
}
