Annotation of Amaya/amaya/HTMLbook.c, revision 1.129
1.1 cvs 1: /*
2: *
1.129 ! vatton 3: * (c) COPYRIGHT INRIA and W3C, 1996-2005
1.1 cvs 4: * Please first read the full copyright statement in file COPYRIGHT.
5: *
6: */
1.65 cvs 7:
1.1 cvs 8: /*
9: * Initialization functions and button functions of Amaya application.
10: *
11: * Authors: V. Quint, I. Vatton
1.85 cvs 12: * R. Guetari (W3C/INRIA) - Windows version.
1.1 cvs 13: */
14:
1.107 carcone 15: #ifdef _WX
16: #include "wx/wx.h"
17: #endif /* _WX */
1.1 cvs 18:
19: /* Included headerfiles */
1.101 gully 20: #define THOT_EXPORT extern
1.1 cvs 21: #include "amaya.h"
1.44 cvs 22: #include "AHTURLTools_f.h"
1.1 cvs 23: #include "print.h"
1.51 cvs 24: #include "css.h"
1.101 gully 25: #include "init_f.h"
1.1 cvs 26:
1.116 gully 27: #include "appdialogue_wx.h"
28: #include "message_wx.h"
29:
1.25 cvs 30: /* structure to register sub-documents in MakeBook function*/
31: typedef struct _SubDoc
32: {
33: struct _SubDoc *SDnext;
34: Element SDel;
1.85 cvs 35: char *SDname;
1.25 cvs 36: }SubDoc;
37:
1.29 cvs 38: /* the structure used for the GetIncludedDocuments_callback function */
1.58 cvs 39: typedef struct _IncludeCtxt
1.53 cvs 40: {
1.58 cvs 41: Element div; /* enclosing element for the search */
42: Element link; /* current processed link */
1.104 vatton 43: char *utf8path; /* called url */
1.85 cvs 44: char *name; /* the fragment name */
1.58 cvs 45: struct _IncludeCtxt *ctxt; /* the previous context */
46: } IncludeCtxt;
1.29 cvs 47:
1.55 cvs 48: /* shared with windialogapi.c */
49: ThotBool PrintURL;
50: ThotBool NumberLinks;
51: ThotBool WithToC;
52: ThotBool IgnoreCSS;
53:
1.25 cvs 54: static struct _SubDoc *SubDocs;
1.85 cvs 55: static char PSfile[MAX_PATH];
56: static char PPrinter[MAX_PATH];
57: static char *DocPrintURL;
1.53 cvs 58: static Document DocPrint;
1.2 cvs 59: static int PaperPrint;
1.73 cvs 60: static int ManualFeed = PP_OFF;
1.71 cvs 61: static int Orientation;
1.2 cvs 62: static int PageSize;
1.71 cvs 63: static int PagePerSheet;
1.1 cvs 64:
1.114 vatton 65: #include "EDITORactions_f.h"
1.1 cvs 66: #include "init_f.h"
67: #include "HTMLactions_f.h"
68: #include "HTMLbook_f.h"
69: #include "HTMLedit_f.h"
1.25 cvs 70: #include "HTMLhistory_f.h"
1.51 cvs 71: #include "UIcss_f.h"
1.1 cvs 72:
1.107 carcone 73: #ifdef _WINGUI
1.37 cvs 74: #include "wininclude.h"
1.103 cvs 75: #endif /* _WINGUI */
1.31 cvs 76:
1.107 carcone 77: #ifdef _WX
78: #include "wxdialogapi_f.h"
79: #endif /* _WX */
80:
1.101 gully 81: static ThotBool GetIncludedDocuments (Element el, Element link,
82: Document doc, IncludeCtxt *prev);
1.1 cvs 83: /*----------------------------------------------------------------------
1.94 vatton 84: RedisplayDocument redisplays a view of a document
85: ----------------------------------------------------------------------*/
86: void RedisplayDocument(Document doc, View view)
87: {
1.95 vatton 88: Element el;
89: int position;
90: int distance;
91:
92: /* get the current position in the document */
93: position = RelativePosition (doc, &distance);
1.94 vatton 94: TtaSetDisplayMode (doc, NoComputedDisplay);
95: TtaSetDisplayMode (doc, DisplayImmediately);
1.95 vatton 96: /* show the document at the same position */
97: el = ElementAtPosition (doc, position);
98: TtaShowElement (doc, view, el, distance);
1.94 vatton 99: }
100:
101:
102: /*----------------------------------------------------------------------
1.16 cvs 103: RegisterSubDoc adds a new entry in SubDoc table.
104: ----------------------------------------------------------------------*/
1.94 vatton 105: static void RegisterSubDoc (Element el, char *url)
1.16 cvs 106: {
107: struct _SubDoc *entry, *last;
108:
109: if (url == NULL || url[0] == EOS)
110: return;
111:
1.101 gully 112: entry = (struct _SubDoc *)TtaGetMemory (sizeof (struct _SubDoc));
1.16 cvs 113: entry->SDnext = NULL;
114: entry->SDel = el;
1.83 cvs 115: entry->SDname = TtaStrdup (url);
1.16 cvs 116:
117: if (SubDocs == NULL)
118: SubDocs = entry;
119: else
120: {
121: last = SubDocs;
122: while (last->SDnext != NULL)
123: last = last->SDnext;
124: last->SDnext = entry;
125: }
126: }
127:
128:
129: /*----------------------------------------------------------------------
130: SearchSubDoc searches whether a document name is registered or not
131: within the SubDoc table.
132: Return the DIV element that correspond to the sub-document or NULL.
133: ----------------------------------------------------------------------*/
1.94 vatton 134: static Element SearchSubDoc (char *url)
1.16 cvs 135: {
136: Element el;
137: struct _SubDoc *entry;
1.47 cvs 138: ThotBool docFound;
1.16 cvs 139:
140: if (url == NULL || url[0] == EOS)
141: return (NULL);
142:
143: entry = SubDocs;
144: docFound = FALSE;
145: el = NULL;
146: while (!docFound && entry != NULL)
147: {
1.83 cvs 148: docFound = (strcmp (url, entry->SDname) == 0);
1.16 cvs 149: if (!docFound)
150: entry = entry->SDnext;
151: else
152: /* document found -> return the DIV element */
153: el = entry->SDel;
154: }
155: return (el);
156: }
157:
158: /*----------------------------------------------------------------------
159: FreeSubDocTable frees all entries in SubDoc table.
160: ----------------------------------------------------------------------*/
1.94 vatton 161: static void FreeSubDocTable ()
1.16 cvs 162: {
163: struct _SubDoc *entry, *last;
164:
165: entry = SubDocs;
166: while (entry != NULL)
167: {
168: last = entry;
169: entry = entry->SDnext;
170: TtaFreeMemory (last->SDname);
171: TtaFreeMemory (last);
172: }
173: SubDocs = NULL;
174: }
175:
176:
177: /*----------------------------------------------------------------------
1.1 cvs 178: SetInternalLinks
1.8 cvs 179: Associate an InternalLink attribute with all anchor (A) elements of the
180: document which designate an element in the same document.
1.1 cvs 181: InternalLink is a Thot reference attribute that links a source and a
182: target anchor and that allows P schemas to display and print cross-references
183: ----------------------------------------------------------------------*/
1.94 vatton 184: void SetInternalLinks (Document document)
1.1 cvs 185: {
1.32 cvs 186: Element el, div, link, target, sibling;
187: ElementType elType, linkType;
1.16 cvs 188: Attribute HrefAttr, IntLinkAttr;
1.17 cvs 189: Attribute attr, ExtLinkAttr;
1.16 cvs 190: AttributeType attrType;
1.85 cvs 191: char *text, *ptr, *url;
1.83 cvs 192: char number[10];
193: char value[MAX_LENGTH];
1.25 cvs 194: int length, i, volume;
195: int status, position;
1.47 cvs 196: ThotBool split;
1.1 cvs 197:
1.16 cvs 198: /* Remember the current status of the document */
199: status = TtaIsDocumentModified (document);
1.32 cvs 200: el = TtaGetMainRoot (document);
201: volume = TtaGetElementVolume (el);
202: elType = TtaGetElementType (el);
203: elType.ElTypeNum = HTML_EL_AnyLink;
1.16 cvs 204: attrType.AttrSSchema = elType.ElSSchema;
1.32 cvs 205: /* looks for all links in the document */
1.16 cvs 206: link = el;
207: while (link != NULL)
208: {
1.25 cvs 209: /* display the progression of the work */
210: el = link;
211: position = 0;
212: while (el != NULL)
213: {
214: sibling = el;
215: do
216: {
217: /* add volume of each previous element */
218: TtaPreviousSibling (&sibling);
219: if (sibling != NULL)
220: position += TtaGetElementVolume (sibling);
221: }
222: while (sibling != NULL);
223: el = TtaGetParent (el);
224: }
1.83 cvs 225: sprintf (number, "%d", position*100/volume);
1.25 cvs 226: TtaSetStatus (document, 1, TtaGetMessage (AMAYA, AM_UPDATED_LINK), number);
227: TtaHandlePendingEvents ();
1.16 cvs 228: link = TtaSearchTypedElement (elType, SearchForward, link);
229: if (link != NULL)
1.32 cvs 230: /* a link has been found */
1.16 cvs 231: {
1.32 cvs 232: linkType = TtaGetElementType (link);
233: if (linkType.ElTypeNum == HTML_EL_Anchor)
234: attrType.AttrTypeNum = HTML_ATTR_HREF_;
235: else
236: attrType.AttrTypeNum = HTML_ATTR_cite;
1.16 cvs 237: HrefAttr = TtaGetAttribute (link, attrType);
238: attrType.AttrTypeNum = HTML_ATTR_InternalLink;
239: IntLinkAttr = TtaGetAttribute (link, attrType);
240: attrType.AttrTypeNum = HTML_ATTR_ExternalLink;
241: ExtLinkAttr = TtaGetAttribute (link, attrType);
242: if (HrefAttr == NULL)
1.32 cvs 243: /* this element is not a link (no href or cite attribute) */
1.16 cvs 244: /* remove attributes InternalLink and ExternalLink if they
245: are present */
246: {
1.8 cvs 247: if (IntLinkAttr != NULL)
1.16 cvs 248: TtaRemoveAttribute (link, IntLinkAttr, document);
249: if (ExtLinkAttr != NULL)
250: TtaRemoveAttribute (link, ExtLinkAttr, document);
251: }
252: else
1.32 cvs 253: /* this element has an HREF or cite attribute */
1.16 cvs 254: {
255: length = TtaGetTextAttributeLength (HrefAttr);
1.101 gully 256: text = (char *)TtaGetMemory (length + 1);
1.16 cvs 257: TtaGiveTextAttributeValue (HrefAttr, text, &length);
258:
259: /* does an external link become an internal link ? */
1.25 cvs 260: if (document == DocBook && SubDocs != NULL)
1.16 cvs 261: {
1.83 cvs 262: ptr = strrchr (text, '#');
1.16 cvs 263: url = text;
1.18 cvs 264: split = FALSE;
1.16 cvs 265: if (ptr == text)
266: /* a local link */
267: url = NULL;
1.17 cvs 268: else if (ptr != NULL)
1.16 cvs 269: {
270: /* split url and name part */
271: ptr[0] = EOS;
272: split = TRUE;
273: }
274:
275: /* Is it a sub-document */
276: div = SearchSubDoc (url);
277: if (split)
278: /* retore the mark */
279: ptr[0] = '#';
280:
281: if (div == NULL)
282: {
283: /* it's not a sub-document */
284: if (url == NULL)
285: /* a local link */
286: ptr = &text[1];
287: else
288: /* still an externa; link */
289: ptr = NULL;
290: }
291: else
292: {
293: /* this link becomes internal */
1.17 cvs 294: if (ptr != NULL)
1.16 cvs 295: {
1.17 cvs 296: /* get the target name */
1.83 cvs 297: strcpy (value, ptr);
298: length = strlen (value);
1.17 cvs 299: /* check whether the name changed */
300: i = 0;
1.98 vatton 301: target = SearchNAMEattribute (document, &value[1], NULL, NULL);
1.17 cvs 302: while (target != NULL)
1.16 cvs 303: {
1.17 cvs 304: /* is it the right NAME */
305: if (TtaIsAncestor (target, div))
306: target = NULL;
307: else
308: {
309: /* continue the search */
310: i++;
1.83 cvs 311: sprintf (&value[length], "%d", i);
1.32 cvs 312: target = SearchNAMEattribute (document,
1.98 vatton 313: &value[1], NULL, NULL);
1.17 cvs 314: }
1.16 cvs 315: }
316: }
1.17 cvs 317: else
318: {
319: /* get the DIV name */
320: attrType.AttrTypeNum = HTML_ATTR_ID;
321: attr = TtaGetAttribute (div, attrType);
322: length = 200;
323: value[0] = '#';
324: TtaGiveTextAttributeValue (attr, &value[1], &length);
325: }
1.16 cvs 326: ptr = &value[1];
327: TtaSetAttributeText (HrefAttr, value, link, document);
328: }
329: }
330: else if (text[0] == '#')
331: ptr = &text[1];
332: else
333: ptr = NULL;
334:
335: if (ptr != NULL)
336: /* it's an internal link. Attach an attribute InternalLink */
337: /* to the link, if this attribute does not exist yet */
338: {
339: if (IntLinkAttr == NULL)
340: {
341: attrType.AttrTypeNum = HTML_ATTR_InternalLink;
342: IntLinkAttr = TtaNewAttribute (attrType);
343: TtaAttachAttribute (link, IntLinkAttr, document);
344: }
345: /* looks for the target element */
1.98 vatton 346: target = SearchNAMEattribute (document, ptr, NULL, NULL);
1.16 cvs 347: if (target != NULL)
348: /* set the Thot link */
1.32 cvs 349: TtaSetAttributeReference (IntLinkAttr, link, document,
1.112 vatton 350: target);
1.16 cvs 351: }
352: else
353: /* it's an external link */
354: {
355: /* Remove the InternalLink attribute if it is present */
356: if (IntLinkAttr != NULL)
357: TtaRemoveAttribute (link, IntLinkAttr, document);
358: /* create an ExternalLink attribute if there is none */
359: if (ExtLinkAttr == NULL)
360: {
361: attrType.AttrTypeNum = HTML_ATTR_ExternalLink;
362: ExtLinkAttr = TtaNewAttribute (attrType);
363: TtaAttachAttribute (link, ExtLinkAttr, document);
364: }
365: }
366: TtaFreeMemory (text);
367: }
368: }
369: }
370: /* Reset document status */
371: if (!status)
372: TtaSetDocumentUnmodified (document);
1.3 cvs 373: }
374:
375: /*----------------------------------------------------------------------
376: CheckPrintingDocument reinitialize printing parameters as soon as
377: the printing document changes.
378: ----------------------------------------------------------------------*/
1.89 vatton 379: static void CheckPrintingDocument (Document document)
1.3 cvs 380: {
1.83 cvs 381: char docName[MAX_LENGTH];
382: char *ptr;
383: char suffix[MAX_LENGTH];
1.81 cvs 384: int lg;
385:
386: if (DocPrint != document || DocPrintURL == NULL ||
1.83 cvs 387: strcmp(DocPrintURL, DocumentURLs[document]))
1.81 cvs 388: {
389: /* initialize print parameters */
390: TtaFreeMemory (DocPrintURL);
391: DocPrint = document;
392: DocPrintURL = TtaStrdup (DocumentURLs[document]);
393:
394: /* define the new default PS file */
395: ptr = TtaGetEnvString ("APP_TMPDIR");
396: if (ptr != NULL && TtaCheckDirectory (ptr))
1.83 cvs 397: strcpy (PSfile, ptr);
1.81 cvs 398: else
1.83 cvs 399: strcpy (PSfile, TtaGetDefEnvString ("APP_TMPDIR"));
400: lg = strlen (PSfile);
401: if (PSfile[lg - 1] == DIR_SEP)
402: PSfile[--lg] = EOS;
403: strcpy (docName, TtaGetDocumentName (document));
1.90 vatton 404: TtaExtractSuffix (docName, suffix);
1.83 cvs 405: sprintf (&PSfile[lg], "%c%s.ps", DIR_SEP, docName);
1.81 cvs 406: TtaSetPsFile (PSfile);
407: }
1.3 cvs 408: }
409:
410: /*----------------------------------------------------------------------
1.72 cvs 411: PrintDocument prints the document using predefined parameters.
1.3 cvs 412: ----------------------------------------------------------------------*/
1.91 vatton 413: static void PrintDocument (Document doc, View view)
1.3 cvs 414: {
1.126 cvs 415: #if defined(_WINDOWS) && defined(_WX) && defined(IV)
1.116 gully 416: /* On windows and with wxWidgets, disable printing for the moment */
417: wxMessageDialog messagedialog( NULL,
418: TtaConvMessageToWX("Not implemented yet"),
419: _T("Warning"),
420: (long) wxOK | wxICON_EXCLAMATION | wxSTAY_ON_TOP);
421: messagedialog.ShowModal();
422: #else /* defined(_WINDOWS) && defined(_WX) */
1.34 cvs 423: AttributeType attrType;
1.84 cvs 424: ElementType elType;
1.34 cvs 425: Attribute attr;
1.84 cvs 426: Element el, docEl;
1.85 cvs 427: char *files, *dir;
1.84 cvs 428: char viewsToPrint[MAX_PATH];
1.47 cvs 429: ThotBool status, textFile;
1.3 cvs 430:
1.38 cvs 431: textFile = (DocumentTypes[doc] == docText ||
1.75 cvs 432: DocumentTypes[doc] == docSource ||
1.74 cvs 433: DocumentTypes[doc] == docCSS);
1.38 cvs 434:
1.81 cvs 435: /* initialize printing information */
1.75 cvs 436: CheckPrintingDocument (doc);
1.83 cvs 437: strcpy (viewsToPrint, "Formatted_view ");
1.75 cvs 438: if (DocumentTypes[doc] == docHTML && WithToC)
1.83 cvs 439: strcat (viewsToPrint, "Table_of_contents ");
1.75 cvs 440:
441: if (textFile)
442: {
443: if (PageSize == PP_A4)
444: {
445: if (Orientation == PP_Landscape)
1.82 cvs 446: TtaSetPrintSchema ("TextFilePL");
1.75 cvs 447: else
1.82 cvs 448: TtaSetPrintSchema ("TextFilePP");
1.75 cvs 449: }
450: else
451: {
452: if (Orientation == PP_Landscape)
1.82 cvs 453: TtaSetPrintSchema ("TextFileUSL");
1.75 cvs 454: else
1.82 cvs 455: TtaSetPrintSchema ("TextFilePPUS");
1.75 cvs 456: }
457: }
458: else if (DocumentTypes[doc] == docSVG)
1.88 vatton 459: TtaSetPrintSchema ("SVGP");
1.75 cvs 460: else if (DocumentTypes[doc] == docMath)
1.82 cvs 461: TtaSetPrintSchema ("MathMLP");
1.75 cvs 462: else if (DocumentTypes[doc] == docAnnot)
1.82 cvs 463: TtaSetPrintSchema ("AnnotP");
1.113 quint 464: else if (DocumentTypes[doc] == docHTML)
1.75 cvs 465: {
1.113 quint 466: if (NumberLinks)
467: /* display numbered links */
468: {
469: /* associate an attribute InternalLink with all anchors refering
470: a target in the same document. This allows P schemas to work
471: properly */
472: SetInternalLinks (DocPrint);
473: if (PageSize == PP_A4)
474: {
475: if (Orientation == PP_Landscape)
476: TtaSetPrintSchema ("HTMLPLL");
477: else
478: TtaSetPrintSchema ("HTMLPLP");
479: }
480: else
481: {
482: if (Orientation == PP_Landscape)
483: TtaSetPrintSchema ("HTMLUSLL");
484: else
485: TtaSetPrintSchema ("HTMLPLPUS");
486: }
487: strcat (viewsToPrint, "Links_view ");
488: }
489: else if (PageSize == PP_A4)
1.75 cvs 490: {
491: if (Orientation == PP_Landscape)
1.113 quint 492: TtaSetPrintSchema ("HTMLPL");
1.75 cvs 493: else
1.113 quint 494: TtaSetPrintSchema ("HTMLPP");
1.75 cvs 495: }
496: else
497: {
498: if (Orientation == PP_Landscape)
1.113 quint 499: TtaSetPrintSchema ("HTMLUSL");
1.75 cvs 500: else
1.113 quint 501: TtaSetPrintSchema ("HTMLPPUS");
502: }
1.75 cvs 503: }
504: status = TtaIsDocumentModified (doc);
1.71 cvs 505:
1.75 cvs 506: if (textFile || DocumentTypes[doc] == docImage ||
507: DocumentTypes[doc] == docHTML)
508: {
509: /* post or remove the PrintURL attribute */
510: attrType.AttrSSchema = TtaGetDocumentSSchema (doc);
1.84 cvs 511: elType.ElSSchema = attrType.AttrSSchema;
1.75 cvs 512: if (textFile)
1.84 cvs 513: {
514: elType. ElTypeNum = TextFile_EL_TextFile;
515: attrType.AttrTypeNum = TextFile_ATTR_PrintURL;
516: }
1.75 cvs 517: else
1.84 cvs 518: {
519: elType. ElTypeNum = HTML_EL_HTML;
520: attrType.AttrTypeNum = HTML_ATTR_PrintURL;
521: }
522: docEl = TtaGetMainRoot (doc);
523: el = TtaSearchTypedElement (elType, SearchForward, docEl);
1.75 cvs 524: attr = TtaGetAttribute (el, attrType);
525: if (!attr && PrintURL)
526: {
527: attr = TtaNewAttribute (attrType);
528: TtaAttachAttribute (el, attr, doc);
529: }
530: if (attr && !PrintURL)
531: TtaRemoveAttribute (el, attr, doc);
532: }
533:
534: /* get the path dir where css files have to be stored */
1.113 quint 535: if ((DocumentTypes[doc] == docHTML || DocumentTypes[doc] == docSVG ||
536: DocumentTypes[doc] == docXml) &&
1.78 cvs 537: !IgnoreCSS)
1.75 cvs 538: {
539: TtaGetPrintNames (&files, &dir);
540: /* store css files and get the list of names */
541: files = CssToPrint (doc, dir);
542: }
543: else
544: files = NULL;
545: TtaPrint (DocPrint, viewsToPrint, files);
546: if (files)
547: TtaFreeMemory (files);
548: if (!status)
549: TtaSetDocumentUnmodified (doc);
1.116 gully 550: #endif /* defined(_WINDOWS) && defined(_WX) */
1.1 cvs 551: }
552:
1.45 cvs 553: /*----------------------------------------------------------------------
554: PrintAs prints the document using predefined parameters.
555: ----------------------------------------------------------------------*/
1.89 vatton 556: void PrintAs (Document doc, View view)
1.45 cvs 557: {
1.103 cvs 558: #ifdef _WINGUI
1.72 cvs 559: DocPrint = doc;
560: ReusePrinterDC ();
1.103 cvs 561: #else /* _WINGUI */
1.45 cvs 562: PrintDocument (doc, view);
1.103 cvs 563: #endif /* _WINGUI */
1.45 cvs 564: }
1.1 cvs 565:
566: /*----------------------------------------------------------------------
1.92 quint 567: CallbackImage handle return of Print form.
1.1 cvs 568: ----------------------------------------------------------------------*/
1.85 cvs 569: void CallbackPrint (int ref, int typedata, char *data)
1.1 cvs 570: {
571: int val;
572:
573: val = (int) data;
1.53 cvs 574: switch (ref - BasePrint)
1.1 cvs 575: {
1.69 cvs 576: case FormPrint:
577: TtaDestroyDialogue (BasePrint + FormPrint);
1.1 cvs 578: switch (val)
579: {
580: case 1:
1.53 cvs 581: TtaSetPrintCommand (PPrinter);
1.81 cvs 582: TtaSetPsFile (PSfile);
1.40 cvs 583: /* update the environment variable */
1.53 cvs 584: TtaSetEnvString ("THOTPRINT", PPrinter, TRUE);
585: PrintDocument (DocPrint, 1);
1.1 cvs 586: break;
587: default:
588: break;
589: }
590: break;
1.69 cvs 591: case PrintOptions:
1.1 cvs 592: switch (val)
593: {
594: case 0:
595: /* Manual feed option */
1.2 cvs 596: if (ManualFeed == PP_ON)
597: ManualFeed = PP_OFF;
598: else
599: ManualFeed = PP_ON;
1.81 cvs 600: TtaSetPrintParameter (PP_ManualFeed, ManualFeed);
1.1 cvs 601: break;
602: case 1:
603: /* Toc option */
1.53 cvs 604: WithToC = !WithToC;
1.1 cvs 605: break;
606: case 2:
1.53 cvs 607: /* NumberLinks option */
608: NumberLinks = !NumberLinks;
1.34 cvs 609: case 3:
610: /* URL option */
1.53 cvs 611: PrintURL = !PrintURL;
612: break;
613: case 4:
614: /* CSS option */
615: IgnoreCSS = !IgnoreCSS;
1.1 cvs 616: break;
617: }
618: break;
1.69 cvs 619: case PaperFormat:
1.1 cvs 620: /* page size submenu */
621: switch (val)
622: {
623: case 0:
1.2 cvs 624: PageSize = PP_A4;
1.1 cvs 625: break;
626: case 1:
1.2 cvs 627: PageSize = PP_US;
1.1 cvs 628: break;
629: }
1.81 cvs 630: TtaSetPrintParameter (PP_PaperSize, PageSize);
1.1 cvs 631: break;
1.71 cvs 632: case PaperOrientation:
633: /* orientation submenu */
634: Orientation = val;
1.81 cvs 635: TtaSetPrintParameter (PP_Orientation, Orientation);
1.71 cvs 636: break;
637: case PPagesPerSheet:
638: /* pages per sheet submenu */
639: switch (val)
640: {
641: case 0:
642: PagePerSheet = 1;
643: break;
644: case 1:
645: PagePerSheet = 2;
646: break;
647: case 2:
648: PagePerSheet = 4;
649: break;
650: }
1.81 cvs 651: TtaSetPrintParameter (PP_PagesPerSheet, PagePerSheet);
1.71 cvs 652: break;
1.69 cvs 653: case PrintSupport:
1.1 cvs 654: /* paper print/save PostScript submenu */
655: switch (val)
656: {
657: case 0:
1.2 cvs 658: if (PaperPrint == PP_PS)
1.1 cvs 659: {
1.2 cvs 660: PaperPrint = PP_PRINTER;
1.110 cvs 661: #ifdef _GTK
1.69 cvs 662: TtaSetTextForm (BasePrint + PPrinterName, PPrinter);
1.110 cvs 663: #endif /* _GTK */
1.81 cvs 664: TtaSetPrintParameter (PP_Destination, PaperPrint);
1.1 cvs 665: }
666: break;
667: case 1:
1.2 cvs 668: if (PaperPrint == PP_PRINTER)
1.1 cvs 669: {
1.2 cvs 670: PaperPrint = PP_PS;
1.110 cvs 671: #ifdef _GTK
1.81 cvs 672: TtaSetTextForm (BasePrint + PPrinterName, PSfile);
1.110 cvs 673: #endif /* _GTK */
1.81 cvs 674: TtaSetPrintParameter (PP_Destination, PaperPrint);
1.1 cvs 675: }
676: break;
677: }
678: break;
1.69 cvs 679: case PPrinterName:
1.1 cvs 680: if (data[0] != '\0')
1.80 cvs 681: {
1.2 cvs 682: if (PaperPrint == PP_PRINTER)
1.40 cvs 683: /* text capture zone for the printer name */
1.83 cvs 684: strncpy (PPrinter, data, MAX_PATH);
1.1 cvs 685: else
686: /* text capture zone for the name of the PostScript file */
1.83 cvs 687: strncpy (PSfile, data, MAX_PATH);
1.80 cvs 688: }
1.1 cvs 689: break;
690: }
691: }
692:
693: /*----------------------------------------------------------------------
694: ----------------------------------------------------------------------*/
1.94 vatton 695: void InitPrint (void)
1.1 cvs 696: {
1.83 cvs 697: char* ptr;
1.1 cvs 698:
1.101 gully 699: BasePrint = TtaSetCallback ((Proc)CallbackPrint, PRINT_MAX_REF);
1.53 cvs 700: DocPrint = 0;
1.81 cvs 701: DocPrintURL = NULL;
1.1 cvs 702:
703: /* read default printer variable */
1.52 cvs 704: ptr = TtaGetEnvString ("THOTPRINT");
1.1 cvs 705: if (ptr == NULL)
1.83 cvs 706: strcpy (PPrinter, "");
1.1 cvs 707: else
1.83 cvs 708: strcpy (PPrinter, ptr);
1.81 cvs 709: TtaSetPrintCommand (PPrinter);
1.2 cvs 710: PaperPrint = PP_PRINTER;
1.81 cvs 711: TtaSetPrintParameter (PP_Destination, PaperPrint);
712:
713: /* define the new default PrintSchema */
714: NumberLinks = FALSE;
715: WithToC = FALSE;
716: IgnoreCSS = FALSE;
1.53 cvs 717: PrintURL = TRUE;
1.81 cvs 718: PageSize = TtaGetPrintParameter (PP_PaperSize);
1.82 cvs 719: TtaSetPrintSchema ("");
1.81 cvs 720: /* no manual feed */
721: ManualFeed = PP_OFF;
722: TtaSetPrintParameter (PP_ManualFeed, ManualFeed);
723: PagePerSheet = 1;
724: TtaSetPrintParameter (PP_PagesPerSheet, PagePerSheet);
1.1 cvs 725: }
726:
727: /*----------------------------------------------------------------------
1.3 cvs 728: SetupAndPrint sets printing parameters and starts the printing process
1.1 cvs 729: ----------------------------------------------------------------------*/
1.91 vatton 730: void SetupAndPrint (Document doc, View view)
1.1 cvs 731: {
1.107 carcone 732: #ifdef _GTK
1.83 cvs 733: char bufMenu[MAX_LENGTH];
1.91 vatton 734: int i;
1.107 carcone 735: #endif /* _GTK */
1.91 vatton 736: ThotBool textFile;
1.38 cvs 737:
1.81 cvs 738: textFile = (DocumentTypes[doc] == docText || DocumentTypes[doc] == docCSS);
739: /* Print form */
740: CheckPrintingDocument (doc);
1.27 cvs 741:
1.107 carcone 742: #ifdef _GTK
1.81 cvs 743: TtaNewSheet (BasePrint + FormPrint, TtaGetViewFrame (doc, view),
744: TtaGetMessage (LIB, TMSG_LIB_PRINT), 1,
1.127 gully 745: TtaGetMessage (LIB, TMSG_BUTTON_PRINT), FALSE, 3, 'L', D_CANCEL);
1.81 cvs 746:
747: /* Paper format submenu */
748: i = 0;
749: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_A4));
1.83 cvs 750: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 751: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_US));
752: TtaNewSubmenu (BasePrint + PaperFormat, BasePrint + FormPrint, 0,
1.109 vatton 753: TtaGetMessage (LIB, TMSG_PAPER_SIZE), 2, bufMenu, NULL, 0, TRUE);
1.81 cvs 754: if (PageSize == PP_US)
755: TtaSetMenuForm (BasePrint + PaperFormat, 1);
756: else
757: TtaSetMenuForm (BasePrint + PaperFormat, 0);
758:
759: /* Orientation submenu */
760: i = 0;
761: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (AMAYA, AM_PORTRAIT));
1.83 cvs 762: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 763: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (AMAYA, AM_LANDSCAPE));
764: TtaNewSubmenu (BasePrint + PaperOrientation, BasePrint + FormPrint, 0,
1.109 vatton 765: TtaGetMessage (AMAYA, AM_ORIENTATION), 2, bufMenu, NULL, 0, TRUE);
1.81 cvs 766: if (Orientation == PP_Landscape)
767: TtaSetMenuForm (BasePrint + PaperOrientation, 1);
768: else
769: TtaSetMenuForm (BasePrint + PaperOrientation, 0);
770: /* Pages per sheet submenu */
771: i = 0;
772: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_1_PAGE_SHEET));
1.83 cvs 773: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 774: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_2_PAGE_SHEET));
1.83 cvs 775: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 776: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_4_PAGE_SHEET));
777: TtaNewSubmenu (BasePrint + PPagesPerSheet, BasePrint + FormPrint, 0,
1.109 vatton 778: TtaGetMessage (LIB, TMSG_REDUCTION), 3, bufMenu, NULL, 0, TRUE);
1.81 cvs 779: if (PagePerSheet == 1)
780: TtaSetMenuForm (BasePrint + PPagesPerSheet, 0);
781: else if (PagePerSheet == 2)
782: TtaSetMenuForm (BasePrint + PPagesPerSheet, 1);
783: else
784: TtaSetMenuForm (BasePrint + PPagesPerSheet, 2);
785:
786: /* Print to paper/ Print to file submenu */
787: i = 0;
788: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_PRINTER));
1.83 cvs 789: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 790: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_PS_FILE));
791: TtaNewSubmenu (BasePrint + PrintSupport, BasePrint + FormPrint, 0,
1.109 vatton 792: TtaGetMessage (LIB, TMSG_OUTPUT), 2, bufMenu, NULL, 0, TRUE);
1.81 cvs 793:
794: /* PaperPrint selector */
795: TtaNewTextForm (BasePrint + PPrinterName, BasePrint + FormPrint, NULL, 30, 1, TRUE);
796: if (PaperPrint == PP_PRINTER)
797: {
798: TtaSetMenuForm (BasePrint + PrintSupport, 0);
799: TtaSetTextForm (BasePrint + PPrinterName, PPrinter);
800: }
801: else
802: {
803: TtaSetMenuForm (BasePrint + PrintSupport, 1);
804: TtaSetTextForm (BasePrint + PPrinterName, PSfile);
805: }
1.1 cvs 806:
1.81 cvs 807: /* The toggle */
808: i = 0;
809: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (LIB, TMSG_MANUAL_FEED));
1.83 cvs 810: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 811: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_PRINT_TOC));
1.83 cvs 812: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 813: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_NUMBERED_LINKS));
1.83 cvs 814: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 815: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_PRINT_URL));
1.83 cvs 816: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 817: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_WITH_CSS));
818: TtaNewToggleMenu (BasePrint + PrintOptions, BasePrint + FormPrint,
819: TtaGetMessage (LIB, TMSG_OPTIONS), 5, bufMenu, NULL, FALSE);
820: if (ManualFeed == PP_ON)
821: TtaSetToggleMenu (BasePrint + PrintOptions, 0, TRUE);
822: else
823: TtaSetToggleMenu (BasePrint + PrintOptions, 0, FALSE);
824: TtaSetToggleMenu (BasePrint + PrintOptions, 1, WithToC);
825: TtaSetToggleMenu (BasePrint + PrintOptions, 2, NumberLinks);
826: TtaSetToggleMenu (BasePrint + PrintOptions, 3, PrintURL);
827: TtaSetToggleMenu (BasePrint + PrintOptions, 4, IgnoreCSS);
828:
829: /* activates the Print form */
830: TtaShowDialogue (BasePrint+FormPrint, FALSE);
831: if (textFile)
832: {
833: /* invalid dialogue entries */
1.102 gully 834: TtaRedrawMenuEntry (BasePrint + PrintOptions, 1, NULL, (ThotColor)-1, FALSE);
835: TtaRedrawMenuEntry (BasePrint + PrintOptions, 2, NULL, (ThotColor)-1, FALSE);
1.81 cvs 836: }
1.107 carcone 837: #endif /* _GTK */
838: #ifdef _WINGUI
1.81 cvs 839: CreatePrintDlgWindow (TtaGetViewFrame (doc, view), PSfile);
1.103 cvs 840: #endif /* _WINGUI */
1.107 carcone 841: #ifdef _WX
1.108 gully 842: {
1.125 gully 843: int paper_format;
844: int orientation;
845: int disposition;
846: int paper_print;
1.128 cvs 847: ThotBool manual_feed;
848: ThotBool with_toc;
849: ThotBool with_links;
850: ThotBool with_url;
851: ThotBool ignore_css;
1.125 gully 852:
853: /* Paper format submenu */
854: if (PageSize == PP_US)
855: paper_format = 1;
856: else
857: paper_format = 0;
858:
859: /* Orientation submenu */
860: if (Orientation == PP_Landscape)
861: orientation = 1;
862: else
863: orientation = 0;
864:
865: /* Pages per sheet submenu */
866: if (PagePerSheet == 1)
867: disposition = 0;
868: else if (PagePerSheet == 2)
869: disposition = 1;
870: else
871: disposition = 2;
872:
873: /* PaperPrint selector */
874: if (PaperPrint == PP_PRINTER)
875: paper_print = 0;
876: else
877: paper_print = 1;
878:
879: /* The toggle */
880: manual_feed = (ManualFeed == PP_ON);
881: with_toc = WithToC;
882: with_links = NumberLinks;
883: with_url = PrintURL;
884: ignore_css = IgnoreCSS;
885:
886: /* The dialog creation */
1.108 gully 887: ThotBool created;
1.125 gully 888: created = CreatePrintDlgWX (BasePrint + FormPrint, TtaGetViewFrame (doc, view),
889: PPrinter,
890: PSfile,
891: paper_format,
892: orientation,
893: disposition,
894: paper_print,
895: manual_feed,
896: with_toc,
897: with_links,
898: with_url,
899: ignore_css);
1.108 gully 900: if (created)
901: {
902: TtaShowDialogue (BasePrint+FormPrint, FALSE);
903: }
904: }
905:
1.107 carcone 906: #endif /* _WX */
1.1 cvs 907: }
908:
909: /*----------------------------------------------------------------------
910: UpdateURLsInSubtree
911: Update NAMEs and URLs in subtree of el element, to take into account
912: the move from one document to another.
913: If a NAME attribute already exists in the new document, it is changed
914: to avoid duplicate names.
915: Transform the HREF and SRC attribute to make them independent from their
916: former base.
917: ----------------------------------------------------------------------*/
1.99 cvs 918: void UpdateURLsInSubtree (NotifyElement *event, Element el)
1.1 cvs 919: {
1.77 cvs 920: Element nextEl, child;
921: ElementType elType;
922: SSchema HTMLschema;
1.1 cvs 923:
924: nextEl = TtaGetFirstChild (el);
1.82 cvs 925: HTMLschema = TtaGetSSchema ("HTML", event->document);
1.99 cvs 926: if (HTMLschema)
1.1 cvs 927: {
1.99 cvs 928: elType.ElSSchema = HTMLschema;
929: while (nextEl != NULL)
1.77 cvs 930: {
1.99 cvs 931: event->element = nextEl;
1.77 cvs 932: ElementPasted (event);
1.99 cvs 933:
934: /* manage included links and anchors */
935: elType.ElTypeNum = HTML_EL_Anchor;
936: child = TtaSearchTypedElement (elType, SearchInTree, nextEl);
937: while (child)
938: {
939: event->element = child;
940: ElementPasted (event);
941: child = TtaSearchTypedElementInTree (elType, SearchForward, nextEl, child);
942: }
943:
944: /* manage included links and anchors */
945: elType.ElTypeNum = HTML_EL_PICTURE_UNIT;
946: child = TtaSearchTypedElement (elType, SearchInTree, nextEl);
947: while (child)
948: {
949: event->element = child;
950: ElementPasted (event);
951: child = TtaSearchTypedElementInTree (elType, SearchForward, nextEl, child);
952: }
953: TtaNextSibling (&nextEl);
1.77 cvs 954: }
1.1 cvs 955: }
956: }
957:
958:
959: /*----------------------------------------------------------------------
960: MoveDocumentBody
1.58 cvs 961: Copy the elements contained in the BODY of the document sourceDoc at the
962: position of the element el in the document destDoc.
963: Delete the element containing el and all its empty ancestors.
1.1 cvs 964: If deleteTree is TRUE, copied elements are deleted from the source
965: document.
1.58 cvs 966: Return the root element that delimits the new inserted part (a div).
1.1 cvs 967: ----------------------------------------------------------------------*/
1.80 cvs 968: static Element MoveDocumentBody (Element el, Document destDoc,
1.85 cvs 969: Document sourceDoc, char *target,
970: char *url, ThotBool deleteTree)
1.1 cvs 971: {
1.58 cvs 972: Element root, ancestor, elem, firstInserted, div;
1.12 cvs 973: Element lastInserted, srce, copy, old, parent, sibling;
974: ElementType elType;
975: NotifyElement event;
1.124 vatton 976: ThotBool checkingMode;
1.47 cvs 977: ThotBool isID;
1.1 cvs 978:
1.67 cvs 979: div = NULL;
1.13 cvs 980: if (target != NULL)
981: {
982: /* locate the target element within the source document */
1.98 vatton 983: root = SearchNAMEattribute (sourceDoc, target, NULL, NULL);
1.13 cvs 984: elType = TtaGetElementType (root);
1.84 cvs 985: isID = (elType.ElTypeNum != HTML_EL_Anchor &&
986: elType.ElTypeNum != HTML_EL_MAP);
1.13 cvs 987: }
988: else
989: {
990: isID = FALSE;
991: /* get the BODY element of source document */
992: root = TtaGetMainRoot (sourceDoc);
993: elType = TtaGetElementType (root);
994: elType.ElTypeNum = HTML_EL_BODY;
995: root = TtaSearchTypedElement (elType, SearchForward, root);
996: }
997:
998: if (root != NULL)
1.12 cvs 999: {
1000: /* don't check the abstract tree against the structure schema */
1001: checkingMode = TtaGetStructureChecking (destDoc);
1.124 vatton 1002: TtaSetStructureChecking (FALSE, destDoc);
1.58 cvs 1003: /* get elem, the ancestor of el which is a child of a DIV or BODY
1.12 cvs 1004: element in the destination document. The copied elements will be
1005: inserted just before this element. */
1.58 cvs 1006: elem = el;
1.12 cvs 1007: do
1.1 cvs 1008: {
1.12 cvs 1009: ancestor = TtaGetParent (elem);
1010: if (ancestor != NULL)
1011: {
1012: elType = TtaGetElementType (ancestor);
1013: if (elType.ElTypeNum == HTML_EL_BODY ||
1014: elType.ElTypeNum == HTML_EL_Division)
1015: ancestor = NULL;
1016: else
1017: elem = ancestor;
1018: }
1.1 cvs 1019: }
1.12 cvs 1020: while (ancestor != NULL);
1021: parent = TtaGetParent (elem);
1.14 cvs 1022:
1023: /* insert a DIV element */
1.15 cvs 1024: elType.ElTypeNum = HTML_EL_Division;
1.16 cvs 1025: lastInserted = TtaNewElement (destDoc, elType);
1026: TtaInsertSibling (lastInserted, elem, TRUE, destDoc);
1.58 cvs 1027: /* this delimits the new inserted part of the document */
1.16 cvs 1028: RegisterSubDoc (lastInserted, url);
1.76 kahan 1029: CreateTargetAnchor (destDoc, lastInserted, FALSE, FALSE);
1.58 cvs 1030: div = lastInserted;
1.14 cvs 1031:
1.12 cvs 1032: /* do copy */
1.16 cvs 1033: firstInserted = NULL;
1.17 cvs 1034: if (isID)
1035: srce = root;
1036: else
1037: srce = TtaGetFirstChild (root);
1.12 cvs 1038: while (srce != NULL)
1.1 cvs 1039: {
1.12 cvs 1040: copy = TtaCopyTree (srce, sourceDoc, destDoc, parent);
1041: if (copy != NULL)
1042: {
1.16 cvs 1043: if (firstInserted == NULL)
1.12 cvs 1044: /* this is the first copied element. Insert it before elem */
1045: {
1.16 cvs 1046: TtaInsertFirstChild (©, lastInserted, destDoc);
1.12 cvs 1047: firstInserted = copy;
1048: }
1049: else
1050: /* insert the new copied element after the element previously
1051: copied */
1052: TtaInsertSibling (copy, lastInserted, FALSE, destDoc);
1053: lastInserted = copy;
1054: /* update the NAMEs and URLs in the copied element */
1.100 quint 1055: event.event = TteElemPaste;
1.12 cvs 1056: event.document = destDoc;
1.100 quint 1057: event.element = copy;
1058: event.elementType = TtaGetElementType (copy);
1.12 cvs 1059: event.position = sourceDoc;
1.100 quint 1060: event.info = 0;
1.12 cvs 1061: UpdateURLsInSubtree(&event, copy);
1062: }
1063: /* get the next element in the source document */
1064: old = srce;
1065: TtaNextSibling (&srce);
1066: if (deleteTree)
1067: TtaDeleteTree (old, sourceDoc);
1.13 cvs 1068: /* Stop here if the target points to a specific element with an ID */
1069: if (isID)
1070: srce = NULL;
1.1 cvs 1071: }
1.12 cvs 1072:
1073: /* delete the element(s) containing the link to the copied document */
1.58 cvs 1074: /* delete the parent element of el and all empty ancestors */
1075: elem = TtaGetParent (el);
1.12 cvs 1076: do
1.1 cvs 1077: {
1.12 cvs 1078: sibling = elem;
1079: TtaNextSibling (&sibling);
1080: if (sibling == NULL)
1081: {
1082: sibling = elem;
1083: TtaPreviousSibling (&sibling);
1084: if (sibling == NULL)
1085: elem = TtaGetParent (elem);
1086: }
1.1 cvs 1087: }
1.12 cvs 1088: while (sibling == NULL);
1089: TtaDeleteTree (elem, destDoc);
1090: /* restore previous chacking mode */
1.124 vatton 1091: TtaSetStructureChecking (checkingMode, destDoc);
1.12 cvs 1092: }
1.58 cvs 1093: /* return the address of the new division */
1094: return (div);
1.1 cvs 1095: }
1096:
1.29 cvs 1097:
1.58 cvs 1098: /*----------------------------------------------------------------------
1099: CloseMakeBook
1100: ----------------------------------------------------------------------*/
1101: static void CloseMakeBook (Document document)
1102: {
1103: ResetStop (document);
1104: /* update internal links */
1105: SetInternalLinks (document);
1106: /* if the document changed force the browser mode */
1.128 cvs 1107: if (SubDocs == NULL)
1108: /* send a warning to the user to avoid to save this document */
1109: /* remove registered sub-documents */
1110: FreeSubDocTable ();
1.58 cvs 1111: DocBook = 0;
1112: TtaSetStatus (document, 1, TtaGetMessage (AMAYA, AM_DOCUMENT_LOADED), NULL);
1113: }
1114:
1115:
1116: /*----------------------------------------------------------------------
1117: GetIncludedDocuments_callback finishes the GetIncludedDocuments procedure
1118: ----------------------------------------------------------------------*/
1119: void GetIncludedDocuments_callback (int newdoc, int status,
1.85 cvs 1120: char *urlName,
1121: char *outputfile,
1.63 cvs 1122: AHTHeaders *http_headers,
1.58 cvs 1123: void * context)
1.29 cvs 1124: {
1.58 cvs 1125: Element link, div;
1126: IncludeCtxt *ctx, *prev;
1.104 vatton 1127: char *utf8path, *ptr;
1.58 cvs 1128: ThotBool found = FALSE;
1.29 cvs 1129:
1130: /* restore GetIncludedDocuments's context */
1.58 cvs 1131: ctx = (IncludeCtxt *) context;
1.29 cvs 1132: if (!ctx)
1133: return;
1134:
1.58 cvs 1135: div = NULL;
1.29 cvs 1136: link = ctx->link;
1.58 cvs 1137: ptr = ctx->name;
1.104 vatton 1138: utf8path = ctx->utf8path;
1139: if (utf8path)
1.29 cvs 1140: {
1.58 cvs 1141: if (newdoc && newdoc != DocBook)
1.29 cvs 1142: {
1.58 cvs 1143: /* it's not the DocBook itself */
1144: /* copy the target document at the position of the link */
1145: TtaSetDocumentModified (DocBook);
1.104 vatton 1146: div = MoveDocumentBody (link, DocBook, newdoc, ptr, utf8path,
1.58 cvs 1147: (ThotBool)(newdoc == IncludedDocument));
1.29 cvs 1148: }
1.58 cvs 1149: /* global variables */
1150: FreeDocumentResource (IncludedDocument);
1151: TtaCloseDocument (IncludedDocument);
1152: IncludedDocument = 0;
1.29 cvs 1153: }
1.58 cvs 1154:
1.104 vatton 1155: if (div)
1.29 cvs 1156: {
1.58 cvs 1157: /* new starting point for the search */
1158: ctx->link = div;
1159: found = GetIncludedDocuments (div, div, DocBook, ctx);
1.29 cvs 1160: }
1.104 vatton 1161:
1.58 cvs 1162: while (!found && ctx)
1163: {
1164: /* this sub-document has no more inclusion, examine the caller */
1165: div = ctx->div;
1166: link = ctx->link;
1167: prev = ctx->ctxt;
1.104 vatton 1168: TtaFreeMemory (utf8path);
1169: utf8path = NULL;
1.58 cvs 1170: TtaFreeMemory (ctx);
1171: ctx = prev;
1172: found = GetIncludedDocuments (div, link, DocBook, ctx);
1173: }
1174: if (!found)
1175: /* all links are now managed */
1176: CloseMakeBook (DocBook);
1.29 cvs 1177: }
1178:
1.1 cvs 1179: /*----------------------------------------------------------------------
1180: GetIncludedDocuments
1.58 cvs 1181: Look forward within the element el, starting from element link, for a
1182: link (A) with attribute rel="chapter" or rel="subdocument" and replace
1183: that link by the contents of the target document.
1184: Return TRUE if one inclusion is launched.
1.1 cvs 1185: ----------------------------------------------------------------------*/
1.96 vatton 1186: static ThotBool GetIncludedDocuments (Element el, Element link,
1187: Document doc, IncludeCtxt *prev)
1.1 cvs 1188: {
1.58 cvs 1189: ElementType elType;
1190: Attribute attr;
1191: AttributeType attrType;
1192: Document newdoc;
1193: IncludeCtxt *ctx = NULL;
1.104 vatton 1194: char *utf8path, *ptr;
1.29 cvs 1195: int length;
1.58 cvs 1196: ThotBool found = FALSE;
1.29 cvs 1197:
1.58 cvs 1198: /* look for anchors with the attribute rel within the element el */
1199: attr = NULL;
1.96 vatton 1200: attrType.AttrSSchema = TtaGetSSchema ("HTML", doc);
1.58 cvs 1201: elType.ElSSchema = attrType.AttrSSchema;
1202: elType.ElTypeNum = HTML_EL_Anchor;
1.29 cvs 1203:
1.58 cvs 1204: /* Get only one included file each time */
1205: while (link && attr == NULL)
1.29 cvs 1206: {
1.58 cvs 1207: link = TtaSearchTypedElementInTree (elType, SearchForward, el, link);
1208: if (link)
1.29 cvs 1209: {
1.58 cvs 1210: attrType.AttrTypeNum = HTML_ATTR_REL;
1211: attr = TtaGetAttribute (link, attrType);
1212: }
1213: if (attr)
1214: {
1215: length = TtaGetTextAttributeLength (attr);
1.104 vatton 1216: utf8path = (char *)TtaGetMemory (length + 1);
1217: TtaGiveTextAttributeValue (attr, utf8path, &length);
1.58 cvs 1218: /* Valid rel values are rel="chapter" or rel="subdocument" */
1.104 vatton 1219: if (strcasecmp (utf8path, "chapter") &&
1220: strcasecmp (utf8path, "subdocument"))
1.58 cvs 1221: attr = NULL;
1.104 vatton 1222: TtaFreeMemory (utf8path);
1.29 cvs 1223: }
1.58 cvs 1224:
1225: if (attr)
1226: {
1227: /* a link with attribute rel="Chapter" has been found */
1228: attrType.AttrTypeNum = HTML_ATTR_HREF_;
1229: attr = TtaGetAttribute (link, attrType);
1230: }
1231: if (attr)
1232: /* this link has an attribute HREF */
1233: {
1234: length = TtaGetTextAttributeLength (attr);
1.104 vatton 1235: utf8path = (char *)TtaGetMemory (length + 1);
1236: TtaGiveTextAttributeValue (attr, utf8path, &length);
1237: ptr = strrchr (utf8path, '#');
1238: if (ptr)
1.58 cvs 1239: {
1.104 vatton 1240: /* link to a particular position within a document */
1241: if (ptr == utf8path)
1242: {
1243: /* local link */
1244: TtaFreeMemory (utf8path);
1245: utf8path = NULL;
1246: }
1247: else
1248: {
1249: ptr[0] = EOS;
1250: ptr = &ptr[1];
1251: }
1.58 cvs 1252: }
1253:
1.104 vatton 1254: if (utf8path)
1.58 cvs 1255: /* this link designates an external document */
1256: {
1257: /* create a new document and loads the target document */
1.82 cvs 1258: IncludedDocument = TtaNewDocument ("HTML", "tmp");
1.58 cvs 1259: if (IncludedDocument != 0)
1260: {
1.104 vatton 1261: TtaSetStatus (doc, 1, TtaGetMessage (AMAYA, AM_FETCHING), utf8path);
1.101 gully 1262: ctx = (IncludeCtxt *)TtaGetMemory (sizeof (IncludeCtxt));
1.58 cvs 1263: ctx->div = el;
1264: ctx->link = link;
1.104 vatton 1265: ctx->utf8path = utf8path; /* the URL of the document */
1.58 cvs 1266: ctx->name = ptr;
1267: ctx->ctxt = prev; /* previous context */
1268: /* Get the reference of the calling document */
1.96 vatton 1269: SetStopButton (doc);
1.104 vatton 1270: newdoc = GetAmayaDoc (utf8path, NULL, IncludedDocument,
1.96 vatton 1271: doc, CE_MAKEBOOK, FALSE,
1.101 gully 1272: (void (*)(int, int, char*, char*, const AHTHeaders*, void*)) GetIncludedDocuments_callback,
1.104 vatton 1273: (void *) ctx);
1.58 cvs 1274: found = TRUE;
1275: }
1276: }
1277: else
1.104 vatton 1278: TtaFreeMemory (utf8path);
1.58 cvs 1279: }
1.29 cvs 1280: }
1.58 cvs 1281: return (found);
1.1 cvs 1282: }
1283:
1284:
1285: /*----------------------------------------------------------------------
1286: MakeBook
1287: Replace all links in a document which have an attribute REL="chapter"
1.5 cvs 1288: or REL="subdocument" by the corresponding target document.
1.1 cvs 1289: ----------------------------------------------------------------------*/
1.96 vatton 1290: void MakeBook (Document doc, View view)
1.1 cvs 1291: {
1.58 cvs 1292: Element root, body;
1293: ElementType elType;
1.1 cvs 1294:
1.58 cvs 1295: /* stops all current transfers on this document */
1.96 vatton 1296: StopTransfer (doc, 1);
1.58 cvs 1297: /* simulate a transfert in the main document */
1.96 vatton 1298: DocBook = doc;
1.58 cvs 1299: IncludedDocument = 0;
1.96 vatton 1300: root = TtaGetMainRoot (doc);
1.58 cvs 1301: elType = TtaGetElementType (root);
1302: elType.ElTypeNum = HTML_EL_BODY;
1303: body = TtaSearchTypedElement (elType, SearchForward, root);
1.29 cvs 1304:
1.58 cvs 1305: if (body)
1.96 vatton 1306: GetIncludedDocuments (body, body, doc, NULL);
1.1 cvs 1307: }
1.105 vatton 1308:
1309: /*----------------------------------------------------------------------
1310: ----------------------------------------------------------------------*/
1311: void ReadAsUTF_8 (Document doc, View view)
1312: {
1313: ReparseAs (doc, view, FALSE, UTF_8);
1314: }
1315:
1316: /*----------------------------------------------------------------------
1317: ----------------------------------------------------------------------*/
1318: void ReadAsISO_8859_1 (Document doc, View view)
1319: {
1320: ReparseAs (doc, view, FALSE, ISO_8859_1);
1321: }
1322:
1323: /*----------------------------------------------------------------------
1324: ----------------------------------------------------------------------*/
1325: void ReadAsISO_8859_2 (Document doc, View view)
1326: {
1327: ReparseAs (doc, view, FALSE, ISO_8859_2);
1328: }
1329:
1330: /*----------------------------------------------------------------------
1331: ----------------------------------------------------------------------*/
1332: void ReadAsISO_8859_3 (Document doc, View view)
1333: {
1334: ReparseAs (doc, view, FALSE, ISO_8859_3);
1335: }
1336:
1337: /*----------------------------------------------------------------------
1338: ----------------------------------------------------------------------*/
1339: void ReadAsISO_8859_4 (Document doc, View view)
1340: {
1341: ReparseAs (doc, view, FALSE, ISO_8859_4);
1342: }
1343:
1344: /*----------------------------------------------------------------------
1345: ----------------------------------------------------------------------*/
1346: void ReadAsISO_8859_5 (Document doc, View view)
1347: {
1348: ReparseAs (doc, view, FALSE, ISO_8859_5);
1349: }
1350:
1351: /*----------------------------------------------------------------------
1352: ----------------------------------------------------------------------*/
1353: void ReadAsISO_8859_6 (Document doc, View view)
1354: {
1355: ReparseAs (doc, view, FALSE, ISO_8859_6);
1356: }
1357:
1358: /*----------------------------------------------------------------------
1359: ----------------------------------------------------------------------*/
1360: void ReadAsISO_8859_7 (Document doc, View view)
1361: {
1362: ReparseAs (doc, view, FALSE, ISO_8859_7);
1363: }
1364:
1365: /*----------------------------------------------------------------------
1366: ----------------------------------------------------------------------*/
1367: void ReadAsISO_8859_8 (Document doc, View view)
1368: {
1369: ReparseAs (doc, view, FALSE, ISO_8859_8);
1370: }
1371:
1372: /*----------------------------------------------------------------------
1373: ----------------------------------------------------------------------*/
1374: void ReadAsISO_8859_9 (Document doc, View view)
1375: {
1376: ReparseAs (doc, view, FALSE, ISO_8859_9);
1377: }
1378:
1379: /*----------------------------------------------------------------------
1380: ----------------------------------------------------------------------*/
1381: void ReadAsISO_8859_15 (Document doc, View view)
1382: {
1383: ReparseAs (doc, view, FALSE, ISO_8859_15);
1384: }
1385:
1386: /*----------------------------------------------------------------------
1387: ----------------------------------------------------------------------*/
1388: void ReadAsKOI8_R (Document doc, View view)
1389: {
1390: ReparseAs (doc, view, FALSE, KOI8_R);
1391: }
1392:
1393: /*----------------------------------------------------------------------
1394: ----------------------------------------------------------------------*/
1395: void ReadAsWINDOWS_1250 (Document doc, View view)
1396: {
1397: ReparseAs (doc, view, FALSE, WINDOWS_1250);
1398: }
1399:
1400: /*----------------------------------------------------------------------
1401: ----------------------------------------------------------------------*/
1402: void ReadAsWINDOWS_1251 (Document doc, View view)
1403: {
1404: ReparseAs (doc, view, FALSE, WINDOWS_1251);
1405: }
1406:
1407: /*----------------------------------------------------------------------
1408: ----------------------------------------------------------------------*/
1409: void ReadAsWINDOWS_1252 (Document doc, View view)
1410: {
1411: ReparseAs (doc, view, FALSE, WINDOWS_1252);
1412: }
1413:
1414: /*----------------------------------------------------------------------
1415: ----------------------------------------------------------------------*/
1416: void ReadAsWINDOWS_1253 (Document doc, View view)
1417: {
1418: ReparseAs (doc, view, FALSE, WINDOWS_1253);
1419: }
1420:
1421: /*----------------------------------------------------------------------
1422: ----------------------------------------------------------------------*/
1423: void ReadAsWINDOWS_1254 (Document doc, View view)
1424: {
1425: ReparseAs (doc, view, FALSE, WINDOWS_1254);
1426: }
1427:
1428: /*----------------------------------------------------------------------
1429: ----------------------------------------------------------------------*/
1430: void ReadAsWINDOWS_1255 (Document doc, View view)
1431: {
1432: ReparseAs (doc, view, FALSE, WINDOWS_1255);
1433: }
1434:
1435: /*----------------------------------------------------------------------
1436: ----------------------------------------------------------------------*/
1437: void ReadAsWINDOWS_1256 (Document doc, View view)
1438: {
1439: ReparseAs (doc, view, FALSE, WINDOWS_1256);
1440: }
1441:
1442: /*----------------------------------------------------------------------
1443: ----------------------------------------------------------------------*/
1444: void ReadAsWINDOWS_1257 (Document doc, View view)
1445: {
1446: ReparseAs (doc, view, FALSE, WINDOWS_1257);
1447: }
1448:
1449: /*----------------------------------------------------------------------
1450: ----------------------------------------------------------------------*/
1451: void ReadAsISO_2022_JP (Document doc, View view)
1452: {
1453: ReparseAs (doc, view, FALSE, ISO_2022_JP);
1454: }
1455:
1456: /*----------------------------------------------------------------------
1457: ----------------------------------------------------------------------*/
1458: void ReadAsEUC_JP (Document doc, View view)
1459: {
1460: ReparseAs (doc, view, FALSE, EUC_JP);
1461: }
1462:
1463: /*----------------------------------------------------------------------
1464: ----------------------------------------------------------------------*/
1465: void ReadAsSHIFT_JIS (Document doc, View view)
1466: {
1467: ReparseAs (doc, view, FALSE, SHIFT_JIS);
1468: }
1.114 vatton 1469:
1470: /*----------------------------------------------------------------------
1.119 vatton 1471: SectionNumbering generates numbers for all HTML Hi elements after
1472: the current position.
1473: ----------------------------------------------------------------------*/
1474: void SectionNumbering (Document doc, View view)
1475: {
1.120 vatton 1476: Element el, new_, child;
1477: DisplayMode dispMode;
1478: SSchema HTMLschema;
1479: ElementType elType, childType, searchedType1, searchedType2;
1480: ElementType searchedType3, searchedType4, searchedType5;
1481: Language lang;
1482: char s[MAX_LENGTH], n[20], *text;
1483: int nH2, nH3, nH4, nH5, nH6, length, i;
1.123 vatton 1484: ThotBool closeUndo, change = FALSE;
1.120 vatton 1485:
1486: /* check if there is HTML Hi elements and if the current position is
1487: within a HTML Body element */
1488: dispMode = TtaGetDisplayMode (doc);
1489:
1490: /* check if there is any HTML element within the document */
1491: HTMLschema = TtaGetSSchema ("HTML", doc);
1492: if (HTMLschema == NULL)
1493: /* no HTML element */
1494: return;
1495:
1496: if (TtaPrepareUndo (doc))
1497: closeUndo = FALSE;
1498: else
1499: {
1500: closeUndo = TRUE;
1501: TtaOpenUndoSequence (doc, NULL, NULL, 0, 0);
1502: }
1503:
1504: el = TtaGetMainRoot (doc);
1505: searchedType1.ElSSchema = HTMLschema;
1506: searchedType1.ElTypeNum = HTML_EL_H2;
1507: searchedType2.ElSSchema = HTMLschema;
1508: searchedType2.ElTypeNum = HTML_EL_H3;
1509: searchedType3.ElSSchema = HTMLschema;
1510: searchedType3.ElTypeNum = HTML_EL_H4;
1511: searchedType4.ElSSchema = HTMLschema;
1512: searchedType4.ElTypeNum = HTML_EL_H5;
1513: searchedType5.ElSSchema = HTMLschema;
1514: searchedType5.ElTypeNum = HTML_EL_H6;
1515: nH2 = nH3 = nH4 = nH5 = nH6 = 0;
1516: while (el)
1517: {
1518: el = TtaSearchElementAmong5Types (searchedType1, searchedType2,
1519: searchedType3, searchedType4,
1520: searchedType5, SearchForward, el);
1521: if (el)
1522: {
1523: /* generate the text number */
1524: elType = TtaGetElementType (el);
1525: s[0] = EOS;
1526: switch (elType.ElTypeNum)
1527: {
1528: case HTML_EL_H2:
1529: nH2++;
1530: nH3 = nH4 = nH5 = nH6 = 0;
1531: sprintf (s, "%d.", nH2);
1532: break;
1533: case HTML_EL_H3:
1534: nH3++;
1535: nH4 = nH5 = nH6 = 0;
1536: if (nH2)
1537: sprintf (s, "%d.", nH2);
1538: sprintf (n, "%d.", nH3);
1539: strcat (s, n);
1540: break;
1541: case HTML_EL_H4:
1542: nH4++;
1543: nH5 = nH6 = 0;
1544: if (nH2)
1545: sprintf (s, "%d.", nH2);
1546: if (nH3)
1547: {
1548: sprintf (n, "%d.", nH3);
1549: strcat (s, n);
1550: }
1551: sprintf (n, "%d.", nH4);
1552: strcat (s, n);
1553: break;
1554: case HTML_EL_H5:
1555: nH5++;
1556: nH6 = 0;
1557: if (nH2)
1558: sprintf (s, "%d.", nH2);
1559: if (nH3)
1560: {
1561: sprintf (n, "%d.", nH3);
1562: strcat (s, n);
1563: }
1564: if (nH4)
1565: {
1566: sprintf (n, "%d.", nH4);
1567: strcat (s, n);
1568: }
1569: sprintf (n, "%d.", nH5);
1570: strcat (s, n);
1571: break;
1572: case HTML_EL_H6:
1573: nH6++;
1574: if (nH2)
1575: sprintf (s, "%d.", nH2);
1576: if (nH3)
1577: {
1578: sprintf (n, "%d.", nH3);
1579: strcat (s, n);
1580: }
1581: if (nH4)
1582: {
1583: sprintf (n, "%d.", nH4);
1584: strcat (s, n);
1585: }
1586: if (nH5)
1587: {
1588: sprintf (n, "%d.", nH5);
1589: strcat (s, n);
1590: }
1591: sprintf (n, "%d.", nH6);
1592: strcat (s, n);
1593: break;
1594: default: break;
1595: }
1596: strcat (s, " ");
1597:
1598: /* look for the first leaf child */
1599: child = el;
1600: if (child)
1601: {
1602: do
1603: {
1604: child = TtaGetFirstChild (child);
1605: childType = TtaGetElementType (child);
1606: }
1607: while (!TtaIsLeaf (childType) && childType.ElSSchema == HTMLschema);
1608: }
1609: if (child && childType.ElSSchema == HTMLschema &&
1610: childType.ElTypeNum == HTML_EL_TEXT_UNIT)
1611: {
1612: /* the first leaf child is a text unit */
1613: new_ = NULL;
1614: /* check the text contents */
1615: length = TtaGetTextLength (child) + 1;
1616: text = (char *)TtaGetMemory (length);
1617: TtaGiveTextContent (child, (unsigned char *)text, &length, &lang);
1618: /* remove the old number */
1619: i = 0;
1620: while (isdigit (text[i]) || text[i] == '.')
1621: i++;
1622: TtaRegisterElementReplace (child, doc);
1623: TtaSetTextContent (child, (unsigned char *)s, Latin_Script, doc);
1624: TtaAppendTextContent (child, (unsigned char *)&text[i], doc);
1.121 vatton 1625: TtaFreeMemory (text);
1.123 vatton 1626: change = TRUE;
1.120 vatton 1627: }
1628: else
1629: {
1630: /* add a new text element */
1631: elType.ElTypeNum = HTML_EL_TEXT_UNIT;
1632: new_ = TtaNewElement (doc, elType);
1633: if (child)
1634: /* insert before */
1635: TtaInsertSibling (new_, child, TRUE, doc);
1636: else
1637: TtaInsertFirstChild (&new_, el, doc);
1638: TtaSetTextContent (new_, (unsigned char *)s, Latin_Script, doc);
1639: TtaRegisterElementCreate (new_, doc);
1.123 vatton 1640: change = TRUE;
1.120 vatton 1641: }
1642: }
1643: }
1644:
1645: if (closeUndo)
1646: TtaCloseUndoSequence (doc);
1647: if (dispMode == DisplayImmediately)
1648: TtaSetDisplayMode (doc, dispMode);
1.123 vatton 1649: if (change)
1650: TtaSetDocumentModified (doc);
1.119 vatton 1651: }
1652:
1653: /*----------------------------------------------------------------------
1.114 vatton 1654: MakeToC generates a Table of Contents at the current position.
1655: Looks for all HTML Hi elements after the current position.
1656: ----------------------------------------------------------------------*/
1657: void MakeToc (Document doc, View view)
1658: {
1659: Element el, new_, *list, parent, copy, srce, child, prev;
1660: Element toc, lH2, lH3, lH4, lH5, lH6, item;
1661: ElementType elType, searchedType1, searchedType2;
1662: ElementType searchedType3, searchedType4, searchedType5;
1663: ElementType ulType, copyType;
1664: AttributeType attrType;
1665: Attribute attr;
1666: DisplayMode dispMode;
1667: char *s, *id;
1668: int firstChar, i;
1669: ThotBool closeUndo;
1670:
1671: /* check if there is HTML Hi elements and if the current position is
1672: within a HTML Body element */
1673: dispMode = TtaGetDisplayMode (doc);
1674:
1675: /* get the insert point */
1676: TtaGiveFirstSelectedElement (doc, &el, &firstChar, &i);
1677: if (el == NULL || TtaIsReadOnly (el))
1.117 vatton 1678: {
1679: /* no selection */
1680: TtaDisplaySimpleMessage (CONFIRM, AMAYA, AM_NO_INSERT_POINT);
1.118 cvs 1681: return;
1.117 vatton 1682: }
1.114 vatton 1683: elType = TtaGetElementType (el);
1684: s = TtaGetSSchemaName (elType.ElSSchema);
1685: if (strcmp (s, "HTML"))
1686: /* not within HTML element */
1687: return;
1688: if (!HTMLelementAllowed (doc))
1689: /* the creation of an HTML element is not allowed here */
1690: return;
1691:
1692: if (dispMode == DisplayImmediately)
1693: TtaSetDisplayMode (doc, SuspendDisplay);
1694:
1695: if (TtaPrepareUndo (doc))
1696: closeUndo = FALSE;
1697: else
1698: {
1699: closeUndo = TRUE;
1700: TtaOpenUndoSequence (doc, NULL, NULL, 0, 0);
1701: }
1702:
1703: attrType.AttrSSchema = elType.ElSSchema;
1704: ulType.ElSSchema = elType.ElSSchema;
1.115 vatton 1705: ulType.ElTypeNum = HTML_EL_Unnumbered_List;
1.114 vatton 1706: searchedType1.ElSSchema = elType.ElSSchema;
1707: searchedType1.ElTypeNum = HTML_EL_H2;
1708: searchedType2.ElSSchema = elType.ElSSchema;
1709: searchedType2.ElTypeNum = HTML_EL_H3;
1710: searchedType3.ElSSchema = elType.ElSSchema;
1711: searchedType3.ElTypeNum = HTML_EL_H4;
1712: searchedType4.ElSSchema = elType.ElSSchema;
1713: searchedType4.ElTypeNum = HTML_EL_H5;
1714: searchedType5.ElSSchema = elType.ElSSchema;
1715: searchedType5.ElTypeNum = HTML_EL_H6;
1.115 vatton 1716: toc = lH2 = lH3 = lH4 = lH5 = lH6 = prev = NULL;
1.114 vatton 1717: list = NULL;
1718: while (el)
1719: {
1720: el = TtaSearchElementAmong5Types (searchedType1, searchedType2,
1721: searchedType3, searchedType4,
1722: searchedType5, SearchForward, el);
1723: if (el)
1724: {
1725: if (toc == NULL)
1726: {
1727: /* genetate the enclosing division */
1728: elType.ElTypeNum = HTML_EL_Division;
1729: TtaCreateElement (elType, doc);
1730: TtaGiveFirstSelectedElement (doc, &child, &firstChar, &i);
1731: toc = TtaGetTypedAncestor (child, elType);
1732: TtaRegisterElementDelete (child, doc);
1733: TtaRemoveTree (child, doc);
1734: if (toc)
1735: {
1736: /* it's the last created element */
1737: attrType.AttrTypeNum = HTML_ATTR_Class;
1738: attr = TtaNewAttribute (attrType);
1739: TtaAttachAttribute (toc, attr, doc);
1740: TtaSetAttributeText (attr, "toc", toc, doc);
1741: TtaRegisterAttributeCreate (attr, toc, doc);
1742: }
1743: }
1744: if (toc == NULL)
1745: el = NULL;
1746: else
1747: {
1748: /* does the element have an ID attribute already? */
1749: attrType.AttrTypeNum = HTML_ATTR_ID;
1750: attr = TtaGetAttribute (el, attrType);
1751: if (!attr)
1752: {
1753: /* generate the ID if it does't exist */
1754: CreateTargetAnchor (doc, el, TRUE, TRUE);
1755: attr = TtaGetAttribute (el, attrType);
1756: }
1757: i = TtaGetTextAttributeLength (attr) + 1;
1758: id = (char *)TtaGetMemory (i + 1);
1759: id[0] = '#';
1760: TtaGiveTextAttributeValue (attr, &id[1], &i);
1761:
1762: /* locate or generate the list */
1763: elType = TtaGetElementType (el);
1764: if (elType.ElTypeNum == HTML_EL_H2)
1765: {
1766: parent = toc;
1767: lH3 = lH4 = lH5 = lH6 = NULL;
1768: list = &lH2;
1769: }
1770: else if (elType.ElTypeNum == HTML_EL_H3)
1771: {
1772: if (lH2)
1773: parent = TtaGetLastChild (lH2);
1774: else
1775: parent = toc;
1776: lH4 = lH5 = lH6 = NULL;
1777: list = &lH3;
1778: }
1779: else if (elType.ElTypeNum == HTML_EL_H4)
1780: {
1781: if (lH3)
1782: parent = TtaGetLastChild (lH3);
1783: else if (lH2)
1784: parent = TtaGetLastChild (lH2);
1785: else
1786: parent = toc;
1787: lH5 = lH6 = NULL;
1788: list = &lH4;
1789: }
1790: else if (elType.ElTypeNum == HTML_EL_H5)
1791: {
1792: if (lH4)
1793: parent = TtaGetLastChild (lH4);
1794: else if (lH3)
1795: parent = TtaGetLastChild (lH3);
1796: else if (lH2)
1797: parent = TtaGetLastChild (lH2);
1798: else
1799: parent = toc;
1800: lH6 = NULL;
1801: list = &lH5;
1802: }
1803: else if (elType.ElTypeNum == HTML_EL_H6)
1804: {
1805: if (lH5)
1806: parent = TtaGetLastChild (lH5);
1807: else if (lH4)
1808: parent = TtaGetLastChild (lH4);
1809: else if (lH3)
1810: parent = TtaGetLastChild (lH3);
1811: else if (lH2)
1812: parent = TtaGetLastChild (lH2);
1813: else
1814: parent = toc;
1815: list = &lH6;
1816: }
1817:
1818: if (*list == NULL)
1819: {
1820: /* generate the list */
1821: *list = TtaNewElement (doc, ulType);
1822: child = TtaGetLastChild (parent);
1823: if (child)
1824: TtaInsertSibling (*list, child, FALSE, doc);
1825: else
1826: TtaInsertFirstChild (list, parent, doc);
1827: TtaRegisterElementCreate (*list, doc);
1828: }
1829: /* generate the list item */
1830: elType.ElTypeNum = HTML_EL_List_Item;
1831: item = TtaNewElement (doc, elType);
1832: /* generate the HTML_EL_Pseudo_paragraph */
1833: elType.ElTypeNum = HTML_EL_Pseudo_paragraph;
1834: parent = TtaNewElement (doc, elType);
1835: TtaInsertFirstChild (&parent, item, doc);
1836: /* generate the link anchor */
1837: elType.ElTypeNum = HTML_EL_Anchor;
1838: new_ = TtaNewElement (doc, elType);
1839: TtaInsertFirstChild (&new_, parent, doc);
1840: attrType.AttrTypeNum = HTML_ATTR_HREF_;
1841: attr = TtaNewAttribute (attrType);
1842: TtaAttachAttribute (new_, attr, doc);
1843: TtaSetAttributeText (attr, id, new_, doc);
1.120 vatton 1844: TtaFreeMemory (id);
1845: id = NULL;
1.114 vatton 1846: /* get a copy of the Hi contents */
1847: srce = TtaGetFirstChild (el);
1848: prev = NULL;
1849: parent = NULL;
1850: while (srce)
1851: {
1852: copyType = TtaGetElementType (srce);
1853: if (copyType.ElTypeNum == HTML_EL_Anchor &&
1854: copyType.ElSSchema == elType.ElSSchema)
1855: {
1856: /* copy the anchor contents instead of the anchor */
1857: parent = srce;
1858: srce = TtaGetFirstChild (parent);
1859: }
1860: if (srce)
1861: {
1862: /* copy children of the next source */
1863: copy = TtaCopyTree (srce, doc, doc, new_);
1864: if (copy)
1865: {
1866: if (prev == NULL)
1867: /* this is the first copied element. Insert it before elem */
1868: TtaInsertFirstChild (©, new_, doc);
1869: else
1870: /* insert the new copied element after the element previously
1871: copied */
1872: TtaInsertSibling (copy, prev, FALSE, doc);
1873: prev = copy;
1874: }
1875: TtaNextSibling (&srce);
1876: }
1877: if (srce == NULL && parent)
1878: {
1879: /* copy children of an anchor */
1880: srce = parent;
1881: parent = NULL;
1882: if (srce)
1883: TtaNextSibling (&srce);
1884: }
1885: }
1.122 quint 1886: child = TtaGetLastChild (*list);
1887: if (child)
1888: TtaInsertSibling (item, child, FALSE, doc);
1889: else
1890: TtaInsertFirstChild (&item, *list, doc);
1.114 vatton 1891: TtaRegisterElementCreate (item, doc);
1892: }
1893: }
1894: }
1895:
1896: if (closeUndo)
1897: TtaCloseUndoSequence (doc);
1898: if (dispMode == DisplayImmediately)
1899: TtaSetDisplayMode (doc, dispMode);
1.115 vatton 1900: /* select the end of the toc */
1901: if (prev)
1902: {
1903: child = prev;
1904: while (child)
1905: {
1906: child = TtaGetLastChild (prev);
1907: if (child)
1908: prev = child;
1909: }
1910: elType = TtaGetElementType (prev);
1911: if (elType.ElTypeNum == HTML_EL_TEXT_UNIT)
1912: {
1913: i = TtaGetElementVolume (prev);
1914: TtaSelectString (doc, prev, i+1, i);
1915: }
1916: else
1917: TtaSelectElement (doc, prev);
1918: }
1.114 vatton 1919: }
Webmaster
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to HTMLbook.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Public] / Amaya / amaya