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