LONG InvokeHandlers(struct IFFHandle *iff, LONG mode, LONG ident,
struct IFFParseBase_intern *IFFParseBase)
{
struct ContextNode *cn;
struct HandlerInfo *hi;
struct LocalContextItem *lci;
LONG err;
/* Either RETURN_2CLIENT or IFFERR_EOC */
LONG stepping_retval;
ULONG param;
D(bug("InvokeHandlers (Iff=%p, mode=%d, ident=0x%08lx\n",
iff, mode, ident
));
if (ident == IFFLCI_ENTRYHANDLER)
stepping_retval = IFF_RETURN2CLIENT;
else
stepping_retval = IFFERR_EOC;
/* Check for IFFPARSE_RAWSTEP *before* calling evt entryhandlers */
if (mode == IFFPARSE_RAWSTEP)
ReturnInt ("InvokeHandlers(1)",LONG,stepping_retval);
/* Get top of contextstack */
cn = TopChunk(iff);
/* Scan downwards to find a contextnode with a matching LCI */
lci = FindLocalItem ( iff, cn->cn_Type, cn->cn_ID, ident );
if (lci)
{
/* Get the HandlerInfo userdata */
hi = LocalItemData(lci);
/* First check if a hook really is present */
if (! hi->hi_Hook)
ReturnInt ("InvokeHandlers",LONG,IFFERR_NOHOOK);
/* What kind off command shall the hook receive */
if (ident == IFFLCI_ENTRYHANDLER)
param = IFFCMD_ENTRY;
else
param = IFFCMD_EXIT;
/* Call the handler */
if ( (err = CallHookPkt ( hi->hi_Hook, hi->hi_Object, (APTR)param)) )
ReturnInt ("InvokeHandlers(2)",LONG,err);
}
/* Check for IFFPARSE_STEP. (stepping through file WITH handlers enabled */
if (mode == IFFPARSE_STEP)
ReturnInt ("InvokeHandlers(3)",LONG,stepping_retval);
ReturnInt ("InvokeHandlers",LONG,0L);
}
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::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);
}
/******* 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 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);
}
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);
}
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__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender *msg)
{
struct SliderData *data = INST_DATA(cl, g);
IPTR retval;
if (msg->gpr_Redraw == GREDRAW_REDRAW)
{
DrawImageState(msg->gpr_RPort,
(struct Image *)data->frame,
g->LeftEdge - BORDERPROPSPACINGX,
g->TopEdge - BORDERPROPSPACINGY,
IDS_NORMAL,
msg->gpr_GInfo->gi_DrInfo);
}
retval = DoSuperMethodA(cl, (Object *)g, (Msg)msg);
renderlabel(GadToolsBase, g, msg->gpr_RPort, data->labelplace);
ReturnInt("Slider::Render", IPTR, retval);
}
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));
}
IPTR GTText__GM_RENDER(Class *cl, struct Gadget *g, struct gpRender *msg)
{
UWORD *pens = msg->gpr_GInfo->gi_DrInfo->dri_Pens;
UBYTE textbuf[256], *str;
struct TextData *data = INST_DATA(cl, g);
WORD left, left2, top, width, height, numchars, tlength;
struct TextFont *oldfont;
struct RastPort *rp = msg->gpr_RPort;
EnterFunc(bug("Text::Render()\n"));
left = g->LeftEdge;
top = g->TopEdge;
width = g->Width;
height = g->Height;
if (msg->gpr_Redraw == GREDRAW_REDRAW)
{
if (data->frame)
{
DrawImageState(msg->gpr_RPort,
(struct Image *)data->frame,
left,
top,
IDS_NORMAL,
msg->gpr_GInfo->gi_DrInfo);
}
renderlabel(GadToolsBase, g, msg->gpr_RPort, data->labelplace);
}
if (data->toprint || (data->gadgetkind != TEXT_KIND))
{
/* preserve font */
oldfont = rp->Font;
SetFont(rp, data->font);
str = textbuf;
if (data->gadgetkind == TEXT_KIND)
{
strncpy(str, (char *)data->toprint, sizeof(textbuf));
textbuf[sizeof(textbuf) - 1] = '\0';
}
else /* NUMERIC_KIND or label of SLIDER_KIND */
{
RawDoFmt(data->format, &(data->toprint), (VOID_FUNC)AROS_ASMSYMNAME(puttostr), &str);
}
D(bug("Text formatted into: %s\n", textbuf));
numchars = strlen(textbuf);
if (data->flags & TEXTF_BORDER)
{
left += VBORDER + 1;
top += HBORDER + 1;
width = g->Width - (VBORDER + 1) * 2;
height = g->Height - (HBORDER + 1) * 2;
}
if (data->flags & TEXTF_CLIPPED)
{
struct TextExtent te;
/* See how many chars fits into the display area */
numchars = TextFit(rp, textbuf, numchars, &te, NULL, 1, width, g->Height);
}
tlength = TextLength(rp, textbuf, numchars);
left2 = left;
switch (data->justification)
{
case GTJ_LEFT:
break;
case GTJ_RIGHT:
left2 += (width - tlength);
break;
case GTJ_CENTER:
left2 += ((width - tlength) / 2);
break;
}
/* Render text */
D(bug("Rendering text of lenghth %d at (%d, %d)\n", numchars, left, top));
SetABPenDrMd(rp, pens[data->backpen], pens[data->backpen], JAM2);
RectFill(rp, left, top, left + width - 1, top + height - 1);
SetAPen(rp, pens[data->frontpen]);
Move(rp, left2,
top + ((height - data->font->tf_YSize) / 2) + data->font->tf_Baseline);
Text(rp, textbuf, numchars);
SetFont(rp, oldfont);
} /* if (data->toprint || (data->gadgetkind != TEXT_KIND)) */
ReturnInt("Text::Render", IPTR, 0);
}
STATIC IPTR text_set(Class * cl, Object * o, struct opSet * msg)
{
IPTR retval = 0UL;
struct TagItem *tag;
const struct TagItem *tstate;
struct TextData *data = INST_DATA(cl, o);
struct RastPort *rport;
EnterFunc(bug("Text::Set()\n"));
tstate = msg->ops_AttrList;
while ((tag = NextTagItem(&tstate)))
{
IPTR tidata = tag->ti_Data;
switch (tag->ti_Tag)
{
case GTA_GadgetKind:
data->gadgetkind = (WORD)tidata;
break;
case GTNM_Number:
data->toprint = tidata;
D(bug("GTNM_Number: %ld\n", tidata));
if (data->dispfunc)
{
#ifdef __MORPHOS__
REG_A7 -= 8;
((ULONG *)REG_A7)[0] = (ULONG)o;
((ULONG *)REG_A7)[1] = data->toprint;
data->toprint = MyEmulHandle->EmulCallDirect68k(data->dispfunc);
REG_A7 += 8;
#else
data->toprint = (ULONG)data->dispfunc((struct Gadget *)o,
(WORD)data->toprint);
#endif
}
retval = 1UL;
break;
case GTTX_Text:
/* If the user has GT_SetGadgetAttrs() us to a different text,
** then don't copy it anymore
*/
if (msg->MethodID != OM_NEW)
{
if (data->flags & TEXTF_COPYTEXT)
{
FreeVec((APTR)data->toprint);
data->flags &= ~TEXTF_COPYTEXT;
}
data->toprint = tidata;
D(bug("GTTX_Text: %s\n", tidata));
}
retval = 1UL;
break;
case GTTX_Border: /* [I] */
case GTNM_Border: /* [I] */
if (tidata)
data->flags |= TEXTF_BORDER;
D(bug("Border: %d\n", tidata));
break;
/*case GTTX_FrontPen: [IS] */
case GTNM_FrontPen: /* [IS] */
data->frontpen = (UBYTE)tidata;
D(bug("FrontPen: %d\n", tidata));
retval = 1UL;
break;
/* case GTTX_BackPen: [IS] */
case GTNM_BackPen: /* [IS] */
data->backpen = (UBYTE)tidata;
D(bug("BackPen: %d\n", tidata));
retval = 1UL;
break;
/* case GTTX_Justification: [I] */
case GTNM_Justification: /* [I] */
data->justification = (UBYTE)tidata;
D(bug("Justification: %d\n", tidata));
break;
case GTNM_Format: /* [I] */
case GTA_Text_Format:
data->format = (STRPTR)tidata;
D(bug("Format: %s\n", tidata));
break;
/* case GTTX_Clipped: [I] */
case GTNM_Clipped:
if (tidata)
data->flags |= TEXTF_CLIPPED;
D(bug("Clipped: %d\n", tidata));
break;
case GTNM_MaxNumberLen: /* [I] */
data->maxnumberlength = tidata;
D(bug("MaxNumberLen: %d\n", tidata));
break;
} /* switch() */
} /* while (iterate taglist) */
/* Redraw the gadget, if an attribute was changed and if this is the
objects' base-class. */
if ((retval) && (OCLASS(o) == cl)) {
rport = ObtainGIRPort(msg->ops_GInfo);
if (rport) {
DoMethod(o, GM_RENDER, (IPTR) msg->ops_GInfo, (IPTR) rport, GREDRAW_UPDATE);
ReleaseGIRPort(rport);
retval = FALSE;
}
}
ReturnInt ("Text::Set", IPTR, retval);
}
LONG PushContextNode
(
struct IFFHandle *iff,
LONG type,
LONG id,
LONG size,
LONG scan,
struct IFFParseBase_intern *IFFParseBase
)
{
/* Allocates and puts a new context-node into the top of the context-stack
Also does GoodType and GoodID checking */
struct ContextNode *cn;
BOOL composite;
D(bug("PushContextNode(iff=%p, type=%c%c%c%c, id=%c%c%c%c, size=%d, scan=%d)\n",
iff,
dmkid(type),
dmkid(id),
size,
scan
));
/* Set the composite flag if we have a composite contextnnode */
if (id == ID_FORM || id == ID_LIST || id == ID_CAT || id == ID_PROP)
{
composite = TRUE;
/* We have a new type, check it */
}
else
{
composite = FALSE;
/* No composite type found. Get old type from top contextnode */
cn = TopChunk(iff);
type = cn->cn_Type;
}
/* Check if type and ids are valid */
if (!(GoodType(type) && GoodID(id)) )
ReturnInt ("PushContextNode",LONG,IFFERR_MANGLED);
/* Allocate a new context node */
if ( !(cn = AllocMem ( sizeof (struct IntContextNode), MEMF_ANY ) ) )
ReturnInt ("PushContextNode",LONG,IFFERR_NOMEM);
/* Put the context node at top of the stack */
AddHead ( (struct List*)&( GetIntIH(iff)->iff_CNStack ), (struct Node*)cn );
/* Set the contextnode attrs */
cn->cn_Type = type;
cn->cn_ID = id;
cn->cn_Size = size;
cn->cn_Scan = scan;
GetIntCN(cn)->cn_Composite = composite;
/* Initialize the LCI-list */
NewList ((struct List*)&( GetIntCN(cn)->cn_LCIList ));
/* Deeper stack */
iff->iff_Depth ++;
ReturnInt ("PushContextNode",LONG,0L);
}
LONG GetChunkHeader(struct IFFHandle *iff,
struct IFFParseBase_intern *IFFParseBase)
{
LONG type,
id,
size;
LONG scan = 0;
LONG bytesread;
D(bug("GetChunkHeader (iff=%p)\n", iff));
/* Reads in the appropriate stuff from a chunk and makes a contextnode of it */
/* Read chunk ID */
bytesread = ReadStreamLong ( iff, &id, IFFParseBase );
/* We may have an IFF Error */
if (bytesread < 0)
ReturnInt ("GetChunkHeader",LONG,bytesread);
/* Read chunk size */
bytesread = ReadStreamLong ( iff, &size, IFFParseBase );
if (bytesread < 0)
ReturnInt ("GetChunkHeader",LONG,bytesread);
/* We must see if we have a IFF header ("FORM", "CAT" or "LIST" */
if ( id == ID_FORM || id == ID_CAT || id == ID_LIST || id == ID_PROP )
{
/* Read chunk size */
bytesread = ReadStreamLong ( iff, &type, IFFParseBase );
if (bytesread < 0)
ReturnInt ("GetChunkHeader",LONG,bytesread);
DB2(bug(" Found Chunk %c%c%c%c size=%d type %c%c%c%c\n",
dmkid(id),
size,
dmkid(type)
));
/* Type is inside chunk so we had to add its size to the scancount. */
scan = sizeof (LONG);
}
else
{
type = 0L;
DB2(bug(" Found Chunk %c%c%c%c size=%d\n",
dmkid(id),
size
));
}
ReturnInt
(
"GetChunkHeader",
LONG,
PushContextNode
(
iff,
type,
id,
size,
scan,
IFFParseBase
)
);
}
ULONG HandleStrInput( struct Gadget *gad,
struct GadgetInfo *ginfo,
struct InputEvent *ievent,
UWORD *imsgcode,
struct IntuitionBase *IntuitionBase)
{
struct SGWork sgw;
struct StringInfo *strinfo = (struct StringInfo *)gad->SpecialInfo;
struct StringExtend *strext = NULL;
ULONG command = 0;
EnterFunc(bug("HandleStrInput(gad=%p, ginfo=%p, ievent=%p)\n",
gad, ginfo, ievent));
if ((ievent->ie_Class == IECLASS_TIMER)) return 0;
D(bug("Gadget text: %s\n", strinfo->Buffer));
if (!ginfo)
ReturnInt("HandleStrInput", ULONG, 0UL);
UpdateStringInfo(gad);
/* Initialize SGWork */
sgw.Gadget = gad;
sgw.StringInfo = strinfo;
sgw.WorkBuffer = strinfo->Buffer; /* default */
sgw.PrevBuffer = strinfo->Buffer;
sgw.Modes = 0;
sgw.IEvent = ievent;
sgw.Code = 0;
sgw.BufferPos = strinfo->BufferPos;
sgw.NumChars = strinfo->NumChars;
sgw.Actions = 0;
sgw.LongInt = strinfo->LongInt;
sgw.GadgetInfo = ginfo;
sgw.EditOp = EO_NOOP;
if (gad->Flags & GFLG_STRINGEXTEND)
{
D(bug("HandleStrInput: Extended gadget\n"));
strext = strinfo->Extension;
if (strext->WorkBuffer)
{
sgw.WorkBuffer = strext->WorkBuffer;
/* The edit hook gets *copy* of the current buffer contents */
strcpy(sgw.WorkBuffer, strinfo->Buffer);
}
sgw.Modes = strext->InitialModes;
}
switch (ievent->ie_Class)
{
case IECLASS_RAWMOUSE:
if (ievent->ie_Code == SELECTDOWN)
{
command = SGH_CLICK;
sgw.Actions = SGA_USE | SGA_REDISPLAY;
D(bug("HandleStrInput: RAWMOUSE event\n"));
}
break;
case IECLASS_RAWKEY:
{
UBYTE buf;
D(bug("HandleStrInput: RAWKEY event\n"));
if (ievent->ie_Code & IECODE_UP_PREFIX)
{
D(bug("HandleStrInput: filter UP event\n"));
}
else
{
command = SGH_KEY;
sgw.Actions = SGA_USE;
if (1 == MapRawKey(sgw.IEvent, &buf, 1, strinfo->AltKeyMap))
{
D(bug("HandleStrInput: sgw.Code 0x%lx\n",buf));
sgw.Code = (UWORD)buf;
}
}
break;
}
}
if (!command)
ReturnInt("HandleStrInput", ULONG , 0UL);
/* Call the global editing hook */
D(bug("calling global hook, Buffer=%s, WorkBuffer=%s\n",
strinfo->Buffer, sgw.WorkBuffer));
CallHookPkt(GetPrivIBase(IntuitionBase)->GlobalEditHook, &sgw, &command);
/* If there is a local edit hook, run it */
if (strext)
{
if (strext->EditHook)
{
D(bug("calling local edit hook\n"));
CallHookPkt(strext->EditHook, &sgw, &command);
}
}
/* Copy possibly changed stuff into stringgad */
if (sgw.Actions & SGA_USE)
{
if (strext)
{
if (strext->WorkBuffer)
strcpy(strinfo->Buffer, strext->WorkBuffer);
}
strinfo->BufferPos = sgw.BufferPos;
strinfo->NumChars = sgw.NumChars;
strinfo->LongInt = sgw.LongInt;
#if 0
if (gad->Activation & GACT_LONGINT)
{
kprintf("strinfo->LongInt = %d\n",strinfo->LongInt);
*/
}
else
{
static void equal_test()
{
boost::function0<int> f;
f = &forty_two;
BOOST_CHECK(f == &forty_two);
BOOST_CHECK(f != ReturnInt(17));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two == f);
BOOST_CHECK(ReturnInt(17) != f);
#endif
BOOST_CHECK(f.contains(&forty_two));
f = ReturnInt(17);
BOOST_CHECK(f != &forty_two);
BOOST_CHECK(f == ReturnInt(17));
BOOST_CHECK(f != ReturnInt(16));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two != f);
BOOST_CHECK(ReturnInt(17) == f);
BOOST_CHECK(ReturnInt(16) != f);
#endif
BOOST_CHECK(f.contains(ReturnInt(17)));
f = contain_test::ReturnIntFE(17);
BOOST_CHECK(f != &forty_two);
BOOST_CHECK(f == contain_test::ReturnIntFE(17));
BOOST_CHECK(f != contain_test::ReturnIntFE(16));
#if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two != f);
BOOST_CHECK(contain_test::ReturnIntFE(17) == f);
BOOST_CHECK(contain_test::ReturnIntFE(16) != f);
#endif
BOOST_CHECK(f.contains(contain_test::ReturnIntFE(17)));
#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
boost::function<int(void)> g;
g = &forty_two;
BOOST_CHECK(g == &forty_two);
BOOST_CHECK(g != ReturnInt(17));
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two == g);
BOOST_CHECK(ReturnInt(17) != g);
# endif
g = ReturnInt(17);
BOOST_CHECK(g != &forty_two);
BOOST_CHECK(g == ReturnInt(17));
BOOST_CHECK(g != ReturnInt(16));
# if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
BOOST_CHECK(&forty_two != g);
BOOST_CHECK(ReturnInt(17) == g);
BOOST_CHECK(ReturnInt(16) != g);
# endif
#endif
}
