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");
}
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");
}
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");
}
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");
}
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");
}
void SAVEDS STDARGS LC_BUILDNAME(L_ExpungeLib) (LC_LIBHEADERTYPEPTR lh)
{
//EnterFunc(bug("GfxHIDD_Expunge()\n"))
if(lh->hdg_csd)
{
free_gfxhiddclass(lh->hdg_csd);
CloseLibrary(lh->hdg_csd->utilitybase);
CloseLibrary(lh->hdg_csd->oopbase);
FreeVec(lh->hdg_csd);
}
ReturnVoid("GfxHIDD_Expunge");
}
/*************************
** Listview::Layout() **
**************************/
VOID AROSListview__GM_LAYOUT(Class *cl, Object *o, struct gpLayout *msg)
{
#undef RELFLAGS
#define RELFLAGS (GFLG_RELRIGHT|GFLG_RELWIDTH|GFLG_RELHEIGHT|GFLG_RELBOTTOM)
struct IBox container;
struct LVData *data = INST_DATA(cl, o);
D(bug("Listview::Layout()\n"));
/* Only recalculate dimensions if this is the first layout, or we
* are a GFLG_xxx gadget
*/
if (msg->gpl_Initial || EG(o)->Flags & RELFLAGS)
{
struct GadgetInfo *gi = msg->gpl_GInfo;
if (gi)
{
struct TagItem tags[] =
{
{AROSA_Listview_Visible, 0},
{TAG_END}
};
D(bug("data->lvd_List: %p\n", data->lvd_List));
GetGadgetIBox(o, gi, &container);
/* Compute widths of each column */
ComputeColumnWidths(container.Width, data);
/* Compute left and right offsets for each column */
ComputeColLeftRight(container.Left, data);
tags[0].ti_Data = ShownEntries(data, &container);
D(bug("Layot: notifying visible=%d, gi=%d\n", tags[0].ti_Data, gi));
DoMethod(o, OM_SET, (IPTR) tags, (IPTR) gi);
} /* if (gadgetinfo supplied) */
} /* if (GFLG_xxx or first layout) */
ReturnVoid("Listview::Layout");
}
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");
}
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
}
/*** BitMap::BlitColorExpansion() **********************************************/
VOID MNAME_BM(BlitColorExpansion)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_BlitColorExpansion *msg)
{
ULONG cemd;
struct bitmap_data *data = OOP_INST_DATA(cl, o);
struct Box box;
HIDDT_Pixel fg, bg;
LONG x, y;
EnterFunc(bug("VGAGfx.BitMap::BlitColorExpansion(%p, %d, %d, %d, %d, %d, %d)\n"
, msg->srcBitMap, msg->srcX, msg->srcY, msg->destX, msg->destY, msg->width, msg->height));
fg = GC_FG(msg->gc);
bg = GC_BG(msg->gc);
cemd = GC_COLEXP(msg->gc);
if (cemd & vHidd_GC_ColExp_Opaque)
{
for (y = 0; y < msg->height; y ++)
{
for (x = 0; x < msg->width; x ++)
{
ULONG is_set;
is_set = HIDD_BM_GetPixel(msg->srcBitMap, x + msg->srcX, y + msg->srcY);
*(data->VideoData + x + msg->destX + ((y + msg->destY) * data->width)) = is_set ? fg : bg;
} /* for (each x) */
} /* for (each y) */
}
else
{
for (y = 0; y < msg->height; y ++)
{
for (x = 0; x < msg->width; x ++)
{
ULONG is_set;
is_set = HIDD_BM_GetPixel(msg->srcBitMap, x + msg->srcX, y + msg->srcY);
if (is_set)
*(data->VideoData + x + msg->destX + ((y + msg->destY) * data->width)) = fg;
} /* for (each x) */
} /* for (each y) */
}
if (data->disp)
{
box.x1 = msg->destX;
box.y1 = msg->destY;
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::BlitColorExpansion");
}
VOID MNAME_BM(FillRect)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_DrawRect *msg)
{
struct bitmap_data *data =OOP_INST_DATA(cl, o);
struct Box box = {0, 0, 0, 0};
HIDDT_Pixel fg = GC_FG(msg->gc);
HIDDT_DrawMode mode = GC_DRMD(msg->gc);
EnterFunc(bug("VGAGfx.BitMap::FillRect(%d,%d,%d,%d)\n",
msg->minX, msg->minY, msg->maxX, msg->maxY));
switch(mode)
{
case vHidd_GC_DrawMode_Copy:
HIDD_BM_FillMemRect8(o,
data->VideoData,
msg->minX,
msg->minY,
msg->maxX,
msg->maxY,
data->width,
fg);
break;
case vHidd_GC_DrawMode_Invert:
HIDD_BM_InvertMemRect(o,
data->VideoData,
msg->minX,
msg->minY,
msg->maxX,
msg->maxY,
data->width);
break;
default:
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
break;
} /* switch(mode) */
if (data->disp)
{
box.x1 = msg->minX;
box.y1 = msg->minY;
box.x2 = msg->maxX;
box.y2 = msg->maxY;
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::FillRect");
}
VOID MNAME_BM(PutImage)(OOP_Class *cl, OOP_Object *o, struct pHidd_BitMap_PutImage *msg)
{
struct bitmap_data *data = OOP_INST_DATA(cl, o);
struct Box box = {0, 0, 0, 0};
BOOL done_by_superclass = FALSE;
int i;
EnterFunc(bug("VGAGfx.BitMap::PutImage(pa=%p, x=%d, y=%d, w=%d, h=%d)\n",
msg->pixels, msg->x, msg->y, msg->width, msg->height));
switch(msg->pixFmt)
{
case vHidd_StdPixFmt_Native:
HIDD_BM_CopyMemBox8(o,
msg->pixels,
0,
0,
data->VideoData,
msg->x,
msg->y,
msg->width,
msg->height,
msg->modulo,
data->width);
break;
case vHidd_StdPixFmt_Native32:
HIDD_BM_PutMem32Image8(o,
msg->pixels,
data->VideoData,
msg->x,
msg->y,
msg->width,
msg->height,
msg->modulo,
data->width);
break;
default:
OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
done_by_superclass = TRUE;
break;
}
if (data->disp && !done_by_superclass)
{
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::PutImage");
}
static VOID bltmask_amiga(struct bltmask_info *bmi
, LONG x_src, LONG y_src
, struct BitMap *destbm
, LONG x_dest, LONG y_dest
, ULONG xsize, ULONG ysize
, ULONG minterm )
{
/* x_src, y_src is the coordinates int the layer. */
LONG y;
UBYTE src_depth, dest_depth;
EnterFunc(bug("bltmask_amiga(%p, %d, %d, %d, %d, %d, %d, %p)\n"
, bmi, x_src, y_src, x_dest, y_dest, xsize, ysize));
src_depth = GetBitMapAttr(bmi->srcbm, BMA_DEPTH);
dest_depth = GetBitMapAttr(destbm, BMA_DEPTH);
for (y = 0; y < ysize; y ++)
{
LONG x;
for (x = 0; x < xsize; x ++)
{
ULONG set_pixel;
ULONG idx, mask;
idx = COORD_TO_BYTEIDX(x + bmi->mask_xmin, y + bmi->mask_ymin, bmi->mask_bpr);
mask = XCOORD_TO_MASK(x + bmi->mask_xmin);
set_pixel = bmi->mask[idx] & mask;
if (set_pixel)
{
ULONG srcpen, destpen, pixval;
srcpen = getbitmappixel(bmi->srcbm
, x + x_src
, y + y_src
, src_depth
, 0xFF
);
/* Could optimize plain copy (0x00C0) here. (does not nead to get dest)
and clear (0x0000) (needs neither src or dest)*/
destpen = getbitmappixel(destbm
, x + x_dest
, y + y_dest
, dest_depth
, 0xFF
);
APPLY_MINTERM(pixval, srcpen, destpen, minterm);
setbitmappixel(destbm
, x + x_dest
, y + y_dest
, pixval
, dest_depth
, 0xFF
);
}
} /* for (each column) */
} /* for (each row) */
ReturnVoid("bltmask_amiga");
}
void UpdateDisp(struct Gadget *gad,
struct BBox *bbox,
struct RastPort *rp,
struct IntuitionBase *IntuitionBase)
{
struct TextExtent te;
struct StringInfo *strinfo = (struct StringInfo *)gad->SpecialInfo;
STRPTR dispstr;
EnterFunc(bug("UpdateDisp(gad=%p, bbox=%p, rp=%p)\n",
gad, bbox, rp));
/* If the cursor is at the trailing \0, insert a SPACE instead */
if (strinfo->BufferPos == strinfo->NumChars)
strinfo->Buffer[strinfo->NumChars] = 0x20;
/* In this function we check if the cursor has gone outside
** of the visible area (because of application setting
** strinfo->BufferPos or strinfo->DispPos to a different value, or
** because of user input).
** This is made a bit difficult by the rule (R), that there
** should NOT be available space on the right, and characters
** scrolled out at the left, at the same time.
** We have 3 possible scenarios:
** 1) Cursor to the left of DispPos:
** Set DispPos to the lowest of BufferPos and the
** maximum allowed disppos (according to (R) ).
** 2) Cursor to the right of visible area:
** Set dispose sou that the cursor is the last visible character.
** This afheres to (R).
** 3) Cursor inside visible area. Do a check on rule (R),
** and if DispPos > max allowed, then adjust it down,
** so that the last character in the buffer becomes last character
** displayed. (The cursor will still be visible after adjustion)
*/
/* 1) Cursor to the left of visible area */
if (strinfo->BufferPos < strinfo->DispPos)
{
WORD max_disppos;
max_disppos = MaxDispPos(strinfo, bbox, rp, IntuitionBase);
strinfo->DispPos = MIN(strinfo->BufferPos, max_disppos);
}
else /* Cursor equal to the right of disppos [ 2) or 3) ] */
{
UWORD strsize;
/* How many pixels are there from current 1st displayed to the cursor ? */
strsize = TextLength(rp,
strinfo->Buffer + strinfo->DispPos,
strinfo->BufferPos - strinfo->DispPos + 1);
/* 2) More than fits into the gadget ? */
if (strsize > bbox->Width)
{
/* Compute new DispPos such that the cursor is at the right */
strinfo->DispPos = strinfo->BufferPos
- TextFit(rp,
&(strinfo->Buffer[strinfo->BufferPos]),
strinfo->NumChars, &te, NULL, -1,
bbox->Width, rp->Font->tf_YSize)
+ 1;
D(bug("cursor right of visible area, new disppos: %d\n", strinfo->DispPos));
}
else /* 3). Cursor inside gadget */
{
WORD max_disppos;
max_disppos = MaxDispPos(strinfo, bbox, rp, IntuitionBase);
if (strinfo->DispPos > max_disppos)
strinfo->DispPos = max_disppos;
} /* if (cursor inside or to the right of visible area )*/
}
/* Update the DispCount */
/* It might be necessary with special handling for centre aligned gads */
dispstr = &(strinfo->Buffer[strinfo->DispPos]);
strinfo->DispCount = TextFit(rp, dispstr,
strinfo->NumChars - strinfo->DispPos,
&te, NULL, 1,
bbox->Width,
rp->Font->tf_YSize);
/* 0-terminate string */
strinfo->Buffer[strinfo->NumChars] = 0x00;
ReturnVoid("UpdateDisp");
}
