/*
** Given an <IMG> markup, find or create an appropriate HtmlImage
** structure and return a pointer to that structure. NULL might
** be returned.
**
** This routine may invoke a callback procedure which could delete
** the HTML widget. Use HtmlLock() if necessary to preserve the
** widget structure.
*/
HtmlImage *HtmlGetImage(HtmlWidget *htmlPtr, HtmlElement *p){
char *zWidth;
char *zHeight;
char *zSrc;
const char *zImageName;
HtmlImage *pImage;
int result;
Tcl_DString cmd;
int lenSrc, lenW, lenH; /* Lengths of various strings */
if( p->base.type!=Html_IMG ){ CANT_HAPPEN; return 0; }
if( htmlPtr->zGetImage==0 || htmlPtr->zGetImage[0]==0 ){
TestPoint(0);
return 0;
}
zSrc = HtmlMarkupArg(p, "src", 0);
if( zSrc==0 ){
return 0;
}
HtmlLock(htmlPtr);
zSrc = HtmlResolveUri(htmlPtr, zSrc);
if( HtmlUnlock(htmlPtr) || zSrc==0 ) return 0;
zWidth = HtmlMarkupArg(p, "width", "");
zHeight = HtmlMarkupArg(p, "height", "");
for(pImage=htmlPtr->imageList; pImage; pImage=pImage->pNext){
if( strcmp(pImage->zUrl,zSrc)==0
&& strcmp(pImage->zWidth, zWidth)==0
&& strcmp(pImage->zHeight, zHeight)==0 ){
HtmlFree(zSrc);
return pImage;
}
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zGetImage, -1);
Tcl_DStringAppendElement(&cmd,zSrc);
Tcl_DStringAppendElement(&cmd,zWidth);
Tcl_DStringAppendElement(&cmd,zHeight);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, p);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( HtmlUnlock(htmlPtr) ){
HtmlFree(zSrc);
}
zImageName = Tcl_GetStringResult(htmlPtr->interp);
lenSrc = strlen(zSrc);
lenW = strlen(zWidth);
lenH = strlen(zHeight);
pImage = HtmlAlloc( sizeof(HtmlImage) + lenSrc + lenW + lenH + 3 );
memset(pImage,0,sizeof(HtmlImage));
pImage->htmlPtr = htmlPtr;
pImage->zUrl = (char*)&pImage[1];
strcpy(pImage->zUrl,zSrc);
HtmlFree(zSrc);
pImage->zWidth = &pImage->zUrl[lenSrc+1];
strcpy(pImage->zWidth, zWidth);
pImage->zHeight = &pImage->zWidth[lenW+1];
strcpy(pImage->zHeight, zHeight);
pImage->w = 0;
pImage->h = 0;
if( result==TCL_OK ){
pImage->image = Tk_GetImage(htmlPtr->interp, htmlPtr->clipwin,
zImageName, ImageChangeProc, pImage);
TestPoint(0);
}else{
Tcl_AddErrorInfo(htmlPtr->interp,
"\n (\"-imagecommand\" command executed by html widget)");
Tcl_BackgroundError(htmlPtr->interp);
pImage->image = 0;
TestPoint(0);
}
if( pImage->image==0 ){
HtmlFree((char*)pImage);
TestPoint(0);
return 0;
}
pImage->pNext = htmlPtr->imageList;
htmlPtr->imageList = pImage;
TestPoint(0);
Tcl_ResetResult(htmlPtr->interp);
return pImage;
}
/*
** This routine adds information to the input texts that doesn't change
** when the display is resized or when new fonts are selected, etc.
** Mostly this means adding style attributes. But other constant
** information (such as numbering on <li> and images used for <IMG>)
** is also obtained. The key is that this routine is only called
** once, where the sizer and layout routines can be called many times.
**
** This routine is called whenever the list of elements grows. The
** style stack is stored as part of the HTML widget so that we can
** always continue where we left off the last time.
**
** In addition to adding style, this routine will invoke callbacks
** needed to acquire information about a markup. The htmlPtr->zIsVisitied
** callback is called for each <a> and the htmlPtr->zGetImage is called
** for each <IMG> or for each <LI> that has a SRC= field.
**
** This routine may invoke a callback procedure which could delete
** the HTML widget.
**
** When a markup is inserted or deleted from the token list, the
** style routine must be completely rerun from the beginning. So
** what we said above, that this routine is only run once, is not
** strictly true.
*/
void HtmlAddStyle(HtmlWidget *htmlPtr, HtmlElement *p){
HtmlStyle style; /* Current style */
int size; /* A new font size */
int i; /* Loop counter */
int paraAlign; /* Current paragraph alignment */
int rowAlign; /* Current table row alignment */
int anchorFlags; /* Flags associated with <a> tag */
int inDt; /* True if within <dt>..</dt> */
HtmlStyle nextStyle; /* Style for next token if useNextStyle==1 */
int useNextStyle = 0; /* True if nextStyle is valid */
char *z; /* A tag parameter's value */
/* The size of header fonts relative to the current font size */
static int header_sizes[] = {+2, +1, 1, 1, -1, -1};
/* Don't allow recursion */
if( htmlPtr->flags & STYLER_RUNNING ){ TestPoint(0); return; }
htmlPtr->flags |= STYLER_RUNNING;
/* Load the style state out of the htmlPtr structure and into local
** variables. This is purely a matter of convenience... */
style = GetCurrentStyle(htmlPtr);
paraAlign = htmlPtr->paraAlignment;
rowAlign = htmlPtr->rowAlignment;
anchorFlags = htmlPtr->anchorFlags;
inDt = htmlPtr->inDt;
/* Loop over tokens */
while( p ){
switch( p->base.type ){
case Html_A:
if( htmlPtr->anchorStart ){
style = HtmlPopStyleStack(htmlPtr, Html_EndA);
htmlPtr->anchorStart = 0;
anchorFlags = 0;
}
z = HtmlMarkupArg(p,"href",0);
if( z ){
HtmlLock(htmlPtr);
style.color = GetLinkColor(htmlPtr, z);
if( htmlPtr->underlineLinks ){
style.flags |= STY_Underline;
}
if( HtmlUnlock(htmlPtr) ) return;
anchorFlags |= STY_Anchor;
PushStyleStack(htmlPtr, Html_EndA, style);
htmlPtr->anchorStart = p;
}
break;
case Html_EndA:
if( htmlPtr->anchorStart ){
p->ref.pOther = htmlPtr->anchorStart;
style = HtmlPopStyleStack(htmlPtr, Html_EndA);
htmlPtr->anchorStart = 0;
anchorFlags = 0;
}
break;
case Html_ADDRESS:
case Html_EndADDRESS:
case Html_BLOCKQUOTE:
case Html_EndBLOCKQUOTE:
paraAlign = ALIGN_None;
TestPoint(0);
break;
case Html_APPLET:
if( htmlPtr->zAppletCommand && *htmlPtr->zAppletCommand ){
nextStyle = style;
nextStyle.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndAPPLET, nextStyle);
useNextStyle = 1;
}else{
PushStyleStack(htmlPtr, Html_EndAPPLET, style);
}
TestPoint(0);
break;
case Html_B:
style.font = BoldFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndB, style);
TestPoint(0);
break;
case Html_EndAPPLET:
case Html_EndB:
case Html_EndBIG:
case Html_EndCENTER:
case Html_EndCITE:
case Html_EndCODE:
case Html_EndCOMMENT:
case Html_EndEM:
case Html_EndFONT:
case Html_EndI:
case Html_EndKBD:
case Html_EndMARQUEE:
case Html_EndNOBR:
case Html_EndNOFRAME:
case Html_EndNOSCRIPT:
case Html_EndS:
case Html_EndSAMP:
case Html_EndSMALL:
case Html_EndSTRIKE:
case Html_EndSTRONG:
case Html_EndSUB:
case Html_EndSUP:
case Html_EndTITLE:
case Html_EndTT:
case Html_EndU:
case Html_EndVAR:
style = HtmlPopStyleStack(htmlPtr, p->base.type);
TestPoint(0);
break;
case Html_BASE:
z = HtmlMarkupArg(p,"href",0);
if( z ){
HtmlLock(htmlPtr);
z = HtmlResolveUri(htmlPtr, z);
if( HtmlUnlock(htmlPtr) ) return;
if( z!=0 ){
if( htmlPtr->zBaseHref ){
HtmlFree(htmlPtr->zBaseHref);
}
htmlPtr->zBaseHref = z;
}
}
break;
case Html_EndDIV:
paraAlign = ALIGN_None;
style = HtmlPopStyleStack(htmlPtr, p->base.type);
TestPoint(0);
break;
case Html_EndBASEFONT:
style = HtmlPopStyleStack(htmlPtr, Html_EndBASEFONT);
style.font = FontFamily(style.font) + 2;
TestPoint(0);
break;
case Html_BIG:
ScaleFont(&style,1);
PushStyleStack(htmlPtr, Html_EndBIG, style);
TestPoint(0);
break;
case Html_CAPTION:
paraAlign = GetAlignment(p, paraAlign);
TestPoint(0);
break;
case Html_EndCAPTION:
paraAlign = ALIGN_None;
TestPoint(0);
break;
case Html_CENTER:
paraAlign = ALIGN_None;
style.align = ALIGN_Center;
PushStyleStack(htmlPtr, Html_EndCENTER, style);
TestPoint(0);
break;
case Html_CITE:
PushStyleStack(htmlPtr, Html_EndCITE, style);
TestPoint(0);
break;
case Html_CODE:
style.font = CWFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndCODE, style);
TestPoint(0);
break;
case Html_COMMENT:
style.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndCOMMENT, style);
TestPoint(0);
break;
case Html_DD:
if( htmlPtr->innerList && htmlPtr->innerList->base.type==Html_DL ){
p->ref.pOther = htmlPtr->innerList;
TestPoint(0);
}else{
p->ref.pOther = 0;
TestPoint(0);
}
inDt = 0;
break;
case Html_DIR:
case Html_MENU:
case Html_UL:
p->list.pPrev = htmlPtr->innerList;
p->list.cnt = 0;
htmlPtr->innerList = p;
if( p->list.pPrev==0 ){
p->list.type = LI_TYPE_Bullet1;
p->list.compact = HtmlMarkupArg(p,"compact",0)!=0;
TestPoint(0);
}else if( p->list.pPrev->list.pPrev==0 ){
p->list.type = LI_TYPE_Bullet2;
p->list.compact = 1;
TestPoint(0);
}else{
p->list.type = LI_TYPE_Bullet3;
p->list.compact = 1;
TestPoint(0);
}
p->list.type = GetUnorderedListType(p,p->list.type);
break;
case Html_EndDL:
inDt = 0;
TestPoint(0);
/* Fall thru into the next case */
case Html_EndDIR:
case Html_EndMENU:
case Html_EndOL:
case Html_EndUL:
p->ref.pOther = htmlPtr->innerList;
if( htmlPtr->innerList ){
htmlPtr->innerList = htmlPtr->innerList->list.pPrev;
TestPoint(0);
}else{
TestPoint(0);
}
break;
case Html_DIV:
paraAlign = ALIGN_None;
style.align = GetAlignment(p, style.align);
PushStyleStack(htmlPtr, Html_EndDIV, style);
TestPoint(0);
break;
case Html_DT:
if( htmlPtr->innerList && htmlPtr->innerList->base.type==Html_DL ){
p->ref.pOther = htmlPtr->innerList;
TestPoint(0);
}else{
p->ref.pOther = 0;
TestPoint(0);
}
inDt = STY_DT;
break;
case Html_EndDD:
case Html_EndDT:
inDt = 0;
TestPoint(0);
break;
case Html_DL:
p->list.pPrev = htmlPtr->innerList;
p->list.cnt = 0;
htmlPtr->innerList = p;
p->list.compact = HtmlMarkupArg(p,"compact",0)!=0;
inDt = 0;
TestPoint(0);
break;
case Html_EM:
style.font = ItalicFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndEM, style);
TestPoint(0);
break;
case Html_EMBED:
break;
case Html_BASEFONT:
case Html_FONT:
z = HtmlMarkupArg(p,"size",0);
if( z ){
if( *z=='-' ){
size = FontSize(style.font) - atoi(&z[1]);
}else if( *z=='+' ){
size = FontSize(style.font) + atoi(&z[1]);
}else{
size = atoi(z);
}
if( size <= 0 ){
size = 1;
}
if( size >= N_FONT_SIZE ){
size = N_FONT_SIZE - 1;
}
style.font = FontFamily(style.font) + size - 1;
}
z = HtmlMarkupArg(p,"color",0);
if( z ){
style.color = HtmlGetColorByName(htmlPtr, z);
}
PushStyleStack(htmlPtr,
p->base.type==Html_FONT ? Html_EndFONT : Html_EndBASEFONT, style);
break;
case Html_FORM: {
char *zUrl;
char *zMethod;
Tcl_DString cmd; /* -formcommand callback */
int result;
char zToken[50];
htmlPtr->formStart = 0;
p->form.id = 0;
if( htmlPtr->zFormCommand==0 || htmlPtr->zFormCommand[0]==0 ){
TestPoint(0);
break;
}
zUrl = HtmlMarkupArg(p,"action",0);
if( zUrl==0 ){
TestPoint(0);
break;
}
HtmlLock(htmlPtr);
zUrl = HtmlResolveUri(htmlPtr, zUrl);
if( HtmlUnlock(htmlPtr) ) return;
if( zUrl==0 ) break;
zMethod = HtmlMarkupArg(p,"method","GET");
sprintf(zToken," %d form ", ++htmlPtr->nForm);
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
Tcl_DStringAppend(&cmd, zToken, -1);
Tcl_DStringAppendElement(&cmd, zUrl);
HtmlFree(zUrl);
Tcl_DStringAppendElement(&cmd, zMethod);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, p);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( HtmlUnlock(htmlPtr) ) return;
if( result==TCL_OK ){
htmlPtr->formStart = p;
p->form.id = htmlPtr->nForm;
}
Tcl_ResetResult(htmlPtr->interp);
break;
}
case Html_EndFORM:
p->ref.pOther = htmlPtr->formStart;
htmlPtr->formStart = 0;
TestPoint(0);
break;
case Html_H1:
case Html_H2:
case Html_H3:
case Html_H4:
case Html_H5:
case Html_H6:
paraAlign = ALIGN_None;
i = (p->base.type - Html_H1)/2 + 1;
if( i>=1 && i<=6 ){
ScaleFont(&style,header_sizes[i-1]);
}
style.font = BoldFont( FontSize(style.font) );
style.align = GetAlignment(p, style.align);
PushStyleStack(htmlPtr, Html_EndH1, style);
break;
case Html_EndH1:
case Html_EndH2:
case Html_EndH3:
case Html_EndH4:
case Html_EndH5:
case Html_EndH6:
paraAlign = ALIGN_None;
style = HtmlPopStyleStack(htmlPtr, Html_EndH1);
TestPoint(0);
break;
case Html_HR:
nextStyle = style;
style.align = GetAlignment(p, ALIGN_None);
useNextStyle = 1;
break;
case Html_I:
style.font = ItalicFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndI, style);
TestPoint(0);
break;
case Html_IMG:
HtmlLock(htmlPtr);
p->image.pImage = HtmlGetImage(htmlPtr, p);
if( HtmlUnlock(htmlPtr) ) return;
TestPoint(0);
break;
case Html_INPUT:
p->input.pForm = htmlPtr->formStart;
TestPoint(0);
break;
case Html_KBD:
style.font = CWFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndKBD, style);
TestPoint(0);
break;
case Html_LI:
if( htmlPtr->innerList ){
p->li.type = htmlPtr->innerList->list.type;
if( htmlPtr->innerList->base.type==Html_OL ){
z = HtmlMarkupArg(p, "value", 0);
if( z ){
int n = atoi(z);
if( n>0 ){
p->li.cnt = n;
htmlPtr->innerList->list.cnt = n+1;
TestPoint(0);
}else{
TestPoint(0);
}
}else{
p->li.cnt = htmlPtr->innerList->list.cnt++;
TestPoint(0);
}
p->li.type = GetOrderedListType(p,p->li.type);
}else{
p->li.type = GetUnorderedListType(p,p->li.type);
TestPoint(0);
}
}else{
p->base.flags &= ~HTML_Visible;
TestPoint(0);
}
break;
case Html_MARQUEE:
style.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndMARQUEE, style);
TestPoint(0);
break;
case Html_NOBR:
style.flags |= STY_NoBreak;
PushStyleStack(htmlPtr, Html_EndNOBR, style);
TestPoint(0);
break;
case Html_NOFRAME:
if( htmlPtr->zFrameCommand && *htmlPtr->zFrameCommand ){
nextStyle = style;
nextStyle.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndNOFRAME, nextStyle);
useNextStyle = 1;
}else{
PushStyleStack(htmlPtr, Html_EndNOFRAME, style);
}
TestPoint(0);
break;
case Html_NOSCRIPT:
if( htmlPtr->zScriptCommand && *htmlPtr->zScriptCommand ){
nextStyle = style;
nextStyle.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndNOSCRIPT, nextStyle);
useNextStyle = 1;
}else{
PushStyleStack(htmlPtr, Html_EndNOSCRIPT, style);
}
TestPoint(0);
break;
case Html_OL:
p->list.pPrev = htmlPtr->innerList;
p->list.type = GetOrderedListType(p,LI_TYPE_Enum_1);
p->list.cnt = 1;
z = HtmlMarkupArg(p,"start",0);
if( z ){
int n = atoi(z);
if( n>0 ){
p->list.cnt = n;
TestPoint(0);
}else{
TestPoint(0);
}
}else{
TestPoint(0);
}
p->list.compact = htmlPtr->innerList!=0 ||
HtmlMarkupArg(p,"compact",0)!=0;
htmlPtr->innerList = p;
break;
case Html_P:
paraAlign = GetAlignment(p, ALIGN_None);
TestPoint(0);
break;
case Html_EndP:
paraAlign = ALIGN_None;
TestPoint(0);
break;
case Html_PRE:
case Html_LISTING:
case Html_XMP:
case Html_PLAINTEXT:
paraAlign = ALIGN_None;
style.font = CWFont( FontSize(style.font) );
style.flags |= STY_Preformatted;
PushStyleStack(htmlPtr, Html_EndPRE, style);
TestPoint(0);
break;
case Html_EndPRE:
case Html_EndLISTING:
case Html_EndXMP:
style = HtmlPopStyleStack(htmlPtr, Html_EndPRE);
TestPoint(0);
break;
case Html_S:
style.flags |= STY_StrikeThru;
PushStyleStack(htmlPtr, Html_EndS, style);
TestPoint(0);
break;
case Html_SCRIPT:
if( htmlPtr->zScriptCommand && *htmlPtr->zScriptCommand ){
Tcl_DString cmd;
int result;
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zScriptCommand, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, p);
Tcl_DStringEndSublist(&cmd);
Tcl_DStringStartSublist(&cmd);
Tcl_DStringAppend(&cmd, p->script.zScript, p->script.nScript);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( HtmlUnlock(htmlPtr) ) return;
Tcl_ResetResult(htmlPtr->interp);
}
nextStyle = style;
style.flags |= STY_Invisible;
useNextStyle = 1;
break;
case Html_SELECT:
p->input.pForm = htmlPtr->formStart;
nextStyle.flags |= STY_Invisible;
useNextStyle = 1;
PushStyleStack(htmlPtr, Html_EndSELECT, style);
htmlPtr->formElemStart = p;
break;
case Html_EndSELECT:
style = HtmlPopStyleStack(htmlPtr, Html_EndSELECT);
if( htmlPtr->formElemStart
&& htmlPtr->formElemStart->base.type==Html_SELECT ){
p->ref.pOther = htmlPtr->formElemStart;
MakeInvisible(p->ref.pOther, p);
}else{
p->ref.pOther = 0;
}
htmlPtr->formElemStart = 0;
break;
case Html_STRIKE:
style.flags |= STY_StrikeThru;
PushStyleStack(htmlPtr, Html_EndSTRIKE, style);
TestPoint(0);
break;
case Html_STYLE:
/* Ignore style sheets */
break;
case Html_SAMP:
style.font = CWFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndSAMP, style);
TestPoint(0);
break;
case Html_SMALL:
ScaleFont(&style,-1);
PushStyleStack(htmlPtr, Html_EndSMALL, style);
TestPoint(0);
break;
case Html_STRONG:
style.font = BoldFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndSTRONG, style);
TestPoint(0);
break;
case Html_SUB:
ScaleFont(&style,-1);
if( style.subscript > -6 ){
style.subscript--;
TestPoint(0);
}else{
TestPoint(0);
}
PushStyleStack(htmlPtr, Html_EndSUB, style);
break;
case Html_SUP:
ScaleFont(&style,-1);
if( style.subscript < 6 ){
style.subscript++;
TestPoint(0);
}else{
TestPoint(0);
}
PushStyleStack(htmlPtr, Html_EndSUP, style);
break;
case Html_TABLE:
paraAlign = ALIGN_None;
nextStyle = style;
nextStyle.align = ALIGN_Left;
z = HtmlMarkupArg(p, "bgcolor", 0);
if( z ){
nextStyle.bgcolor = HtmlGetColorByName(htmlPtr, z);
style.bgcolor = nextStyle.bgcolor;
/* }else{
nextStyle.bgcolor = COLOR_Background; */
}
PushStyleStack(htmlPtr, Html_EndTABLE, nextStyle);
useNextStyle = 1;
htmlPtr->inTd = 0;
htmlPtr->inTr = 0;
TestPoint(0);
break;
case Html_EndTABLE:
paraAlign = ALIGN_None;
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
htmlPtr->inTd = 0;
}
if( htmlPtr->inTr ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTR);
htmlPtr->inTr = 0;
}
style = HtmlPopStyleStack(htmlPtr, p->base.type);
TestPoint(0);
break;
case Html_TD:
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
}
htmlPtr->inTd = 1;
paraAlign = GetAlignment(p, rowAlign);
if( (z = HtmlMarkupArg(p, "bgcolor", 0))!=0 ){
style.bgcolor = HtmlGetColorByName(htmlPtr, z);
}
PushStyleStack(htmlPtr, Html_EndTD, style);
TestPoint(0);
break;
case Html_TEXTAREA:
p->input.pForm = htmlPtr->formStart;
nextStyle = style;
nextStyle.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndTEXTAREA, nextStyle);
htmlPtr->formElemStart = p;
useNextStyle = 1;
TestPoint(0);
break;
case Html_EndTEXTAREA:
style = HtmlPopStyleStack(htmlPtr, Html_EndTEXTAREA);
if( htmlPtr->formElemStart
&& htmlPtr->formElemStart->base.type==Html_TEXTAREA ){
p->ref.pOther = htmlPtr->formElemStart;
}else{
p->ref.pOther = 0;
}
htmlPtr->formElemStart = 0;
break;
case Html_TH:
/* paraAlign = GetAlignment(p, rowAlign); */
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
}
paraAlign = GetAlignment(p, ALIGN_Center);
style.font = BoldFont( FontSize(style.font) );
if( (z = HtmlMarkupArg(p, "bgcolor", 0))!=0 ){
style.bgcolor = HtmlGetColorByName(htmlPtr, z);
}
PushStyleStack(htmlPtr, Html_EndTD, style);
htmlPtr->inTd = 1;
TestPoint(0);
break;
case Html_TR:
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
htmlPtr->inTd = 0;
}
if( htmlPtr->inTr ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTR);
}
rowAlign = GetAlignment(p, ALIGN_None);
if( (z = HtmlMarkupArg(p, "bgcolor", 0))!=0 ){
style.bgcolor = HtmlGetColorByName(htmlPtr, z);
}
PushStyleStack(htmlPtr, Html_EndTR, style);
htmlPtr->inTr = 1;
TestPoint(0);
break;
case Html_EndTR:
if( htmlPtr->inTd ){
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
htmlPtr->inTd = 0;
}
style = HtmlPopStyleStack(htmlPtr, Html_EndTR);
htmlPtr->inTr = 0;
paraAlign = ALIGN_None;
rowAlign = ALIGN_None;
TestPoint(0);
break;
case Html_EndTD:
case Html_EndTH:
style = HtmlPopStyleStack(htmlPtr, Html_EndTD);
htmlPtr->inTd = 0;
paraAlign = ALIGN_None;
rowAlign = ALIGN_None;
TestPoint(0);
break;
case Html_TITLE:
style.flags |= STY_Invisible;
PushStyleStack(htmlPtr, Html_EndTITLE, style);
TestPoint(0);
break;
case Html_TT:
style.font = CWFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndTT, style);
TestPoint(0);
break;
case Html_U:
style.flags |= STY_Underline;
PushStyleStack(htmlPtr, Html_EndU, style);
break;
case Html_VAR:
style.font = ItalicFont( FontSize(style.font) );
PushStyleStack(htmlPtr, Html_EndVAR, style);
TestPoint(0);
break;
default:
TestPoint(0);
break;
}
p->base.style = style;
p->base.style.flags |= anchorFlags | inDt;
if( paraAlign!=ALIGN_None ){
p->base.style.align = paraAlign;
}
if( useNextStyle ){
style = nextStyle;
useNextStyle = 0;
}
TRACE(HtmlTrace_Style,
("Style of 0x%08x font=%02d color=%02d bg=%02d "
"align=%d flags=0x%04x token=%s\n",
(int)p, p->base.style.font, p->base.style.color, p->base.style.bgcolor,
p->base.style.align, p->base.style.flags, HtmlTokenName(p)));
p = p->pNext;
}
/* Copy state information back into the htmlPtr structure for
** safe keeping. */
htmlPtr->paraAlignment = paraAlign;
htmlPtr->rowAlignment = rowAlign;
htmlPtr->anchorFlags = anchorFlags;
htmlPtr->inDt = inDt;
htmlPtr->flags &= ~STYLER_RUNNING;
}
/*
** This routine implements the Sizer() function for <INPUT>,
** <SELECT> and <TEXTAREA> markup.
**
** A side effect of sizing these markups is that widgets are
** created to represent the corresponding input controls.
**
** The function normally returns 0. But if it is dealing with
** a <SELECT> or <TEXTAREA> that is incomplete, 1 is returned.
** In that case, the sizer will be called again at some point in
** the future when more information is available.
*/
int HtmlControlSize(HtmlWidget *htmlPtr, HtmlElement *pElem){
char *zWin; /* Name of child widget that implements this input */
int incomplete = 0; /* True if data is incomplete */
Tcl_DString cmd; /* The complete -formcommand callback */
if( pElem->input.sized ) return 0;
pElem->input.type = InputType(pElem);
switch( pElem->input.type ){
case INPUT_TYPE_Checkbox:
case INPUT_TYPE_Hidden:
case INPUT_TYPE_Image:
case INPUT_TYPE_Radio:
case INPUT_TYPE_Reset:
case INPUT_TYPE_Submit:
case INPUT_TYPE_Text:
case INPUT_TYPE_Password:
case INPUT_TYPE_File: {
int result;
char zToken[50];
if( pElem->input.pForm==0 || htmlPtr->zFormCommand==0
|| htmlPtr->zFormCommand[0]==0 ){
EmptyInput(pElem);
break;
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
sprintf(zToken," %d input ",pElem->input.pForm->form.id);
Tcl_DStringAppend(&cmd, zToken, -1);
pElem->input.cnt = ++htmlPtr->nInput;
zWin = MakeWindowName(htmlPtr, pElem);
Tcl_DStringAppend(&cmd, zWin, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, pElem);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !HtmlUnlock(htmlPtr) ){
SizeAndLink(htmlPtr, zWin, pElem);
}
HtmlFree(zWin);
break;
}
case INPUT_TYPE_Select: {
int result;
char zToken[50];
if( pElem->input.pForm==0 || htmlPtr->zFormCommand==0
|| htmlPtr->zFormCommand[0]==0 ){
EmptyInput(pElem);
break;
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
sprintf(zToken," %d select ",pElem->input.pForm->form.id);
Tcl_DStringAppend(&cmd, zToken, -1);
pElem->input.cnt = ++htmlPtr->nInput;
zWin = MakeWindowName(htmlPtr, pElem);
Tcl_DStringAppend(&cmd, zWin, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, pElem);
Tcl_DStringEndSublist(&cmd);
Tcl_DStringStartSublist(&cmd);
AddSelectOptions(&cmd, pElem, pElem->input.pEnd);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !HtmlUnlock(htmlPtr) ){
SizeAndLink(htmlPtr, zWin, pElem);
}
HtmlFree(zWin);
break;
}
case INPUT_TYPE_TextArea: {
int result;
char zToken[50];
if( pElem->input.pForm==0 || htmlPtr->zFormCommand==0
|| htmlPtr->zFormCommand[0]==0 ){
EmptyInput(pElem);
break;
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1);
sprintf(zToken," %d textarea ",pElem->input.pForm->form.id);
Tcl_DStringAppend(&cmd, zToken, -1);
pElem->input.cnt = ++htmlPtr->nInput;
zWin = MakeWindowName(htmlPtr, pElem);
Tcl_DStringAppend(&cmd, zWin, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, pElem);
Tcl_DStringEndSublist(&cmd);
Tcl_DStringStartSublist(&cmd);
HtmlAppendText(&cmd, pElem, pElem->input.pEnd);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !HtmlUnlock(htmlPtr) ){
SizeAndLink(htmlPtr, zWin, pElem);
}
HtmlFree(zWin);
break;
}
case INPUT_TYPE_Applet: {
int result;
if( htmlPtr->zAppletCommand==0 || htmlPtr->zAppletCommand[0]==0 ){
EmptyInput(pElem);
break;
}
Tcl_DStringInit(&cmd);
Tcl_DStringAppend(&cmd, htmlPtr->zAppletCommand, -1);
Tcl_DStringAppend(&cmd, " ", 1);
pElem->input.cnt = ++htmlPtr->nInput;
zWin = MakeWindowName(htmlPtr, pElem);
Tcl_DStringAppend(&cmd, zWin, -1);
Tcl_DStringStartSublist(&cmd);
HtmlAppendArglist(&cmd, pElem);
Tcl_DStringEndSublist(&cmd);
HtmlLock(htmlPtr);
result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd));
Tcl_DStringFree(&cmd);
if( !HtmlUnlock(htmlPtr) ){
SizeAndLink(htmlPtr, zWin, pElem);
}
HtmlFree(zWin);
break;
}
default: {
CANT_HAPPEN;
pElem->base.flags &= ~HTML_Visible;
pElem->base.style.flags |= STY_Invisible;
pElem->input.tkwin = 0;
break;
}
}
return incomplete;
}
