/* ** Advance the layout as far as possible */ void HtmlLayout(HtmlWidget *htmlPtr){ HtmlLayoutContext *pLC; int btm; if( htmlPtr->pFirst==0 ) return; HtmlLock(htmlPtr); HtmlSizer(htmlPtr); if( HtmlUnlock(htmlPtr) ) return; pLC = &htmlPtr->layoutContext; pLC->htmlPtr = htmlPtr; pLC->pageWidth = htmlPtr->realWidth - 2*(htmlPtr->inset + htmlPtr->padx); pLC->left = 0; pLC->right = 0; pLC->pStart = htmlPtr->nextPlaced; if( pLC->pStart==0 ){ pLC->pStart = htmlPtr->pFirst; } if( pLC->pStart ){ pLC->maxX = htmlPtr->maxX; pLC->maxY = htmlPtr->maxY; btm = pLC->bottom; HtmlLock(htmlPtr); HtmlLayoutBlock(pLC); if( HtmlUnlock(htmlPtr) ) return; htmlPtr->maxX = pLC->maxX; htmlPtr->maxY = pLC->maxY; htmlPtr->nextPlaced = pLC->pStart; htmlPtr->flags |= HSCROLL | VSCROLL; HtmlRedrawText(htmlPtr, btm); } }
/* ** For the markup <a href=XXX>, find out if the URL has been visited ** before or not. Return COLOR_Visited or COLOR_Unvisited, as ** appropriate. ** ** This routine may invoke a callback procedure which could delete ** the HTML widget. The calling function should call HtmlLock() ** if it needs the widget structure to be preserved. */ static int GetLinkColor(HtmlWidget *htmlPtr, char *zURL){ char *zCmd; int result; int isVisited; if( htmlPtr->tkwin==0 ){ TestPoint(0); return COLOR_Normal; } if( htmlPtr->zIsVisited==0 || htmlPtr->zIsVisited[0]==0 ){ TestPoint(0); return COLOR_Unvisited; } zCmd = HtmlAlloc( strlen(htmlPtr->zIsVisited) + strlen(zURL) + 10 ); if( zCmd==0 ){ TestPoint(0); return COLOR_Unvisited; } sprintf(zCmd,"%s {%s}",htmlPtr->zIsVisited, zURL); HtmlLock(htmlPtr); result = Tcl_GlobalEval(htmlPtr->interp,zCmd); HtmlFree(zCmd); if( HtmlUnlock(htmlPtr) ){ return COLOR_Unvisited; } if( result!=TCL_OK ){ TestPoint(0); goto errorOut; } result = Tcl_GetBoolean(htmlPtr->interp, Tcl_GetStringResult(htmlPtr->interp), &isVisited); if( result!=TCL_OK ){ TestPoint(0); goto errorOut; } TestPoint(0); return isVisited ? COLOR_Visited : COLOR_Unvisited; errorOut: Tcl_AddErrorInfo(htmlPtr->interp, "\n (\"-isvisitedcommand\" command executed by html widget)"); Tcl_BackgroundError(htmlPtr->interp); TestPoint(0); return COLOR_Unvisited; }
/* ** Delete all input controls. This happens when the HTML widget ** is cleared. ** ** When the TCL "exit" command is invoked, the order of operations ** here is very touchy. */ void HtmlDeleteControls(HtmlWidget *htmlPtr){ HtmlElement *p; /* For looping over all controls */ Tcl_Interp *interp; /* The interpreter */ interp = htmlPtr->interp; p = htmlPtr->firstInput; htmlPtr->firstInput = 0; htmlPtr->lastInput = 0; htmlPtr->nInput = 0; if( p==0 || htmlPtr->tkwin==0 ) return; HtmlLock(htmlPtr); for(; p; p=p->input.pNext){ if( p->input.pForm && p->input.pForm->form.id>0 && htmlPtr->zFormCommand && htmlPtr->zFormCommand[0] && !Tcl_InterpDeleted(interp) && htmlPtr->clipwin ){ Tcl_DString cmd; int result; char zBuf[60]; Tcl_DStringInit(&cmd); Tcl_DStringAppend(&cmd, htmlPtr->zFormCommand, -1); sprintf(zBuf," %d flush", p->input.pForm->form.id); Tcl_DStringAppend(&cmd, zBuf, -1); result = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd)); Tcl_DStringFree(&cmd); if( !Tcl_InterpDeleted(interp) ){ if( result != TCL_OK ){ Tcl_AddErrorInfo(htmlPtr->interp, "\n (-formcommand flush callback executed by html widget)"); Tcl_BackgroundError(htmlPtr->interp); TestPoint(0); } Tcl_ResetResult(htmlPtr->interp); } p->input.pForm->form.id = 0; } if( p->input.tkwin ){ if( htmlPtr->clipwin!=0 ) Tk_DestroyWindow(p->input.tkwin); p->input.tkwin = 0; } p->input.sized = 0; } HtmlUnlock(htmlPtr); }
/* ** This is a convenient wrapper routine for HtmlCallResolver. ** It makes a copy of the result into memory obtained from HtmlAlloc() ** and invokes Tcl_ResetResult(). */ char *HtmlResolveUri(HtmlWidget *htmlPtr, char *zUri){ char *azSeq[2]; char *zSrc; int result; if( zUri==0 || *zUri==0 ) return 0; azSeq[0] = zUri; azSeq[1] = 0; HtmlLock(htmlPtr); result = HtmlCallResolver(htmlPtr, azSeq); if( HtmlUnlock(htmlPtr) ) return 0; if( result==TCL_OK ){ zSrc = HtmlAlloc( strlen(htmlPtr->interp->result) + 1 ); if( zSrc ) strcpy(zSrc, htmlPtr->interp->result); }else{ zSrc = 0; } Tcl_ResetResult(htmlPtr->interp); return zSrc; }
/* ** 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; }
/* ** Compute the size of all elements in the widget. Assume that a ** style has already been assigned to all elements. ** ** Some of the elements might have already been sized. Refer to the ** htmlPtr->lastSized and only compute sizes for elements that follow ** this one. If htmlPtr->lastSized==0, then size everything. ** ** This routine only computes the sizes of individual elements. The ** size of aggregate elements (like tables) are computed separately. ** ** The HTML_Visible flag is also set on every element that results ** in ink on the page. ** ** This routine may invoke a callback procedure which could delete ** the HTML widget. */ void HtmlSizer(HtmlWidget *htmlPtr){ HtmlElement *p; int iFont = -1; Tk_Font font; int spaceWidth = 0; Tk_FontMetrics fontMetrics; char *z; int stop = 0; if( htmlPtr->pFirst==0 ){ TestPoint(0); return; } if( htmlPtr->lastSized==0 ){ p = htmlPtr->pFirst; TestPoint(0); }else{ p = htmlPtr->lastSized->pNext; TestPoint(0); } for(; !stop && p; p=p->pNext){ if( p->base.style.flags & STY_Invisible ){ p->base.flags &= ~HTML_Visible; TestPoint(0); continue; } if( iFont != p->base.style.font ){ iFont = p->base.style.font; HtmlLock(htmlPtr); font = HtmlGetFont(htmlPtr, iFont); if( HtmlUnlock(htmlPtr) ) break; Tk_GetFontMetrics(font, &fontMetrics); spaceWidth = 0; } switch( p->base.type ){ case Html_Text: p->text.w = Tk_TextWidth(font, p->text.zText, p->base.count); p->base.flags |= HTML_Visible; p->text.descent = fontMetrics.descent; p->text.ascent = fontMetrics.ascent; if( spaceWidth==0 ){ spaceWidth = Tk_TextWidth(font, " ", 1); TestPoint(0); }else{ TestPoint(0); } p->text.spaceWidth = spaceWidth; break; case Html_Space: if( spaceWidth==0 ){ spaceWidth = Tk_TextWidth(font, " ", 1); } p->space.w = spaceWidth; p->space.descent = fontMetrics.descent; p->space.ascent = fontMetrics.ascent; p->base.flags &= ~HTML_Visible; break; case Html_TD: case Html_TH: z = HtmlMarkupArg(p, "rowspan","1"); p->cell.rowspan = atoi(z); z = HtmlMarkupArg(p, "colspan","1"); p->cell.colspan = atoi(z); p->base.flags |= HTML_Visible; TestPoint(0); break; case Html_LI: p->li.descent = fontMetrics.descent; p->li.ascent = fontMetrics.ascent; p->base.flags |= HTML_Visible; TestPoint(0); break; case Html_IMG: p->base.flags |= HTML_Visible; p->image.redrawNeeded = 0; p->image.textAscent = fontMetrics.ascent; p->image.textDescent = fontMetrics.descent; p->image.align = HtmlGetImageAlignment(p); if( p->image.pImage==0 ){ p->image.ascent = fontMetrics.ascent; p->image.descent = fontMetrics.descent; p->image.zAlt = HtmlMarkupArg(p, "alt", "<image>"); p->image.w = Tk_TextWidth(font, p->image.zAlt, strlen(p->image.zAlt)); }else{ int w, h; p->image.pNext = p->image.pImage->pList; p->image.pImage->pList = p; Tk_SizeOfImage(p->image.pImage->image, &w, &h); p->image.h = h; p->image.w = w; p->image.ascent = h/2; p->image.descent = h - p->image.ascent; } if( (z = HtmlMarkupArg(p, "width", 0))!=0 ){ int w = atoi(z); if( w>0 ) p->image.w = w; } if( (z = HtmlMarkupArg(p, "height", 0))!=0 ){ int h = atoi(z); if( h>0 ) p->image.h = h; } break; case Html_HR: case Html_TABLE: p->base.flags |= HTML_Visible; TestPoint(0); break; case Html_APPLET: case Html_EMBED: case Html_INPUT: p->input.textAscent = fontMetrics.ascent; p->input.textDescent = fontMetrics.descent; stop = HtmlControlSize(htmlPtr, p); break; case Html_SELECT: case Html_TEXTAREA: p->input.textAscent = fontMetrics.ascent; p->input.textDescent = fontMetrics.descent; break; case Html_EndSELECT: case Html_EndTEXTAREA: if( p->ref.pOther ){ p->ref.pOther->input.pEnd = p; stop = HtmlControlSize(htmlPtr, p->ref.pOther); } break; default: p->base.flags &= ~HTML_Visible; break; } } if( p ){ htmlPtr->lastSized = p; }else{ htmlPtr->lastSized = htmlPtr->pLast; } }
/* ** The input azSeries[] is a sequence of URIs. This command must ** resolve them all and put the result in the interp->result field ** of the interpreter associated with the HTML widget. Return ** TCL_OK on success and TCL_ERROR if there is a failure. ** ** This function can cause the HTML widget to be deleted or changed ** arbitrarily. */ int HtmlCallResolver( HtmlWidget *htmlPtr, /* The widget that is doing the resolving. */ char **azSeries /* A list of URIs. NULL terminated */ ){ int rc = TCL_OK; /* Return value of this function. */ char *z; HtmlVerifyLock(htmlPtr); if( htmlPtr->zResolverCommand && htmlPtr->zResolverCommand[0] ){ /* ** Append the current base URI then the azSeries arguments to the ** TCL command specified by the -resolvercommand optoin, then execute ** the result. ** ** The -resolvercommand could do nasty things, such as delete ** the HTML widget out from under us. Be prepared for the worst. */ Tcl_DString cmd; Tcl_DStringInit(&cmd); Tcl_DStringAppend(&cmd, htmlPtr->zResolverCommand, -1); if( htmlPtr->zBaseHref && htmlPtr->zBaseHref[0] ){ z = Trim(htmlPtr->zBaseHref); }else if( htmlPtr->zBase && htmlPtr->zBase[0] ){ z = Trim(htmlPtr->zBase); } if( z ){ Tcl_DStringAppendElement(&cmd, z); HtmlFree(z); } while( azSeries[0] ){ z = Trim(azSeries[0]); if( z ){ Tcl_DStringAppendElement(&cmd, z); HtmlFree(z); } azSeries++; } HtmlLock(htmlPtr); rc = Tcl_GlobalEval(htmlPtr->interp, Tcl_DStringValue(&cmd)); Tcl_DStringFree(&cmd); if( HtmlUnlock(htmlPtr) ) return TCL_ERROR; if( rc!=TCL_OK ){ Tcl_AddErrorInfo(htmlPtr->interp, "\n (-resolvercommand executed by HTML widget)"); } }else{ /* ** No -resolvercommand has been specified. Do the default ** resolver algorithm specified in section 5.2 of RFC 2396. */ HtmlUri *base, *term; if( htmlPtr->zBaseHref && htmlPtr->zBaseHref[0] ){ base = ParseUri(htmlPtr->zBaseHref); }else{ base = ParseUri(htmlPtr->zBase); } while( azSeries[0] ){ term = ParseUri(azSeries[0]); azSeries++; if( term->zScheme==0 && term->zAuthority==0 && term->zPath==0 && term->zQuery==0 && term->zFragment ){ ReplaceStr(&base->zFragment, term->zFragment); }else if( term->zScheme ){ HtmlUri temp; temp = *term; *term = *base; *base = temp; }else if( term->zAuthority ){ ReplaceStr(&base->zAuthority, term->zAuthority); ReplaceStr(&base->zPath, term->zPath); ReplaceStr(&base->zQuery, term->zQuery); ReplaceStr(&base->zFragment, term->zFragment); }else if( term->zPath && (term->zPath[0]=='/' || base->zPath==0) ){ ReplaceStr(&base->zPath, term->zPath); ReplaceStr(&base->zQuery, term->zQuery); ReplaceStr(&base->zFragment, term->zFragment); }else if( term->zPath && base->zPath ){ char *zBuf; int i, j; zBuf = HtmlAlloc( strlen(base->zPath) + strlen(term->zPath) + 2 ); if( zBuf ){ sprintf(zBuf,"%s", base->zPath); for(i=strlen(zBuf)-1; i>=0 && zBuf[i]!='/'; i--){ zBuf[i] = 0; } strcat(zBuf, term->zPath); for(i=0; zBuf[i]; i++){ if( zBuf[i]=='/' && zBuf[i+1]=='.' && zBuf[i+2]=='/' ){ strcpy(&zBuf[i+1], &zBuf[i+3]); i--; continue; } if( zBuf[i]=='/' && zBuf[i+1]=='.' && zBuf[i+2]==0 ){ zBuf[i+1] = 0; continue; } if( i>0 && zBuf[i]=='/' && zBuf[i+1]=='.' && zBuf[i+2]=='.' && (zBuf[i+3]=='/' || zBuf[i+3]==0) ){ for(j=i-1; j>=0 && zBuf[j]!='/'; j--){} if( zBuf[i+3] ){ strcpy(&zBuf[j+1], &zBuf[i+4]); }else{ zBuf[j+1] = 0; } i = j-1; if( i<-1 ) i = -1; continue; } } HtmlFree(base->zPath); base->zPath = zBuf; } ReplaceStr(&base->zQuery, term->zQuery); ReplaceStr(&base->zFragment, term->zFragment); } FreeUri(term); } Tcl_SetResult(htmlPtr->interp, BuildUri(base), TCL_DYNAMIC); FreeUri(base); } return rc; }
/* ** Display a single HtmlBlock. This is where all the drawing ** happens. */ void HtmlBlockDraw( HtmlWidget *htmlPtr, /* The main HTML widget */ HtmlBlock *pBlock, /* Block which needs to be drawn */ Drawable drawable, /* Draw the line on this */ int drawableLeft, /* Virtual coordinate of left edge of drawable */ int drawableTop, /* Virtual coordinate of top edge of drawable */ int drawableWidth, /* Width of the drawable */ int drawableHeight /* Height of the drawable */ ){ Tk_Font font; /* Font to use to render text */ GC gc; /* A graphics context */ HtmlElement *src; /* HtmlElement holding style information */ HtmlElement *pTable; /* The table (when drawing part of a table) */ int x, y; /* Where to draw */ if( pBlock==0 ){ TestPoint(0); return; } src = pBlock->base.pNext; while( src && (src->base.flags & HTML_Visible)==0 ){ src = src->base.pNext; TestPoint(0); } if( src==0 ){ TestPoint(0); return; } if( pBlock->n>0 ){ /* We must be dealing with plain old text */ if( src->base.type==Html_Text ){ x = src->text.x; y = src->text.y; TestPoint(0); }else{ CANT_HAPPEN; return; } if( pBlock->base.flags & HTML_Selected ){ HtmlLock(htmlPtr); DrawSelectionBackground(htmlPtr, pBlock, drawable, drawableLeft, drawableTop); if( HtmlUnlock(htmlPtr) ) return; } gc = HtmlGetGC(htmlPtr, src->base.style.color, src->base.style.font); font = HtmlGetFont(htmlPtr, src->base.style.font); if( font==0 ) return; Tk_DrawChars(htmlPtr->display, drawable, gc, font, pBlock->z, pBlock->n, x - drawableLeft, y - drawableTop); if( src->base.style.flags & STY_Underline ){ Tk_UnderlineChars(htmlPtr->display, drawable, gc, font, pBlock->z, x - drawableLeft, y-drawableTop, 0, pBlock->n); } if( src->base.style.flags & STY_StrikeThru ){ XRectangle xrec; xrec.x = pBlock->left - drawableLeft; xrec.y = (pBlock->top + pBlock->bottom)/2 - drawableTop; xrec.width = pBlock->right - pBlock->left; xrec.height = 1 + (pBlock->bottom - pBlock->top > 15); XFillRectangles(htmlPtr->display, drawable, gc, &xrec, 1); } if( pBlock==htmlPtr->pInsBlock && htmlPtr->insStatus>0 ){ int x; XRectangle xrec; if( htmlPtr->insIndex < pBlock->n ){ x = src->text.x - drawableLeft; x += Tk_TextWidth(font, pBlock->z, htmlPtr->insIndex); }else{ x = pBlock->right - drawableLeft; } if( x>0 ){ TestPoint(0); x--; } xrec.x = x; xrec.y = pBlock->top - drawableTop; xrec.width = 2; xrec.height = pBlock->bottom - pBlock->top; XFillRectangles(htmlPtr->display, drawable, gc, &xrec, 1); } }else{ /* We are dealing with a single HtmlElement which contains something ** other than plain text. */ int top, btm, cntr; int cnt, w; char zBuf[30]; switch( src->base.type ){ case Html_LI: x = src->li.x; y = src->li.y; cntr = (top+btm)/2; switch( src->li.type ){ case LI_TYPE_Enum_1: sprintf(zBuf,"%d.",src->li.cnt); TestPoint(0); break; case LI_TYPE_Enum_A: GetLetterIndex(zBuf,src->li.cnt,1); TestPoint(0); break; case LI_TYPE_Enum_a: GetLetterIndex(zBuf,src->li.cnt,0); TestPoint(0); break; case LI_TYPE_Enum_I: GetRomanIndex(zBuf,src->li.cnt,1); TestPoint(0); break; case LI_TYPE_Enum_i: GetRomanIndex(zBuf,src->li.cnt,0); TestPoint(0); break; default: zBuf[0] = 0; TestPoint(0); break; } gc = HtmlGetGC(htmlPtr, src->base.style.color, src->base.style.font); switch( src->li.type ){ case LI_TYPE_Undefined: case LI_TYPE_Bullet1: XFillArc(htmlPtr->display, drawable, gc, x - 7 - drawableLeft, y - 8 - drawableTop, 7, 7, 0, 360*64); TestPoint(0); break; case LI_TYPE_Bullet2: XDrawArc(htmlPtr->display, drawable, gc, x - 7 - drawableLeft, y - 8 - drawableTop, 7, 7, 0, 360*64); TestPoint(0); break; case LI_TYPE_Bullet3: XDrawRectangle(htmlPtr->display, drawable, gc, x - 7 - drawableLeft, y - 8 - drawableTop, 7, 7); TestPoint(0); break; case LI_TYPE_Enum_1: case LI_TYPE_Enum_A: case LI_TYPE_Enum_a: case LI_TYPE_Enum_I: case LI_TYPE_Enum_i: cnt = strlen(zBuf); font = HtmlGetFont(htmlPtr, src->base.style.font); if( font==0 ) return; w = Tk_TextWidth(font, zBuf, cnt); Tk_DrawChars(htmlPtr->display, drawable, gc, font, zBuf, cnt, x - w - drawableLeft, y - drawableTop); TestPoint(0); break; } break; case Html_HR: { int relief = htmlPtr->ruleRelief; switch( relief ){ case TK_RELIEF_RAISED: case TK_RELIEF_SUNKEN: break; default: relief = TK_RELIEF_FLAT; break; } HtmlDrawRect(htmlPtr, drawable, src, src->hr.x - drawableLeft, src->hr.y - drawableTop, src->hr.w, src->hr.h, 1, relief); break; } case Html_TABLE: { int relief = htmlPtr->tableRelief; switch( relief ){ case TK_RELIEF_RAISED: case TK_RELIEF_SUNKEN: break; default: relief = TK_RELIEF_FLAT; break; } HtmlDrawRect(htmlPtr, drawable, src, src->table.x - drawableLeft, src->table.y - drawableTop, src->table.w, src->table.h, src->table.borderWidth, relief); break; } case Html_TH: case Html_TD: { int depth, relief; pTable = src->cell.pTable; depth = pTable && pTable->table.borderWidth>0; switch( htmlPtr->tableRelief ){ case TK_RELIEF_RAISED: relief = TK_RELIEF_SUNKEN; break; case TK_RELIEF_SUNKEN: relief = TK_RELIEF_RAISED; break; default: relief = TK_RELIEF_FLAT; break; } HtmlDrawRect(htmlPtr, drawable, src, src->cell.x - drawableLeft, src->cell.y - drawableTop, src->cell.w, src->cell.h, depth, relief); break; } case Html_IMG: if( src->image.pImage ){ HtmlDrawImage(src, drawable, drawableLeft, drawableTop, drawableLeft + drawableWidth, drawableTop + drawableHeight); }else if( src->image.zAlt ){ gc = HtmlGetGC(htmlPtr, src->base.style.color, src->base.style.font); font = HtmlGetFont(htmlPtr, src->base.style.font); if( font==0 ) return; Tk_DrawChars(htmlPtr->display, drawable, gc, font, src->image.zAlt, strlen(src->image.zAlt), src->image.x - drawableLeft, src->image.y - drawableTop); TestPoint(0); } break; default: TestPoint(0); break; } } }
/* Process as much of the input HTML as possible. Construct new ** HtmlElement structures and appended them to the list. Return ** the number of characters actually processed. ** ** This routine may invoke a callback procedure which could delete ** the HTML widget. ** ** This routine is not reentrant for the same HTML widget. To ** prevent reentrancy (during a callback), the p->iCol field is ** set to a negative number. This is a flag to future invocations ** not to reentry this routine. The p->iCol field is restored ** before exiting, of course. */ static int Tokenize( HtmlWidget *p /* The HTML widget doing the parsing */ ){ char *z; /* The input HTML text */ int c; /* The next character of input */ int n; /* Number of characters processed so far */ int iCol; /* Column of input */ int i, j; /* Loop counters */ int h; /* Result from HtmlHash() */ int nByte; /* Space allocated for a single HtmlElement */ HtmlElement *pElem; /* A new HTML element */ int selfClose; /* True for content free elements. Ex: <br/> */ int argc; /* The number of arguments on a markup */ HtmlTokenMap *pMap; /* For searching the markup name hash table */ char *zBuf; /* For handing out buffer space */ # define mxARG 200 /* Maximum number of parameters in a single markup */ char *argv[mxARG]; /* Pointers to each markup argument. */ int arglen[mxARG]; /* Length of each markup argument */ iCol = p->iCol; n = p->nComplete; z = p->zText; if( iCol<0 ){ TestPoint(0); return n; } /* Prevents recursion */ p->iCol = -1; while( (c=z[n])!=0 ){ if( p->pScript ){ /* We are in the middle of <SCRIPT>...</SCRIPT>. Just look for ** the </SCRIPT> markup. (later:) Treat <STYLE>...</STYLE> the ** same way. */ HtmlScript *pScript = p->pScript; char *zEnd; int nEnd; if( pScript->markup.base.type==Html_SCRIPT ){ zEnd = "</script>"; nEnd = 9; }else{ zEnd = "</style>"; nEnd = 8; } if( pScript->zScript==0 ){ pScript->zScript = &z[n]; pScript->nScript = 0; } for(i=n+pScript->nScript; z[i]; i++){ if( z[i]=='<' && z[i+1]=='/' && strnicmp(&z[i],zEnd,nEnd)==0 ){ pScript->nScript = i - n; p->pScript = 0; n = i+nEnd; break; } } if( p->pScript ){ pScript->nScript = i - n; } continue; }else if( isspace(c) ){ /* White space */ for(i=0; (c=z[n+i])!=0 && isspace(c) && c!='\n' && c!='\r'; i++){} if( c=='\r' && z[n+i+1]=='\n' ){ i++; } pElem = HtmlAlloc( sizeof(HtmlSpaceElement) ); if( pElem==0 ){ goto incomplete; } pElem->base.type = Html_Space; if( c=='\n' || c=='\r' ){ pElem->base.flags = HTML_NewLine; pElem->base.count = 1; i++; iCol = 0; TestPoint(0); }else{ int iColStart = iCol; pElem->base.flags = 0; for(j=0; j<i; j++){ iCol = NextColumn(iCol, z[n+j]); TestPoint(0); } pElem->base.count = iCol - iColStart; } AppendElement(p,pElem); n += i; }else if( c!='<' || p->iPlaintext!=0 || (!isalpha(z[n+1]) && z[n+1]!='/' && z[n+1]!='!' && z[n+1]!='?') ){ /* Ordinary text */ for(i=1; (c=z[n+i])!=0 && !isspace(c) && c!='<'; i++){} if( c==0 ){ TestPoint(0); goto incomplete; } if( p->iPlaintext!=0 && z[n]=='<' ){ switch( p->iPlaintext ){ case Html_LISTING: if( i>=10 && strnicmp(&z[n],"</listing>",10)==0 ){ p->iPlaintext = 0; goto doMarkup; } break; case Html_XMP: if( i>=6 && strnicmp(&z[n],"</xmp>",6)==0 ){ p->iPlaintext = 0; goto doMarkup; } break; case Html_TEXTAREA: if( i>=11 && strnicmp(&z[n],"</textarea>",11)==0 ){ p->iPlaintext = 0; goto doMarkup; } break; default: break; } } nByte = sizeof(HtmlTextElement) + i; pElem = HtmlAlloc( nByte ); if( pElem==0 ){ goto incomplete; } memset(pElem,0,nByte); pElem->base.type = Html_Text; sprintf(pElem->text.zText,"%.*s",i,&z[n]); AppendElement(p,pElem); if( p->iPlaintext==0 || p->iPlaintext==Html_TEXTAREA ){ HtmlTranslateEscapes(pElem->text.zText); } pElem->base.count = strlen(pElem->text.zText); n += i; iCol += i; }else if( strncmp(&z[n],"<!--",4)==0 ){ /* An HTML comment. Just skip it. */ for(i=4; z[n+i]; i++){ if( z[n+i]=='-' && strncmp(&z[n+i],"-->",3)==0 ){ break; } } if( z[n+i]==0 ){ TestPoint(0); goto incomplete; } for(j=0; j<i+3; j++){ iCol = NextColumn(iCol, z[n+j]); } n += i + 3; }else{ /* Markup. ** ** First get the name of the markup */ doMarkup: argc = 1; argv[0] = &z[n+1]; for(i=1; (c=z[n+i])!=0 && !isspace(c) && c!='>' && (i<2 || c!='/'); i++){} arglen[0] = i - 1; if( c==0 ){ goto incomplete; } /* ** Now parse up the arguments */ while( isspace(z[n+i]) ){ i++; } while( (c=z[n+i])!=0 && c!='>' && (c!='/' || z[n+i+1]!='>') ){ if( argc>mxARG-3 ){ argc = mxARG-3; } argv[argc] = &z[n+i]; j = 0; while( (c=z[n+i+j])!=0 && !isspace(c) && c!='>' && c!='=' && (c!='/' || z[n+i+j+1]!='>') ){ j++; } arglen[argc] = j; if( c==0 ){ goto incomplete; } i += j; while( isspace(c) ){ i++; c = z[n+i]; } if( c==0 ){ goto incomplete; } argc++; if( c!='=' ){ argv[argc] = ""; arglen[argc] = 0; argc++; continue; } i++; c = z[n+i]; while( isspace(c) ){ i++; c = z[n+i]; } if( c==0 ){ goto incomplete; } if( c=='\'' || c=='"' ){ int cQuote = c; i++; argv[argc] = &z[n+i]; for(j=0; (c=z[n+i+j])!=0 && c!=cQuote; j++){} if( c==0 ){ goto incomplete; } arglen[argc] = j; i += j+1; TestPoint(0); }else{ argv[argc] = &z[n+i]; for(j=0; (c=z[n+i+j])!=0 && !isspace(c) && c!='>'; j++){} if( c==0 ){ goto incomplete; } arglen[argc] = j; i += j; } argc++; while( isspace(z[n+i]) ){ i++; } } if( c=='/' ){ i++; c = z[n+i]; selfClose = 1; }else{ selfClose = 0; } if( c==0 ){ goto incomplete; } for(j=0; j<i+1; j++){ iCol = NextColumn(iCol, z[n+j]); } n += i + 1; /* Lookup the markup name in the hash table */ if( !isInit ){ HtmlHashInit(); isInit = 1; } c = argv[0][arglen[0]]; argv[0][arglen[0]] = 0; h = HtmlHash(argv[0]); for(pMap = apMap[h]; pMap; pMap=pMap->pCollide){ if( stricmp(pMap->zName,argv[0])==0 ){ break; } TestPoint(0); } argv[0][arglen[0]] = c; if( pMap==0 ){ continue; } /* Ignore unknown markup */ makeMarkupEntry: /* Construct a HtmlMarkup entry for this markup. */ if( pMap->extra ){ nByte = pMap->extra; }else if( argc==1 ){ nByte = sizeof(HtmlBaseElement); }else{ nByte = sizeof(HtmlMarkupElement); } if( argc>1 ){ nByte += sizeof(char*) * argc; for(j=1; j<argc; j++){ nByte += arglen[j] + 1; } } pElem = HtmlAlloc( nByte ); if( pElem==0 ){ goto incomplete; } memset(pElem,0,nByte); pElem->base.type = pMap->type; pElem->base.count = argc - 1; if( argc>1 ){ if( pMap->extra ){ pElem->markup.argv = (char**)&((char*)pElem)[pMap->extra]; }else{ pElem->markup.argv = (char**)&((HtmlMarkupElement*)pElem)[1]; } zBuf = (char*)&pElem->markup.argv[argc]; for(j=1; j<argc; j++){ pElem->markup.argv[j-1] = zBuf; zBuf += arglen[j] + 1; sprintf(pElem->markup.argv[j-1],"%.*s",arglen[j],argv[j]); HtmlTranslateEscapes(pElem->markup.argv[j-1]); if( (j&1)==1 ){ ToLower(pElem->markup.argv[j-1]); } } pElem->markup.argv[argc-1] = 0; } /* The new markup has now be constructed in pElem. But before ** appending to the list, check to see if there is a special ** handler for this markup type. */ if( p->zHandler[pMap->type] ){ Tcl_DString str; Tcl_DStringInit(&str); Tcl_DStringAppend(&str, p->zHandler[pMap->type], -1); Tcl_DStringAppendElement(&str, pMap->zName); Tcl_DStringStartSublist(&str); for(j=0; j<argc-1; j++){ Tcl_DStringAppendElement(&str, pElem->markup.argv[j]); } Tcl_DStringEndSublist(&str); HtmlFree(pElem); HtmlLock(p); Tcl_GlobalEval(p->interp, Tcl_DStringValue(&str)); Tcl_DStringFree(&str); if( HtmlUnlock(p) ){ return 0; } /* Tricky, tricky. The callback might have caused the p->zText ** pointer to change, so renew our copy of that pointer. The ** callback might also have cleared or destroyed the widget. ** If so, abort this routine. */ z = p->zText; if( z==0 || p->tkwin==0 ){ n = 0; iCol = 0; goto incomplete; } continue; } /* No special handler for this markup. Just append it to the ** list of all tokens. */ AppendElement(p,pElem); switch( pMap->type ){ case Html_PLAINTEXT: case Html_LISTING: case Html_XMP: case Html_TEXTAREA: p->iPlaintext = pMap->type; break; case Html_STYLE: case Html_SCRIPT: p->pScript = (HtmlScript*)pElem; break; default: break; } /* If this is self-closing markup (ex: <br/> or <img/>) then ** synthesize a closing token. */ if( selfClose && argv[0][0]!='/' && strcmp(&pMap[1].zName[1],pMap->zName)==0 ){ selfClose = 0; pMap++; argc = 1; goto makeMarkupEntry; } } } incomplete: p->iCol = iCol; return n; }
/* ** Given a base index name (without any modifiers) return a pointer ** to the token described, and the character within that token. ** ** Valid input forms include: ** ** N.M Token number N (with numbering starting at 1) and ** character number M (with numbering starting at 0). ** ** end The end of all text ** ** N.last Last character of token number N. ** ** sel.first First character of the selection. ** ** sel.last Last character of the selection. ** ** ins The character holding the insertion cursor. ** ** @X,Y The character a location X,Y of the clipping window. ** ** Zero is returned if we are successful and non-zero if there is ** any kind of error. ** ** If the given token doesn't exist (for example if there are only 10 ** tokens and 11.5 is requested) then *ppToken is left pointing to NULL. ** But the function still returns 0 for success. */ static int DecodeBaseIndex( HtmlWidget *htmlPtr, /* The HTML widget we are dealing with */ const char *zBase, /* The base index string */ HtmlElement **ppToken, /* Write the pointer to the token here */ int *pIndex /* Write the character offset here */ ){ int x, y; int n; int i; HtmlElement *p; HtmlBlock *pBlock; HtmlBlock *pNearby; int dist = 1000000; int rc = 0; while( isspace(*zBase) ){ TestPoint(0); zBase++; } switch( *zBase ){ case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': n = sscanf(zBase,"%d.%d",&x,&y); if( n>0 ){ p = *ppToken = HtmlTokenByIndex(htmlPtr, x, 0); TestPoint(0); }else{ TestPoint(0); } if( n==2 ){ *pIndex = y; TestPoint(0); }else{ for(i=1; isdigit(zBase[i]); i++){ TestPoint(0); } if( zBase[i]==0 ){ *pIndex = 0; TestPoint(0); }else if( strcmp(&zBase[i],".last")==0 ){ maxIndex(p,pIndex); TestPoint(0); }else{ rc = 1; TestPoint(0); } } break; case 'e': if( strcmp(zBase,"end")==0 ){ p = *ppToken = htmlPtr->pLast; maxIndex(p,pIndex); TestPoint(0); }else{ rc = 1; TestPoint(0); } break; case 's': if( strcmp(zBase,"sel.first")==0 ){ *ppToken = htmlPtr->selBegin.p; *pIndex = htmlPtr->selBegin.i; TestPoint(0); }else if( strcmp(zBase,"sel.last")==0 ){ *ppToken = htmlPtr->selEnd.p; *pIndex = htmlPtr->selEnd.i; TestPoint(0); }else{ rc = 1; TestPoint(0); } break; case 'i': if( strcmp(zBase,"insert")==0 ){ *ppToken = htmlPtr->ins.p; *pIndex = htmlPtr->ins.i; TestPoint(0); }else{ rc = 1; TestPoint(0); } break; case '@': n = sscanf(zBase,"@%d,%d",&x,&y); if( n!=2 ){ rc = 1; TestPoint(0); break; } x += htmlPtr->xOffset; y += htmlPtr->yOffset; pNearby = 0; *ppToken = htmlPtr->pLast; *pIndex = 0; for(pBlock=htmlPtr->firstBlock; pBlock; pBlock=pBlock->pNext){ int dotest; if( pBlock->n==0 ){ switch( pBlock->base.pNext->base.type ){ case Html_LI: case Html_IMG: case Html_INPUT: case Html_TEXTAREA: case Html_SELECT: dotest = 1; TestPoint(0); break; default: dotest = 0; TestPoint(0); break; } }else{ dotest = 1; TestPoint(0); } if (dotest){ if( pBlock->top <= y && pBlock->bottom >= y ){ if( pBlock->left > x ){ if( pBlock->left - x < dist ){ dist = pBlock->left - x; pNearby = pBlock; TestPoint(0); }else{ TestPoint(0); } }else if( pBlock->right < x ){ if( x - pBlock->right < dist ){ dist = x - pBlock->right; pNearby = pBlock; TestPoint(0); }else{ TestPoint(0); } }else{ HtmlLock(htmlPtr); FindIndexInBlock(htmlPtr, pBlock, x, ppToken, pIndex); if( HtmlUnlock(htmlPtr) ) return 1; TestPoint(0); break; } }else{ int distY; int distX; if( pBlock->bottom < y ){ distY = y - pBlock->bottom; TestPoint(0); }else{ distY = pBlock->top - y; TestPoint(0); } if( pBlock->left > x ){ distX = pBlock->left - x; TestPoint(0); }else if( pBlock->right < x ){ distX = x - pBlock->right; TestPoint(0); }else{ distX = 0; TestPoint(0); } if( distX + 4*distY < dist ){ dist = distX + 4*distY; pNearby = pBlock; TestPoint(0); }else{ TestPoint(0); } } } } if( pBlock==0 ){ if( pNearby ){ HtmlLock(htmlPtr); FindIndexInBlock(htmlPtr, pNearby, x, ppToken, pIndex); if( HtmlUnlock(htmlPtr) ) return 1; TestPoint(0); }else{ TestPoint(0); } }else{ TestPoint(0); } break; default: rc = 1; TestPoint(0); break; } return rc; }
/* ** Given a Block and an x coordinate, find the Index of the character ** that is closest to the given x coordinate. ** ** The x-coordinate might specify a point to the left of the block, ** in which case the procedure returns the first token and a character ** index of 0. Or the x-coordinate might specify a point to the right ** of the block, in which case the last token is returned with an index ** equal to its last character. */ static void FindIndexInBlock( HtmlWidget *htmlPtr, /* The widget */ HtmlBlock *pBlock, /* The block */ int x, /* The x coordinate */ HtmlElement **ppToken, /* Write the closest token here */ int *pIndex /* Write the charater index in ppToken here */ ){ HtmlElement *p; Tk_Font font; int len; int n; p = pBlock->base.pNext; HtmlLock(htmlPtr); font = HtmlGetFont(htmlPtr, p->base.style.font); if( HtmlUnlock(htmlPtr) ){ *ppToken = p; *pIndex = 0; return; } if( x <= pBlock->left ){ *ppToken = p; *pIndex = 0; TestPoint(0); return; }else if( x>= pBlock->right ){ *ppToken = p; *pIndex = 0; while( p && p->base.type!=Html_Block ){ *ppToken = p; p = p->base.pNext; TestPoint(0); } p = *ppToken; if( p && p->base.type==Html_Text ){ *pIndex = p->base.count - 1; TestPoint(0); }else{ TestPoint(0); } return; } if( pBlock->n==0 ){ *ppToken = p; *pIndex = 0; TestPoint(0); }else{ TestPoint(0); } n = Tk_MeasureChars(font, pBlock->z, pBlock->n, x - pBlock->left, 0, &len); *pIndex = 0; *ppToken = 0; while( p && n>=0 ){ switch( p->base.type ){ case Html_Text: if( n<p->base.count ){ *pIndex = n; TestPoint(0); }else{ *pIndex = p->base.count - 1; TestPoint(0); } *ppToken = p; n -= p->base.count; break; case Html_Space: if( p->base.style.flags & STY_Preformatted ){ if( n<p->base.count ){ *pIndex = n; TestPoint(0); }else{ *pIndex = p->base.count - 1; TestPoint(0); } *ppToken = p; n -= p->base.count; }else{ *pIndex = 0; *ppToken = p; n--; TestPoint(0); } break; default: TestPoint(0); break; } if( p ){ p = p->base.pNext; TestPoint(0); }else{ TestPoint(0); } } }
/* ** 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; }
/* ** Do as much layout as possible on the block of text defined by ** the HtmlLayoutContext. */ void HtmlLayoutBlock(HtmlLayoutContext *pLC){ HtmlElement *p, *pNext; for(p=pLC->pStart; p && p!=pLC->pEnd; p=pNext){ int lineWidth; int actualWidth; int y = 0; int leftMargin; int maxX = 0; /* Do as much break markup as we can. */ while( p && p!=pLC->pEnd ){ HtmlLock(pLC->htmlPtr); pNext = DoBreakMarkup(pLC, p); if( HtmlUnlock(pLC->htmlPtr) ) return; if( pNext==p ){ TestPoint(0); break; } if( pNext ){ TRACE(HtmlTrace_BreakMarkup, ("Processed token %s as break markup\n", HtmlTokenName(p))); pLC->pStart = p; } p = pNext; TestPoint(0); } if( p==0 || p==pLC->pEnd ){ TestPoint(0); break; } #ifdef TABLE_TRIM_BLANK HtmlLineWasBlank = 0; #endif /* TABLE_TRIM_BLANK */ /* We might try several times to layout a single line... */ while( 1 ){ /* Compute margins */ HtmlComputeMargins(pLC, &leftMargin, &y, &lineWidth); /* Layout a single line of text */ pNext = GetLine(pLC, p, pLC->pEnd, lineWidth, pLC->left-leftMargin, &actualWidth); TRACE(HtmlTrace_GetLine, ("GetLine page=%d left=%d right=%d available=%d used=%d\n", pLC->pageWidth, pLC->left, pLC->right, lineWidth, actualWidth)); FixAnchors(p,pNext,pLC->bottom); /* Move down and repeat the layout if we exceeded the available ** line length and it is possible to increase the line length by ** moving past some obsticle. */ if( actualWidth > lineWidth && InWrapAround(pLC) ){ ClearObstacle(pLC, CLEAR_First); TestPoint(0); continue; } /* Lock the line into place and exit the loop */ y = FixLine(p, pNext, y, lineWidth, actualWidth, leftMargin, &maxX); TestPoint(0); break; } #ifdef TABLE_TRIM_BLANK /* * I noticed that a newline following break markup would result * in a blank line being drawn. So if an "empty" line was found * I subtract any whitespace caused by break markup. */ if (actualWidth <= 0) { HtmlLineWasBlank = 1; } #endif /* TABLE_TRIM_BLANK */ /* If a line was completed, advance to the next line */ if( pNext && actualWidth>0 && y > pLC->bottom ){ pLC->bottom = y; pLC->headRoom = 0; pLC->pStart = pNext; } if( y > pLC->maxY ){ pLC->maxY = y; } if( maxX > pLC->maxX ){ pLC->maxX = maxX; } } }
/* ** 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; }