/******* TapUnit::Write() **********************************/ ULONG UXTapUnit__Hidd_TapUnit__Write(OOP_Class *cl, OOP_Object *o, struct pHidd_TapUnit_Write *msg) { struct HIDDTapUnitData * data = OOP_INST_DATA(cl, o); ULONG len = 0; EnterFunc(bug("TapUnit::Write()\n")); if (TRUE == data->stopped) return 0; D(bug("Writing %d bytes to fd %d. The stream is:", msg->Length, data->filedescriptor)); D({ UBYTE *ptr = msg->Outbuffer; int j; for (j=0; j < MIN(64,msg->Length); j++) { if ((j%16) == 0) bug("\n%03x:", j); bug(" %02x", ptr[j]); } bug("\n"); });
VOID CM__Root__Get(OOP_Class *cl, OOP_Object *o, struct pRoot_Get *msg) { struct colormap_data *data; ULONG idx; EnterFunc(bug("ColorMap::Get()\n")); data = OOP_INST_DATA(cl, o); if (IS_COLORMAP_ATTR(msg->attrID, idx)) { switch (idx) { case aoHidd_ColorMap_NumEntries: *msg->storage = data->clut.entries; break; default: D(bug("!!! Unknow colormap attr in ColorMap::Get()\n")); OOP_DoSuperMethod(cl, o, (OOP_Msg)msg); break; } } else { OOP_DoSuperMethod(cl, o, (OOP_Msg)msg); } ReturnVoid("ColorMap::Get"); }
/******* SerialUnit::Write() **********************************/ ULONG serialunit_write(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_Write *msg) { struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o); ULONG len = msg->Length; ULONG count = 0; UWORD utx; EnterFunc(bug("SerialUnit::Write()\n")); /* * If the output is currently stopped just don't do anything here. */ if (TRUE == data->stopped) return 0; utx = serial_in_w(data, UTX); /* * I may only write something here if nothing is in the fifo right * now because otherwise this might be handled through an interrupt. */ if (utx & FIFO_EMPTY) { /* write data into FIFO */ do { serial_out_w(data, UTX, msg->Outbuffer[count++]); len--; utx = serial_in_w(data, UTX); } while (len > 0 && (utx & TX_AVAIL)); } ReturnInt("SerialUnit::Write()",ULONG, count); }
STATIC VOID FOGadCleanup(struct LayoutData *ld, struct AslBase_intern *AslBase) { struct FOUserData *udata = (struct FOUserData *)ld->ld_UserData; struct FontRequester *req = (struct FontRequester *)ld->ld_Req; struct IntReq *intreq = ld->ld_IntReq; // struct IntFontReq *iforeq = (struct IntFontReq *)intreq; EnterFunc(bug("FOGadCleanup(ld=%p)\n", ld)); if (ld->ld_Window && ld->ld_GList) { RemoveGList(ld->ld_Window, ld->ld_GList, -1); } killscrollergadget(&udata->NameScrollGad, AslBase); killscrollergadget(&udata->SizeScrollGad, AslBase); FreeObjects(&FOREQ_FIRST_OBJECT(udata), &FOREQ_LAST_OBJECT(udata), AslBase); FOFreeFonts(ld, AslBase); if (udata->PreviewFont) CloseFont(udata->PreviewFont); if (ld->ld_Window) { req->fo_LeftEdge = intreq->ir_LeftEdge = ld->ld_Window->LeftEdge; req->fo_TopEdge = intreq->ir_TopEdge = ld->ld_Window->TopEdge; req->fo_Width = intreq->ir_Width = ld->ld_Window->Width; req->fo_Height = intreq->ir_Height = ld->ld_Window->Height; } ReturnVoid("FOGadCleanup"); }
/******* SerialUnit::Write() **********************************/ ULONG PCSerUnit__Hidd_SerialUnit__Write(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_Write *msg) { struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o); unsigned char status; ULONG len = msg->Length; ULONG count = 0; EnterFunc(bug("SerialUnit::Write()\n")); /* * If the output is currently stopped just don't do anything here. */ if (TRUE == data->stopped) return 0; status = serial_inp(data, UART_LSR); if (status & UART_LSR_THRE) { /* write data into FIFO */ do { serial_outp(data, UART_TX, msg->Outbuffer[count++]); len--; } while (len > 0 && serial_inp(data, UART_LSR & UART_LSR_TEMT)); } ReturnInt("SerialUnit::Write()",ULONG, count); }
IPTR GTSlider__GM_HANDLEINPUT(Class *cl, Object *o, struct gpInput *msg) { struct InputEvent *ie = msg->gpi_IEvent; IPTR retval; struct SliderData *data = INST_DATA(cl ,o); EnterFunc(bug("Slider::HandleInput()\n")); retval = DoSuperMethodA(cl, o, (Msg)msg); /* Mousemove ? */ if ((ie->ie_Class == IECLASS_RAWMOUSE) && (ie->ie_Code == IECODE_NOBUTTON)) { LONG top; /* Get the PGA_Top attribute */ DoSuperMethod(cl, o, OM_GET, PGA_Top, (IPTR) &top); /* Level changed ? */ if (data->level - data->min != top) { data->level = data->min + top; notifylevel(cl, o, data->level, msg->gpi_GInfo, GadToolsBase); } } else { if (retval != GMR_MEACTIVE) { data->level = data->min + (WORD)*(msg->gpi_Termination); notifylevel(cl, o, data->level, msg->gpi_GInfo, GadToolsBase); } } ReturnInt("Slider::HandleInput", IPTR, retval); }
static void bitmap_dispose(Class *cl, Object *obj, Msg *msg) { struct HIDDBitMapAmigaIntuiData *data = INST_DATA(cl, obj); struct pHidd_BitMap_PrivateSet private_set_msg; EnterFunc(bug("BitMapAmigaIntui::Dispose()\n")); if(data->screen) { /* We use an own buffer so set the BaseAddress to NULL to prevent the superclass to free our own buffer. */ struct TagItem set[] = { {aHidd_BitMap_BaseAddress, NULL}, {TAG_END , 0 } }; CloseScreen(data->screen); private_set_msg.mID = GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PrivateSet); private_set_msg.attrList = set; DoSuperMethod(cl, obj, (Msg) &private_set_msg); } DoSuperMethod(cl, obj, (Msg) msg); ReturnVoid("BitMapAmigaIntui::Dispose"); }
/******* TapUnit::Dispose() ***********************************/ OOP_Object *UXTapUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg) { struct HIDDTapUnitData * data; EnterFunc(bug("TapUnit::Dispose()\n")); data = OOP_INST_DATA(cl, obj); D(bug("Freeing filedescriptor (%d)!\n",data->filedescriptor)); if (-1 != data->filedescriptor) { Hidd_UnixIO_AbortAsyncIO(data->unixio_read, data->filedescriptor, SysBase); close(data->filedescriptor); FreeMem(data->replyport_read, sizeof(struct MsgPort)); FreeMem(data->replyport_write, sizeof(struct MsgPort)); FreeMem(data->softint_read , sizeof(struct Interrupt)); FreeMem(data->softint_write, sizeof(struct Interrupt)); OOP_DisposeObject(data->unixio_read); OOP_DisposeObject(data->unixio_write); } OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg); ReturnPtr("TapUnit::Dispose()", OOP_Object *, obj); }
OOP_Object *CM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg) { struct Library *UtilityBase = CSD(cl)->cs_UtilityBase; struct Library *OOPBase = CSD(cl)->cs_OOPBase; struct colormap_data *data; ULONG numentries; struct TagItem *tag, *tstate; BOOL ok = FALSE; EnterFunc(bug("ColorMap::New()\n")); numentries = 256; for (tstate = msg->attrList; (tag = NextTagItem(&tstate)); ) { ULONG idx; if (IS_COLORMAP_ATTR(tag->ti_Tag, idx)) { switch (idx) { case aoHidd_ColorMap_NumEntries: numentries = tag->ti_Data; if (numentries > 256 || numentries < 0) { D(bug("!!! ILLEGAL value for NumEntries in ColorMap::New()\n")); } break; } /* switch */ } } /* Create the object */ o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg); if (NULL == o) return NULL; data = OOP_INST_DATA(cl, o); data->clut.entries = numentries; data->clut.colors = AllocMem(sizeof (HIDDT_Color) * data->clut.entries, MEMF_CLEAR); if (NULL != data->clut.colors) { ok = TRUE; } if (!ok) { ULONG dispose_mid; dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose); OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid); o = NULL; } ReturnPtr("ColorMap::New", OOP_Object *, o); }
static LONG open_con(struct conbase *conbase, struct IOFileSys *iofs) { struct filehandle *fh = (struct filehandle *)iofs->IOFS.io_Unit; STRPTR filename = iofs->io_Union.io_OPEN.io_Filename; #if DEBUG ULONG mode = iofs->io_Union.io_OPEN.io_FileMode; #endif struct conTaskParams params; struct Task *contask; LONG err = 0; EnterFunc(bug("open_conh(filename=%s, mode=%d)\n", filename, mode)); /* we're a console, we don't have a parent */ if (filename[0] == '/' && filename[1] == '\0') err = iofs->io_DosError = ERROR_OBJECT_NOT_FOUND; else if (fh != NULL && fh != (struct filehandle *)1) { /* DupLock */ fh->usecount++; } else { UBYTE sig = AllocSignal(-1); if (sig == (UBYTE)-1) { iofs->io_DosError = ERROR_NO_FREE_STORE; /* Any other error code better suited here? */ } else { params.conbase = conbase; params.iofs = iofs; params.parentTask = FindTask(NULL); params.initSignal = 1L << sig; contask = createConTask(¶ms, conbase); if (contask) { Wait(params.initSignal); if (iofs->io_DosError) { RemTask(contask); } } FreeSignal(sig); } err = iofs->io_DosError; } ReturnInt("open_conh", LONG, err); }
static int GFX_Init(LIBBASETYPEPTR LIBBASE) { struct class_static_data *csd = &LIBBASE->hdg_csd; EnterFunc(bug("GfxHIDD_Init()\n")); InitSemaphore(&csd->rgbconvertfuncs_sem); ReturnInt("GfxHIDD_Init", ULONG, TRUE); }
/******* TapUnit::Init() **********************************/ BOOL UXTapUnit__Hidd_TapUnit__Init(OOP_Class *cl, OOP_Object *o, struct pHidd_TapUnit_Init *msg) { struct HIDDTapUnitData * data = OOP_INST_DATA(cl, o); EnterFunc(bug("TapUnit::Init()\n")); data->DataReceivedCallBack = msg->DataReceived; data->DataReceivedUserData = msg->DataReceivedUserData; data->DataWriteCallBack = msg->WriteData; data->DataWriteUserData = msg->WriteDataUserData; ReturnBool("TapUnit::Init()", TRUE); }
ULONG SAVEDS STDARGS LC_BUILDNAME(L_InitLib) (LC_LIBHEADERTYPEPTR lh) { struct class_static_data *xsd; /* GfxHidd static data */ // SysBase = sysBase; EnterFunc(bug("GfxHIDD_Init()\n")); /* We map the memory into the shared memory space, because it is to be accessed by many processes, eg searching for a HIDD etc. Well, maybe once we've got MP this might help...:-) */ xsd = AllocVec(sizeof(struct class_static_data), MEMF_CLEAR|MEMF_PUBLIC); lh->hdg_csd = xsd; if(xsd) { xsd->sysbase = SysBase; D(bug(" Got csd\n")); xsd->oopbase = OpenLibrary(AROSOOP_NAME, 0); if (xsd->oopbase) { D(bug(" Got OOPBase\n")); xsd->utilitybase = OpenLibrary("utility.library", 37); if (xsd->utilitybase) { D(bug(" Got UtilityBase\n")); xsd->gfxhiddclass = init_gfxhiddclass(xsd); // D(bug(" GfxHiddClass: %p\n", csd->gfxhiddclass)) if(xsd->gfxhiddclass) { // D(bug(" Got GfxHIDDClass\n")) ReturnInt("GfxHIDD_Init", ULONG, TRUE); } CloseLibrary(xsd->utilitybase); } CloseLibrary(xsd->oopbase); } FreeVec(xsd); lh->hdg_csd = NULL; } ReturnInt("GfxHIDD_Init", ULONG, FALSE); }
/******* SerialUnit::New() ***********************************/ static OOP_Object *serialunit_new(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg) { struct HIDDSerialUnitData * data; struct TagItem *tag, *tstate; ULONG unitnum = 0; EnterFunc(bug("SerialUnit::New()\n")); tstate = msg->attrList; while ((tag = NextTagItem(&tstate))) { ULONG idx; #define csd CSD(cl->UserData) if (IS_HIDDSERIALUNIT_ATTR(tag->ti_Tag, idx)) { #undef csd switch (idx) { case aoHidd_SerialUnit_Unit: unitnum = (ULONG)tag->ti_Data; break; } } } /* while (tags to process) */ obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg); if (obj) { WORD dummy; data = OOP_INST_DATA(cl, obj); data->baseaddr = bases[unitnum]; data->datalength = 8; data->parity = FALSE; data->baudrate = 0; /* will be initialize in set_baudrate() */ data->unitnum = unitnum; CSD(cl->UserData)->units[data->unitnum] = data; D(bug("Unit %d at 0x0%x\n", data->unitnum, data->baseaddr)); /* Init UART - See 14-10 of dragonball documentation */ serial_out_w(data,USTCNT, UEN | RXEN); dummy = RREG_W(URX1); serial_out_w(data, USTCNT, (get_ustcnt(data) | UEN | RXEN | TXEN)); set_baudrate(data, SER_DEFAULT_BAUDRATE); } /* if (obj) */ ReturnPtr("SerialUnit::New()", OOP_Object *, obj); }
VOID _Timer_Start(Class *cl, Object *o, Msg msg) { struct TimerData *data; EnterFunc(bug("Timer::Start(cl=%p, o=%p)\n", cl, o)); D(bug("data=%p\n", data)); data = INST_DATA(cl, o); D(bug("data=%p\n", data)); gettimeofday(&(data->start_time), NULL); ReturnVoid("Timer::Start"); }
void free_serialunitclass(struct class_static_data *csd) { EnterFunc(bug("free_serialhiddclass(csd=%p)\n", csd)); if(csd) { OOP_RemoveClass(csd->serialhiddclass); if(csd->serialhiddclass) OOP_DisposeObject((OOP_Object *) csd->serialhiddclass); csd->serialhiddclass = NULL; } ReturnVoid("free_serialhiddclass"); }
STATIC WORD MaxDispPos(struct StringInfo *strinfo, struct BBox *bbox, struct RastPort *rp, struct IntuitionBase *IntuitionBase) { WORD numfit, max_disppos, numchars; struct TextExtent te; BOOL cursor_at_end; cursor_at_end = (strinfo->BufferPos == strinfo->NumChars); EnterFunc(bug("MaxDispPos(current length: %d, bufferpos=%d)\n", strinfo->NumChars, strinfo->BufferPos)); D(bug("cursor_at_end: %d\n", cursor_at_end)); if (cursor_at_end) /* Cursor at end of string ? */ { D(bug("Making cursor last char\n")); numchars = strinfo->NumChars + 1; /* Take cursor into account */ /* This has allready been done by UpdateDisp() which called us strinfo->Buffer[strinfo->NumChars] = 0x20; */ } else { numchars = strinfo->NumChars; } /* Find the amount of characters that fit into the bbox, counting ** from the last character in the buffer and forward, */ numfit = TextFit(rp, &(strinfo->Buffer[numchars - 1]), numchars, &te, NULL, -1, bbox->Width, rp->Font->tf_YSize); max_disppos = numchars - numfit; /* if ((max_disppos > 0) && (!cursor_at_end)) max_disppos --; */ D(bug("Numchars w/cursor: %d, Numfit: %d, maxdisppos=%d bbox->Width = %d te->te_Width = %d\n", numchars, numfit, max_disppos, bbox->Width, te.te_Width)); ReturnInt("MaxDispPos", WORD, max_disppos); }
void free_bitmapclass(struct class_static_data *csd) { EnterFunc(bug("free_bitmapclassAmigaIntui(csd=%p)\n", csd)); if(csd) { RemoveClass(csd->bitmapclass); DisposeObject((Object *) csd->bitmapclass); csd->bitmapclass = NULL; if(HiddBitMapAttrBase) ReleaseAttrBase(IID_Hidd_BitMap); } ReturnVoid("free_bitmapclassAmigaIntui"); }
/******* SerialUnit::Dispose() ***********************************/ static OOP_Object *serialunit_dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg) { struct HIDDSerialUnitData * data; EnterFunc(bug("SerialUnit::Dispose()\n")); data = OOP_INST_DATA(cl, obj); CSD(cl->UserData)->units[data->unitnum] = NULL; /* stop all interrupts, disabling the UART (might save power) */ serial_out_w(data, USTCNT, 0); OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg); ReturnPtr("SerialUnit::Dispose()", OOP_Object *, obj); }
IPTR GTSlider__GM_GOACTIVE(Class *cl, Object *o, struct gpInput *msg) { IPTR retval; struct SliderData *data = INST_DATA(cl, o); EnterFunc(bug("Slider::GoActive()\n")); retval = DoSuperMethodA(cl, o, (Msg)msg); if (retval != GMR_MEACTIVE) { data->level = data->min + (WORD)*(msg->gpi_Termination); notifylevel(cl, o, data->level, msg->gpi_GInfo, GadToolsBase); } ReturnInt("Slider::Goactive", IPTR, retval); }
IPTR GTSlider__OM_NEW(Class * cl, Object * o, struct opSet *msg) { struct DrawInfo *dri; struct TagItem fitags[] = { {IA_Width , 0UL }, {IA_Height , 0UL }, {IA_Resolution , 0UL }, {IA_FrameType , FRAME_BUTTON }, {IA_EdgesOnly , TRUE }, {TAG_DONE } }; EnterFunc(bug("Slider::New()\n")); o = (Object *)DoSuperMethodA(cl, o, (Msg)msg); if (o) { struct SliderData *data = INST_DATA(cl, o); dri = (struct DrawInfo *)GetTagData(GA_DrawInfo, (IPTR) NULL, msg->ops_AttrList); fitags[0].ti_Data = GetTagData(GA_Width, 0, msg->ops_AttrList) + BORDERPROPSPACINGX * 2; fitags[1].ti_Data = GetTagData(GA_Height, 0, msg->ops_AttrList) + BORDERPROPSPACINGY * 2; fitags[2].ti_Data = (dri->dri_Resolution.X << 16) + dri->dri_Resolution.Y; data->frame = NewObjectA(NULL, FRAMEICLASS, fitags); if (data->frame) { data->freedom=GetTagData(PGA_Freedom,FREEHORIZ,msg->ops_AttrList); data->min = 0; data->max = 15; data->level = data->freedom==FREEHORIZ?data->min:data->max; GTSlider__OM_SET(cl, o, msg); data->labelplace = GetTagData(GA_LabelPlace, GV_LabelPlace_Left, msg->ops_AttrList); } else { CoerceMethod(cl, o, OM_DISPOSE); o = NULL; } } ReturnPtr("Slider::New", IPTR, (IPTR)o); }
/******* SerialUnit::Dispose() ***********************************/ OOP_Object *PCSerUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg) { struct HIDDSerialUnitData * data; EnterFunc(bug("SerialUnit::Dispose()\n")); data = OOP_INST_DATA(cl, obj); Disable(); CSD(cl->UserData)->units[data->unitnum] = NULL; Enable(); /* stop all interrupts */ serial_outp(data, UART_IER, 0); OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg); ReturnPtr("SerialUnit::Dispose()", OOP_Object *, obj); }
VOID MNAME_BM(PutImageLUT)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImageLUT *msg) { struct bitmap_data *data = OOP_INST_DATA(cl, o); struct Box box = {0, 0, 0, 0}; EnterFunc(bug("VGAGfx.BitMap::PutImageLUT(pa=%p, x=%d, y=%d, w=%d, h=%d)\n", msg->pixels, msg->x, msg->y, msg->width, msg->height)); HIDD_BM_CopyMemBox8(o, msg->pixels, 0, 0, data->VideoData, msg->x, msg->y, msg->width, msg->height, msg->modulo, data->width); if (data->disp) { box.x1 = msg->x; box.y1 = msg->y; box.x2 = box.x1 + msg->width - 1; box.y2 = box.y1 + msg->height - 1; ObtainSemaphore(&XSD(cl)->HW_acc); vgaRefreshArea(data, 1, &box); if ( ( (XSD(cl)->mouseX + XSD(cl)->mouseW - 1 >= box.x1) && (XSD(cl)->mouseX <= box.x2) ) || ( (XSD(cl)->mouseY + XSD(cl)->mouseH - 1 >= box.y1) && (XSD(cl)->mouseY <= box.y2) ) ) draw_mouse(XSD(cl)); ReleaseSemaphore(&XSD(cl)->HW_acc); } ReturnVoid("VGAGfx.BitMap::PutImageLUT"); }
OOP_Object *PCVesa__Hidd_Gfx__NewBitMap(OOP_Class *cl, OOP_Object *o, struct pHidd_Gfx_NewBitMap *msg) { BOOL displayable; BOOL framebuffer; OOP_Class *classptr = NULL; struct TagItem tags[2]; struct pHidd_Gfx_NewBitMap yourmsg; EnterFunc(bug("VesaGfx::NewBitMap()\n")); displayable = GetTagData(aHidd_BitMap_Displayable, FALSE, msg->attrList); framebuffer = GetTagData(aHidd_BitMap_FrameBuffer, FALSE, msg->attrList); if (framebuffer) classptr = XSD(cl)->onbmclass; else if (displayable) classptr = XSD(cl)->offbmclass; else { HIDDT_ModeID modeid; modeid = (HIDDT_ModeID)GetTagData(aHidd_BitMap_ModeID, vHidd_ModeID_Invalid, msg->attrList); if (modeid != vHidd_ModeID_Invalid) classptr = XSD(cl)->offbmclass; else { HIDDT_StdPixFmt stdpf; stdpf = (HIDDT_StdPixFmt)GetTagData(aHidd_BitMap_StdPixFmt, vHidd_StdPixFmt_Unknown, msg->attrList); if (stdpf == vHidd_StdPixFmt_Unknown) { OOP_Object *friend; friend = (OOP_Object *)GetTagData(aHidd_BitMap_Friend, 0, msg->attrList); if (friend != NULL) { OOP_Object *gfxhidd; OOP_GetAttr(friend, aHidd_BitMap_GfxHidd, (APTR)&gfxhidd); if (gfxhidd == o) { classptr = XSD(cl)->offbmclass; } } } } }
OOP_Object *PCVesa__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg) { struct TagItem pftags[] = { {aHidd_PixFmt_RedShift, 0}, /* 0 */ {aHidd_PixFmt_GreenShift, 0}, /* 1 */ {aHidd_PixFmt_BlueShift, 0}, /* 2 */ {aHidd_PixFmt_AlphaShift, 0}, /* 3 */ {aHidd_PixFmt_RedMask, 0}, /* 4 */ {aHidd_PixFmt_GreenMask, 0}, /* 5 */ {aHidd_PixFmt_BlueMask, 0}, /* 6 */ {aHidd_PixFmt_AlphaMask, 0}, /* 7 */ {aHidd_PixFmt_ColorModel, 0}, /* 8 */ {aHidd_PixFmt_Depth, 0}, /* 9 */ {aHidd_PixFmt_BytesPerPixel,0}, /* 10 */ {aHidd_PixFmt_BitsPerPixel, 0}, /* 11 */ {aHidd_PixFmt_StdPixFmt, 0}, /* 12 */ {aHidd_PixFmt_CLUTShift, 0}, /* 13 */ {aHidd_PixFmt_CLUTMask, 0}, /* 14 */ {aHidd_PixFmt_BitMapType, 0}, /* 15 */ {TAG_DONE, 0UL } }; struct TagItem sync_mode[] = { {aHidd_Sync_PixelClock, 0}, {aHidd_Sync_HDisp, 0}, {aHidd_Sync_VDisp, 0}, {aHidd_Sync_Description,0}, {aHidd_Sync_HSyncStart, 0}, {aHidd_Sync_HSyncEnd, 0}, {aHidd_Sync_HTotal, 0}, {aHidd_Sync_VSyncStart, 0}, {aHidd_Sync_VSyncEnd, 0}, {aHidd_Sync_VTotal, 0}, {TAG_DONE, 0UL} }; struct TagItem modetags[] = { {aHidd_Gfx_PixFmtTags, (IPTR)pftags}, {aHidd_Gfx_SyncTags, (IPTR)sync_mode}, {TAG_DONE, 0UL} }; struct TagItem yourtags[] = { {aHidd_Gfx_ModeTags, (IPTR)modetags}, {TAG_MORE, 0UL} }; struct pRoot_New yourmsg; pftags[0].ti_Data = XSD(cl)->data.redshift; pftags[1].ti_Data = XSD(cl)->data.greenshift; pftags[2].ti_Data = XSD(cl)->data.blueshift; pftags[3].ti_Data = 0; pftags[4].ti_Data = XSD(cl)->data.redmask; pftags[5].ti_Data = XSD(cl)->data.greenmask; pftags[6].ti_Data = XSD(cl)->data.bluemask; pftags[7].ti_Data = 0; pftags[8].ti_Data = (XSD(cl)->data.depth > 8) ? vHidd_ColorModel_TrueColor : vHidd_ColorModel_Palette; pftags[9].ti_Data = (XSD(cl)->data.depth > 24) ? 24 : XSD(cl)->data.depth; pftags[10].ti_Data = XSD(cl)->data.bytesperpixel; pftags[11].ti_Data = (XSD(cl)->data.bitsperpixel > 24) ? 24 : XSD(cl)->data.bitsperpixel; pftags[12].ti_Data = vHidd_StdPixFmt_Native; pftags[14].ti_Data = (1 << XSD(cl)->data.depth) - 1; pftags[15].ti_Data = vHidd_BitMapType_Chunky; sync_mode[1].ti_Data = XSD(cl)->data.width; sync_mode[2].ti_Data = XSD(cl)->data.height; __sprintf(syncdescription, "VESA:%ldx%ld", XSD(cl)->data.width, XSD(cl)->data.height); sync_mode[3].ti_Data = (IPTR)syncdescription; yourtags[1].ti_Data = (IPTR)msg->attrList; yourmsg.mID = msg->mID; yourmsg.attrList = yourtags; msg = &yourmsg; EnterFunc(bug("VesaGfx::New()\n")); o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg); if (o) { D(bug("Got object from super\n")); XSD(cl)->vesagfxhidd = o; XSD(cl)->mouse.shape = NULL; ReturnPtr("VesaGfx::New", OOP_Object *, o); } ReturnPtr("VesaGfx::New", OOP_Object *, NULL); }
/*********** BitMap::New() *************************************/ OOP_Object *MNAME_ROOT(New)(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg) { EnterFunc(bug("VesaGfx.BitMap::New()\n")); o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg) msg); if (o) { struct BitmapData *data; IPTR width, height, depth, multi; OOP_Object *friend, *pf; data = OOP_INST_DATA(cl, o); /* clear all data */ memset(data, 0, sizeof(struct BitmapData)); /* Get attr values */ OOP_GetAttr(o, aHidd_BitMap_Width, &width); OOP_GetAttr(o, aHidd_BitMap_Height, &height); OOP_GetAttr(o, aHidd_BitMap_GfxHidd, (IPTR *)&data->gfxhidd); OOP_GetAttr(o, aHidd_BitMap_PixFmt, (IPTR *)&pf); data->pixfmtobj = pf; OOP_GetAttr(pf, aHidd_PixFmt_Depth, &depth); OOP_GetAttr(pf, aHidd_PixFmt_BytesPerPixel, &multi); /* Get the friend bitmap. This should be a displayable bitmap */ OOP_GetAttr(o, aHidd_BitMap_Friend, (IPTR *)&friend); /* If you got a friend bitmap, copy its colormap */ if (friend) { struct BitmapData *src = OOP_INST_DATA(cl, friend); CopyMem(&src->cmap, &data->cmap, 4*16); } ASSERT (width != 0 && height != 0 && depth != 0); width=(width+15) & ~15; data->width = width; data->height = height; data->bpp = depth; data->disp = 0; data->bytesperpix = multi; data->bytesperline = width * multi; data->VideoData = AllocVec(width*height*multi, MEMF_PUBLIC | MEMF_CLEAR); if (data->VideoData) { data->data = &XSD(cl)->data; if (XSD(cl)->activecallback) XSD(cl)->activecallback(XSD(cl)->callbackdata, o, TRUE); ReturnPtr("VesaGfx.BitMap::New()", OOP_Object *, o); } /* if got data->VideoData */ { OOP_MethodID disp_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose); OOP_CoerceMethod(cl, o, (OOP_Msg) &disp_mid); } o = NULL; } /* if created object */
STATIC ULONG FOHandleEvents(struct LayoutData *ld, struct AslBase_intern *AslBase) { struct IntuiMessage *imsg = ld->ld_Event; struct FOUserData *udata = (struct FOUserData *)ld->ld_UserData; struct IntFontReq *iforeq = (struct IntFontReq *)ld->ld_IntReq; WORD gadid; ULONG retval = GHRET_OK; EnterFunc(bug("FOHandleEvents: Class: %d\n", imsg->Class)); switch (imsg->Class) { case IDCMP_CLOSEWINDOW: retval = FALSE; break; case IDCMP_RAWKEY: switch (imsg->Code) { case CURSORUP: FOChangeActiveFont(ld, -1, imsg->Qualifier, FALSE, AslBase); break; case RAWKEY_PAGEUP: FOChangeActiveFont(ld, -1, IEQUALIFIER_LSHIFT, FALSE, AslBase); break; case RAWKEY_HOME: FOChangeActiveFont(ld, -1, IEQUALIFIER_LALT, FALSE, AslBase); break; case RAWKEY_NM_WHEEL_UP: FOChangeActiveFont(ld, -3, imsg->Qualifier, FALSE, AslBase); break; case CURSORDOWN: FOChangeActiveFont(ld, 1, imsg->Qualifier, FALSE, AslBase); break; case RAWKEY_PAGEDOWN: FOChangeActiveFont(ld, 1, IEQUALIFIER_LSHIFT, FALSE, AslBase); break; case RAWKEY_END: FOChangeActiveFont(ld, 1, IEQUALIFIER_LALT, FALSE, AslBase); break; case RAWKEY_NM_WHEEL_DOWN: FOChangeActiveFont(ld, 3, imsg->Qualifier, FALSE, AslBase); break; } break; case IDCMP_VANILLAKEY: switch(imsg->Code) { case 27: retval = FALSE; break; } break; case IDCMP_GADGETUP: gadid = ((struct Gadget *)imsg->IAddress)->GadgetID; D(bug("GADGETUP! gadgetid=%d code=%d\n", gadid, imsg->Code)); switch (gadid) { case ID_BUTCANCEL: retval = FALSE; break; case ID_BUTOK: retval = FOGetSelectedFont(ld, AslBase); break; case ID_NAMELISTVIEW: { struct ASLLVFontReqNode *fontnode; IPTR active; IPTR size; GetAttr(ASLLV_Active, udata->NameListview, &active); GetAttr(STRINGA_LongVal, udata->SizeString, &size); if ((fontnode = (struct ASLLVFontReqNode *)FindListNode(&udata->NameListviewList, (WORD)active))) { FOActivateFont(ld, active, (LONG)size, AslBase); if (imsg->Code) /* TRUE if double clicked */ { retval = FOGetSelectedFont(ld, AslBase); } } ActivateGadget((struct Gadget *)udata->NameString, ld->ld_Window, NULL); } break; case ID_SIZELISTVIEW: if (udata->ActiveFont) { struct Node *node; IPTR active; GetAttr(ASLLV_Active, udata->SizeListview, &active); if ((node = FindListNode(&udata->ActiveFont->SizeList, (WORD)active))) { FOSetSizeString((LONG)node->ln_Name, ld, AslBase); FOUpdatePreview(ld, AslBase); if (imsg->Code) /* TRUE if double clicked */ { retval = FOGetSelectedFont(ld, AslBase); } } ActivateGadget((struct Gadget *)udata->SizeString, ld->ld_Window, NULL); } break; case ID_NAMESTRING: if (imsg->Code == STRINGCODE_CURSORUP) { FOChangeActiveFont(ld, -1, imsg->Qualifier, TRUE, AslBase); ActivateGadget((struct Gadget *)udata->NameString, ld->ld_Window, NULL); break; } else if (imsg->Code == STRINGCODE_CURSORDOWN) { FOChangeActiveFont(ld, 1, imsg->Qualifier, TRUE, AslBase); ActivateGadget((struct Gadget *)udata->NameString, ld->ld_Window, NULL); break; } else if ((imsg->Code == 0) || (imsg->Code == 9)) { FOUpdatePreview(ld, AslBase); break; } break; case ID_SIZESTRING: if (imsg->Code == STRINGCODE_CURSORUP) { FOChangeActiveSize(ld, -1, imsg->Qualifier, AslBase); ActivateGadget((struct Gadget *)udata->SizeString, ld->ld_Window, NULL); break; } else if (imsg->Code == STRINGCODE_CURSORDOWN) { FOChangeActiveSize(ld, 1, imsg->Qualifier, AslBase); ActivateGadget((struct Gadget *)udata->SizeString, ld->ld_Window, NULL); break; } else if ((imsg->Code == 0) || (imsg->Code == 9)) { IPTR val; LONG size; GetAttr(STRINGA_LongVal, udata->SizeString, (IPTR *)&val); size = (LONG)val; if ((size < iforeq->ifo_MinHeight) || (size > iforeq->ifo_MaxHeight)) { if (size < iforeq->ifo_MinHeight) size = iforeq->ifo_MinHeight; if (size > iforeq->ifo_MaxHeight) size = iforeq->ifo_MaxHeight; FOSetSizeString(size, ld, AslBase); } FOActivateSize(ld, -size, AslBase); break; } break; case ID_STYLE: case ID_FRONTPEN: case ID_BACKPEN: FOUpdatePreview(ld, AslBase); break; } /* switch (gadget ID) */ break; /* case IDCMP_GADGETUP: */ case IDCMP_MENUPICK: if (ld->ld_Menu) { UWORD men = imsg->Code; while(men != MENUNULL) { struct MenuItem *item; if ((item = ItemAddress(ld->ld_Menu, men))) { switch((IPTR)GTMENUITEM_USERDATA(item)) { /* Control menu */ case FOMEN_LASTFONT: FOChangeActiveFont(ld, -1, 0, FALSE, AslBase); break; case FOMEN_NEXTFONT: FOChangeActiveFont(ld, 1, 0, FALSE, AslBase); break; case FOMEN_RESTORE: FORestore(ld, iforeq->ifo_TextAttr.ta_Name, iforeq->ifo_TextAttr.ta_YSize, AslBase); break; case FOMEN_RESCAN: FOGetFonts(ld, AslBase); break; case FOMEN_OK: retval = FOGetSelectedFont(ld, AslBase); break; case FOMEN_CANCEL: retval = FALSE; break; } /* switch id */ men = item->NextSelect; } /* if ((item = ItemAddress(ld->ld_Menu, men))) */ else { men = MENUNULL; } } /* while(men != MENUNULL) */ } /* if (ld->ld_Menu) */ break; /* case IDCMP_MENUPICK: */ } /* switch (imsg->Class) */ ReturnInt ("FOHandleEvents", ULONG, retval); }
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)); }
AROS_UFH3(VOID, FOTagHook, AROS_UFHA(struct Hook *, hook, A0), AROS_UFHA(struct ParseTagArgs *, pta, A2), AROS_UFHA(struct AslBase_intern *, AslBase, A1) ) { AROS_USERFUNC_INIT struct TagItem *tag; const struct TagItem *tstate; struct IntFontReq *iforeq; EnterFunc(bug("FOTagHook(hook=%p, pta=%p)\n", hook, pta)); iforeq = (struct IntFontReq *)pta->pta_IntReq; tstate = pta->pta_Tags; while ((tag = NextTagItem(&tstate)) != NULL) { IPTR tidata = tag->ti_Data; switch (tag->ti_Tag) { case ASLFO_InitialName: if (tidata) iforeq->ifo_TextAttr.ta_Name = (STRPTR)tidata; break; case ASLFO_InitialSize: iforeq->ifo_TextAttr.ta_YSize = (UWORD)tidata; break; case ASLFO_InitialStyle: iforeq->ifo_TextAttr.ta_Style = (UBYTE)tidata; break; case ASLFO_InitialFlags: iforeq->ifo_TextAttr.ta_Flags = (UBYTE)tidata; break; case ASLFO_InitialFrontPen: iforeq->ifo_FrontPen = (UBYTE)tidata; break; case ASLFO_InitialBackPen: iforeq->ifo_BackPen = (UBYTE)tidata; break; case ASLFO_InitialDrawMode: iforeq->ifo_DrawMode = (UBYTE)tidata; break; case ASLFO_Flags: iforeq->ifo_Flags = (UBYTE)tidata; break; case ASLFO_DoFrontPen: if (tidata) iforeq->ifo_Flags |= FOF_DOFRONTPEN; else iforeq->ifo_Flags &= ~FOF_DOFRONTPEN; break; case ASLFO_DoBackPen: if (tidata) iforeq->ifo_Flags |= FOF_DOBACKPEN; else iforeq->ifo_Flags &= ~FOF_DOBACKPEN; break; case ASLFO_DoStyle: if (tidata) iforeq->ifo_Flags |= FOF_DOSTYLE; else iforeq->ifo_Flags &= ~FOF_DOSTYLE; break; case ASLFO_DoDrawMode: if (tidata) iforeq->ifo_Flags |= FOF_DODRAWMODE; else iforeq->ifo_Flags &= ~FOF_DODRAWMODE; break; case ASLFO_FixedWidthOnly: if (tidata) iforeq->ifo_Flags |= FOF_FIXEDWIDTHONLY; else iforeq->ifo_Flags &= ~FOF_FIXEDWIDTHONLY; break; case ASLFO_MinHeight: iforeq->ifo_MinHeight = (UWORD)tidata; break; case ASLFO_MaxHeight: iforeq->ifo_MaxHeight = (UWORD)tidata; break; case ASLFO_FilterFunc: iforeq->ifo_FilterFunc = (struct Hook *)tidata; break; case ASLFO_HookFunc: iforeq->ifo_HookFunc = (APTR)tidata; break; case ASLFO_MaxFrontPen: iforeq->ifo_MaxFrontPen = (UWORD)tidata; break; case ASLFO_MaxBackPen: iforeq->ifo_MaxBackPen = (UWORD)tidata; break; case ASLFO_ModeList: iforeq->ifo_ModeList = (STRPTR *)tidata; break; case ASLFO_FrontPens: iforeq->ifo_FrontPens = (UBYTE *)tidata; break; case ASLFO_BackPens: iforeq->ifo_BackPens = (UBYTE *)tidata; break; case ASLFO_SampleText: iforeq->ifo_SampleText = (STRPTR)tidata; break; default: break; } /* switch (tag->ti_Tag) */ } /* while ((tag = NextTagItem(&tstate)) != 0) */ ReturnVoid("FOTagHook"); AROS_USERFUNC_EXIT }
/******* SerialUnit::New() ***********************************/ OOP_Object *PCSerUnit__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg) { struct HIDDSerialUnitData * data; struct TagItem *tag, *tstate; ULONG unitnum = 0; EnterFunc(bug("SerialUnit::New()\n")); tstate = msg->attrList; while ((tag = NextTagItem((const struct TagItem **)&tstate))) { ULONG idx; #define csd CSD(cl->UserData) if (IS_HIDDSERIALUNIT_ATTR(tag->ti_Tag, idx)) #undef csd { switch (idx) { case aoHidd_SerialUnit_Unit: unitnum = (ULONG)tag->ti_Data; break; } } } /* while (tags to process) */ obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg); if (obj) { struct IntuitionBase * IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0); data = OOP_INST_DATA(cl, obj); data->baseaddr = bases[unitnum]; if (NULL != IntuitionBase) { struct Preferences prefs; GetPrefs(&prefs,sizeof(prefs)); data->baudrate = prefs.BaudRate; adapt_data(data, &prefs); CloseLibrary((struct Library *)IntuitionBase); } else { data->datalength = 8; data->parity = FALSE; data->baudrate = 9600; /* will be initialize in set_baudrate() */ } data->unitnum = unitnum; Disable(); CSD(cl->UserData)->units[data->unitnum] = data; Enable(); D(bug("Unit %d at 0x0%x\n", data->unitnum, data->baseaddr)); /* Wake up UART */ serial_outp(data, UART_LCR, 0xBF); serial_outp(data, UART_EFR, UART_EFR_ECB); serial_outp(data, UART_IER, 0); serial_outp(data, UART_EFR, 0); serial_outp(data, UART_LCR, 0); /* clear the FIFOs */ serial_outp(data, UART_FCR, (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT)); /* clear the interrupt registers */ (void)serial_inp(data, UART_RX); (void)serial_inp(data, UART_IIR); (void)serial_inp(data, UART_MSR); /* initilize the UART */ serial_outp(data, UART_LCR, get_lcr(data)); serial_outp(data, UART_MCR, UART_MCR_OUT2 | UART_MCR_DTR | UART_MCR_RTS); serial_outp(data, UART_IER, UART_IER_RDI | UART_IER_THRI | UART_IER_RLSI | UART_IER_MSI); /* clear the interrupt registers again ... */ (void)serial_inp(data, UART_LSR); (void)serial_inp(data, UART_RX); (void)serial_inp(data, UART_IIR); (void)serial_inp(data, UART_MSR); set_baudrate(data, data->baudrate); } /* if (obj) */ ReturnPtr("SerialUnit::New()", OOP_Object *, obj); }