Annotation of Amaya/amaya/templateInstantiate.c, revision 1.28
1.19 vatton 1: /*
2: *
3: * COPYRIGHT INRIA and W3C, 2006-2007
4: * Please first read the full copyright statement in file COPYRIGHT.
5: *
6: */
7:
1.1 vatton 8: #include "templates.h"
9:
10: #define THOT_EXPORT extern
11: #include "templateDeclarations.h"
12:
1.8 kia 13: #include "Elemlist.h"
14:
1.1 vatton 15: #include "EDITimage_f.h"
16: #include "HTMLactions_f.h"
17: #include "HTMLsave_f.h"
18: #include "init_f.h"
19: #include "mydictionary_f.h"
20: #include "templates_f.h"
21: #include "templateDeclarations_f.h"
22: #include "templateInstantiate_f.h"
23: #include "Templatebuilder_f.h"
24: #include "templateUtils_f.h"
25: #include "fetchHTMLname_f.h"
26: #include "Template.h"
27:
28: #ifdef TEMPLATES
29: #define TEMPLATE_SCHEMA_NAME "Template"
30:
31: typedef struct _InstantiateCtxt
32: {
33: char * templatePath;
34: char * instancePath;
35: char * schemaName;
36: DocumentType docType;
37: ThotBool dontReplace;
38: } InstantiateCtxt;
39: #endif /* TEMPLATES */
40:
41:
42: /*----------------------------------------------------------------------
43: CreateInstance
1.3 vatton 44: ----------------------------------------------------------------------*/
1.1 vatton 45: void CreateInstance(char *templatePath, char *instancePath)
1.3 vatton 46: {
1.1 vatton 47: #ifdef TEMPLATES
1.14 vatton 48: Document doc = 0;
1.5 vatton 49: DocumentType docType;
1.14 vatton 50: ElementType elType;
51: Element root, title, text;
52: char *s;
53: int alreadyOnDoc = 0;
54: ThotBool alreadyViewing = FALSE;
1.1 vatton 55:
1.8 kia 56: XTigerTemplate t = (XTigerTemplate)Dictionary_Get (Templates_Dic, templatePath);
1.1 vatton 57: if (t == NULL)
58: //The template must be loaded before calling this function
59: return;
60:
1.5 vatton 61: doc = GetTemplateDocument (t);
1.3 vatton 62: while (alreadyOnDoc < DocumentTableLength-1 && !alreadyViewing)
1.1 vatton 63: {
64: alreadyOnDoc++;
65: if (DocumentURLs[alreadyOnDoc])
66: alreadyViewing = !strcmp (DocumentURLs[alreadyOnDoc],instancePath);
67: }
68:
69: if (!TtaPrepareUndo (doc))
70: {
71: TtaOpenUndoSequence (doc, NULL, NULL, 0, 0);
1.14 vatton 72: root = TtaGetRootElement(doc);
73: elType = TtaGetElementType (root);
74: // get the target document type
75: s = TtaGetSSchemaName (elType.ElSSchema);
76: if (strcmp (s, "HTML") == 0)
77: docType = docHTML;
78: else if (strcmp (s, "SVG") == 0)
79: docType = docSVG;
80: else if (strcmp (s, "MathML") == 0)
81: docType = docMath;
82: else
83: docType = docXml;
84:
1.1 vatton 85: SetRelativeURLs (doc, instancePath);
86:
87: switch (docType)
88: {
1.14 vatton 89: case docSVG:
1.1 vatton 90: TtaExportDocumentWithNewLineNumbers (doc, instancePath, "SVGT");
91: break;
1.14 vatton 92: case docMath:
1.1 vatton 93: TtaExportDocumentWithNewLineNumbers (doc, instancePath, "MathMLT");
94: break;
1.14 vatton 95: case docHTML:
96: // Initialize the document title
97: elType.ElTypeNum = HTML_EL_TITLE;
98: title = TtaSearchTypedElement (elType, SearchInTree, root);
99: text = TtaGetFirstChild (title);
100: while (text)
101: {
102: elType = TtaGetElementType (text);
103: if (elType.ElTypeNum == HTML_EL_TEXT_UNIT && Answer_text[0] != EOS)
104: {
105: TtaSetTextContent (text, (unsigned char*)Answer_text,
106: TtaGetDefaultLanguage (), doc);
107: text = NULL;
108: }
109: else if ((elType.ElTypeNum == Template_EL_useEl ||
110: elType.ElTypeNum == Template_EL_useSimple) &&
111: !strcmp (TtaGetSSchemaName (elType.ElSSchema), "Template"))
112: // Ignore the template use element
113: text = TtaGetFirstChild (text);
114: else
115: // Look for the first text child
116: TtaNextSibling (&text);
117: }
1.1 vatton 118: if (TtaGetDocumentProfile(doc)==L_Xhtml11 || TtaGetDocumentProfile(doc)==L_Basic)
119: TtaExportDocumentWithNewLineNumbers (doc, instancePath, "HTMLT11");
120: else
121: TtaExportDocumentWithNewLineNumbers (doc, instancePath, "HTMLTX");
122: break;
1.14 vatton 123: default:
1.1 vatton 124: TtaExportDocumentWithNewLineNumbers (doc, instancePath, NULL);
125: break;
126: }
127:
128: TtaCloseUndoSequence (doc);
129: TtaUndoNoRedo (doc);
130: TtaClearUndoHistory (doc);
131: }
132:
1.3 vatton 133: if (!alreadyViewing)
134: {
135: // Open the instance
1.1 vatton 136: TtaExtractName (instancePath, DirectoryName, DocumentName);
137: CallbackDialogue (BaseDialog + OpenForm, INTEGER_DATA, (char *) 1);
138: }
1.3 vatton 139: else
140: {
141: // Reload on the existing view
142: Reload (alreadyOnDoc, 0);
143: }
1.1 vatton 144: #endif /* TEMPLATES */
145: }
146:
147: /*----------------------------------------------------------------------
1.3 vatton 148: ----------------------------------------------------------------------*/
1.7 cvs 149: void InstantiateTemplate_callback (int newdoc, int status, char *urlName, char *outputfile,
150: char *proxyName, AHTHeaders *http_headers, void * context)
1.1 vatton 151: {
152: #ifdef TEMPLATES
153: InstantiateCtxt *ctx = (InstantiateCtxt*)context;
154:
155: DoInstanceTemplate (ctx->templatePath);
156: CreateInstance (ctx->templatePath, ctx->instancePath);
157: TtaFreeMemory (ctx->templatePath);
158: TtaFreeMemory (ctx->instancePath);
159: TtaFreeMemory (ctx);
160: #endif /* TEMPLATES */
161: }
162:
163: /*----------------------------------------------------------------------
1.3 vatton 164: ----------------------------------------------------------------------*/
1.1 vatton 165: void InstantiateTemplate (Document doc, char *templatename, char *docname,
166: DocumentType docType, ThotBool loaded)
167: {
168: #ifdef TEMPLATES
169: if (!loaded)
1.3 vatton 170: {
171: // Create the callback context
172: InstantiateCtxt *ctx = (InstantiateCtxt *)TtaGetMemory (sizeof (InstantiateCtxt));
173: ctx->templatePath = TtaStrdup (templatename);
174: ctx->instancePath = TtaStrdup (docname);
175: ctx->schemaName = GetSchemaFromDocType(docType);
176: ctx->docType = docType;
1.1 vatton 177:
1.3 vatton 178: GetAmayaDoc (templatename, NULL, doc, doc, CE_MAKEBOOK, FALSE,
1.6 cvs 179: (void (*)(int, int, char*, char*, char*, const AHTHeaders*, void*)) InstantiateTemplate_callback,
1.3 vatton 180: (void *) ctx);
181: }
1.1 vatton 182: else
183: {
184: DoInstanceTemplate (templatename);
185: CreateInstance (templatename, docname);
1.3 vatton 186: }
1.1 vatton 187: #endif /* TEMPLATES */
188: }
189:
190: /*----------------------------------------------------------------------
191: InstantiateAttribute
1.3 vatton 192: ----------------------------------------------------------------------*/
1.1 vatton 193: static void InstantiateAttribute (XTigerTemplate t, Element el, Document doc)
194: {
195: #ifdef TEMPLATES
196: AttributeType useType, nameType, defaultType, attrType;
197: Attribute useAttr, nameAttr, defAttr, attr;
198: ElementType elType;
199: Element parent;
200: char *text, *elementName;
201: ThotBool level;
202: NotifyAttribute event;
203:
204: parent = TtaGetParent (el);
205: if (!parent)
206: return;
207: // if attribute "use" has value "optional", don't do anything
208: useType.AttrSSchema = TtaGetSSchema (TEMPLATE_SCHEMA_NAME, doc);
209: useType.AttrTypeNum = Template_ATTR_useAt;
210: useAttr = TtaGetAttribute (el, useType);
211: if (useAttr)
212: // there is a "use" attribute. Check its value
213: {
1.10 kia 214: text = GetAttributeStringValue (el, useAttr, NULL);
1.25 vatton 215: if (!text)
1.1 vatton 216: return;
1.25 vatton 217: if (strcmp (text, "optional") == 0)
1.18 kia 218: {
219: TtaFreeMemory(text);
220: return;
221: }
222: TtaFreeMemory(text);
1.1 vatton 223: }
1.18 kia 224:
1.1 vatton 225: // get the "name" and "default" attributes
226: nameType.AttrSSchema = defaultType.AttrSSchema = TtaGetSSchema (TEMPLATE_SCHEMA_NAME, doc);
1.9 vatton 227: nameType.AttrTypeNum = Template_ATTR_ref_name;
1.1 vatton 228: defaultType.AttrTypeNum = Template_ATTR_defaultAt;
229: nameAttr = TtaGetAttribute (el, nameType);
230: defAttr = TtaGetAttribute (el, defaultType);
231: if (nameAttr)
232: {
1.10 kia 233: text = GetAttributeStringValue (el, nameAttr, NULL);
1.1 vatton 234: if (text)
235: {
236: elType = TtaGetElementType (parent);
237: elementName = TtaGetElementTypeName (elType);
238: level = TRUE;
239: MapHTMLAttribute (text, &attrType, elementName, &level, doc);
240: TtaFreeMemory(text);
241: attr = TtaNewAttribute (attrType);
242: if (attr)
243: {
244: TtaAttachAttribute (parent, attr, doc);
245: if (defAttr)
246: {
1.10 kia 247: text = GetAttributeStringValue (el, defAttr, NULL);
1.25 vatton 248: if (text)
1.18 kia 249: TtaSetAttributeText(attr, text, parent, doc);
1.1 vatton 250: TtaFreeMemory(text);
251: // if it's a src arttribute for an image, load the image
252: if (!strcmp (TtaGetSSchemaName (elType.ElSSchema), "HTML") &&
253: elType.ElTypeNum == HTML_EL_IMG)
254: if (attrType.AttrTypeNum == HTML_ATTR_SRC &&
255: attrType.AttrSSchema == elType.ElSSchema)
256: {
257: event.document = doc;
258: event.element = parent;
259: event.attribute = attr;
260: SRCattrModified (&event);
261: }
262: }
263: }
264: }
265: }
266: #endif /* TEMPLATES */
267: }
268:
269: #ifdef TEMPLATES
270: /*----------------------------------------------------------------------
271: ProcessAttr
1.9 vatton 272: Look for all "attribute" elements in the subtree and instantiate them
1.3 vatton 273: ----------------------------------------------------------------------*/
1.1 vatton 274: static void ProcessAttr (XTigerTemplate t, Element el, Document doc)
275: {
276: Element child;
277: ElementType elType;
278:
279: for (child = TtaGetFirstChild (el); child; TtaNextSibling(&child))
280: {
281: elType = TtaGetElementType (child);
282: if (elType.ElTypeNum == Template_EL_attribute &&
283: !strcmp (TtaGetSSchemaName (elType.ElSSchema), TEMPLATE_SCHEMA_NAME))
284: InstantiateAttribute (t, child, doc);
285: else
286: ProcessAttr (t, child, doc);
287: }
288: }
289: #endif /* TEMPLATES */
290:
1.12 kia 291:
292: /*----------------------------------------------------------------------
293: Template_GetNewSimpleTypeInstance
294: Create an new instance of xt:use/SimpleType
295: The decl attribute must embed SimpleType declaration (no validation).
296: @param decl Declaration of new element
297: @param parent Future parent element
298: @param doc Document
299: @return The new element
300: ----------------------------------------------------------------------*/
301: Element Template_GetNewSimpleTypeInstance(Document doc, Element parent, Declaration decl)
302: {
303: Element newEl = NULL;
304: #ifdef TEMPLATES
305: ElementType elType;
306: char *empty = " ";
1.24 vatton 307:
1.17 kia 308: elType.ElSSchema = TtaGetSSchema(TEMPLATE_SSHEMA_NAME, doc);
1.12 kia 309: elType.ElTypeNum = Template_EL_TEXT_UNIT;
310: newEl = TtaNewElement (doc, elType);
311: TtaSetTextContent (newEl, (unsigned char*) empty, 0, doc);
1.24 vatton 312: #endif /* TEMPLATES */
1.12 kia 313: return newEl;
314: }
315:
316: /*----------------------------------------------------------------------
317: Template_GetNewXmlElementInstance
318: Create an new instance of xt:use/XmlElement
319: The decl attribute must embed XmlElement declaration (no validation).
320: @param decl Declaration of new element
321: @param parent Future parent element
322: @param doc Document
323: @return The new element
324: ----------------------------------------------------------------------*/
325: Element Template_GetNewXmlElementInstance(Document doc, Element parent, Declaration decl)
326: {
327: Element newEl = NULL;
328: #ifdef TEMPLATES
329: ElementType elType;
330:
1.24 vatton 331: GIType (decl->name, &elType, doc);
332: if (elType.ElTypeNum != 0)
1.12 kia 333: {
1.23 kia 334: newEl = TtaNewTree (doc, elType, "");
1.12 kia 335: }
336: #endif /* TEMPLATES */
337: return newEl;
338: }
339:
340: /*----------------------------------------------------------------------
1.16 kia 341: Template_InsertUseChildren
342: Insert children to a xt:use
343: The dec parameter must be valid and will not be verified. It must be a
344: direct child element (for union elements).
345: @param el element (xt:use) in which insert a new element
346: @param dec Template declaration of the element to insert
347: @return The inserted element (the xt:use element if insertion is multiple as component)
348: ----------------------------------------------------------------------*/
349: Element Template_InsertUseChildren(Document doc, Element el, Declaration dec)
350: {
1.19 vatton 351: Element newEl = NULL;
1.16 kia 352: #ifdef TEMPLATES
1.19 vatton 353: Element current = NULL;
354: Element child = NULL;
355: //char *attrCurrentTypeValue;
356: //ElementType elType;
1.17 kia 357:
1.25 vatton 358: if (TtaGetDocumentAccessMode(doc))
1.16 kia 359: {
1.23 kia 360: switch (dec->nature)
361: {
362: case SimpleTypeNat:
363: newEl = Template_GetNewSimpleTypeInstance(doc, el, dec);
364: TtaInsertFirstChild (&newEl, el, doc);
365: break;
366: case XmlElementNat:
367: newEl = Template_GetNewXmlElementInstance(doc, el, dec);
368: TtaInsertFirstChild (&newEl, el, doc);
369: break;
370: case ComponentNat:
371: newEl = TtaCopyTree(dec->componentType.content, doc, doc, el);
372: ProcessAttr (dec->declaredIn, newEl, doc);
373:
374: /* Copy elements from new use to existing use. */
375: while((child = TtaGetFirstChild(newEl)))
376: {
377: TtaRemoveTree (child, doc);
1.25 vatton 378: if (current)
1.23 kia 379: TtaInsertSibling (child, current, FALSE, doc);
380: else
381: TtaInsertFirstChild (&child, el, doc);
382: current = child;
383: }
384:
385: /* Copy currentType attribute. */
386: //attrCurrentTypeValue = GetAttributeStringValue (el, Template_ATTR_currentType, NULL);
387: //SetAttributeStringValue (el, Template_ATTR_currentType, attrCurrentTypeValue);
388: TtaDeleteTree(newEl, doc);
389: newEl = el;
390: break;
391: case UnionNat :
392: /* Nothing to do.*/
393: // elType.ElTypeNum = Template_EL_useEl;
394: // cont = TtaNewElement (doc, elType);
395: // if (cont)
396: // {
397: // TtaSetAccessRight (cont, ReadWrite, doc);
398: // at = TtaNewAttribute (att);
399: // if (at)
400: // {
401: // TtaAttachAttribute (cont, at, doc);
402: // TtaSetAttributeText(at, types, cont, doc);
403: // }
404: // }
405: /* @@@@@ */
406: break;
407: default :
408: //Impossible
409: break;
410: }
411: }
1.16 kia 412: #endif /* TEMPLATES */
413: return newEl;
414: }
415:
416: /*----------------------------------------------------------------------
1.1 vatton 417: InstantiateUse
1.3 vatton 418: ----------------------------------------------------------------------*/
1.1 vatton 419: Element InstantiateUse (XTigerTemplate t, Element el, Document doc,
1.27 kia 420: ThotBool registerUndo)
1.1 vatton 421: {
422: #ifdef TEMPLATES
1.23 kia 423: Element cont = NULL;
1.1 vatton 424: ElementType elType;
425: Declaration dec;
1.28 ! kia 426: int size, nbitems, i;
1.1 vatton 427: struct menuType *items;
428: char *types;
429: ThotBool oldStructureChecking;
430:
1.25 vatton 431: if (!t)
1.23 kia 432: return NULL;
433:
1.1 vatton 434: /* get the value of the "types" attribute */
435: cont = NULL;
1.12 kia 436: elType = TtaGetElementType (el);
1.18 kia 437: types = GetAttributeStringValueFromNum(el, Template_ATTR_types, &size);
1.25 vatton 438: if (!types)
1.18 kia 439: return NULL;
1.1 vatton 440: giveItems (types, size, &items, &nbitems);
441: // No structure checking
442: oldStructureChecking = TtaGetStructureChecking (doc);
443: TtaSetStructureChecking (FALSE, doc);
1.10 kia 444:
1.1 vatton 445: if (nbitems == 1)
446: /* only one type in the "types" attribute */
447: {
1.17 kia 448: dec = Template_GetDeclaration (t, items[0].label);
1.1 vatton 449: if (dec)
1.27 kia 450: {
1.16 kia 451: cont = Template_InsertUseChildren(doc, el, dec);
1.27 kia 452: if(cont)
453: {
454: TtaChangeTypeOfElement (el, doc, Template_EL_useSimple);
455: if(registerUndo)
456: TtaRegisterElementTypeChange(el, Template_EL_useEl, doc);
457: }
458: }
1.1 vatton 459: }
1.26 kia 460:
1.4 quint 461: TtaFreeMemory(types);
1.28 ! kia 462:
! 463:
! 464: for(i=0; i<nbitems; i++)
! 465: TtaFreeMemory(items[i].label);
1.18 kia 466: TtaFreeMemory(items);
1.1 vatton 467: TtaSetStructureChecking (oldStructureChecking, doc);
468: return cont;
1.23 kia 469: #else /* TEMPLATES */
470: return NULL;
1.1 vatton 471: #endif /* TEMPLATES */
472: }
473:
474: /*----------------------------------------------------------------------
1.22 kia 475: InstantiateRepeat
476: Check for min and max param and validate xt:repeat element content.
477: @param registerUndo True to register undo creation sequences.
1.3 vatton 478: ----------------------------------------------------------------------*/
1.22 kia 479: void InstantiateRepeat (XTigerTemplate t, Element el, Document doc, ThotBool registerUndo)
1.1 vatton 480: {
481: #ifdef TEMPLATES
482: int curVal, minVal, maxVal;
483: Attribute curAtt, minAtt, maxAtt;
484: AttributeType curType, minType, maxType;
1.27 kia 485: char *text, *types = NULL, *title=NULL;
1.1 vatton 486:
1.25 vatton 487: if (!t)
1.23 kia 488: return;
489:
1.1 vatton 490: //Preparing types
491: curType.AttrSSchema = TtaGetSSchema (TEMPLATE_SCHEMA_NAME, doc);
492: minType.AttrSSchema = maxType.AttrSSchema = curType.AttrSSchema;
493: curType.AttrTypeNum = Template_ATTR_currentOccurs;
494: minType.AttrTypeNum = Template_ATTR_minOccurs;
495: maxType.AttrTypeNum = Template_ATTR_maxOccurs;
496:
497: //Get currentOccurs, minOccurs and maxOccurs attributes
498: curAtt = TtaGetAttribute (el, curType);
499: minAtt = TtaGetAttribute (el, minType);
500: maxAtt = TtaGetAttribute (el, maxType);
501:
502: //Get the values
503: if (minAtt)
504: {
1.10 kia 505: text = GetAttributeStringValue(el, minAtt, NULL);
1.1 vatton 506: if (text)
507: {
508: minVal = atoi(text);
509: TtaFreeMemory(text);
510: }
511: else
512: //Error : Attribute with no value
513: return;
514: }
515: else
516: minVal = 0;
517:
518: if (maxAtt)
519: {
1.10 kia 520: text = GetAttributeStringValue (el, maxAtt, NULL);
1.1 vatton 521: if (text)
522: {
523: if (!strcmp (text, "*"))
524: maxVal = INT_MAX;
525: else
526: maxVal = atoi (text);
527: TtaFreeMemory (text);
528: }
529: else
530: //Error : Attribute with no value
531: return;
532: }
533: else
534: maxVal = INT_MAX;
535:
536: if (curAtt)
537: {
1.10 kia 538: text = GetAttributeStringValue(el, curAtt, NULL);
1.1 vatton 539: if (text)
540: {
1.2 quint 541: curVal = atoi(text);
1.1 vatton 542: TtaFreeMemory(text);
543: }
544: else
545: //Error : Attribute with no value
546: return;
547: }
548: else
549: curVal = minVal;
550:
551: text = (char*)TtaGetMemory(MAX_LENGTH);
552:
553: //Create non existing attributes
554: if (!minAtt)
555: {
556: minAtt = TtaNewAttribute(minType);
557: sprintf(text,"%d",minVal);
558: TtaAttachAttribute(el, minAtt, doc);
559: TtaSetAttributeText(minAtt, text, el, doc);
1.25 vatton 560: if (registerUndo)
1.22 kia 561: TtaRegisterAttributeCreate(minAtt, el, doc);
1.1 vatton 562: }
563:
564: if (!maxAtt)
565: {
566: maxAtt = TtaNewAttribute(maxType);
567: if (maxVal<INT_MAX)
568: sprintf(text,"%d",maxVal);
569: else
570: sprintf(text,"*");
571: TtaAttachAttribute(el, maxAtt, doc);
572: TtaSetAttributeText(maxAtt, text, el, doc);
1.25 vatton 573: if (registerUndo)
1.22 kia 574: TtaRegisterAttributeCreate(maxAtt, el, doc);
1.1 vatton 575: }
576:
577: if (!curAtt)
1.2 quint 578: {
1.1 vatton 579: curAtt = TtaNewAttribute(curType);
580: sprintf(text,"%d",curVal);
581: TtaAttachAttribute(el, curAtt, doc);
582: TtaSetAttributeText(curAtt, text, el, doc);
1.25 vatton 583: if (registerUndo)
1.22 kia 584: TtaRegisterAttributeCreate(curAtt, el, doc);
1.1 vatton 585: }
586:
587: if (text)
588: TtaFreeMemory(text);
589:
590: //We must have currentOccurs children
591: Element child, newChild;
592: int childrenCount;
593:
594: child = TtaGetFirstChild(el);
595: if (!child)
596: //Error : a repeat must have at least one child which will be the model
597: return;
598:
599: for(childrenCount = 0; child; TtaNextSibling(&child))
600: {
601: //TODO : Check that every child is valid
602: childrenCount ++;
603: }
604:
605: if (childrenCount > maxVal)
606: //Error : too many children!
607: return;
608:
609: child = TtaGetLastChild(el);
1.27 kia 610: types = GetAttributeStringValueFromNum(child, Template_ATTR_types, NULL);
611: title = GetAttributeStringValueFromNum(child, Template_ATTR_title, NULL);
612:
1.1 vatton 613:
614: while(childrenCount < curVal)
615: {
1.27 kia 616: ElementType newElType;
617: newElType.ElSSchema = TtaGetSSchema (TEMPLATE_SCHEMA_NAME, doc);
618: newElType.ElTypeNum = Template_EL_useEl;
619: newChild = TtaNewElement(doc, newElType);
620:
621: // Insert it
1.1 vatton 622: TtaInsertSibling(newChild, child, FALSE, doc);
1.27 kia 623: SetAttributeStringValueWithUndo(newChild, Template_ATTR_types, types);
624: SetAttributeStringValueWithUndo(newChild, Template_ATTR_title, title);
625:
626: InstantiateUse(t, newChild, doc, TRUE);
627:
1.25 vatton 628: if (registerUndo)
1.22 kia 629: TtaRegisterElementCreate(newChild, doc);
1.1 vatton 630: child = newChild;
631: childrenCount++;
632: }
1.27 kia 633:
634: TtaFreeMemory(types);
635: TtaFreeMemory(title);
1.1 vatton 636: #endif /* TEMPLATES */
637: }
638:
639: /*----------------------------------------------------------------------
640: ParseTemplate
1.3 vatton 641: ----------------------------------------------------------------------*/
1.1 vatton 642: static void ParseTemplate (XTigerTemplate t, Element el, Document doc,
643: ThotBool loading)
644: {
645: #ifdef TEMPLATES
646: AttributeType attType;
1.5 vatton 647: Attribute att;
648: Element aux, child; //Needed when deleting trees
649: char *name;
650: ElementType elType = TtaGetElementType (el);
1.1 vatton 651:
1.25 vatton 652: if (!t)
1.23 kia 653: return;
654:
1.5 vatton 655: name = TtaGetSSchemaName (elType.ElSSchema);
656: if (!strcmp (name, "Template"))
1.1 vatton 657: {
1.5 vatton 658: switch(elType.ElTypeNum)
1.1 vatton 659: {
660: case Template_EL_head :
661: //Remove it and all of its children
662: TtaDeleteTree(el, doc);
663: //We must stop searching into this tree
664: return;
665: break;
666: case Template_EL_component :
1.25 vatton 667: // remove the name attribute
1.5 vatton 668: attType.AttrSSchema = elType.ElSSchema;
1.1 vatton 669: attType.AttrTypeNum = Template_ATTR_name;
1.18 kia 670: name = GetAttributeStringValueFromNum (el, Template_ATTR_name, NULL);
1.5 vatton 671: TtaRemoveAttribute (el, TtaGetAttribute (el, attType), doc);
1.25 vatton 672: // replace the component by a use
1.1 vatton 673: if (NeedAMenu (el, doc))
1.5 vatton 674: TtaChangeElementType (el, Template_EL_useEl);
1.1 vatton 675: else
1.5 vatton 676: TtaChangeElementType (el, Template_EL_useSimple);
1.25 vatton 677: // generate the types attribute
1.1 vatton 678: attType.AttrTypeNum = Template_ATTR_types;
1.5 vatton 679: att = TtaNewAttribute (attType);
680: TtaAttachAttribute (el, att, doc);
1.25 vatton 681: if (name)
1.18 kia 682: TtaSetAttributeText (att, name, el, doc);
1.25 vatton 683: // generate the title attribute
684: attType.AttrTypeNum = Template_ATTR_title;
685: att = TtaNewAttribute (attType);
686: TtaAttachAttribute (el, att, doc);
687: if (name)
688: TtaSetAttributeText (att, name, el, doc);
689: // generate the currentType attribute
1.1 vatton 690: attType.AttrTypeNum = Template_ATTR_currentType;
1.5 vatton 691: att = TtaNewAttribute (attType);
1.18 kia 692: TtaAttachAttribute (el, att, doc);
1.25 vatton 693: if (name)
1.18 kia 694: TtaSetAttributeText (att, name, el, doc);
1.28 ! kia 695: TtaFreeMemory(name);
1.1 vatton 696: break;
697: case Template_EL_option :
698: aux = NULL;
699: break;
700: case Template_EL_bag :
701: //Link to types
702: //Allow editing the content
703: break;
704: case Template_EL_useEl :
705: case Template_EL_useSimple :
706: /* if this use element is not empty, don't do anything: it is
707: supposed to contain a valid instance. This should be
708: checked, though */
709: if (!TtaGetFirstChild (el))
1.27 kia 710: InstantiateUse (t, el, doc, FALSE);
1.1 vatton 711: break;
712: case Template_EL_attribute :
713: if (!loading)
714: InstantiateAttribute (t, el, doc);
715: break;
716: case Template_EL_repeat :
1.22 kia 717: InstantiateRepeat (t, el, doc, FALSE);
1.1 vatton 718: break;
719: default :
720: break;
721: }
722: }
723:
1.5 vatton 724: child = TtaGetFirstChild (el);
725: while (child)
1.1 vatton 726: {
727: aux = child;
1.5 vatton 728: TtaNextSibling (&aux);
729: ParseTemplate (t, child, doc, loading);
1.1 vatton 730: child = aux;
731: }
732: #endif /* TEMPLATES */
733: }
734:
735: /*----------------------------------------------------------------------
1.3 vatton 736: ----------------------------------------------------------------------*/
1.1 vatton 737: void DoInstanceTemplate (char *templatename)
738: {
739: #ifdef TEMPLATES
740: XTigerTemplate t;
741: ElementType elType;
742: Element root, piElem, doctype, elFound, text;
743: char *s, *charsetname = NULL, buffer[MAX_LENGTH];
744: int pi_type;
745: Document doc;
746:
747: //Instantiate all elements
1.8 kia 748: t = (XTigerTemplate) Dictionary_Get (Templates_Dic, templatename);
1.25 vatton 749: if (!t)
1.23 kia 750: return;
751:
1.1 vatton 752: doc = GetTemplateDocument (t);
753: root = TtaGetMainRoot (doc);
754: ParseTemplate (t, root, doc, FALSE);
755:
756: //Look for PIs
757: /* check if the document has a DOCTYPE declaration */
758: #ifdef ANNOTATIONS
759: if (DocumentTypes[doc] == docAnnot)
760: elType = TtaGetElementType (root);
761: else
762: #endif /* ANNOTATIONS */
763: elType = TtaGetElementType (root);
764: s = TtaGetSSchemaName (elType.ElSSchema);
765: if (strcmp (s, "HTML") == 0)
766: {
767: elType.ElTypeNum = HTML_EL_DOCTYPE;
768: pi_type = HTML_EL_XMLPI;
769: }
770: #ifdef _SVG
771: else if (strcmp (s, "SVG") == 0)
772: {
773: elType.ElTypeNum = SVG_EL_DOCTYPE;
774: pi_type = SVG_EL_XMLPI;
775: }
776: #endif /* _SVG */
777: else if (strcmp (s, "MathML") == 0)
778: {
779: elType.ElTypeNum = MathML_EL_DOCTYPE;
780: pi_type = MathML_EL_XMLPI;
781: }
782: else
783: {
784: elType.ElTypeNum = XML_EL_doctype;
785: pi_type = XML_EL_xmlpi;
786: }
787: doctype = TtaSearchTypedElement (elType, SearchInTree, root);
788: if (!doctype)
789: {
790: /* generate the XML declaration */
791: /* Check the Thot abstract tree against the structure schema. */
792: TtaSetStructureChecking (FALSE, doc);
793: elType.ElTypeNum = pi_type;
794: doctype = TtaNewTree (doc, elType, "");
795: TtaInsertFirstChild (&doctype, root, doc);
796: elFound = TtaGetFirstChild (doctype);
797: text = TtaGetFirstChild (elFound);
798: strcpy (buffer, "xml version=\"1.0\" encoding=\"");
799: charsetname = UpdateDocumentCharset (doc);
800: strcat (buffer, charsetname);
801: strcat (buffer, "\"");
802: TtaSetTextContent (text, (unsigned char*)buffer, Latin_Script, doc);
803: TtaSetStructureChecking (TRUE, doc);
1.28 ! kia 804: TtaFreeMemory(charsetname);
1.1 vatton 805: }
806:
807: /* generate the XTiger PI */
808: /* Check the Thot abstract tree against the structure schema. */
809: TtaSetStructureChecking (FALSE, doc);
810: elType.ElTypeNum = pi_type;
811: piElem = TtaNewTree (doc, elType, "");
812: TtaInsertSibling(piElem, doctype, FALSE, doc);
813: elFound = TtaGetFirstChild (piElem);
814: text = TtaGetFirstChild (elFound);
815: strcpy (buffer, "xtiger template=\"");
816: strcat (buffer, templatename);
1.17 kia 817: strcat (buffer, "\" version=\"");
1.20 vatton 818: if (t->version)
819: strcat (buffer, t->version);
820: else
821: strcat (buffer, "0.8");
1.1 vatton 822: strcat (buffer, "\"");
1.25 vatton 823: if (t->templateVersion)
1.20 vatton 824: {
825: strcat (buffer, " templateVersion=\"");
826: strcat (buffer, t->templateVersion);
827: strcat (buffer, "\"");
828: }
1.1 vatton 829: TtaSetTextContent (text, (unsigned char*)buffer, Latin_Script, doc);
830: TtaSetStructureChecking (TRUE, doc);
1.5 vatton 831:
832: // update the document title
833: if (!strcmp (s, "HTML"))
834: {
835: elType.ElTypeNum = HTML_EL_TITLE;
836: elFound = TtaSearchTypedElement (elType, SearchInTree, root);
837: if (elFound)
838: {
839: elFound = TtaGetFirstChild (elFound);
840: TtaSetTextContent (elFound, (unsigned char *)Answer_text,
841: TtaGetDefaultLanguage (), doc);
842: }
843: }
1.1 vatton 844: #endif /* TEMPLATES */
845: }
846:
847: /*----------------------------------------------------------------------
1.3 vatton 848: PreInstantiateComponents: Instantiates all components in order to improve
849: editing.
850: ----------------------------------------------------------------------*/
1.25 vatton 851: void PreInstantiateComponents (XTigerTemplate t)
1.1 vatton 852: {
853: #ifdef TEMPLATES
1.25 vatton 854: if (!t)
1.23 kia 855: return;
856:
1.1 vatton 857: DicDictionary components = GetComponents(t);
858: Declaration comp;
859:
1.8 kia 860: for(Dictionary_First(components);!Dictionary_IsDone(components);Dictionary_Next(components))
1.1 vatton 861: {
1.8 kia 862: comp = (Declaration) Dictionary_CurrentElement(components);
1.1 vatton 863: ParseTemplate(t, GetComponentContent(comp), GetTemplateDocument(t), TRUE);
864: }
865: #endif /* TEMPLATES */
866: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to templateInstantiate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / Amaya / amaya