static void
FreeCursorBits(CursorBitsPtr bits)
{
if (--bits->refcnt > 0)
return;
free(bits->source);
free(bits->mask);
#ifdef ARGB_CURSOR
free(bits->argb);
#endif
dixFiniPrivates(bits, PRIVATE_CURSOR_BITS);
if (bits->refcnt == 0)
{
GlyphSharePtr *prev, this;
for (prev = &sharedGlyphs;
(this = *prev) && (this->bits != bits);
prev = &this->next)
;
if (this)
{
*prev = this->next;
CloseFont(this->font, (Font)0);
free(this);
}
free(bits);
}
}
__autoexit void amiga_exit (void)
{
int i;
for (i = 0; i < HISTORY_LINES; i++)
{
if (*(History + i))
FreeVec (*(History + i));
*(History + i) = 0;
}
if (GameReq)
FreeAslRequest (GameReq);
if (SaveReq)
FreeAslRequest (SaveReq);
if (ScriptReq)
FreeAslRequest (ScriptReq);
if (Menus)
FreeMenus (Menus);
if (Visual)
FreeVisualInfo (Visual);
if (ThisProcess)
ThisProcess->pr_WindowPtr = OldWindowPtr;
if (Window)
CloseWindow (Window);
if (Screen)
CloseScreen (Screen);
if (Font)
CloseFont (Font);
if (DefaultPubScreen)
UnlockPubScreen (0, DefaultPubScreen);
if (Icon)
FreeDiskObject (Icon);
}
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 int MUIMasterExpunge(LIBBASETYPEPTR lh)
{
MUIMasterBase = (struct Library *)lh;
CloseFont(((struct MUIMasterBase_intern *)MUIMasterBase)->topaz8font);
return TRUE;
}
int lib_graphics_f_CloseFont_2(emumsg_syscall_t *msg)
{
/* Make real syscall */
CloseFont(
(struct TextFont *)msg->arg[0]._aptr
);
return HOOK_DONE;
}
static void close_zoomer()
{
DrawBitmap(dx, dy, isaves);
free(isaves);
isaves = NULL;
iv_seteventhandler(prevhandler);
SetKeyboardRate(700, 500);
PartialUpdate(dx, dy, dw + 4, dh + 4);
CloseFont(menu_arrow_font);
}
IPTR GTText__OM_DISPOSE(Class *cl, Object *o, Msg msg)
{
struct TextData *data = INST_DATA(cl, o);
if (data->flags & TEXTF_COPYTEXT) FreeVec((APTR)data->toprint);
if (data->font) CloseFont(data->font);
if (data->frame) DisposeObject(data->frame);
return DoSuperMethodA(cl, o, msg);
}
VOID AROSCycle__OM_DISPOSE(Class *cl, Object *o, Msg msg)
{
struct CycleData *data = INST_DATA(cl, o);
if (EG(o)->GadgetRender)
DisposeObject(EG(o)->GadgetRender);
if (data->font) CloseFont(data->font);
DoSuperMethodA(cl,o,msg);
}
void statusbar_destroy(video_canvas_t *canvas)
{
int i;
for (i=0; i<b_num; i++) {
if (canvas->os->pens[i] != -1) {
ReleasePen(canvas->os->window->WScreen->ViewPort.ColorMap, canvas->os->pens[i]);
canvas->os->pens[i] = -1;
}
}
if (canvas->os->font != NULL) {
CloseFont(canvas->os->font);
canvas->os->font = NULL;
}
canvas->os->has_statusbar = 0;
}
void CloseBlankerWindow( void )
{
if ( BlankerWnd ) {
CloseWindow( BlankerWnd );
BlankerWnd = NULL;
}
if ( BlankerGList ) {
FreeGadgets( BlankerGList );
BlankerGList = NULL;
}
if ( BlankerFont ) {
CloseFont( BlankerFont );
BlankerFont = NULL;
}
}
// Free backdrop info
void backdrop_free(BackdropInfo *info)
{
if (info)
{
// Free icons
backdrop_free_list(info);
// Free font
if (info->font) CloseFont(info->font);
// Free memory
FreeMemHandle(info->memory);
// Free structure
FreeVec(info);
}
}
/**************************
** Listview::Dispose() **
**************************/
VOID AROSListview__OM_DISPOSE(Class *cl, Object *o, Msg msg)
{
struct LVData *data;
data = INST_DATA(cl, o);
if (data->lvd_DHArray)
FreeVec(data->lvd_DHArray);
if (data->lvd_ColAttrs)
FreeVec(data->lvd_ColAttrs);
if (data->lvd_Font)
CloseFont(data->lvd_Font);
return;
}
PBTabPanel::~PBTabPanel()
{
if (m_pActiveTab)
{
free(m_pActiveTab);
m_pActiveTab = NULL;
}
if (m_pInactiveTab)
{
free(m_pInactiveTab);
m_pInactiveTab = NULL;
}
if (m_pFont)
{
CloseFont(m_pFont);
m_pFont = NULL;
}
}
/**
* does the diX part of freeing the characteristics in the GC.
*
* \param value must conform to DeleteType
*/
int
FreeGC(void *value, XID gid)
{
GCPtr pGC = (GCPtr) value;
CloseFont(pGC->font, (Font) 0);
(*pGC->funcs->DestroyClip) (pGC);
if (!pGC->tileIsPixel)
(*pGC->pScreen->DestroyPixmap) (pGC->tile.pixmap);
if (pGC->stipple)
(*pGC->pScreen->DestroyPixmap) (pGC->stipple);
(*pGC->funcs->DestroyGC) (pGC);
if (pGC->dash != DefaultDash)
free(pGC->dash);
dixFreeObjectWithPrivates(pGC, PRIVATE_GC);
return Success;
}
/**
* does the diX part of freeing the characteristics in the GC.
*
* \param value must conform to DeleteType
*/
_X_EXPORT int
FreeGC(pointer value, XID gid)
{
GCPtr pGC = (GCPtr)value;
CloseFont(pGC->font, (Font)0);
(* pGC->funcs->DestroyClip)(pGC);
if (!pGC->tileIsPixel)
(* pGC->pScreen->DestroyPixmap)(pGC->tile.pixmap);
if (pGC->stipple)
(* pGC->pScreen->DestroyPixmap)(pGC->stipple);
(*pGC->funcs->DestroyGC) (pGC);
if (pGC->dash != DefaultDash)
xfree(pGC->dash);
xfree(pGC);
return(Success);
}
// Free font data
void font_free(font_data *data)
{
if (data)
{
// Close stuff
font_close(data);
// Free font
if (data->font) CloseFont(data->font);
// Free port
DeleteMsgPort(data->appport);
// Close locale stuff
if (data->locale.li_Locale)
{
CloseLocale(data->locale.li_Locale);
CloseCatalog(data->locale.li_Catalog);
}
// Free args
FreeArgs(data->args);
// Free labels
FreeVec(data->size_labels);
// Free data
FreeVec(data);
}
// Close library
#ifdef __amigaos4__
DropInterface((struct Interface *)IDOpus);
#endif
CloseLibrary(DOpusBase);
}
/*
* Open a requester with a fixed font.
*
* Only reqtools.library seems to have the ability to use custom fonts.
* This crashes, if I don't open requtools.library manually. Is this no auto-open library !?
*
* Is there really so much code necessary, just to open a fixed width requester !?
*
* This is no WinAPI call.
*/
int MessageBox_fixed(HWND hWnd, TCHAR *lpText, TCHAR *lpCaption, UINT uType/*, UINT size*/) {
rtReqInfo *req;
ULONG ret;
BOOL i_opened_it=false;
struct TextFont *font;
struct Window *window;
struct TextAttr myta = {
"fixed.font",
8,
0,
NULL
};
struct TagItem tags[]={
{RT_TextAttr, (IPTR) &myta},
{RT_Window, NULL},
{RTEZ_ReqTitle , (IPTR) lpCaption},
{RT_ReqPos, REQPOS_CENTERSCR},
{RT_WaitPointer, TRUE},
{RT_LockWindow, TRUE},
{TAG_DONE}
};
DebOut("Caption: %s\n", lpCaption);
DebOut("Text: %s\n", lpText);
font=OpenDiskFont(&myta);
if(!font) {
DebOut("unable to open fixed.font\n");
tags[0].ti_Tag=TAG_IGNORE;
}
window=(struct Window *)XGET(win, MUIA_Window_Window);
if(window) {
DebOut("window: %lx\n", window);
tags[1].ti_Data=(IPTR) window;
}
else {
DebOut("ERROR: no window !?\n");
tags[1].ti_Tag=TAG_IGNORE;
}
/* do I really have to open it !? */
if(!ReqToolsBase) {
i_opened_it=TRUE;
ReqToolsBase = (struct ReqToolsBase *)OpenLibrary("reqtools.library", 0);
}
if(!ReqToolsBase) {
fprintf(stderr, "ERROR: Unable to open reqtools.library!\n");
DebOut("ERROR: Unable to open reqtools.library!\n");
return FALSE;
}
ret=rtEZRequestA(lpText, "Ok", NULL, NULL, tags);
if(i_opened_it) {
CloseLibrary((struct Library *)ReqToolsBase);
ReqToolsBase=NULL;
}
if(font) {
CloseFont(font);
}
return TRUE;
}
// Get font
void font_get_font(font_data *data)
{
// Make window busy
SetWindowBusy(data->window);
// Existing font?
if (data->font)
{
// Free font
CloseFont(data->font);
data->font=NULL;
}
// Has the font name changed?
if (stricmp(data->font_name,data->last_font_name))
{
struct FontContentsHeader *fch;
BPTR lock;
// Empty labels
font_build_labels(data,0);
// Is the name a full path?
if (strchr(data->font_name,'/') || strchr(data->font_name,':'))
{
// Lock font
if ((lock=Lock(data->font_name,ACCESS_READ)))
{
BPTR parent;
// Get lock on parent
parent=ParentDir(lock);
// Unlock lock on file
UnLock(lock);
lock=parent;
}
}
// Lock fonts: directory
else lock=Lock("fonts:",ACCESS_READ);
// Got lock?
if (lock)
{
// Get font contents
if ((fch=NewFontContents(lock,FilePart(data->font_name))))
{
// Build labels
font_build_labels(data,fch);
// Free contents
DisposeFontContents(fch);
}
// Unlock drawer
UnLock(lock);
}
}
// Fill out TextAttr
data->attr.ta_Name=data->font_name;
data->attr.ta_YSize=data->font_size;
data->attr.ta_Style=0;
data->attr.ta_Flags=0;
// Open font
data->font=OpenDiskFont(&data->attr);
// Show font name and size
SetGadgetValue(data->list,GAD_FONT_FONT,(ULONG)FilePart(data->font_name));
SetGadgetValue(data->list,GAD_FONT_SIZE,data->font_size);
// Got font?
if (data->font)
{
short ch,pos,hi;
// First character
ch=data->font->tf_LoChar;
if (ch<33) ch=33;
// Hi character
hi=data->font->tf_HiChar;
if (hi>126 && ch<127) hi=127;
// Build display text
for (pos=0;ch<hi;ch++,pos++)
data->font_text[pos]=ch;
data->font_text[pos]=0;
// Got labels?
if (data->size_labels)
{
// Find label corresponding to this size
for (pos=0;data->size_labels[pos];pos++)
{
if (atoi(data->size_labels[pos])==data->font_size)
{
// Set cycle gadget
SetGadgetValue(data->list,GAD_FONT_CYCLE,pos);
break;
}
}
}
}
// Empty labels
else font_build_labels(data,0);
// Copy name
strcpy(data->last_font_name,data->font_name);
// Clear 'first' flag
data->first=FALSE;
// Clear window busy
ClearWindowBusy(data->window);
}
STATIC IPTR _OM_SET(Class *cl, Object *o,struct opSet *msg)
{
IPTR retval = (IPTR)0;
const struct TagItem *tag, *tstate;
struct LVData *data;
EnterFunc(bug("ListView::OM_SET\n"));
data = INST_DATA(cl, o);
tstate = msg->ops_AttrList;
/* Set to 1 to signal visual changes */
while ((tag = NextTagItem(&tstate)) != NULL)
{
switch (tag->ti_Tag)
{
case AROSA_Listview_DisplayHook:
data->lvd_DisplayHook = (struct Hook *)tag->ti_Data;
retval = 1UL;
break;
case AROSA_Listview_FrontPen:
data->lvd_FrontPen = (UBYTE)tag->ti_Data;
retval = 1UL;
break;
case AROSA_Listview_BackPen:
data->lvd_BackPen = (UBYTE)tag->ti_Data;
retval = 1UL;
break;
case AROSA_Listview_Visible:
case AROSA_Listview_Total:
{
struct TagItem tags[] =
{
{tag->ti_Tag, tag->ti_Data},
{TAG_END}
};
NotifyAttrs(cl, o, msg, tags);
} break;
case AROSA_Listview_List:
{
ULONG numentries;
struct TagItem tags[] =
{
{AROSA_Listview_First, 0},
{AROSA_Listview_Total, 0},
{TAG_END}
};
data->lvd_List = (Object *)tag->ti_Data;
GetAttr(AROSA_List_Entries, data->lvd_List, (IPTR *)&numentries);
SetAttrs(data->lvd_List,
AROSA_List_Active, AROSV_List_Active_None,
TAG_END);
tags[1].ti_Data = numentries;
DoMethod(o, OM_SET, (IPTR) tags, (IPTR) msg->ops_GInfo);
retval = 1UL;
} break;
case AROSA_Listview_HorSpacing:
data->lvd_HorSpacing = (UBYTE)tag->ti_Data;
retval = 1UL;
break;
case AROSA_Listview_VertSpacing:
data->lvd_VertSpacing = (UBYTE)tag->ti_Data;
ReCalcEntryHeight(data);
retval = 1UL;
break;
case AROSA_Listview_Format:
{
struct ColumnAttrs *colattrs = data->lvd_ColAttrs;
ULONG colattrsz = UB(&colattrs[data->lvd_MaxColumns]) - UB(&colattrs[0]);
memset(colattrs, 0, colattrsz);
ParseFormatString((STRPTR)tag->ti_Data, data);
retval = 1UL;
} break;
case AROSA_Listview_First:
{
struct TagItem tags[] =
{
{AROSA_Listview_First, tag->ti_Data},
{TAG_END}
};
LONG old = data->lvd_First;
#if DEBUG
if (msg->MethodID == OM_SET)
{
D(bug("_First OM_SET\n"));
} else
{
D(bug("_First OM_UPDATEd, lvd_NC=%d\n",
data->lvd_NotifyCount));
}
#endif
retval = 1UL;
data->lvd_First = (LONG)tag->ti_Data;
if ( ( msg->MethodID == OM_UPDATE )
&& ( old != data->lvd_First ))
{
struct RastPort *rp;
WORD steps;
UWORD visible, abs_steps;
struct IBox box;
steps = tag->ti_Data - old;
abs_steps = steps < 0 ? -steps : steps;
GetGadgetIBox(o, msg->ops_GInfo, &box);
visible = NumVisible(&box, data->lvd_EntryHeight);
if (abs_steps < visible >> 1)
{
if ((rp = ObtainGIRPort(msg->ops_GInfo)) != NULL)
{
LONG dy;
/* We make the assumption that the listview
** is alvays 'full'. If it isn't, the
** Scroll gadget won't be scrollable, and
** we won't receive any OM_UPDATEs.
*/
dy = steps * data->lvd_EntryHeight;
ScrollRaster(rp, 0, dy,
box.Left + LV_BORDERWIDTH_X,
box.Top + LV_BORDERWIDTH_Y,
box.Left + box.Width - 1 - LV_BORDERWIDTH_X,
box.Top + LV_BORDERWIDTH_Y + visible * data->lvd_EntryHeight);
data->lvd_DamageOffset = ((steps > 0) ?
visible - abs_steps : 0);
data->lvd_NumDamaged = abs_steps;
DoMethod(o, GM_RENDER, (IPTR) msg->ops_GInfo, (IPTR) rp, GREDRAW_UPDATE);
ReleaseGIRPort(rp);
retval = 0UL;
} /* if (ObtainGIRPort succeed) */
} /* if (at most half the visible entries scrolled out) */
} /* if (msg is of type OM_UPDATE) */
/* Notify change */
NotifyAttrs(cl, o, msg, tags);
} break;
case AROSA_Listview_RenderHook:
data->lvd_RenderHook = (struct Hook *)data->lvd_RenderHook;
retval = 1UL;
break;
case AROSA_Listview_MultiSelect:
SETFLAG(data->lvd_Flags, tag->ti_Data, LVFLG_MULTISELECT);
break;
case GA_TextAttr:
{
struct TextFont *tf;
tf = OpenFont((struct TextAttr *)tag->ti_Data);
if (tf)
{
if (data->lvd_Font)
{
CloseFont(data->lvd_Font);
}
data->lvd_Font = tf;
}
ReCalcEntryHeight(data);
} break;
default:
break;
} /* switch (tag->ti_Tag) */
} /* while (more tags to iterate) */
ReturnPtr("ListView::OM_SET", IPTR, retval);
}
int
ChangeGC(ClientPtr client, GC * pGC, BITS32 mask, ChangeGCValPtr pUnion)
{
BITS32 index2;
int error = 0;
PixmapPtr pPixmap;
BITS32 maskQ;
assert(pUnion);
pGC->serialNumber |= GC_CHANGE_SERIAL_BIT;
maskQ = mask; /* save these for when we walk the GCque */
while (mask && !error) {
index2 = (BITS32) lowbit(mask);
mask &= ~index2;
pGC->stateChanges |= index2;
switch (index2) {
case GCFunction:
{
CARD8 newalu;
NEXTVAL(CARD8, newalu);
if (newalu <= GXset)
pGC->alu = newalu;
else {
if (client)
client->errorValue = newalu;
error = BadValue;
}
break;
}
case GCPlaneMask:
NEXTVAL(unsigned long, pGC->planemask);
break;
case GCForeground:
NEXTVAL(unsigned long, pGC->fgPixel);
/*
* this is for CreateGC
*/
if (!pGC->tileIsPixel && !pGC->tile.pixmap) {
pGC->tileIsPixel = TRUE;
pGC->tile.pixel = pGC->fgPixel;
}
break;
case GCBackground:
NEXTVAL(unsigned long, pGC->bgPixel);
break;
case GCLineWidth: /* ??? line width is a CARD16 */
NEXTVAL(CARD16, pGC->lineWidth);
break;
case GCLineStyle:
{
unsigned int newlinestyle;
NEXTVAL(unsigned int, newlinestyle);
if (newlinestyle <= LineDoubleDash)
pGC->lineStyle = newlinestyle;
else {
if (client)
client->errorValue = newlinestyle;
error = BadValue;
}
break;
}
case GCCapStyle:
{
unsigned int newcapstyle;
NEXTVAL(unsigned int, newcapstyle);
if (newcapstyle <= CapProjecting)
pGC->capStyle = newcapstyle;
else {
if (client)
client->errorValue = newcapstyle;
error = BadValue;
}
break;
}
case GCJoinStyle:
{
unsigned int newjoinstyle;
NEXTVAL(unsigned int, newjoinstyle);
if (newjoinstyle <= JoinBevel)
pGC->joinStyle = newjoinstyle;
else {
if (client)
client->errorValue = newjoinstyle;
error = BadValue;
}
break;
}
case GCFillStyle:
{
unsigned int newfillstyle;
NEXTVAL(unsigned int, newfillstyle);
if (newfillstyle <= FillOpaqueStippled)
pGC->fillStyle = newfillstyle;
else {
if (client)
client->errorValue = newfillstyle;
error = BadValue;
}
break;
}
case GCFillRule:
{
unsigned int newfillrule;
NEXTVAL(unsigned int, newfillrule);
if (newfillrule <= WindingRule)
pGC->fillRule = newfillrule;
else {
if (client)
client->errorValue = newfillrule;
error = BadValue;
}
break;
}
case GCTile:
NEXT_PTR(PixmapPtr, pPixmap);
if ((pPixmap->drawable.depth != pGC->depth) ||
(pPixmap->drawable.pScreen != pGC->pScreen)) {
error = BadMatch;
}
else {
pPixmap->refcnt++;
if (!pGC->tileIsPixel)
(*pGC->pScreen->DestroyPixmap) (pGC->tile.pixmap);
pGC->tileIsPixel = FALSE;
pGC->tile.pixmap = pPixmap;
}
break;
case GCStipple:
NEXT_PTR(PixmapPtr, pPixmap);
if (pPixmap && ((pPixmap->drawable.depth != 1) ||
(pPixmap->drawable.pScreen != pGC->pScreen)))
{
error = BadMatch;
}
else {
if (pPixmap)
pPixmap->refcnt++;
if (pGC->stipple)
(*pGC->pScreen->DestroyPixmap) (pGC->stipple);
pGC->stipple = pPixmap;
}
break;
case GCTileStipXOrigin:
NEXTVAL(INT16, pGC->patOrg.x);
break;
case GCTileStipYOrigin:
NEXTVAL(INT16, pGC->patOrg.y);
break;
case GCFont:
{
FontPtr pFont;
NEXT_PTR(FontPtr, pFont);
pFont->refcnt++;
if (pGC->font)
CloseFont(pGC->font, (Font) 0);
pGC->font = pFont;
break;
}
case GCSubwindowMode:
{
unsigned int newclipmode;
NEXTVAL(unsigned int, newclipmode);
if (newclipmode <= IncludeInferiors)
pGC->subWindowMode = newclipmode;
else {
if (client)
client->errorValue = newclipmode;
error = BadValue;
}
break;
}
case GCGraphicsExposures:
{
unsigned int newge;
NEXTVAL(unsigned int, newge);
if (newge <= xTrue)
pGC->graphicsExposures = newge;
else {
if (client)
client->errorValue = newge;
error = BadValue;
}
break;
}
case GCClipXOrigin:
NEXTVAL(INT16, pGC->clipOrg.x);
break;
case GCClipYOrigin:
NEXTVAL(INT16, pGC->clipOrg.y);
break;
case GCClipMask:
NEXT_PTR(PixmapPtr, pPixmap);
if (pPixmap) {
if ((pPixmap->drawable.depth != 1) ||
(pPixmap->drawable.pScreen != pGC->pScreen)) {
error = BadMatch;
break;
}
pPixmap->refcnt++;
}
(*pGC->funcs->ChangeClip) (pGC, pPixmap ? CT_PIXMAP : CT_NONE,
(void *) pPixmap, 0);
break;
case GCDashOffset:
NEXTVAL(INT16, pGC->dashOffset);
break;
case GCDashList:
{
CARD8 newdash;
NEXTVAL(CARD8, newdash);
if (newdash == 4) {
if (pGC->dash != DefaultDash) {
free(pGC->dash);
pGC->numInDashList = 2;
pGC->dash = DefaultDash;
}
}
else if (newdash != 0) {
unsigned char *dash;
dash = malloc(2 * sizeof(unsigned char));
if (dash) {
if (pGC->dash != DefaultDash)
free(pGC->dash);
pGC->numInDashList = 2;
pGC->dash = dash;
dash[0] = newdash;
dash[1] = newdash;
}
else
error = BadAlloc;
}
else {
if (client)
client->errorValue = newdash;
error = BadValue;
}
break;
}
case GCArcMode:
{
unsigned int newarcmode;
NEXTVAL(unsigned int, newarcmode);
if (newarcmode <= ArcPieSlice)
pGC->arcMode = newarcmode;
else {
if (client)
client->errorValue = newarcmode;
error = BadValue;
}
break;
}
default:
if (client)
client->errorValue = maskQ;
error = BadValue;
break;
}
} /* end while mask && !error */
if (pGC->fillStyle == FillTiled && pGC->tileIsPixel) {
if (!CreateDefaultTile(pGC)) {
pGC->fillStyle = FillSolid;
error = BadAlloc;
}
}
(*pGC->funcs->ChangeGC) (pGC, maskQ);
return error;
}
main()
{
unsigned char str[256], *pp;
int i;
struct TextAttr ta = { "topaz.font", 8, FS_NORMAL, FPF_ROMFONT };
struct RastPort rp;
struct BitMap bm = { 256, /* bytes per row */
8, /* rows */
0, /* flags */
1, /* depth */
0, /* pad */
0 }; /* planes */
struct TextFont *tf;
InitRastPort (& rp);
rp.BitMap = &bm;
bm.Planes[0] = pp = AllocRaster (256 * 8, 8);
if (!pp)
{
fprintf (stderr, "Can't allocate raster!\n");
exit (1);
}
bzero (pp, 256 * 8);
tf = OpenFont (& ta);
if (! tf)
{
fprintf (stderr, "can't open topaz font.\n");
exit (1);
}
SetFont (&rp, tf);
/* initialize string to be printed */
for (i = 32; i < 256; i++) str[i - 32] = i;
Move (&rp, 0, 6);
Text (&rp, str, 256 - 32);
{
int bin = open ("bitmap", 1);
if (bin >= 0)
{
write (bin, pp, 256*8);
close (bin);
}
}
/* dump them.. */
printf ("/* generated automatically by dumpfont.c. *DONT* distribute\n");
printf (" this file, it contains information Copyright by Commodore!\n");
printf ("\n");
printf (" This is the (new) topaz80 system font: */\n\n");
printf ("unsigned char kernel_font_width = 8;\n");
printf ("unsigned char kernel_font_height = 8;\n");
printf ("unsigned char kernel_font_lo = 32;\n");
printf ("unsigned char kernel_font_hi = 255;\n\n");
printf ("unsigned char kernel_cursor[] = {\n");
printf (" 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };\n\n");
printf ("unsigned char kernel_font[] = {\n");
for (i = 0; i < 256 - 32; i++)
{
printf ("/* %c */ ", i + 32);
printf ("0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x, 0x%02x,\n",
pp[i+0*256], pp[i+1*256], pp[i+2*256], pp[i+3*256],
pp[i+4*256], pp[i+5*256], pp[i+6*256], pp[i+7*256]);
}
printf ("};\n");
CloseFont (tf);
FreeRaster (pp, 256 * 8, 8);
}
void balda_keyboard_view_free(balda_keyboard_view_t* kb)
{
assert(kb);
CloseFont(kb->font);
free(kb);
}
// Cleanup a lister
void lister_cleanup(Lister *lister,BOOL bye)
{
struct Node *node;
// Send goodbye message?
if (bye)
{
// Update our position
if (!(environment->env->lister_options&LISTEROPTF_SNAPSHOT))
PositionUpdate(lister,0);
// Send goodbye message
IPC_Goodbye(lister->ipc,&main_ipc,WINDOW_LISTER);
}
// Is lister iconified?
if (lister->appicon)
{
// Remove AppIcon
RemoveAppIcon(lister->appicon);
// Free icon
FreeDiskObjectCopy(lister->appicon_icon);
}
// If we still have a progress window, close it
lister_progress_off(lister);
// Showing a special buffer?
if (lister->cur_buffer==lister->special_buffer)
{
// Return to normal
lister->cur_buffer=lister->old_buffer;
}
// Remove buffer lock
if (lister->cur_buffer)
{
// Get buffer list lock
lock_listlock(&GUI->buffer_list,TRUE);
// Unlock buffer
buffer_clear_lock(lister->cur_buffer,1);
// If buffer is empty or buffer count exceeds maximum, free it
if (lister->cur_buffer->buf_TotalEntries[0]==0 ||
GUI->buffer_count>environment->env->settings.max_buffer_count ||
(environment->env->settings.dir_flags&DIRFLAGS_DISABLE_CACHING))
{
// Free buffer
lister_free_buffer(lister->cur_buffer);
}
// Unlock buffer list
unlock_listlock(&GUI->buffer_list);
}
// Free user data
while ((node=lister->user_data_list.list.lh_Head)->ln_Succ)
{
Remove(node);
FreeMemH(node);
}
// Free ports
if (lister->app_port)
{
DOpusAppMessage *msg;
while ((msg=(DOpusAppMessage *)GetMsg(lister->app_port)))
ReplyAppMessage(msg);
DeleteMsgPort(lister->app_port);
}
// Close font
if (lister->font)
CloseFont(lister->font);
// Free signals
if (lister->abort_signal!=-1)
FreeSignal(lister->abort_signal);
if (lister->hot_name_bit!=-1)
FreeSignal(lister->hot_name_bit);
// Free timer stuff
if (lister->timer_port)
{
// Close timers
FreeTimer(lister->foo_timer);
FreeTimer(lister->icon_drag_timer);
FreeTimer(lister->busy_timer);
FreeTimer(lister->edit_timer);
FreeTimer(lister->scroll_timer);
// Delete timer port
DeleteMsgPort(lister->timer_port);
}
// Free regions
if (lister->title_region) DisposeRegion(lister->title_region);
if (lister->refresh_extra) DisposeRegion(lister->refresh_extra);
// Free special buffer
if (lister->special_buffer) buffer_free(lister->special_buffer);
// Free reselection
FreeReselect(&lister->reselect);
// Free history
Att_RemList(lister->path_history,0);
// Free popup menu
PopUpFreeHandle(lister->lister_tool_menu);
// Free toolbar
FreeToolBar(lister->toolbar_alloc);
// Free IPC data
IPC_Free(lister->ipc);
// Free lister data
lister_free(lister);
// Decrement count
--main_lister_count;
}
_X_EXPORT int
dixChangeGC(ClientPtr client, register GC *pGC, register BITS32 mask, CARD32 *pC32, ChangeGCValPtr pUnion)
{
register BITS32 index2;
register int error = 0;
PixmapPtr pPixmap;
BITS32 maskQ;
assert( (pC32 && !pUnion) || (!pC32 && pUnion) );
pGC->serialNumber |= GC_CHANGE_SERIAL_BIT;
maskQ = mask; /* save these for when we walk the GCque */
while (mask && !error)
{
index2 = (BITS32) lowbit (mask);
mask &= ~index2;
pGC->stateChanges |= index2;
switch (index2)
{
case GCFunction:
{
CARD8 newalu;
NEXTVAL(CARD8, newalu);
if (newalu <= GXset)
pGC->alu = newalu;
else
{
clientErrorValue = newalu;
error = BadValue;
}
break;
}
case GCPlaneMask:
NEXTVAL(unsigned long, pGC->planemask);
break;
case GCForeground:
NEXTVAL(unsigned long, pGC->fgPixel);
/*
* this is for CreateGC
*/
if (!pGC->tileIsPixel && !pGC->tile.pixmap)
{
pGC->tileIsPixel = TRUE;
pGC->tile.pixel = pGC->fgPixel;
}
break;
case GCBackground:
NEXTVAL(unsigned long, pGC->bgPixel);
break;
case GCLineWidth: /* ??? line width is a CARD16 */
NEXTVAL(CARD16, pGC->lineWidth);
break;
case GCLineStyle:
{
unsigned int newlinestyle;
NEXTVAL(unsigned int, newlinestyle);
if (newlinestyle <= LineDoubleDash)
pGC->lineStyle = newlinestyle;
else
{
clientErrorValue = newlinestyle;
error = BadValue;
}
break;
}
case GCCapStyle:
{
unsigned int newcapstyle;
NEXTVAL(unsigned int, newcapstyle);
if (newcapstyle <= CapProjecting)
pGC->capStyle = newcapstyle;
else
{
clientErrorValue = newcapstyle;
error = BadValue;
}
break;
}
case GCJoinStyle:
{
unsigned int newjoinstyle;
NEXTVAL(unsigned int, newjoinstyle);
if (newjoinstyle <= JoinBevel)
pGC->joinStyle = newjoinstyle;
else
{
clientErrorValue = newjoinstyle;
error = BadValue;
}
break;
}
case GCFillStyle:
{
unsigned int newfillstyle;
NEXTVAL(unsigned int, newfillstyle);
if (newfillstyle <= FillOpaqueStippled)
pGC->fillStyle = newfillstyle;
else
{
clientErrorValue = newfillstyle;
error = BadValue;
}
break;
}
case GCFillRule:
{
unsigned int newfillrule;
NEXTVAL(unsigned int, newfillrule);
if (newfillrule <= WindingRule)
pGC->fillRule = newfillrule;
else
{
clientErrorValue = newfillrule;
error = BadValue;
}
break;
}
case GCTile:
{
XID newpix = 0;
if (pUnion)
{
NEXT_PTR(PixmapPtr, pPixmap);
}
else
{
NEXTVAL(XID, newpix);
pPixmap = (PixmapPtr)SecurityLookupIDByType(client,
newpix, RT_PIXMAP, SecurityReadAccess);
}
if (pPixmap)
{
if ((pPixmap->drawable.depth != pGC->depth) ||
(pPixmap->drawable.pScreen != pGC->pScreen))
{
error = BadMatch;
}
else
{
pPixmap->refcnt++;
if (!pGC->tileIsPixel)
(* pGC->pScreen->DestroyPixmap)(pGC->tile.pixmap);
pGC->tileIsPixel = FALSE;
pGC->tile.pixmap = pPixmap;
}
}
else
{
clientErrorValue = newpix;
error = BadPixmap;
}
break;
}
case GCStipple:
{
XID newstipple = 0;
if (pUnion)
{
NEXT_PTR(PixmapPtr, pPixmap);
}
else
{
NEXTVAL(XID, newstipple)
pPixmap = (PixmapPtr)SecurityLookupIDByType(client,
newstipple, RT_PIXMAP, SecurityReadAccess);
}
if (pPixmap)
{
if ((pPixmap->drawable.depth != 1) ||
(pPixmap->drawable.pScreen != pGC->pScreen))
{
error = BadMatch;
}
else
{
pPixmap->refcnt++;
if (pGC->stipple)
(* pGC->pScreen->DestroyPixmap)(pGC->stipple);
pGC->stipple = pPixmap;
}
}
else
{
clientErrorValue = newstipple;
error = BadPixmap;
}
break;
}
case GCTileStipXOrigin:
NEXTVAL(INT16, pGC->patOrg.x);
break;
case GCTileStipYOrigin:
NEXTVAL(INT16, pGC->patOrg.y);
break;
case GCFont:
{
FontPtr pFont;
XID newfont = 0;
if (pUnion)
{
NEXT_PTR(FontPtr, pFont);
}
else
{
NEXTVAL(XID, newfont)
pFont = (FontPtr)SecurityLookupIDByType(client, newfont,
RT_FONT, SecurityReadAccess);
}
if (pFont)
{
pFont->refcnt++;
if (pGC->font)
CloseFont(pGC->font, (Font)0);
pGC->font = pFont;
}
else
{
clientErrorValue = newfont;
error = BadFont;
}
break;
}
case GCSubwindowMode:
{
unsigned int newclipmode;
NEXTVAL(unsigned int, newclipmode);
if (newclipmode <= IncludeInferiors)
pGC->subWindowMode = newclipmode;
else
{
clientErrorValue = newclipmode;
error = BadValue;
}
break;
}
case GCGraphicsExposures:
{
unsigned int newge;
NEXTVAL(unsigned int, newge);
if (newge <= xTrue)
pGC->graphicsExposures = newge;
else
{
clientErrorValue = newge;
error = BadValue;
}
break;
}
case GCClipXOrigin:
NEXTVAL(INT16, pGC->clipOrg.x);
break;
case GCClipYOrigin:
NEXTVAL(INT16, pGC->clipOrg.y);
break;
case GCClipMask:
{
Pixmap pid = 0;
int clipType = 0;
if (pUnion)
{
NEXT_PTR(PixmapPtr, pPixmap);
}
else
{
NEXTVAL(Pixmap, pid)
if (pid == None)
{
clipType = CT_NONE;
pPixmap = NullPixmap;
}
else
pPixmap = (PixmapPtr)SecurityLookupIDByType(client,
pid, RT_PIXMAP, SecurityReadAccess);
}
if (pPixmap)
{
if ((pPixmap->drawable.depth != 1) ||
(pPixmap->drawable.pScreen != pGC->pScreen))
{
error = BadMatch;
}
else
{
clipType = CT_PIXMAP;
pPixmap->refcnt++;
}
}
else if (!pUnion && (pid != None))
{
clientErrorValue = pid;
error = BadPixmap;
}
if(error == Success)
{
(*pGC->funcs->ChangeClip)(pGC, clipType,
(pointer)pPixmap, 0);
}
break;
}
case GCDashOffset:
NEXTVAL(INT16, pGC->dashOffset);
break;
case GCDashList:
{
CARD8 newdash;
NEXTVAL(CARD8, newdash);
if (newdash == 4)
{
if (pGC->dash != DefaultDash)
{
xfree(pGC->dash);
pGC->numInDashList = 2;
pGC->dash = DefaultDash;
}
}
else if (newdash != 0)
{
unsigned char *dash;
dash = (unsigned char *)xalloc(2 * sizeof(unsigned char));
if (dash)
{
if (pGC->dash != DefaultDash)
xfree(pGC->dash);
pGC->numInDashList = 2;
pGC->dash = dash;
dash[0] = newdash;
dash[1] = newdash;
}
else
error = BadAlloc;
}
else
{
clientErrorValue = newdash;
error = BadValue;
}
break;
}
case GCArcMode:
{
unsigned int newarcmode;
NEXTVAL(unsigned int, newarcmode);
if (newarcmode <= ArcPieSlice)
pGC->arcMode = newarcmode;
else
{
clientErrorValue = newarcmode;
error = BadValue;
}
break;
}
default:
clientErrorValue = maskQ;
error = BadValue;
break;
}
} /* end while mask && !error */
if (pGC->fillStyle == FillTiled && pGC->tileIsPixel)
{
if (!CreateDefaultTile (pGC))
{
pGC->fillStyle = FillSolid;
error = BadAlloc;
}
}
(*pGC->funcs->ChangeGC)(pGC, maskQ);
return error;
}
// Listview dispatcher
ULONG LIBFUNC listview_dispatch(
REG(a0, Class *cl),
REG(a2, Object *obj),
REG(a1, Msg msg))
{
ListViewData *data=0;
struct Gadget *gadget=0;
ULONG retval=0;
// Get gadget and data pointers
if (obj)
{
gadget=(struct Gadget *)obj;
data=INST_DATA(cl,obj);
}
// Look at method
switch (msg->MethodID)
{
// Create a new instance
case OM_NEW:
// Create superclass instance
if ((retval=DoSuperMethodA(cl,obj,msg)))
{
struct TagItem *tags,*tag;
short a;
struct Image *image;
struct TextAttr *attr;
// Get pointer to our gadget and instance data
gadget=(struct Gadget *)retval;
data=INST_DATA(cl,(APTR)retval);
// Initialise data
data->dims=*(struct IBox *)&gadget->LeftEdge;
NewList(&data->boopsi_list);
data->sel=-1;
data->last_selection=-1;
// Initialise mapping tags
data->scroll_map[0].ti_Tag=PGA_Top;
data->scroll_map[0].ti_Data=DLV_Top;
data->scroll_map[1].ti_Tag=TAG_END;
data->arrow_up_map[0].ti_Tag=GA_ID;
data->arrow_up_map[0].ti_Data=DLV_ScrollUp;
data->arrow_up_map[1].ti_Tag=TAG_END;
data->arrow_down_map[0].ti_Tag=GA_ID;
data->arrow_down_map[0].ti_Data=DLV_ScrollDown;
data->arrow_down_map[1].ti_Tag=TAG_END;
// Get taglist
tags=((struct opSet *)msg)->ops_AttrList;
// Get width of scroller
data->scroller_width=GetTagData(DLV_ScrollWidth,16,tags);
// Flags
if (FindTagItem(DLV_ShowSelected,tags))
data->flags|=LVF_SHOW_SELECTED;
if (GetTagData(DLV_ThinBorder,0,tags))
data->flags|=LVF_THIN_BORDER;
if (GetTagData(DLV_MultiSelect,0,tags))
data->flags|=LVF_MULTI_SELECT;
else
if (GetTagData(DLV_Check,0,tags))
data->flags|=LVF_SELECTED_CHECK;
else
if ((a=GetTagData(DLV_ShowChecks,0,tags)))
{
data->flags|=LVF_SHOW_CHECKS;
if (a==2) data->flags|=LVF_NO_HIGHLIGHT;
}
if (GetTagData(DLV_Highlight,0,tags))
data->flags|=LVF_SELECTED_HIGH;
if (GetTagData(DLV_ReadOnly,0,tags))
data->flags|=LVF_READ_ONLY;
if (GetTagData(DLV_NoScroller,0,tags))
{
data->flags|=LVF_NO_SCROLLER;
data->scroller_width=0;
}
else
if (GetTagData(DLV_ScrollLeft,0,tags))
data->flags|=LVF_SCROLLER_LEFT;
if (GetTagData(DLV_TopJustify,0,tags))
data->flags|=LVF_TOP_JUSTIFY;
if (GetTagData(DLV_RightJustify,0,tags))
data->flags|=LVF_RIGHT_JUSTIFY;
if ((a=GetTagData(DLV_DragNotify,0,tags)))
{
data->flags|=LVF_DRAG_NOTIFY;
if (a==2) data->flags|=LVF_NO_VERT_SCROLL;
}
data->layout_flags=GetTagData(DLV_Flags,PLACETEXT_ABOVE,tags);
if (GetTagData(DLV_ShowFilenames,0,tags))
data->flags|=LVF_SHOW_FILENAMES;
if (GetTagData(DLV_ShowSeparators,0,tags))
data->flags|=LVF_SHOW_SEPARATORS;
// Get title
if ((tag=FindTagItem(GA_Text,tags)))
{
char *ptr;
short pos=0;
// Get pointer to title
if ((ptr=(char *)tag->ti_Data))
{
data->title_uscore=-1;
// Copy title string, look for underscore
while (*ptr && pos<78)
{
// Underscore?
if (*ptr=='_')
{
// Remember position, skip over it
data->title_uscore=pos;
}
// Otherwise, store
else data->title[pos++]=*ptr;
++ptr;
}
data->title[pos]=0;
}
}
// Get font to use
if ((attr=(struct TextAttr *)GetTagData(GTCustom_TextAttr,0,tags)))
{
if ((data->list_font=OpenFont(attr)))
data->flags|=LVF_GOT_FONT;
}
if (!data->list_font) data->list_font=((struct GfxBase *)GfxBase)->DefaultFont;
// Arrow height
data->arrow_height=data->list_font->tf_YSize-2;
if (data->arrow_height<10) data->arrow_height=10;
// Fix dimensions
listview_get_dims(cl,data);
data->text_height=data->list_font->tf_YSize;
// Need check mark?
if (data->flags&(LVF_MULTI_SELECT|LVF_SHOW_CHECKS) ||
(data->flags&(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))==(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))
{
// Create check image
if ((data->check=(struct Image *)NewObject(
0,"dopusiclass",
DIA_Type,IM_CHECK,
IA_Width,13,
IA_Height,data->text_height-1,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->check,OM_ADDTAIL,&data->boopsi_list);
}
data->text_offset=23;
}
else data->text_offset=2;
// Scroller needed?
if (!(data->flags&LVF_NO_SCROLLER))
{
// Create scroller
if ((data->scroller=(struct Gadget *)NewObject(
0,"propgclass",
GA_Previous,gadget,
GA_ID,LVGID_SCROLLER,
GA_Left,(data->flags&LVF_SCROLLER_LEFT)?data->dims.Left+4:data->dims.Left+data->dims.Width-data->scroller_width+4,
GA_Top,data->dims.Top+2,
GA_Width,data->scroller_width-8,
GA_Height,data->dims.Height-4-(data->arrow_height<<1),
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
PGA_Freedom,FREEVERT,
PGA_NewLook, TRUE,
PGA_Borderless,TRUE,
PGA_Visible,1,
PGA_Total,1,
ICA_TARGET,gadget,
ICA_MAP,data->scroll_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->scroller,OM_ADDTAIL,&data->boopsi_list);
}
// Create up arrow image
if ((image=(struct Image *)NewObject(
0,"dopusiclass",
IA_Width,data->scroller_dims.Width,
IA_Height,data->arrow_height,
DIA_Type,IM_ARROW_UP,
DIA_ThinBorders,(data->flags&LVF_THIN_BORDER)?TRUE:FALSE,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)image,OM_ADDTAIL,&data->boopsi_list);
}
// Create up arrow button
if ((data->arrows[0]=(struct Gadget *)NewObject(
0,"buttongclass",
GA_ID,LVGID_ARROW,
GA_Previous,data->scroller,
GA_Left,data->scroller_dims.Left,
GA_Top,data->scroller_dims.Top+data->scroller_dims.Height,
GA_Width,data->scroller_dims.Width,
GA_Height,data->arrow_height,
GA_Image,image,
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
ICA_TARGET,gadget,
ICA_MAP,data->arrow_up_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->arrows[0],OM_ADDTAIL,&data->boopsi_list);
}
// Create down arrow image
if ((image=(struct Image *)NewObject(
0,"dopusiclass",
IA_Width,data->scroller_dims.Width,
IA_Height,data->arrow_height,
DIA_Type,IM_ARROW_DOWN,
DIA_ThinBorders,(data->flags&LVF_THIN_BORDER)?TRUE:FALSE,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)image,OM_ADDTAIL,&data->boopsi_list);
}
// Create down arrow button
if ((data->arrows[1]=(struct Gadget *)NewObject(
0,"buttongclass",
GA_ID,LVGID_ARROW,
GA_Previous,data->arrows[0],
GA_Left,data->scroller_dims.Left,
GA_Top,data->scroller_dims.Top+data->scroller_dims.Height+data->arrow_height,
GA_Width,data->scroller_dims.Width,
GA_Height,data->arrow_height,
GA_Image,image,
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
ICA_TARGET,gadget,
ICA_MAP,data->arrow_down_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->arrows[1],OM_ADDTAIL,&data->boopsi_list);
}
}
}
else break;
// Fall through to OM_SET
// Update/Set
case OM_UPDATE:
case OM_SET:
{
struct TagItem *tag,*tags;
unsigned short old;
struct Node *node;
short item;
short redraw=0;
// Get taglist
tags=((struct opSet *)msg)->ops_AttrList;
// Make visible?
if ((tag=FindTagItem(DLV_MakeVisible,tags)))
{
short scroll;
// Remember old top
old=data->top;
// Get scroll amount
scroll=tag->ti_Data-old;
// Need to scroll?
if (scroll<0 ||
scroll>=data->lines)
{
// Get scroll amount
if (scroll>=data->lines)
scroll-=data->lines-1;
// Get new top
data->top+=scroll;
// Bounds check
if (data->top>data->count-data->lines)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Redraw?
if (old!=data->top)
{
data->last_sel=-1;
redraw=2;
}
}
}
// New top?
else
if ((tag=FindTagItem(DLV_Top,tags)))
{
// Remember old top
old=data->top;
// Get new top
data->top=tag->ti_Data;
// Bounds check
if (data->top>data->count-data->lines)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Redraw?
if (old!=data->top)
{
data->last_sel=-1;
redraw=2;
}
}
// Scroll up
else
if ((tag=FindTagItem(DLV_ScrollUp,tags)))
{
// Is this the gadgetup?
if (msg->MethodID==OM_UPDATE &&
!(((struct opUpdate *)msg)->opu_Flags&OPUF_INTERIM))
{
// Clear scroll count
data->scroll_count=0;
}
// Or is this the second/third scroll (first/second intuitick)?
else
if (msg->MethodID==OM_UPDATE &&
(data->scroll_count==1 || data->scroll_count==2))
{
// Throw this away
++data->scroll_count;
}
// Otherwise, check it's valid
else
if (tag->ti_Data!=(ULONG)-LVGID_ARROW)
{
// Bounds check
if (data->top>0)
{
--data->top;
data->last_sel=-1;
redraw=2;
}
// Increment scroll count if necessary
if (msg->MethodID==OM_UPDATE) ++data->scroll_count;
}
}
// Scroll down
else
if ((tag=FindTagItem(DLV_ScrollDown,tags)))
{
// Is this the gadgetup?
if (msg->MethodID==OM_UPDATE &&
!(((struct opUpdate *)msg)->opu_Flags&OPUF_INTERIM))
{
// Clear scroll count
data->scroll_count=0;
}
// Or is this the second/third scroll (first/second intuitick)?
else
if (msg->MethodID==OM_UPDATE &&
(data->scroll_count==1 || data->scroll_count==2))
{
// Throw this away
++data->scroll_count;
}
// Otherwise, check it's valid
else
if (tag->ti_Data!=(ULONG)-LVGID_ARROW)
{
// Bounds check
if (data->top<data->count-data->lines)
{
++data->top;
data->last_sel=-1;
redraw=2;
}
// Increment scroll count if necessary
if (msg->MethodID==OM_UPDATE) ++data->scroll_count;
}
}
// New labels
if ((tag=FindTagItem(DLV_Labels,tags)))
{
// clear top item
data->top_item=0;
// Store new label pointer
data->labels=(struct List *)tag->ti_Data;
// Detached list?
if (data->labels==(struct List *)~0)
data->flags|=LVF_DETACHED;
// No list
else
if (data->labels==0)
{
// Clear detach flag
data->count=0;
data->flags&=~LVF_DETACHED;
redraw=1;
}
// Valid list
else
{
// Count items
for (data->count=0,node=data->labels->lh_Head;
node->ln_Succ;
data->count++,node=node->ln_Succ);
// Bounds check top
if (data->top+data->lines>data->count)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Check selection for out-of-bounds
if (data->sel>data->count-1) data->sel=-1;
// Clear detach flag
data->flags&=~LVF_DETACHED;
redraw=1;
}
}
// Selected
if ((tag=FindTagItem(DLV_Selected,tags)) ||
(tag=FindTagItem(DLV_SelectPrevious,tags)) ||
(tag=FindTagItem(DLV_SelectNext,tags)) ||
(tag=FindTagItem(DLV_PageUp,tags)) ||
(tag=FindTagItem(DLV_PageDown,tags)) ||
(tag=FindTagItem(DLV_Home,tags)) ||
(tag=FindTagItem(DLV_End,tags)))
{
// Store old
old=data->sel;
// Get new selected
if (tag->ti_Tag==DLV_Selected)
{
data->sel=tag->ti_Data;
}
else
if (tag->ti_Tag==DLV_SelectPrevious)
{
if (data->sel>0) --data->sel;
}
else
if (tag->ti_Tag==DLV_SelectNext)
{
++data->sel;
}
else
if (tag->ti_Tag==DLV_PageUp)
{
if (data->sel==data->top)
data->sel-=data->lines-1;
else
data->sel=data->top;
if (data->sel<0) data->sel=0;
}
else
if (tag->ti_Tag==DLV_PageDown)
{
if (data->sel==data->top+data->lines-1)
data->sel+=data->lines-1;
else
data->sel=data->top+data->lines-1;
}
else
if (tag->ti_Tag==DLV_Home)
{
data->sel=0;
}
else
if (tag->ti_Tag==DLV_End)
{
data->sel=data->count-1;
}
// Bounds check
if (data->sel>data->count-1) data->sel=data->count-1;
if (data->sel<0) data->sel=-1;
// Changed?
if (data->sel!=old && !(gadget->Flags&GFLG_DISABLED))
{
// Save selection
if (!redraw)
{
data->last_sel=data->last_selection;
redraw=2;
}
data->last_selection=data->sel;
// Send notify
DoMethod(obj,OM_NOTIFY,0,((struct opSet *)msg)->ops_GInfo,0);
}
}
// Disabled (set only)
if (msg->MethodID==OM_SET &&
(tag=FindTagItem(GA_Disabled,tags)))
{
// Different to current state?
if ((tag->ti_Data && !(gadget->Flags&GFLG_DISABLED)) ||
(!tag->ti_Data && gadget->Flags&GFLG_DISABLED))
{
struct TagItem distags[2];
short a;
// Fill out disable tags
distags[0].ti_Tag=GA_Disabled;
distags[0].ti_Data=tag->ti_Data;
distags[1].ti_Tag=TAG_DONE;
// Set state of slider
if (data->scroller)
{
DoMethod(
(Object *)data->scroller,
OM_SET,
distags,
((struct opSet *)msg)->ops_GInfo);
// And arrows
for (a=0;a<2;a++)
DoMethod(
(Object *)data->arrows[a],
OM_SET,
distags,
((struct opSet *)msg)->ops_GInfo);
// Set flag to say disable state changed
if (!tag->ti_Data)
data->flags|=LVF_DISABLE_CHANGE;
}
// Change disable state and redraw
gadget->Flags^=GFLG_DISABLED;
redraw=1;
}
}
// Get top item
if (!data->labels) data->top_item=0;
else
if (!(data->flags&LVF_DETACHED) && data->labels)
{
for (node=data->labels->lh_Head,item=0;
node->ln_Succ && item<data->top;
node=node->ln_Succ,item++);
data->top_item=node;
}
// Do we need to redraw the list?
if (msg->MethodID==OM_SET || msg->MethodID==OM_UPDATE)
{
if (redraw && !(data->flags&LVF_DETACHED))
{
struct RastPort *rp;
// Get rastport
if ((rp=ObtainGIRPort(((struct opSet *)msg)->ops_GInfo)))
{
// Send redraw
DoMethod(
obj,
GM_RENDER,
((struct opSet *)msg)->ops_GInfo,
rp,
(redraw==2)?GREDRAW_UPDATE:GREDRAW_REDRAW);
ReleaseGIRPort(rp);
}
}
}
}
break;
// Get an attribute
case OM_GET:
{
struct opGet *get;
// Get get message
get=(struct opGet *)msg;
// Default to ok
retval=1;
// Look at attribute
switch (get->opg_AttrID)
{
// Selected
case DLV_Selected:
*get->opg_Storage=(ULONG)data->last_selection;
break;
// Top
case DLV_Top:
*get->opg_Storage=(ULONG)data->top;
break;
// Lines
case DLV_Lines:
*get->opg_Storage=(ULONG)data->lines;
break;
// Labels
case DLV_Labels:
*get->opg_Storage=(ULONG)data->labels;
break;
// Get line from coordinates
case DLV_GetLine:
{
unsigned short x,y;
struct gpInput fake;
// Get coordinates
x=((*get->opg_Storage)>>16)&0xffff;
y=(*get->opg_Storage)&0xffff;
// Fake gpInput
fake.gpi_Mouse.X=x-gadget->LeftEdge;
fake.gpi_Mouse.Y=y-gadget->TopEdge;
// Get selection
*get->opg_Storage=(ULONG)listview_get_sel(cl,gadget,data,&fake,0);
}
break;
// Draw a line from the listview
case DLV_DrawLine:
{
ListViewDraw *draw=(ListViewDraw *)*get->opg_Storage;
// Draw line
listview_draw_item(
cl,
gadget,
draw->rp,
draw->drawinfo,
data,
draw->node,
draw->line,
&draw->box);
}
break;
// Other
default:
retval=DoSuperMethodA(cl,obj,msg);
break;
}
}
break;
// Kill an instance
case OM_DISPOSE:
{
APTR object_ptr;
Object *object;
// Free BOOPSI objects
object_ptr=data->boopsi_list.lh_Head;
while ((object=NextObject((APTR)&object_ptr)))
DisposeObject(object);
// Free font
if (data->flags&LVF_GOT_FONT)
CloseFont(data->list_font);
retval=DoSuperMethodA(cl,obj,msg);
}
break;
// Render gadget
case GM_RENDER:
// Cache DrawInfo
data->draw_info=((struct gpRender *)msg)->gpr_GInfo->gi_DrInfo;
// If a full redraw, clear double-click time
if (((struct gpRender *)msg)->gpr_Redraw==GREDRAW_REDRAW)
data->seconds=0;
// Show gadget
listview_render(cl,gadget,data,(struct gpRender *)msg);
break;
// Hit test
case GM_HITTEST:
{
struct gpHitTest *test;
// Get test pointer
test=(struct gpHitTest *)msg;
// See if we're hit
if (test->gpht_Mouse.X>=data->text_dims.Left-gadget->LeftEdge &&
test->gpht_Mouse.Y>=data->text_dims.Top-gadget->TopEdge &&
test->gpht_Mouse.X<data->text_dims.Left+data->text_dims.Width-gadget->LeftEdge &&
test->gpht_Mouse.Y<data->text_dims.Top+data->text_dims.Height-gadget->TopEdge)
{
retval=GMR_GADGETHIT;
}
}
break;
// Notify
case OM_NOTIFY:
// Drag notify?
if (data->flags&LVF_DRAG_FLAG)
{
// Fill out tags
data->notify_tags[0].ti_Tag=DLV_DragNotify;
data->notify_tags[0].ti_Data=data->drag_sel;
data->notify_tags[1].ti_Tag=GA_ID;
data->notify_tags[1].ti_Data=gadget->GadgetID;
data->notify_tags[2].ti_Tag=GA_Left;
data->notify_tags[2].ti_Data=data->text_dims.Left;
data->notify_tags[3].ti_Tag=GA_Top;
data->notify_tags[3].ti_Data=data->text_dims.Top+
UMult32(data->drag_sel-data->top,data->text_height);
data->notify_tags[4].ti_Tag=GA_Width;
data->notify_tags[4].ti_Data=data->text_dims.Width;
data->notify_tags[5].ti_Tag=GA_Height;
data->notify_tags[5].ti_Data=data->text_height;
data->notify_tags[6].ti_Tag=GA_RelRight;
data->notify_tags[6].ti_Data=data->drag_x_position;
data->notify_tags[7].ti_Tag=GA_RelBottom;
data->notify_tags[7].ti_Data=data->drag_y_position;
data->notify_tags[8].ti_Tag=DLV_Top;
data->notify_tags[8].ti_Data=data->top;
data->notify_tags[9].ti_Tag=DLV_Object;
data->notify_tags[9].ti_Data=(ULONG)gadget;
data->notify_tags[10].ti_Tag=TAG_END;
// Clear flag
data->flags&=~LVF_DRAG_FLAG;
}
// Otherwise normal notify
else
{
ULONG seconds,micros;
// Fill out tags
data->notify_tags[0].ti_Tag=DLV_Selected;
data->notify_tags[0].ti_Data=data->last_selection;
data->notify_tags[1].ti_Tag=GA_ID;
data->notify_tags[1].ti_Data=gadget->GadgetID;
data->notify_tags[2].ti_Tag=TAG_END;
// Get current time
CurrentTime(&seconds,µs);
// Double-click?
if (data->click_sel==data->last_selection &&
DoubleClick(data->seconds,data->micros,seconds,micros))
{
// Set double-click flag
data->notify_tags[2].ti_Tag=DLV_DoubleClick;
data->notify_tags[2].ti_Data=TRUE;
data->notify_tags[3].ti_Tag=TAG_END;
// Clear double-click
data->seconds=0;
}
// Otherwise
else
{
// Remember double-click
data->seconds=seconds;
data->micros=micros;
data->click_sel=data->last_selection;
}
}
// Send message
DoSuperMethod(cl,obj,OM_NOTIFY,data->notify_tags,((struct opUpdate *)msg)->opu_GInfo,0);
break;
// Go (in)active/Handle input
case GM_GOACTIVE:
case GM_GOINACTIVE:
case GM_HANDLEINPUT:
{
struct gpInput *input;
short redraw=0;
// Get input pointer
input=(struct gpInput *)msg;
// Go active?
if (input->MethodID==GM_GOACTIVE)
{
// Default is not to activate
retval=GMR_NOREUSE;
// Ok to go active?
if (!(gadget->Flags&GFLG_DISABLED) && input->gpi_IEvent)
{
// Left button down and valid list?
if (input->gpi_IEvent->ie_Code==SELECTDOWN &&
data->labels &&
!(data->flags&(LVF_READ_ONLY|LVF_DETACHED)))
{
short sel;
// Get selection
if ((sel=listview_get_sel(cl,gadget,data,input,0))>-1)
{
// Ok to activate
retval=GMR_MEACTIVE;
// Store current top
data->last_top=data->top;
// Remember x and y click-offset
data->drag_x_position=input->gpi_Mouse.X-
(data->text_dims.Left-data->dims.Left);
data->drag_y_position=input->gpi_Mouse.Y-
(data->text_dims.Top-data->dims.Top)-
UMult32(sel-data->top,data->text_height);
// Change?
if (data->sel!=sel ||
!(data->flags&LVF_SHOW_SELECTED) ||
(data->flags&LVF_SELECTED_CHECK))
{
// New selection
data->last_sel=data->last_selection;
data->sel=sel;
redraw=1;
}
// Set selected flag
gadget->Flags|=GFLG_SELECTED;
}
}
}
}
// Go inactive?
else
if (msg->MethodID==GM_GOINACTIVE)
{
// Clear selected flag
gadget->Flags&=~GFLG_SELECTED;
// If we're showing selection with checks, we need to redraw last selection
if ((data->flags&(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))==(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))
data->last_sel=data->last_selection;
redraw=1;
// Save this selection
data->last_selection=data->sel;
// Send notify
DoMethod(obj,OM_NOTIFY,0,((struct gpInput *)msg)->gpi_GInfo,0);
// Clear cancel flag
data->flags&=~LVF_CANCEL;
}
// Handle input
else
{
// Default return value
retval=GMR_MEACTIVE;
// Is it a mouse event?
if (input->gpi_IEvent->ie_Class==IECLASS_RAWMOUSE)
{
// Look at mouse code
switch (input->gpi_IEvent->ie_Code)
{
// Left button up
case SELECTUP:
{
// Set return code
*input->gpi_Termination=data->sel;
// Gadget processing finished
retval=GMR_NOREUSE|GMR_VERIFY;
data->flags|=LVF_CANCEL;
// Multi-selection?
if (data->flags&LVF_MULTI_SELECT)
{
struct Node *node;
short count;
// Get this node
for (node=data->labels->lh_Head,count=0;
node->ln_Succ && count<data->sel;
node=node->ln_Succ,count++);
// Did we get it?
if (node && node->ln_Succ)
{
// Save old selection
data->last_sel=data->sel;
// Toggle selection
node->lve_Flags^=LVEF_SELECTED;
redraw=1;
}
}
}
break;
// No button; mouse moved
case IECODE_NOBUTTON:
{
short sel;
// Is mouse outside of lister?
if (input->gpi_Mouse.X<0 ||
input->gpi_Mouse.X>=data->list_dims.Width)
{
// Drag notify?
if (data->flags&LVF_DRAG_NOTIFY)
{
// Valid selection?
if (data->sel>-1)
{
// Notify drag
data->flags|=LVF_DRAG_FLAG;
data->drag_sel=data->sel;
// Will fall through to MENUDOWN (if NO_VERT_SCROLL)
if (!(data->flags&LVF_NO_VERT_SCROLL))
{
retval=GMR_NOREUSE;
data->flags|=LVF_CANCEL;
break;
}
}
else break;
}
else break;
}
// Get selection
else
if ((sel=listview_get_sel(cl,gadget,data,input,1))>-1 ||
(sel==-1 && (data->flags&LVF_NO_VERT_SCROLL)))
{
// Change?
if (data->sel!=sel || sel==-1)
{
// Clear double-click
data->seconds=0;
// No vertical scroll?
if (data->flags&LVF_NO_VERT_SCROLL)
{
// Drag notify?
if (data->flags&LVF_DRAG_NOTIFY)
{
// Notify drag
data->flags|=LVF_DRAG_FLAG;
data->drag_sel=data->sel;
// Will fall through to MENUDOWN
}
else break;
}
// Otherwise
else
{
// Save old selection
data->last_sel=data->sel;
// New selection
data->sel=sel;
redraw=1;
break;
}
}
else break;
}
else break;
}
// Right button does cancel
case MENUDOWN:
{
// Gadget processing finished
retval=GMR_NOREUSE;
data->flags|=LVF_CANCEL;
// Show selected?
if (data->flags&LVF_SHOW_SELECTED)
{
// Restore last selection
data->last_sel=data->sel;
data->sel=data->last_selection;
// Does top need to change?
if (data->top!=data->last_top)
{
short item;
data->top=data->last_top;
data->last_sel=-1;
for (data->top_item=data->labels->lh_Head,item=0;
data->top_item->ln_Succ && item<data->top;
data->top_item=data->top_item->ln_Succ,item++);
}
redraw=1;
}
}
break;
}
}
// Or a timer event
else
if (input->gpi_IEvent->ie_Class==IECLASS_TIMER)
{
short sel;
// Get selection
if ((sel=listview_get_sel(cl,gadget,data,input,2))>-1)
{
// Change?
if (data->sel!=sel)
{
// Save old selection
data->last_sel=data->sel;
// New selection
data->sel=sel;
// Do we have to scroll?
if (sel<data->top)
{
if (data->top>0)
{
// Scroll up
--data->top;
data->top_item=data->top_item->ln_Pred;
// Redraw the list
data->last_sel=-1;
redraw=1;
}
}
else
if (sel>=data->top+data->lines)
{
if (data->top+data->lines<data->count)
{
// Scroll down
++data->top;
data->top_item=data->top_item->ln_Succ;
// Redraw the list
data->last_sel=-1;
redraw=1;
}
}
else redraw=1;
}
}
}
}
// Redraw needed?
if (redraw)
{
struct RastPort *rp;
// Get rastport
if ((rp=ObtainGIRPort(input->gpi_GInfo)))
{
// Send redraw
DoMethod(obj,GM_RENDER,input->gpi_GInfo,rp,GREDRAW_UPDATE);
ReleaseGIRPort(rp);
}
}
}
break;
// Resize
case GM_RESIZE:
// Handle the resize
listview_resize(cl,gadget,data,(struct gpResize *)msg);
break;
// Unknown method
default:
retval=DoSuperMethodA(cl,obj,msg);
break;
}
return retval;
}
main(int argc, char *argv[])
{
unsigned char str[256];
int i;
int j;
struct RastPort rp;
unsigned char *pp;
struct BitMap bm = {
256, /* bytes per row */
8, /* rows */
0, /* flags */
1, /* depth */
0, /* pad */
0 /* planes */
};
struct TextAttr ta;
struct TextFont *tf;
struct FontRequester *fr;
struct TagItem frtags[] = {
ASL_Hail, (ULONG)"NetBSD font choices",
ASL_Width, 640,
ASL_Height, 400,
ASL_LeftEdge, 10,
ASL_TopEdge, 10,
ASL_OKText, (ULONG)"Dump",
ASL_CancelText, (ULONG)"Cancel",
ASL_FontName, (ULONG)"topaz.font",
ASL_FontHeight, 8L,
ASL_FontStyles, FS_NORMAL,
ASL_FuncFlags, FONF_STYLES | FONF_FIXEDWIDTH,
TAG_DONE
};
/* Let the user pick a font to dump */
if (fr = (struct FontRequester *)
AllocAslRequest(ASL_FontRequest, frtags)) {
if (!AslRequest(fr, NULL)) {
FreeAslRequest(fr);
fprintf(stderr, "User requested exit\n");
exit (0);
}
ta.ta_Name = (STRPTR)malloc(strlen(fr->fo_Attr.ta_Name));
strcpy(ta.ta_Name, fr->fo_Attr.ta_Name);
ta.ta_YSize = fr->fo_Attr.ta_YSize;
ta.ta_Style = fr->fo_Attr.ta_Style;
ta.ta_Flags = fr->fo_Attr.ta_Flags;
FreeAslRequest(fr);
} else {
fprintf(stderr, "Can't allocate Font Requestor\n");
exit (1);
}
/* Open the selected font */
tf = (struct TextFont *)OpenDiskFont (&ta);
if (! tf) {
fprintf (stderr, "Can't open font: %s\n", ta.ta_Name);
exit (1);
}
#ifdef DEBUG
fprintf(stderr, "Information on selected font:\n");
fprintf(stderr, "Name=%s\n", ta.ta_Name);
fprintf(stderr, "Height=%d tf_Style=%x tf_Flags=%x Width=%d Baseline=%d\n",
tf->tf_YSize, tf->tf_Style, tf->tf_Flags, tf->tf_XSize, tf->tf_Baseline);
#endif
/* Check for NetBSD restrictions */
if (tf->tf_Flags & FPF_PROPORTIONAL) {
fprintf(stderr, "NetBSD does not support proportional fonts\n");
exit (1);
}
if (tf->tf_XSize > NetBSDwidth) {
fprintf(stderr, "NetBSD does not support fonts wider than %d pixels\n", NetBSDwidth);
exit (1);
}
/* Allocate area to render font in */
InitBitMap(&bm, 1, 256 * NetBSDwidth, tf->tf_YSize);
InitRastPort (&rp);
rp.BitMap = &bm;
bm.Planes[0] = pp = AllocRaster (256 * NetBSDwidth, tf->tf_YSize);
if (!pp) {
fprintf (stderr, "Can't allocate raster!\n");
exit (1);
}
/* Initialize string to be rendered */
for (i = 32; i < 256; i++) {
str[i - 32] = i;
}
/* Render string with selected font */
SetFont (&rp, tf);
SetSoftStyle(&rp, ta.ta_Style ^ tf->tf_Style,
FSF_BOLD | FSF_UNDERLINED | FSF_ITALIC);
Move (&rp, 0, tf->tf_Baseline);
ClearEOL(&rp);
if (tf->tf_XSize != NetBSDwidth) {
/* right-justify char in cell */
Move (&rp, NetBSDwidth - tf->tf_XSize, tf->tf_Baseline);
/* Narrow font, put each character in space of normal font */
for (i = 0; i < (256 - 32); i++) {
Text (&rp, &str[i], 1);
Move (&rp, rp.cp_x + (NetBSDwidth - tf->tf_XSize), rp.cp_y);
}
} else {
Text (&rp, str, 256 - 32);
}
/* Dump them.. */
printf ("/* Generated automatically by fontdumper.c. *DONT* distribute\n");
printf (" this file, it may contain information Copyright by Commodore!\n");
printf ("\n");
printf (" Font: %s/%d\n", ta.ta_Name, tf->tf_YSize);
printf (" */\n\n");
printf ("unsigned char kernel_font_width = %d;\n", tf->tf_XSize);
printf ("unsigned char kernel_font_height = %d;\n", tf->tf_YSize);
printf ("unsigned char kernel_font_baseline = %d;\n", tf->tf_Baseline);
printf ("short kernel_font_boldsmear = %d;\n", tf->tf_BoldSmear);
printf ("unsigned char kernel_font_lo = 32;\n");
printf ("unsigned char kernel_font_hi = 255;\n\n");
printf ("unsigned char kernel_cursor[] = {\n");
for (j = 0; j < (tf->tf_YSize -1); j++) {
printf ("0xff, ");
}
printf ("0xff };\n\n");
printf ("unsigned char kernel_font[] = {\n");
for (i = 0; i < 256 - 32; i++) {
printf ("/* %c */", i + 32);
for (j = 0; j < tf->tf_YSize; j++) {
printf (" 0x%02x,", pp[i+j*256]);
}
printf ("\n");
}
printf ("};\n");
CloseFont (tf);
FreeRaster (pp, 256 * NetBSDwidth, tf->tf_YSize);
return (0);
}
_X_EXPORT int
CopyGC(register GC *pgcSrc, register GC *pgcDst, register BITS32 mask)
{
register BITS32 index2;
BITS32 maskQ;
int error = 0;
if (pgcSrc == pgcDst)
return Success;
pgcDst->serialNumber |= GC_CHANGE_SERIAL_BIT;
pgcDst->stateChanges |= mask;
maskQ = mask;
while (mask)
{
index2 = (BITS32) lowbit (mask);
mask &= ~index2;
switch (index2)
{
case GCFunction:
pgcDst->alu = pgcSrc->alu;
break;
case GCPlaneMask:
pgcDst->planemask = pgcSrc->planemask;
break;
case GCForeground:
pgcDst->fgPixel = pgcSrc->fgPixel;
break;
case GCBackground:
pgcDst->bgPixel = pgcSrc->bgPixel;
break;
case GCLineWidth:
pgcDst->lineWidth = pgcSrc->lineWidth;
break;
case GCLineStyle:
pgcDst->lineStyle = pgcSrc->lineStyle;
break;
case GCCapStyle:
pgcDst->capStyle = pgcSrc->capStyle;
break;
case GCJoinStyle:
pgcDst->joinStyle = pgcSrc->joinStyle;
break;
case GCFillStyle:
pgcDst->fillStyle = pgcSrc->fillStyle;
break;
case GCFillRule:
pgcDst->fillRule = pgcSrc->fillRule;
break;
case GCTile:
{
if (EqualPixUnion(pgcDst->tileIsPixel,
pgcDst->tile,
pgcSrc->tileIsPixel,
pgcSrc->tile))
{
break;
}
if (!pgcDst->tileIsPixel)
(* pgcDst->pScreen->DestroyPixmap)(pgcDst->tile.pixmap);
pgcDst->tileIsPixel = pgcSrc->tileIsPixel;
pgcDst->tile = pgcSrc->tile;
if (!pgcDst->tileIsPixel)
pgcDst->tile.pixmap->refcnt++;
break;
}
case GCStipple:
{
if (pgcDst->stipple == pgcSrc->stipple)
break;
if (pgcDst->stipple)
(* pgcDst->pScreen->DestroyPixmap)(pgcDst->stipple);
pgcDst->stipple = pgcSrc->stipple;
if (pgcDst->stipple)
pgcDst->stipple->refcnt ++;
break;
}
case GCTileStipXOrigin:
pgcDst->patOrg.x = pgcSrc->patOrg.x;
break;
case GCTileStipYOrigin:
pgcDst->patOrg.y = pgcSrc->patOrg.y;
break;
case GCFont:
if (pgcDst->font == pgcSrc->font)
break;
if (pgcDst->font)
CloseFont(pgcDst->font, (Font)0);
if ((pgcDst->font = pgcSrc->font) != NullFont)
(pgcDst->font)->refcnt++;
break;
case GCSubwindowMode:
pgcDst->subWindowMode = pgcSrc->subWindowMode;
break;
case GCGraphicsExposures:
pgcDst->graphicsExposures = pgcSrc->graphicsExposures;
break;
case GCClipXOrigin:
pgcDst->clipOrg.x = pgcSrc->clipOrg.x;
break;
case GCClipYOrigin:
pgcDst->clipOrg.y = pgcSrc->clipOrg.y;
break;
case GCClipMask:
(* pgcDst->funcs->CopyClip)(pgcDst, pgcSrc);
break;
case GCDashOffset:
pgcDst->dashOffset = pgcSrc->dashOffset;
break;
case GCDashList:
if (pgcSrc->dash == DefaultDash)
{
if (pgcDst->dash != DefaultDash)
{
xfree(pgcDst->dash);
pgcDst->numInDashList = pgcSrc->numInDashList;
pgcDst->dash = pgcSrc->dash;
}
}
else
{
unsigned char *dash;
unsigned int i;
dash = (unsigned char *)xalloc(pgcSrc->numInDashList *
sizeof(unsigned char));
if (dash)
{
if (pgcDst->dash != DefaultDash)
xfree(pgcDst->dash);
pgcDst->numInDashList = pgcSrc->numInDashList;
pgcDst->dash = dash;
for (i=0; i<pgcSrc->numInDashList; i++)
dash[i] = pgcSrc->dash[i];
}
else
error = BadAlloc;
}
break;
case GCArcMode:
pgcDst->arcMode = pgcSrc->arcMode;
break;
default:
clientErrorValue = maskQ;
error = BadValue;
break;
}
}
if (pgcDst->fillStyle == FillTiled && pgcDst->tileIsPixel)
{
if (!CreateDefaultTile (pgcDst))
{
pgcDst->fillStyle = FillSolid;
error = BadAlloc;
}
}
(*pgcDst->funcs->CopyGC) (pgcSrc, maskQ, pgcDst);
return error;
}
static ULONG EqualizeItems(struct MenuItem *firstitem, struct MenuItem *lastitem,
struct Image *amikeyimage, struct VisualInfo *vi,
struct GadToolsBase_intern * GadToolsBase)
{
struct MenuItem *item;
struct TextExtent te;
WORD minx = 0, maxwidth = 0, maxrightstuffwidth = 0;
if (!firstitem) return 0;
/* Calc. the max. width of item text/image (+ checkmark image)
Calc. the min. item->LeftEdge */
for(item = firstitem; item && (item != lastitem); item = item->NextItem)
{
if (item->LeftEdge < minx) minx = item->LeftEdge;
if (item->Width > maxwidth) maxwidth = item->Width;
}
/* Calc. the max. width of AmigaKey/CommandString/">>" */
FontExtent(vi->vi_dri->dri_Font, &te);
for(item = firstitem; item && (item != lastitem); item = item->NextItem)
{
WORD width = 0;
if (item->Flags & COMMSEQ)
{
width = te.te_Width;
if (item->Flags & ITEMTEXT)
{
struct TextFont *font;
struct IntuiText *it = (struct IntuiText *)item->ItemFill;
if (it->ITextFont)
{
if ((font = OpenFont(it->ITextFont)))
{
struct TextExtent e;
FontExtent(font, &e);
width = e.te_Width;
CloseFont(font);
}
}
}
width += amikeyimage->Width +
AMIGAKEY_KEY_SPACING;
}
else if (item->Flags & ITEMTEXT)
{
struct IntuiText *it = (struct IntuiText *)item->ItemFill;
struct IntuiText *it2;
if ((it2 = it->NextText))
{
it2->FrontPen = it->FrontPen;
it2->BackPen = it->BackPen;
it2->DrawMode = it->DrawMode;
it2->TopEdge = it->TopEdge;
/* save width also in it->LeftEdge. Will be used below to
calc. x position */
width = it2->LeftEdge = MyIntuiTextLength(vi, it2, GadToolsBase);
}
}
if (width > maxrightstuffwidth) maxrightstuffwidth = width;
} /* for(item = firstitem; item; item = item->NextItem) */
/* Calc. x coordinate of command strings and ">>"'s and submenu pos. */
if (maxrightstuffwidth)
{
maxwidth += maxrightstuffwidth + TEXT_AMIGAKEY_SPACING;
for(item = firstitem; item && (item != lastitem); item = item->NextItem)
{
struct MenuItem *subitem;
if (item->Flags & ITEMTEXT)
{
struct IntuiText *it = (struct IntuiText *)item->ItemFill;
if ((it = it->NextText))
{
/* it->LeftEdge contains the pixel width. see above */
it->LeftEdge = minx + maxwidth - it->LeftEdge - ITEXT_EXTRA_RIGHT;
}
}
for(subitem = item->SubItem; subitem; subitem = subitem->NextItem)
{
subitem->LeftEdge += (maxwidth - maxrightstuffwidth);
}
}
} /* if (maxrightstuffwidth) */
/* Make all items have the same width and set also the width and the
drawinfo of barlabel images */
for(item = firstitem; item && (item != lastitem); item = item->NextItem)
{
item->Width = maxwidth;
if(!(item->Flags & ITEMTEXT))
{
struct Image *im = (struct Image *)item->ItemFill;
if (is_menubarlabelclass_image(im, GadToolsBase))
{
struct TagItem image_tags [] =
{
{IA_Width , maxwidth - ITEXT_EXTRA_LEFT - ITEXT_EXTRA_RIGHT },
{SYSIA_DrawInfo , (IPTR)vi->vi_dri },
{TAG_DONE }
};
SetAttrsA(im, image_tags);
}
}
}
return (ULONG)maxwidth;
}
static BOOL LayOutReq (struct AHIAudioModeRequesterExt *req, struct TextAttr *TextAttr)
{
struct Gadget *gad;
struct NewGadget ng;
struct TextAttr *gadtextattr;
struct TextFont *font;
LONG fontwidth,buttonheight,buttonwidth,pixels;
struct IntuiText intuitext = {1,0,JAM1,0,0,NULL,NULL,NULL};
LONG sliderlevels,sliderlevel;
LONG selected;
selected=GetSelected(req);
GetSliderAttrs(req,&sliderlevels,&sliderlevel);
// Calculate gadget area
req->gx=req->Window->BorderLeft+4;
req->gy=req->Window->BorderTop+2;
req->gw=req->Window->Width-req->gx-(req->Window->BorderRight+4);
req->gh=req->Window->Height-req->gy-(req->Window->BorderBottom+2);
if(req->Gadgets)
{
RemoveGList(req->Window,req->Gadgets,-1);
FreeGadgets(req->Gadgets);
SetAPen(req->Window->RPort,0);
SetDrMd(req->Window->RPort,JAM1);
EraseRect(req->Window->RPort, req->Window->BorderLeft, req->Window->BorderTop,
req->Window->Width-req->Window->BorderRight-1,req->Window->Height-req->Window->BorderBottom-1);
RefreshWindowFrame(req->Window);
}
req->Gadgets=NULL;
if((gad=CreateContext(&req->Gadgets)))
{
if(TextAttr)
gadtextattr=TextAttr;
else
gadtextattr=req->Window->WScreen->Font;
if((font=OpenFont(gadtextattr)))
{
fontwidth=font->tf_XSize;
CloseFont(font);
}
else
return FALSE;
buttonheight=gadtextattr->ta_YSize+6;
intuitext.ITextFont=gadtextattr;
intuitext.IText=req->PositiveText;
buttonwidth=IntuiTextLength(&intuitext);
intuitext.IText=req->NegativeText;
pixels=IntuiTextLength(&intuitext);
buttonwidth=max(pixels,buttonwidth);
buttonwidth+=4+fontwidth;
// Create gadgets and check if they fit
// Do the two buttons fit?
if(2*buttonwidth > req->gw)
return FALSE;
ng.ng_TextAttr=gadtextattr;
ng.ng_VisualInfo=req->vi;
ng.ng_UserData=req;
// OK button
ng.ng_LeftEdge=req->gx;
ng.ng_TopEdge=req->gy+req->gh-buttonheight;
ng.ng_Width=buttonwidth;
ng.ng_Height=buttonheight;
ng.ng_GadgetText=req->PositiveText;
ng.ng_GadgetID=OKBUTTON;
ng.ng_Flags=PLACETEXT_IN;
gad=CreateGadget(BUTTON_KIND,gad,&ng,TAG_END);
// Cancel button
ng.ng_LeftEdge=req->gx+req->gw-ng.ng_Width;
ng.ng_GadgetText=req->NegativeText;
ng.ng_GadgetID=CANCELBUTTON;
gad=CreateGadget(BUTTON_KIND,gad,&ng,TAG_END);
// Frequency
if(req->Flags & freqgad)
{
intuitext.IText = GetString(msgReqFrequency, req->Catalog);
pixels=IntuiTextLength(&intuitext)+INTERWIDTH;
if(pixels+MINSLIDERWIDTH+INTERWIDTH+FREQLEN2*fontwidth > req->gw)
return FALSE;
ng.ng_Width=req->gw-pixels-INTERWIDTH-FREQLEN2*fontwidth;
ng.ng_LeftEdge=req->gx+pixels;
ng.ng_TopEdge-=2+buttonheight;
ng.ng_GadgetText = GetString(msgReqFrequency, req->Catalog);
ng.ng_GadgetID=FREQSLIDER;
ng.ng_Flags=PLACETEXT_LEFT;
gad=CreateGadget(SLIDER_KIND,gad,&ng,
GTSL_Min,0,
GTSL_Max,sliderlevels-1,
GTSL_Level,sliderlevel,
GTSL_LevelFormat, (ULONG) FREQTEXT2,
GTSL_MaxLevelLen,FREQLEN2,
GTSL_LevelPlace,PLACETEXT_RIGHT,
GTSL_DispFunc, (ULONG) m68k_IndexToFrequency,
GA_RelVerify,TRUE,
GA_Disabled,!sliderlevels || (req->tempAudioID == AHI_DEFAULT_ID),
TAG_DONE);
req->slidergadget=gad; // Save for HadleReq()...
}
// ListView
if((ng.ng_Height=ng.ng_TopEdge-2-req->gy) < buttonheight)
return FALSE;
ng.ng_LeftEdge=req->gx;
ng.ng_TopEdge=req->gy;
ng.ng_Width=req->gw;
ng.ng_GadgetText=NULL,
ng.ng_GadgetID=LISTVIEW;
ng.ng_Flags=PLACETEXT_ABOVE;
gad=CreateGadget(LISTVIEW_KIND,gad,&ng,
GTLV_ScrollWidth,(fontwidth>8 ? fontwidth*2 : 18),
GTLV_Labels, (ULONG) req->list,
GTLV_ShowSelected,NULL,
((selected == ~0) || (GadToolsBase->lib_Version >= 39) ? TAG_IGNORE : GTLV_Top),selected,
(selected == ~0 ? TAG_IGNORE : GTLV_MakeVisible),selected,
GTLV_Selected,selected,
TAG_DONE);
req->listviewgadget=gad; // Save for HadleReq()...
if(!gad)
return FALSE;
}
else
return FALSE;
AddGList(req->Window,req->Gadgets,~0,-1,NULL);
RefreshGList(req->Gadgets,req->Window,NULL,-1);
GT_RefreshWindow(req->Window,NULL);
return TRUE;
}
BOOL layoutmenuitems(struct MenuItem * firstitem,
struct VisualInfo * vi,
struct TagItem * taglist,
struct GadToolsBase_intern * GadToolsBase)
{
struct Menu * menu;
struct MenuItem * menuitem = firstitem;
struct MenuItem * equalizeitem = firstitem;
struct Image * amikeyimage, * chkimage;
struct TextExtent te;
ULONG curX = 0;
ULONG curY = 0;
WORD numcolumns = 1;
amikeyimage = (struct Image *)GetTagData(GTMN_AmigaKey, 0, taglist);
if (!amikeyimage) amikeyimage = vi->vi_dri->dri_AmigaKey;
chkimage = (struct Image *)GetTagData(GTMN_Checkmark, 0, taglist);
if (!chkimage) chkimage = vi->vi_dri->dri_CheckMark;
FontExtent(vi->vi_dri->dri_Font, &te);
while (NULL != menuitem)
{
ULONG addwidth = 0;
ULONG addleft = 0;
menuitem->LeftEdge = curX;
menuitem->TopEdge = curY;
if (0 != (menuitem->Flags & CHECKIT))
{
/*
** A checkmark will appear on the left.
*/
addleft += chkimage->Width + CHECKMARK_TEXT_SPACING;
addwidth += chkimage->Width + CHECKMARK_TEXT_SPACING;
}
if (0 != (menuitem->Flags & ITEMTEXT))
{
/*
** Text
*/
struct IntuiText * it = (struct IntuiText *)menuitem->ItemFill;
struct TagItem * ti;
if (NULL == it)
return FALSE;
if (NULL != (ti = FindTagItem(GTMN_FrontPen, taglist)))
{
it->FrontPen = ti->ti_Data;
}
else
{
it->FrontPen = vi->vi_dri->dri_Pens[BARDETAILPEN];
}
it->ITextFont = (struct TextAttr *)GetTagData(GTMN_TextAttr,
0,
taglist);
it->LeftEdge = ITEXT_EXTRA_LEFT + addleft;
it->TopEdge = ITEXT_EXTRA_TOP;
menuitem->Width = MyIntuiTextLength(vi, it, GadToolsBase) +
addwidth + ITEXT_EXTRA_LEFT + ITEXT_EXTRA_RIGHT;
/*
** Calculate the height menu item.
*/
if (NULL == it->ITextFont)
{
/*
** No font is provided, so I will work with the screen font.
*/
menuitem->Height = vi->vi_dri->dri_Font->tf_YSize + ITEXT_EXTRA_TOP + ITEXT_EXTRA_BOTTOM;
}
else
{
struct TextFont * font;
if (NULL != (font = OpenFont(it->ITextFont)))
{
menuitem->Height = font->tf_YSize + ITEXT_EXTRA_TOP + ITEXT_EXTRA_BOTTOM;
CloseFont(font);
}
else
return FALSE;
}
} /* if (0 != (menuitem->Flags & ITEMTEXT)) */
else
{
/*
** Image
*/
struct Image * im = (struct Image *)menuitem->ItemFill;
if (NULL == im) return FALSE;
if (is_menubarlabelclass_image(im, GadToolsBase))
{
menuitem->Width = 10;
menuitem->Height = 7;
}
else
{
menuitem->Width = im->Width + addwidth + IMAGE_EXTRA_LEFT + IMAGE_EXTRA_RIGHT;
menuitem->Height = im->Height + IMAGE_EXTRA_TOP + IMAGE_EXTRA_BOTTOM;
im->LeftEdge = IMAGE_EXTRA_LEFT + addleft;
im->TopEdge = IMAGE_EXTRA_TOP;
}
} /* if (0 != (menuitem->Flags & ITEMTEXT)) else ... */
curY += menuitem->Height;
/*
** In case this menu becomes too high it will have more columns.
*/
if (curY > vi->vi_screen->Height)
{
ULONG width;
width = EqualizeItems(equalizeitem, menuitem, amikeyimage, vi, GadToolsBase);
equalizeitem = menuitem;
curY = 0;
curX += width + MENU_COLUMN_SPACING;
menuitem->LeftEdge = curX;
menuitem->TopEdge = curY;
curY += menuitem->Height;
numcolumns++;
}
/*
** Process the next menu item
*/
menuitem = menuitem->NextItem;
} /* while (NULL != menuitem) */
EqualizeItems(equalizeitem, NULL, amikeyimage, vi, GadToolsBase);
menu = (struct Menu *)GetTagData(GTMN_Menu, 0, taglist);
if (menu && (menu->FirstItem == firstitem))
{
/* Make sure the menu box is at least as large as the menu title,
otherwise it looks ugly */
WORD menuwidth, minx, maxx, titlewidth, prevy = -1, col = 1;
minx = 32767;
maxx = -32768;
for(menuitem = firstitem; menuitem; menuitem = menuitem->NextItem)
{
if (menuitem->LeftEdge < minx) minx = menuitem->LeftEdge;
if (menuitem->LeftEdge + menuitem->Width - 1 > maxx) maxx = menuitem->LeftEdge + menuitem->Width - 1;
}
menuwidth = maxx - minx + 1;
titlewidth = TextLength(&vi->vi_screen->RastPort, menu->MenuName, strlen(menu->MenuName));
if (titlewidth > menuwidth)
{
WORD extrawidth = (titlewidth - menuwidth + numcolumns / 2) / numcolumns;
for(menuitem = firstitem; menuitem; menuitem = menuitem->NextItem)
{
struct MenuItem *subitem;
if (menuitem->TopEdge < prevy) col++;
prevy = menuitem->TopEdge;
menuitem->LeftEdge += (col - 1) * extrawidth;
menuitem->Width += extrawidth;
if (menuitem->Flags & ITEMTEXT)
{
struct IntuiText *it = (struct IntuiText *)menuitem->ItemFill;
if ((it = it->NextText))
{
it->LeftEdge += extrawidth;
}
}
else
{
struct Image *im = (struct Image *)menuitem->ItemFill;
if (is_menubarlabelclass_image(im, GadToolsBase))
{
im->Width += extrawidth;
}
}
if ((subitem = menuitem->SubItem))
{
while(subitem)
{
subitem->LeftEdge += extrawidth;
subitem = subitem->NextItem;
}
}
} /* for(menuitem = firstitem; menuitem; menuitem = menuitem->NextItem) */
} /* if (titlewidth > menuwidth) */
} /* if (menu && (menu->FirstItem == firstitem)) */
return TRUE;
}
