Annotation of Amaya/amaya/HTMLbook.c, revision 1.149
1.1 cvs 1: /*
2: *
1.147 vatton 3: * (c) COPYRIGHT INRIA and W3C, 1996-2007
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
1.135 vatton 16: #include "wx/wx.h"
1.107 carcone 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
1.135 vatton 32: {
33: struct _SubDoc *SDnext;
34: Element SDel;
35: char *SDname;
36: }SubDoc;
1.25 cvs 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.139 vatton 54: static struct _SubDoc *SubDocs = NULL;
1.85 cvs 55: static char PSfile[MAX_PATH];
56: static char PPrinter[MAX_PATH];
57: static char *DocPrintURL;
1.139 vatton 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
1.135 vatton 78: #include "wxdialogapi_f.h"
1.107 carcone 79: #endif /* _WX */
80:
1.101 gully 81: static ThotBool GetIncludedDocuments (Element el, Element link,
1.135 vatton 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)
1.135 vatton 123: last = last->SDnext;
1.16 cvs 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)
1.135 vatton 150: entry = entry->SDnext;
1.16 cvs 151: else
1.135 vatton 152: /* document found -> return the DIV element */
153: el = entry->SDel;
1.16 cvs 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)
1.135 vatton 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.135 vatton 230: /* a link has been found */
231: {
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;
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)
243: /* this element is not a link (no href or cite attribute) */
244: /* remove attributes InternalLink and ExternalLink if they
245: are present */
246: {
247: if (IntLinkAttr != NULL)
248: TtaRemoveAttribute (link, IntLinkAttr, document);
249: if (ExtLinkAttr != NULL)
250: TtaRemoveAttribute (link, ExtLinkAttr, document);
251: }
252: else
253: /* this element has an HREF or cite attribute */
254: {
255: length = TtaGetTextAttributeLength (HrefAttr);
256: text = (char *)TtaGetMemory (length + 1);
257: TtaGiveTextAttributeValue (HrefAttr, text, &length);
258:
259: /* does an external link become an internal link ? */
260: if (document == DocBook && SubDocs != NULL)
261: {
262: ptr = strrchr (text, '#');
263: url = text;
264: split = FALSE;
265: if (ptr == text)
266: /* a local link */
267: url = NULL;
268: else if (ptr != NULL)
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 */
294: if (ptr != NULL)
295: {
296: /* get the target name */
297: strcpy (value, ptr);
298: length = strlen (value);
299: /* check whether the name changed */
300: i = 0;
301: target = SearchNAMEattribute (document, &value[1], NULL, NULL);
302: while (target != NULL)
303: {
304: /* is it the right NAME */
305: if (TtaIsAncestor (target, div))
306: target = NULL;
307: else
308: {
309: /* continue the search */
310: i++;
311: sprintf (&value[length], "%d", i);
312: target = SearchNAMEattribute (document,
313: &value[1], NULL, NULL);
314: }
315: }
316: }
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: }
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 */
346: target = SearchNAMEattribute (document, ptr, NULL, NULL);
347: if (target != NULL)
348: /* set the Thot link */
349: TtaSetAttributeReference (IntLinkAttr, link, document,
350: target);
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: }
1.16 cvs 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.135 vatton 397: strcpy (PSfile, ptr);
1.81 cvs 398: else
1.135 vatton 399: strcpy (PSfile, TtaGetDefEnvString ("APP_TMPDIR"));
1.83 cvs 400: lg = strlen (PSfile);
401: if (PSfile[lg - 1] == DIR_SEP)
1.135 vatton 402: PSfile[--lg] = EOS;
1.83 cvs 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.135 vatton 411: PrintDocument prints the document using predefined parameters.
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,
1.135 vatton 418: TtaConvMessageToWX("Not implemented yet"),
419: _T("Warning"),
420: (long) wxOK | wxICON_EXCLAMATION | wxSTAY_ON_TOP);
1.116 gully 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.135 vatton 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)
1.135 vatton 444: {
445: if (Orientation == PP_Landscape)
446: TtaSetPrintSchema ("TextFilePL");
447: else
448: TtaSetPrintSchema ("TextFilePP");
449: }
1.75 cvs 450: else
1.135 vatton 451: {
452: if (Orientation == PP_Landscape)
453: TtaSetPrintSchema ("TextFileUSL");
454: else
455: TtaSetPrintSchema ("TextFilePPUS");
456: }
1.75 cvs 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)
1.135 vatton 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: }
1.113 quint 489: else if (PageSize == PP_A4)
1.135 vatton 490: {
491: if (Orientation == PP_Landscape)
492: TtaSetPrintSchema ("HTMLPL");
493: else
494: TtaSetPrintSchema ("HTMLPP");
495: }
1.75 cvs 496: else
1.135 vatton 497: {
498: if (Orientation == PP_Landscape)
499: TtaSetPrintSchema ("HTMLUSL");
500: else
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.135 vatton 513: {
514: elType. ElTypeNum = TextFile_EL_TextFile;
515: attrType.AttrTypeNum = TextFile_ATTR_PrintURL;
516: }
1.75 cvs 517: else
1.135 vatton 518: {
519: elType. ElTypeNum = HTML_EL_HTML;
520: attrType.AttrTypeNum = HTML_ATTR_PrintURL;
521: }
1.84 cvs 522: docEl = TtaGetMainRoot (doc);
523: el = TtaSearchTypedElement (elType, SearchForward, docEl);
1.75 cvs 524: attr = TtaGetAttribute (el, attrType);
525: if (!attr && PrintURL)
1.135 vatton 526: {
527: attr = TtaNewAttribute (attrType);
528: TtaAttachAttribute (el, attr, doc);
529: }
1.75 cvs 530: if (attr && !PrintURL)
1.135 vatton 531: TtaRemoveAttribute (el, attr, doc);
1.75 cvs 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: /*----------------------------------------------------------------------
1.135 vatton 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.135 vatton 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: {
1.133 cvs 571: long int val;
1.1 cvs 572:
1.133 cvs 573: val = (long 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)
1.135 vatton 579: {
580: case 1:
581: TtaSetPrintCommand (PPrinter);
582: TtaSetPsFile (PSfile);
583: /* update the environment variable */
584: TtaSetEnvString ("THOTPRINT", PPrinter, TRUE);
585: TtaSaveAppRegistry ();
586: PrintDocument (DocPrint, 1);
587: break;
588: default:
589: break;
590: }
1.1 cvs 591: break;
1.69 cvs 592: case PrintOptions:
1.1 cvs 593: switch (val)
1.135 vatton 594: {
595: case 0:
596: /* Manual feed option */
597: if (ManualFeed == PP_ON)
598: ManualFeed = PP_OFF;
599: else
600: ManualFeed = PP_ON;
601: TtaSetPrintParameter (PP_ManualFeed, ManualFeed);
602: break;
603: case 1:
604: /* Toc option */
605: WithToC = !WithToC;
606: break;
607: case 2:
608: /* NumberLinks option */
609: NumberLinks = !NumberLinks;
610: case 3:
611: /* URL option */
612: PrintURL = !PrintURL;
613: break;
614: case 4:
615: /* CSS option */
616: IgnoreCSS = !IgnoreCSS;
617: break;
618: }
1.1 cvs 619: break;
1.69 cvs 620: case PaperFormat:
1.1 cvs 621: /* page size submenu */
622: switch (val)
1.135 vatton 623: {
624: case 0:
625: PageSize = PP_A4;
626: break;
627: case 1:
628: PageSize = PP_US;
629: break;
630: }
1.81 cvs 631: TtaSetPrintParameter (PP_PaperSize, PageSize);
1.1 cvs 632: break;
1.71 cvs 633: case PaperOrientation:
634: /* orientation submenu */
635: Orientation = val;
1.81 cvs 636: TtaSetPrintParameter (PP_Orientation, Orientation);
1.71 cvs 637: break;
638: case PPagesPerSheet:
639: /* pages per sheet submenu */
640: switch (val)
1.135 vatton 641: {
642: case 0:
643: PagePerSheet = 1;
644: break;
645: case 1:
646: PagePerSheet = 2;
647: break;
648: case 2:
649: PagePerSheet = 4;
650: break;
651: }
1.81 cvs 652: TtaSetPrintParameter (PP_PagesPerSheet, PagePerSheet);
1.71 cvs 653: break;
1.69 cvs 654: case PrintSupport:
1.1 cvs 655: /* paper print/save PostScript submenu */
656: switch (val)
1.135 vatton 657: {
658: case 0:
659: if (PaperPrint == PP_PS)
660: {
661: PaperPrint = PP_PRINTER;
1.110 cvs 662: #ifdef _GTK
1.135 vatton 663: TtaSetTextForm (BasePrint + PPrinterName, PPrinter);
1.110 cvs 664: #endif /* _GTK */
1.135 vatton 665: TtaSetPrintParameter (PP_Destination, PaperPrint);
666: }
667: break;
668: case 1:
669: if (PaperPrint == PP_PRINTER)
670: {
671: PaperPrint = PP_PS;
1.110 cvs 672: #ifdef _GTK
1.135 vatton 673: TtaSetTextForm (BasePrint + PPrinterName, PSfile);
1.110 cvs 674: #endif /* _GTK */
1.135 vatton 675: TtaSetPrintParameter (PP_Destination, PaperPrint);
676: }
677: break;
678: }
1.1 cvs 679: break;
1.69 cvs 680: case PPrinterName:
1.131 vatton 681: if (data[0] != EOS)
1.135 vatton 682: {
683: if (PaperPrint == PP_PRINTER)
684: /* text capture zone for the printer name */
685: strncpy (PPrinter, data, MAX_PATH);
686: else
687: /* text capture zone for the name of the PostScript file */
688: strncpy (PSfile, data, MAX_PATH);
689: }
1.1 cvs 690: break;
691: }
692: }
693:
694: /*----------------------------------------------------------------------
695: ----------------------------------------------------------------------*/
1.94 vatton 696: void InitPrint (void)
1.1 cvs 697: {
1.83 cvs 698: char* ptr;
1.1 cvs 699:
1.135 vatton 700: BasePrint = TtaSetCallback ((Proc)CallbackPrint, PRINT_MAX_REF);
701: DocPrint = 0;
702: DocPrintURL = NULL;
703:
704: /* read default printer variable */
705: ptr = TtaGetEnvString ("THOTPRINT");
706: if (ptr == NULL)
707: strcpy (PPrinter, "");
708: else
709: strcpy (PPrinter, ptr);
710: TtaSetPrintCommand (PPrinter);
711: PaperPrint = PP_PRINTER;
712: TtaSetPrintParameter (PP_Destination, PaperPrint);
713:
714: /* define the new default PrintSchema */
715: NumberLinks = FALSE;
716: WithToC = FALSE;
717: IgnoreCSS = FALSE;
718: PrintURL = TRUE;
719: PageSize = TtaGetPrintParameter (PP_PaperSize);
720: TtaSetPrintSchema ("");
721: /* no manual feed */
722: ManualFeed = PP_OFF;
723: TtaSetPrintParameter (PP_ManualFeed, ManualFeed);
724: PagePerSheet = 1;
725: TtaSetPrintParameter (PP_PagesPerSheet, PagePerSheet);
1.1 cvs 726: }
727:
728: /*----------------------------------------------------------------------
1.3 cvs 729: SetupAndPrint sets printing parameters and starts the printing process
1.1 cvs 730: ----------------------------------------------------------------------*/
1.91 vatton 731: void SetupAndPrint (Document doc, View view)
1.1 cvs 732: {
1.107 carcone 733: #ifdef _GTK
1.83 cvs 734: char bufMenu[MAX_LENGTH];
1.91 vatton 735: int i;
1.107 carcone 736: #endif /* _GTK */
1.91 vatton 737: ThotBool textFile;
1.38 cvs 738:
1.81 cvs 739: textFile = (DocumentTypes[doc] == docText || DocumentTypes[doc] == docCSS);
740: /* Print form */
741: CheckPrintingDocument (doc);
1.27 cvs 742:
1.107 carcone 743: #ifdef _GTK
1.81 cvs 744: TtaNewSheet (BasePrint + FormPrint, TtaGetViewFrame (doc, view),
1.135 vatton 745: TtaGetMessage (LIB, TMSG_LIB_PRINT), 1,
746: TtaGetMessage (LIB, TMSG_BUTTON_PRINT), FALSE, 3, 'L', D_CANCEL);
1.81 cvs 747:
748: /* Paper format submenu */
749: i = 0;
750: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_A4));
1.83 cvs 751: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 752: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_US));
753: TtaNewSubmenu (BasePrint + PaperFormat, BasePrint + FormPrint, 0,
1.135 vatton 754: TtaGetMessage (LIB, TMSG_PAPER_SIZE), 2, bufMenu, NULL, 0, TRUE);
1.81 cvs 755: if (PageSize == PP_US)
756: TtaSetMenuForm (BasePrint + PaperFormat, 1);
757: else
758: TtaSetMenuForm (BasePrint + PaperFormat, 0);
759:
760: /* Orientation submenu */
761: i = 0;
762: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (AMAYA, AM_PORTRAIT));
1.83 cvs 763: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 764: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (AMAYA, AM_LANDSCAPE));
765: TtaNewSubmenu (BasePrint + PaperOrientation, BasePrint + FormPrint, 0,
1.135 vatton 766: TtaGetMessage (AMAYA, AM_ORIENTATION), 2, bufMenu, NULL, 0, TRUE);
1.81 cvs 767: if (Orientation == PP_Landscape)
768: TtaSetMenuForm (BasePrint + PaperOrientation, 1);
769: else
770: TtaSetMenuForm (BasePrint + PaperOrientation, 0);
771: /* Pages per sheet submenu */
772: i = 0;
773: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_1_PAGE_SHEET));
1.83 cvs 774: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 775: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_2_PAGE_SHEET));
1.83 cvs 776: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 777: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_4_PAGE_SHEET));
778: TtaNewSubmenu (BasePrint + PPagesPerSheet, BasePrint + FormPrint, 0,
1.135 vatton 779: TtaGetMessage (LIB, TMSG_REDUCTION), 3, bufMenu, NULL, 0, TRUE);
1.81 cvs 780: if (PagePerSheet == 1)
781: TtaSetMenuForm (BasePrint + PPagesPerSheet, 0);
782: else if (PagePerSheet == 2)
783: TtaSetMenuForm (BasePrint + PPagesPerSheet, 1);
784: else
785: TtaSetMenuForm (BasePrint + PPagesPerSheet, 2);
786:
787: /* Print to paper/ Print to file submenu */
788: i = 0;
789: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_PRINTER));
1.83 cvs 790: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 791: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_PS_FILE));
792: TtaNewSubmenu (BasePrint + PrintSupport, BasePrint + FormPrint, 0,
1.135 vatton 793: TtaGetMessage (LIB, TMSG_OUTPUT), 2, bufMenu, NULL, 0, TRUE);
1.81 cvs 794:
795: /* PaperPrint selector */
796: TtaNewTextForm (BasePrint + PPrinterName, BasePrint + FormPrint, NULL, 30, 1, TRUE);
797: if (PaperPrint == PP_PRINTER)
798: {
799: TtaSetMenuForm (BasePrint + PrintSupport, 0);
800: TtaSetTextForm (BasePrint + PPrinterName, PPrinter);
801: }
802: else
803: {
804: TtaSetMenuForm (BasePrint + PrintSupport, 1);
805: TtaSetTextForm (BasePrint + PPrinterName, PSfile);
806: }
1.1 cvs 807:
1.81 cvs 808: /* The toggle */
809: i = 0;
810: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (LIB, TMSG_MANUAL_FEED));
1.83 cvs 811: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 812: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_PRINT_TOC));
1.83 cvs 813: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 814: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_NUMBERED_LINKS));
1.83 cvs 815: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 816: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_PRINT_URL));
1.83 cvs 817: i += strlen (&bufMenu[i]) + 1;
1.81 cvs 818: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_WITH_CSS));
819: TtaNewToggleMenu (BasePrint + PrintOptions, BasePrint + FormPrint,
1.135 vatton 820: TtaGetMessage (LIB, TMSG_OPTIONS), 5, bufMenu, NULL, FALSE);
1.81 cvs 821: if (ManualFeed == PP_ON)
822: TtaSetToggleMenu (BasePrint + PrintOptions, 0, TRUE);
823: else
824: TtaSetToggleMenu (BasePrint + PrintOptions, 0, FALSE);
825: TtaSetToggleMenu (BasePrint + PrintOptions, 1, WithToC);
826: TtaSetToggleMenu (BasePrint + PrintOptions, 2, NumberLinks);
827: TtaSetToggleMenu (BasePrint + PrintOptions, 3, PrintURL);
828: TtaSetToggleMenu (BasePrint + PrintOptions, 4, IgnoreCSS);
829:
830: /* activates the Print form */
831: TtaShowDialogue (BasePrint+FormPrint, FALSE);
832: if (textFile)
833: {
834: /* invalid dialogue entries */
1.102 gully 835: TtaRedrawMenuEntry (BasePrint + PrintOptions, 1, NULL, (ThotColor)-1, FALSE);
836: TtaRedrawMenuEntry (BasePrint + PrintOptions, 2, NULL, (ThotColor)-1, FALSE);
1.81 cvs 837: }
1.107 carcone 838: #endif /* _GTK */
839: #ifdef _WINGUI
1.81 cvs 840: CreatePrintDlgWindow (TtaGetViewFrame (doc, view), PSfile);
1.103 cvs 841: #endif /* _WINGUI */
1.107 carcone 842: #ifdef _WX
1.108 gully 843: {
1.125 gully 844: int paper_format;
845: int orientation;
846: int disposition;
847: int paper_print;
1.128 cvs 848: ThotBool manual_feed;
849: ThotBool with_toc;
850: ThotBool with_links;
851: ThotBool with_url;
852: ThotBool ignore_css;
1.125 gully 853:
854: /* Paper format submenu */
855: if (PageSize == PP_US)
856: paper_format = 1;
857: else
858: paper_format = 0;
859:
860: /* Orientation submenu */
861: if (Orientation == PP_Landscape)
862: orientation = 1;
863: else
864: orientation = 0;
865:
866: /* Pages per sheet submenu */
867: if (PagePerSheet == 1)
868: disposition = 0;
869: else if (PagePerSheet == 2)
870: disposition = 1;
871: else
872: disposition = 2;
873:
874: /* PaperPrint selector */
875: if (PaperPrint == PP_PRINTER)
876: paper_print = 0;
877: else
878: paper_print = 1;
879:
880: /* The toggle */
881: manual_feed = (ManualFeed == PP_ON);
882: with_toc = WithToC;
883: with_links = NumberLinks;
884: with_url = PrintURL;
885: ignore_css = IgnoreCSS;
886:
887: /* The dialog creation */
1.108 gully 888: ThotBool created;
1.125 gully 889: created = CreatePrintDlgWX (BasePrint + FormPrint, TtaGetViewFrame (doc, view),
1.135 vatton 890: PPrinter,
891: PSfile,
892: paper_format,
893: orientation,
894: disposition,
895: paper_print,
896: manual_feed,
897: with_toc,
898: with_links,
899: with_url,
900: ignore_css);
1.108 gully 901: if (created)
902: {
1.135 vatton 903: TtaShowDialogue (BasePrint+FormPrint, FALSE);
1.108 gully 904: }
905: }
906:
1.107 carcone 907: #endif /* _WX */
1.1 cvs 908: }
909:
910: /*----------------------------------------------------------------------
911: UpdateURLsInSubtree
912: Update NAMEs and URLs in subtree of el element, to take into account
913: the move from one document to another.
914: If a NAME attribute already exists in the new document, it is changed
915: to avoid duplicate names.
916: Transform the HREF and SRC attribute to make them independent from their
917: former base.
918: ----------------------------------------------------------------------*/
1.99 cvs 919: void UpdateURLsInSubtree (NotifyElement *event, Element el)
1.1 cvs 920: {
1.77 cvs 921: Element nextEl, child;
922: ElementType elType;
923: SSchema HTMLschema;
1.1 cvs 924:
925: nextEl = TtaGetFirstChild (el);
1.82 cvs 926: HTMLschema = TtaGetSSchema ("HTML", event->document);
1.99 cvs 927: if (HTMLschema)
1.1 cvs 928: {
1.141 vatton 929: // first check the id of the enclosing division
930: MakeUniqueName (el, event->document, TRUE, TRUE);
1.99 cvs 931: elType.ElSSchema = HTMLschema;
1.136 vatton 932: while (nextEl)
1.135 vatton 933: {
1.136 vatton 934: CheckPastedElement (nextEl, event->document, 0, event->position, TRUE);
1.135 vatton 935: /* manage included links and anchors */
936: elType.ElTypeNum = HTML_EL_Anchor;
937: child = TtaSearchTypedElement (elType, SearchInTree, nextEl);
938: while (child)
939: {
1.136 vatton 940: CheckPastedElement (child, event->document, 0, event->position, TRUE);
1.135 vatton 941: child = TtaSearchTypedElementInTree (elType, SearchForward, nextEl, child);
942: }
1.99 cvs 943:
1.135 vatton 944: /* manage included links and anchors */
945: elType.ElTypeNum = HTML_EL_PICTURE_UNIT;
946: child = TtaSearchTypedElement (elType, SearchInTree, nextEl);
947: while (child)
948: {
1.136 vatton 949: CheckPastedElement (child, event->document, 0, event->position, TRUE);
1.135 vatton 950: child = TtaSearchTypedElementInTree (elType, SearchForward, nextEl, child);
951: }
952: TtaNextSibling (&nextEl);
953: }
1.1 cvs 954: }
955: }
956:
957:
958: /*----------------------------------------------------------------------
959: MoveDocumentBody
1.58 cvs 960: Copy the elements contained in the BODY of the document sourceDoc at the
961: position of the element el in the document destDoc.
962: Delete the element containing el and all its empty ancestors.
1.1 cvs 963: If deleteTree is TRUE, copied elements are deleted from the source
964: document.
1.58 cvs 965: Return the root element that delimits the new inserted part (a div).
1.1 cvs 966: ----------------------------------------------------------------------*/
1.80 cvs 967: static Element MoveDocumentBody (Element el, Document destDoc,
1.135 vatton 968: Document sourceDoc, char *target,
969: char *url, ThotBool deleteTree)
1.1 cvs 970: {
1.140 vatton 971: Element root, ancestor, elem, firstInserted, div;
1.12 cvs 972: Element lastInserted, srce, copy, old, parent, sibling;
1.140 vatton 973: ElementType elType;
974: SSchema nature;
1.12 cvs 975: NotifyElement event;
1.143 vatton 976: int i, j;
977: ThotBool checkingMode, isID;
1.1 cvs 978:
1.67 cvs 979: div = NULL;
1.140 vatton 980: if (target)
1.13 cvs 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 &&
1.135 vatton 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:
1.140 vatton 998: if (root)
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.135 vatton 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.135 vatton 1008: {
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: }
1019: }
1.140 vatton 1020: while (ancestor);
1.12 cvs 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.140 vatton 1032: // check if new natures are added
1033: if (DocumentMeta[destDoc] && !DocumentMeta[destDoc]->compound)
1034: {
1035: nature = NULL;
1036: TtaNextNature (sourceDoc, &nature);
1037: if (nature)
1038: DocumentMeta[destDoc]->compound = TRUE;
1039: }
1040:
1.12 cvs 1041: /* do copy */
1.16 cvs 1042: firstInserted = NULL;
1.17 cvs 1043: if (isID)
1.135 vatton 1044: srce = root;
1.17 cvs 1045: else
1.135 vatton 1046: srce = TtaGetFirstChild (root);
1.140 vatton 1047: while (srce)
1.135 vatton 1048: {
1049: copy = TtaCopyTree (srce, sourceDoc, destDoc, parent);
1050: if (copy != NULL)
1051: {
1052: if (firstInserted == NULL)
1053: /* this is the first copied element. Insert it before elem */
1054: {
1055: TtaInsertFirstChild (©, lastInserted, destDoc);
1056: firstInserted = copy;
1057: }
1058: else
1059: /* insert the new copied element after the element previously
1060: copied */
1061: TtaInsertSibling (copy, lastInserted, FALSE, destDoc);
1062: lastInserted = copy;
1063: /* update the NAMEs and URLs in the copied element */
1064: event.event = TteElemPaste;
1065: event.document = destDoc;
1066: event.element = copy;
1067: event.elementType = TtaGetElementType (copy);
1068: event.position = sourceDoc;
1069: event.info = 0;
1070: UpdateURLsInSubtree(&event, copy);
1071: }
1072: /* get the next element in the source document */
1073: old = srce;
1074: TtaNextSibling (&srce);
1075: if (deleteTree)
1.143 vatton 1076: {
1077: // remove the current selection if it concerns the removed subtree
1078: TtaGiveFirstSelectedElement (sourceDoc, &elem, &i, &j);
1079: if (elem)
1080: {
1081: if (TtaIsAncestor (elem, old))
1082: TtaCancelSelection (sourceDoc);
1083: else
1084: {
1085: TtaGiveLastSelectedElement (sourceDoc, &elem, &i, &j);
1086: if (elem &&TtaIsAncestor (elem, old))
1087: TtaCancelSelection (sourceDoc);
1088: }
1089: }
1090: TtaDeleteTree (old, sourceDoc);
1091: }
1.135 vatton 1092: /* Stop here if the target points to a specific element with an ID */
1093: if (isID)
1094: srce = NULL;
1095: }
1.12 cvs 1096:
1097: /* delete the element(s) containing the link to the copied document */
1.58 cvs 1098: /* delete the parent element of el and all empty ancestors */
1099: elem = TtaGetParent (el);
1.12 cvs 1100: do
1.135 vatton 1101: {
1102: sibling = elem;
1103: TtaNextSibling (&sibling);
1104: if (sibling == NULL)
1105: {
1106: sibling = elem;
1107: TtaPreviousSibling (&sibling);
1108: if (sibling == NULL)
1109: elem = TtaGetParent (elem);
1110: }
1111: }
1.12 cvs 1112: while (sibling == NULL);
1113: TtaDeleteTree (elem, destDoc);
1114: /* restore previous chacking mode */
1.124 vatton 1115: TtaSetStructureChecking (checkingMode, destDoc);
1.12 cvs 1116: }
1.58 cvs 1117: /* return the address of the new division */
1118: return (div);
1.1 cvs 1119: }
1120:
1.29 cvs 1121:
1.58 cvs 1122: /*----------------------------------------------------------------------
1123: CloseMakeBook
1124: ----------------------------------------------------------------------*/
1125: static void CloseMakeBook (Document document)
1126: {
1127: ResetStop (document);
1128: /* update internal links */
1129: SetInternalLinks (document);
1130: /* if the document changed force the browser mode */
1.139 vatton 1131: if (SubDocs)
1.128 cvs 1132: /* send a warning to the user to avoid to save this document */
1133: /* remove registered sub-documents */
1134: FreeSubDocTable ();
1.58 cvs 1135: DocBook = 0;
1136: TtaSetStatus (document, 1, TtaGetMessage (AMAYA, AM_DOCUMENT_LOADED), NULL);
1137: }
1138:
1139:
1140: /*----------------------------------------------------------------------
1141: GetIncludedDocuments_callback finishes the GetIncludedDocuments procedure
1142: ----------------------------------------------------------------------*/
1143: void GetIncludedDocuments_callback (int newdoc, int status,
1.135 vatton 1144: char *urlName,
1.145 cvs 1145: char *outputfile,
1146: char *proxyName,
1.135 vatton 1147: AHTHeaders *http_headers,
1148: void * context)
1.29 cvs 1149: {
1.58 cvs 1150: Element link, div;
1151: IncludeCtxt *ctx, *prev;
1.104 vatton 1152: char *utf8path, *ptr;
1.58 cvs 1153: ThotBool found = FALSE;
1.29 cvs 1154:
1155: /* restore GetIncludedDocuments's context */
1.58 cvs 1156: ctx = (IncludeCtxt *) context;
1.29 cvs 1157: if (!ctx)
1158: return;
1159:
1.58 cvs 1160: div = NULL;
1.29 cvs 1161: link = ctx->link;
1.58 cvs 1162: ptr = ctx->name;
1.104 vatton 1163: utf8path = ctx->utf8path;
1164: if (utf8path)
1.29 cvs 1165: {
1.58 cvs 1166: if (newdoc && newdoc != DocBook)
1.135 vatton 1167: {
1168: /* it's not the DocBook itself */
1169: /* copy the target document at the position of the link */
1170: TtaSetDocumentModified (DocBook);
1171: div = MoveDocumentBody (link, DocBook, newdoc, ptr, utf8path,
1172: (ThotBool)(newdoc == IncludedDocument));
1173: }
1.58 cvs 1174: /* global variables */
1175: FreeDocumentResource (IncludedDocument);
1176: TtaCloseDocument (IncludedDocument);
1177: IncludedDocument = 0;
1.29 cvs 1178: }
1.58 cvs 1179:
1.104 vatton 1180: if (div)
1.29 cvs 1181: {
1.58 cvs 1182: /* new starting point for the search */
1183: ctx->link = div;
1184: found = GetIncludedDocuments (div, div, DocBook, ctx);
1.29 cvs 1185: }
1.104 vatton 1186:
1.58 cvs 1187: while (!found && ctx)
1188: {
1189: /* this sub-document has no more inclusion, examine the caller */
1190: div = ctx->div;
1191: link = ctx->link;
1192: prev = ctx->ctxt;
1.104 vatton 1193: TtaFreeMemory (utf8path);
1194: utf8path = NULL;
1.58 cvs 1195: TtaFreeMemory (ctx);
1196: ctx = prev;
1197: found = GetIncludedDocuments (div, link, DocBook, ctx);
1198: }
1199: if (!found)
1200: /* all links are now managed */
1201: CloseMakeBook (DocBook);
1.29 cvs 1202: }
1203:
1.1 cvs 1204: /*----------------------------------------------------------------------
1205: GetIncludedDocuments
1.58 cvs 1206: Look forward within the element el, starting from element link, for a
1207: link (A) with attribute rel="chapter" or rel="subdocument" and replace
1208: that link by the contents of the target document.
1209: Return TRUE if one inclusion is launched.
1.1 cvs 1210: ----------------------------------------------------------------------*/
1.96 vatton 1211: static ThotBool GetIncludedDocuments (Element el, Element link,
1.135 vatton 1212: Document doc, IncludeCtxt *prev)
1.1 cvs 1213: {
1.58 cvs 1214: ElementType elType;
1215: Attribute attr;
1216: AttributeType attrType;
1217: Document newdoc;
1218: IncludeCtxt *ctx = NULL;
1.104 vatton 1219: char *utf8path, *ptr;
1.29 cvs 1220: int length;
1.58 cvs 1221: ThotBool found = FALSE;
1.29 cvs 1222:
1.58 cvs 1223: /* look for anchors with the attribute rel within the element el */
1224: attr = NULL;
1.96 vatton 1225: attrType.AttrSSchema = TtaGetSSchema ("HTML", doc);
1.58 cvs 1226: elType.ElSSchema = attrType.AttrSSchema;
1227: elType.ElTypeNum = HTML_EL_Anchor;
1.29 cvs 1228:
1.58 cvs 1229: /* Get only one included file each time */
1230: while (link && attr == NULL)
1.29 cvs 1231: {
1.58 cvs 1232: link = TtaSearchTypedElementInTree (elType, SearchForward, el, link);
1233: if (link)
1.135 vatton 1234: {
1235: attrType.AttrTypeNum = HTML_ATTR_REL;
1236: attr = TtaGetAttribute (link, attrType);
1237: }
1.58 cvs 1238: if (attr)
1.135 vatton 1239: {
1240: length = TtaGetTextAttributeLength (attr);
1241: utf8path = (char *)TtaGetMemory (length + 1);
1242: TtaGiveTextAttributeValue (attr, utf8path, &length);
1243: /* Valid rel values are rel="chapter" or rel="subdocument" */
1244: if (strcasecmp (utf8path, "chapter") &&
1245: strcasecmp (utf8path, "subdocument"))
1246: attr = NULL;
1247: TtaFreeMemory (utf8path);
1248: }
1.58 cvs 1249:
1250: if (attr)
1.135 vatton 1251: {
1252: /* a link with attribute rel="Chapter" has been found */
1253: attrType.AttrTypeNum = HTML_ATTR_HREF_;
1254: attr = TtaGetAttribute (link, attrType);
1255: }
1.58 cvs 1256: if (attr)
1.135 vatton 1257: /* this link has an attribute HREF */
1258: {
1259: length = TtaGetTextAttributeLength (attr);
1260: utf8path = (char *)TtaGetMemory (length + 1);
1261: TtaGiveTextAttributeValue (attr, utf8path, &length);
1262: ptr = strrchr (utf8path, '#');
1263: if (ptr)
1264: {
1265: /* link to a particular position within a document */
1266: if (ptr == utf8path)
1267: {
1268: /* local link */
1269: TtaFreeMemory (utf8path);
1270: utf8path = NULL;
1271: }
1272: else
1273: {
1274: ptr[0] = EOS;
1275: ptr = &ptr[1];
1276: }
1277: }
1.58 cvs 1278:
1.135 vatton 1279: if (utf8path)
1280: /* this link designates an external document */
1281: {
1282: /* create a new document and loads the target document */
1283: IncludedDocument = TtaNewDocument ("HTML", "tmp");
1284: if (IncludedDocument != 0)
1285: {
1286: TtaSetStatus (doc, 1, TtaGetMessage (AMAYA, AM_FETCHING), utf8path);
1287: ctx = (IncludeCtxt *)TtaGetMemory (sizeof (IncludeCtxt));
1288: ctx->div = el;
1289: ctx->link = link;
1290: ctx->utf8path = utf8path; /* the URL of the document */
1291: ctx->name = ptr;
1292: ctx->ctxt = prev; /* previous context */
1293: /* Get the reference of the calling document */
1294: SetStopButton (doc);
1295: newdoc = GetAmayaDoc (utf8path, NULL, IncludedDocument,
1296: doc, CE_MAKEBOOK, FALSE,
1.144 cvs 1297: (void (*)(int, int, char*, char*, char*, const AHTHeaders*, void*)) GetIncludedDocuments_callback,
1.135 vatton 1298: (void *) ctx);
1299: found = TRUE;
1300: }
1301: }
1302: else
1303: TtaFreeMemory (utf8path);
1304: }
1.29 cvs 1305: }
1.58 cvs 1306: return (found);
1.1 cvs 1307: }
1308:
1309:
1310: /*----------------------------------------------------------------------
1311: MakeBook
1312: Replace all links in a document which have an attribute REL="chapter"
1.5 cvs 1313: or REL="subdocument" by the corresponding target document.
1.1 cvs 1314: ----------------------------------------------------------------------*/
1.96 vatton 1315: void MakeBook (Document doc, View view)
1.1 cvs 1316: {
1.58 cvs 1317: Element root, body;
1318: ElementType elType;
1.1 cvs 1319:
1.139 vatton 1320: if (SubDocs)
1321: // another make_book is wi=orking
1322: return;
1.58 cvs 1323: /* stops all current transfers on this document */
1.96 vatton 1324: StopTransfer (doc, 1);
1.58 cvs 1325: /* simulate a transfert in the main document */
1.96 vatton 1326: DocBook = doc;
1.58 cvs 1327: IncludedDocument = 0;
1.96 vatton 1328: root = TtaGetMainRoot (doc);
1.58 cvs 1329: elType = TtaGetElementType (root);
1330: elType.ElTypeNum = HTML_EL_BODY;
1331: body = TtaSearchTypedElement (elType, SearchForward, root);
1332: if (body)
1.96 vatton 1333: GetIncludedDocuments (body, body, doc, NULL);
1.1 cvs 1334: }
1.105 vatton 1335:
1336: /*----------------------------------------------------------------------
1337: ----------------------------------------------------------------------*/
1338: void ReadAsUTF_8 (Document doc, View view)
1339: {
1340: ReparseAs (doc, view, FALSE, UTF_8);
1341: }
1342:
1343: /*----------------------------------------------------------------------
1344: ----------------------------------------------------------------------*/
1345: void ReadAsISO_8859_1 (Document doc, View view)
1346: {
1347: ReparseAs (doc, view, FALSE, ISO_8859_1);
1348: }
1349:
1350: /*----------------------------------------------------------------------
1351: ----------------------------------------------------------------------*/
1352: void ReadAsISO_8859_2 (Document doc, View view)
1353: {
1354: ReparseAs (doc, view, FALSE, ISO_8859_2);
1355: }
1356:
1357: /*----------------------------------------------------------------------
1358: ----------------------------------------------------------------------*/
1359: void ReadAsISO_8859_3 (Document doc, View view)
1360: {
1361: ReparseAs (doc, view, FALSE, ISO_8859_3);
1362: }
1363:
1364: /*----------------------------------------------------------------------
1365: ----------------------------------------------------------------------*/
1366: void ReadAsISO_8859_4 (Document doc, View view)
1367: {
1368: ReparseAs (doc, view, FALSE, ISO_8859_4);
1369: }
1370:
1371: /*----------------------------------------------------------------------
1372: ----------------------------------------------------------------------*/
1373: void ReadAsISO_8859_5 (Document doc, View view)
1374: {
1375: ReparseAs (doc, view, FALSE, ISO_8859_5);
1376: }
1377:
1378: /*----------------------------------------------------------------------
1379: ----------------------------------------------------------------------*/
1380: void ReadAsISO_8859_6 (Document doc, View view)
1381: {
1382: ReparseAs (doc, view, FALSE, ISO_8859_6);
1383: }
1384:
1385: /*----------------------------------------------------------------------
1386: ----------------------------------------------------------------------*/
1387: void ReadAsISO_8859_7 (Document doc, View view)
1388: {
1389: ReparseAs (doc, view, FALSE, ISO_8859_7);
1390: }
1391:
1392: /*----------------------------------------------------------------------
1393: ----------------------------------------------------------------------*/
1394: void ReadAsISO_8859_8 (Document doc, View view)
1395: {
1396: ReparseAs (doc, view, FALSE, ISO_8859_8);
1397: }
1398:
1399: /*----------------------------------------------------------------------
1400: ----------------------------------------------------------------------*/
1401: void ReadAsISO_8859_9 (Document doc, View view)
1402: {
1403: ReparseAs (doc, view, FALSE, ISO_8859_9);
1404: }
1405:
1406: /*----------------------------------------------------------------------
1407: ----------------------------------------------------------------------*/
1408: void ReadAsISO_8859_15 (Document doc, View view)
1409: {
1410: ReparseAs (doc, view, FALSE, ISO_8859_15);
1411: }
1412:
1413: /*----------------------------------------------------------------------
1414: ----------------------------------------------------------------------*/
1415: void ReadAsKOI8_R (Document doc, View view)
1416: {
1417: ReparseAs (doc, view, FALSE, KOI8_R);
1418: }
1419:
1420: /*----------------------------------------------------------------------
1421: ----------------------------------------------------------------------*/
1422: void ReadAsWINDOWS_1250 (Document doc, View view)
1423: {
1424: ReparseAs (doc, view, FALSE, WINDOWS_1250);
1425: }
1426:
1427: /*----------------------------------------------------------------------
1428: ----------------------------------------------------------------------*/
1429: void ReadAsWINDOWS_1251 (Document doc, View view)
1430: {
1431: ReparseAs (doc, view, FALSE, WINDOWS_1251);
1432: }
1433:
1434: /*----------------------------------------------------------------------
1435: ----------------------------------------------------------------------*/
1436: void ReadAsWINDOWS_1252 (Document doc, View view)
1437: {
1438: ReparseAs (doc, view, FALSE, WINDOWS_1252);
1439: }
1440:
1441: /*----------------------------------------------------------------------
1442: ----------------------------------------------------------------------*/
1443: void ReadAsWINDOWS_1253 (Document doc, View view)
1444: {
1445: ReparseAs (doc, view, FALSE, WINDOWS_1253);
1446: }
1447:
1448: /*----------------------------------------------------------------------
1449: ----------------------------------------------------------------------*/
1450: void ReadAsWINDOWS_1254 (Document doc, View view)
1451: {
1452: ReparseAs (doc, view, FALSE, WINDOWS_1254);
1453: }
1454:
1455: /*----------------------------------------------------------------------
1456: ----------------------------------------------------------------------*/
1457: void ReadAsWINDOWS_1255 (Document doc, View view)
1458: {
1459: ReparseAs (doc, view, FALSE, WINDOWS_1255);
1460: }
1461:
1462: /*----------------------------------------------------------------------
1463: ----------------------------------------------------------------------*/
1464: void ReadAsWINDOWS_1256 (Document doc, View view)
1465: {
1466: ReparseAs (doc, view, FALSE, WINDOWS_1256);
1467: }
1468:
1469: /*----------------------------------------------------------------------
1470: ----------------------------------------------------------------------*/
1471: void ReadAsWINDOWS_1257 (Document doc, View view)
1472: {
1473: ReparseAs (doc, view, FALSE, WINDOWS_1257);
1474: }
1475:
1476: /*----------------------------------------------------------------------
1477: ----------------------------------------------------------------------*/
1.134 vatton 1478: void ReadAsGB_2312 (Document doc, View view)
1479: {
1480: ReparseAs (doc, view, FALSE, GB_2312);
1481: }
1482:
1483: /*----------------------------------------------------------------------
1484: ----------------------------------------------------------------------*/
1.105 vatton 1485: void ReadAsISO_2022_JP (Document doc, View view)
1486: {
1487: ReparseAs (doc, view, FALSE, ISO_2022_JP);
1488: }
1489:
1490: /*----------------------------------------------------------------------
1491: ----------------------------------------------------------------------*/
1492: void ReadAsEUC_JP (Document doc, View view)
1493: {
1494: ReparseAs (doc, view, FALSE, EUC_JP);
1495: }
1496:
1497: /*----------------------------------------------------------------------
1498: ----------------------------------------------------------------------*/
1499: void ReadAsSHIFT_JIS (Document doc, View view)
1500: {
1501: ReparseAs (doc, view, FALSE, SHIFT_JIS);
1502: }
1.114 vatton 1503:
1504: /*----------------------------------------------------------------------
1.119 vatton 1505: SectionNumbering generates numbers for all HTML Hi elements after
1506: the current position.
1507: ----------------------------------------------------------------------*/
1508: void SectionNumbering (Document doc, View view)
1509: {
1.120 vatton 1510: Element el, new_, child;
1511: DisplayMode dispMode;
1512: SSchema HTMLschema;
1513: ElementType elType, childType, searchedType1, searchedType2;
1514: ElementType searchedType3, searchedType4, searchedType5;
1515: Language lang;
1516: char s[MAX_LENGTH], n[20], *text;
1517: int nH2, nH3, nH4, nH5, nH6, length, i;
1.123 vatton 1518: ThotBool closeUndo, change = FALSE;
1.120 vatton 1519:
1520: /* check if there is HTML Hi elements and if the current position is
1.135 vatton 1521: within a HTML Body element */
1.120 vatton 1522: dispMode = TtaGetDisplayMode (doc);
1523:
1524: /* check if there is any HTML element within the document */
1525: HTMLschema = TtaGetSSchema ("HTML", doc);
1526: if (HTMLschema == NULL)
1527: /* no HTML element */
1528: return;
1529:
1530: if (TtaPrepareUndo (doc))
1.135 vatton 1531: closeUndo = FALSE;
1.120 vatton 1532: else
1533: {
1534: closeUndo = TRUE;
1535: TtaOpenUndoSequence (doc, NULL, NULL, 0, 0);
1536: }
1537:
1538: el = TtaGetMainRoot (doc);
1539: searchedType1.ElSSchema = HTMLschema;
1540: searchedType1.ElTypeNum = HTML_EL_H2;
1541: searchedType2.ElSSchema = HTMLschema;
1542: searchedType2.ElTypeNum = HTML_EL_H3;
1543: searchedType3.ElSSchema = HTMLschema;
1544: searchedType3.ElTypeNum = HTML_EL_H4;
1545: searchedType4.ElSSchema = HTMLschema;
1546: searchedType4.ElTypeNum = HTML_EL_H5;
1547: searchedType5.ElSSchema = HTMLschema;
1548: searchedType5.ElTypeNum = HTML_EL_H6;
1549: nH2 = nH3 = nH4 = nH5 = nH6 = 0;
1550: while (el)
1551: {
1552: el = TtaSearchElementAmong5Types (searchedType1, searchedType2,
1.135 vatton 1553: searchedType3, searchedType4,
1554: searchedType5, SearchForward, el);
1.120 vatton 1555: if (el)
1.135 vatton 1556: {
1557: /* generate the text number */
1558: elType = TtaGetElementType (el);
1559: s[0] = EOS;
1560: switch (elType.ElTypeNum)
1561: {
1562: case HTML_EL_H2:
1563: nH2++;
1564: nH3 = nH4 = nH5 = nH6 = 0;
1565: sprintf (s, "%d.", nH2);
1566: break;
1567: case HTML_EL_H3:
1568: nH3++;
1569: nH4 = nH5 = nH6 = 0;
1570: if (nH2)
1571: sprintf (s, "%d.", nH2);
1572: sprintf (n, "%d.", nH3);
1573: strcat (s, n);
1574: break;
1575: case HTML_EL_H4:
1576: nH4++;
1577: nH5 = nH6 = 0;
1578: if (nH2)
1579: sprintf (s, "%d.", nH2);
1580: if (nH3)
1581: {
1582: sprintf (n, "%d.", nH3);
1583: strcat (s, n);
1584: }
1585: sprintf (n, "%d.", nH4);
1586: strcat (s, n);
1587: break;
1588: case HTML_EL_H5:
1589: nH5++;
1590: nH6 = 0;
1591: if (nH2)
1592: sprintf (s, "%d.", nH2);
1593: if (nH3)
1594: {
1595: sprintf (n, "%d.", nH3);
1596: strcat (s, n);
1597: }
1598: if (nH4)
1599: {
1600: sprintf (n, "%d.", nH4);
1601: strcat (s, n);
1602: }
1603: sprintf (n, "%d.", nH5);
1604: strcat (s, n);
1605: break;
1606: case HTML_EL_H6:
1607: nH6++;
1608: if (nH2)
1609: sprintf (s, "%d.", nH2);
1610: if (nH3)
1611: {
1612: sprintf (n, "%d.", nH3);
1613: strcat (s, n);
1614: }
1615: if (nH4)
1616: {
1617: sprintf (n, "%d.", nH4);
1618: strcat (s, n);
1619: }
1620: if (nH5)
1621: {
1622: sprintf (n, "%d.", nH5);
1623: strcat (s, n);
1624: }
1625: sprintf (n, "%d.", nH6);
1626: strcat (s, n);
1627: break;
1628: default: break;
1629: }
1630: strcat (s, " ");
1631:
1632: /* look for the first leaf child */
1633: child = el;
1634: if (child)
1635: {
1636: do
1637: {
1638: child = TtaGetFirstChild (child);
1639: childType = TtaGetElementType (child);
1640: }
1641: while (!TtaIsLeaf (childType) && childType.ElSSchema == HTMLschema);
1642: }
1643: if (child && childType.ElSSchema == HTMLschema &&
1644: childType.ElTypeNum == HTML_EL_TEXT_UNIT)
1645: {
1646: /* the first leaf child is a text unit */
1647: new_ = NULL;
1648: /* check the text contents */
1649: length = TtaGetTextLength (child) + 1;
1650: text = (char *)TtaGetMemory (length);
1651: TtaGiveTextContent (child, (unsigned char *)text, &length, &lang);
1652: /* remove the old number */
1653: i = 0;
1654: while (isdigit (text[i]) || text[i] == '.')
1655: i++;
1.138 vatton 1656: // remove extra spaces
1657: while (text[i] == SPACE)
1658: i++;
1.135 vatton 1659: TtaRegisterElementReplace (child, doc);
1660: TtaSetTextContent (child, (unsigned char *)s, Latin_Script, doc);
1661: TtaAppendTextContent (child, (unsigned char *)&text[i], doc);
1662: TtaFreeMemory (text);
1663: change = TRUE;
1664: }
1665: else
1666: {
1667: /* add a new text element */
1668: elType.ElTypeNum = HTML_EL_TEXT_UNIT;
1669: new_ = TtaNewElement (doc, elType);
1670: if (child)
1671: /* insert before */
1672: TtaInsertSibling (new_, child, TRUE, doc);
1673: else
1674: TtaInsertFirstChild (&new_, el, doc);
1675: TtaSetTextContent (new_, (unsigned char *)s, Latin_Script, doc);
1676: TtaRegisterElementCreate (new_, doc);
1677: change = TRUE;
1678: }
1679: }
1.120 vatton 1680: }
1681:
1682: if (closeUndo)
1683: TtaCloseUndoSequence (doc);
1684: if (dispMode == DisplayImmediately)
1685: TtaSetDisplayMode (doc, dispMode);
1.123 vatton 1686: if (change)
1687: TtaSetDocumentModified (doc);
1.119 vatton 1688: }
1689:
1690: /*----------------------------------------------------------------------
1.114 vatton 1691: MakeToC generates a Table of Contents at the current position.
1692: Looks for all HTML Hi elements after the current position.
1693: ----------------------------------------------------------------------*/
1694: void MakeToc (Document doc, View view)
1695: {
1.146 quint 1696: Element el, new_, *list, parent, copy, srce, child, prev, ancest;
1.114 vatton 1697: Element toc, lH2, lH3, lH4, lH5, lH6, item;
1698: ElementType elType, searchedType1, searchedType2;
1699: ElementType searchedType3, searchedType4, searchedType5;
1700: ElementType ulType, copyType;
1701: AttributeType attrType;
1702: Attribute attr;
1703: DisplayMode dispMode;
1.148 vatton 1704: char *s, *id, *value;
1.114 vatton 1705: int firstChar, i;
1.148 vatton 1706: ThotBool closeUndo, found;
1.114 vatton 1707:
1708: /* check if there is HTML Hi elements and if the current position is
1.135 vatton 1709: within a HTML Body element */
1.114 vatton 1710: dispMode = TtaGetDisplayMode (doc);
1711:
1712: /* get the insert point */
1713: TtaGiveFirstSelectedElement (doc, &el, &firstChar, &i);
1714: if (el == NULL || TtaIsReadOnly (el))
1.117 vatton 1715: {
1716: /* no selection */
1717: TtaDisplaySimpleMessage (CONFIRM, AMAYA, AM_NO_INSERT_POINT);
1.135 vatton 1718: return;
1.117 vatton 1719: }
1.137 vatton 1720: else if (TtaIsReadOnly (el))
1721: {
1722: /* read-only */
1723: TtaDisplaySimpleMessage (CONFIRM, LIB, TMSG_EL_RO);
1724: return;
1725: }
1726:
1.114 vatton 1727: elType = TtaGetElementType (el);
1728: s = TtaGetSSchemaName (elType.ElSSchema);
1729: if (strcmp (s, "HTML"))
1730: /* not within HTML element */
1.146 quint 1731: {
1732: /* skip ancestors that are Template elements */
1733: ancest = el;
1734: while (ancest && !strcmp (s, "Template"))
1735: {
1736: ancest = TtaGetParent (ancest);
1737: if (ancest)
1738: {
1739: elType = TtaGetElementType (ancest);
1740: s = TtaGetSSchemaName (elType.ElSSchema);
1741: }
1742: }
1743: if (strcmp (s, "HTML"))
1744: return;
1745: }
1746:
1.114 vatton 1747: if (!HTMLelementAllowed (doc))
1748: /* the creation of an HTML element is not allowed here */
1749: return;
1750:
1751: attrType.AttrSSchema = elType.ElSSchema;
1752: ulType.ElSSchema = elType.ElSSchema;
1.115 vatton 1753: ulType.ElTypeNum = HTML_EL_Unnumbered_List;
1.114 vatton 1754: searchedType1.ElSSchema = elType.ElSSchema;
1755: searchedType1.ElTypeNum = HTML_EL_H2;
1756: searchedType2.ElSSchema = elType.ElSSchema;
1757: searchedType2.ElTypeNum = HTML_EL_H3;
1758: searchedType3.ElSSchema = elType.ElSSchema;
1759: searchedType3.ElTypeNum = HTML_EL_H4;
1760: searchedType4.ElSSchema = elType.ElSSchema;
1761: searchedType4.ElTypeNum = HTML_EL_H5;
1762: searchedType5.ElSSchema = elType.ElSSchema;
1763: searchedType5.ElTypeNum = HTML_EL_H6;
1.115 vatton 1764: toc = lH2 = lH3 = lH4 = lH5 = lH6 = prev = NULL;
1.114 vatton 1765: list = NULL;
1.148 vatton 1766: /* check if the insert point is already within a table of contents */
1767: ancest = el;
1768: found = FALSE;
1769: while (ancest &&
1770: elType.ElSSchema != ulType.ElSSchema ||
1771: elType.ElTypeNum != HTML_EL_Division)
1772: {
1773: if (!found && !strcmp (s, "Template"))
1774: // cross an enclosing XTiger element
1775: found = TRUE;
1776: ancest = TtaGetParent (ancest);
1777: if (ancest)
1778: {
1779: elType = TtaGetElementType (ancest);
1780: s = TtaGetSSchemaName (elType.ElSSchema);
1781: }
1782: }
1783: if (ancest)
1784: {
1785: // check if that division has the toc class
1786: attrType.AttrTypeNum = HTML_ATTR_Class;
1787: attr = TtaGetAttribute (ancest, attrType);
1788: if (attr)
1789: {
1790: i = TtaGetTextAttributeLength (attr);
1791: if (i == 3)
1792: {
1793: value = (char *)TtaGetMemory (i + 1);
1794: TtaGiveTextAttributeValue(attr, value, &i);
1795: if (strcmp (value, "toc"))
1796: attr = NULL;
1797: }
1798: else
1799: attr = NULL;
1800: }
1801: if (attr)
1802: {
1803: if (found)
1.149 ! vatton 1804: {
! 1805: TtaDisplaySimpleMessage (CONFIRM, LIB, TMSG_EL_RO);
! 1806: return;
! 1807: }
1.148 vatton 1808: else
1809: toc = ancest;
1810: }
1811: }
1812:
1813: if (dispMode == DisplayImmediately)
1814: TtaSetDisplayMode (doc, SuspendDisplay);
1815:
1816: if (TtaPrepareUndo (doc))
1817: closeUndo = FALSE;
1818: else
1.114 vatton 1819: {
1.148 vatton 1820: closeUndo = TRUE;
1821: TtaOpenUndoSequence (doc, NULL, NULL, 0, 0);
1822: }
1823:
1824: if (toc)
1825: {
1826: // replace the old toc by the new one
1827: child = TtaGetFirstChild (toc);
1828: TtaRegisterElementDelete (child, doc);
1829: TtaRemoveTree (child, doc);
1830: }
1831:
1832: // keep in memory the current selected element
1833: ancest = el;
1834: el = TtaGetMainRoot (doc);
1835: while (el)
1836: {
1837: el = TtaSearchElementAmong5Types (searchedType1, searchedType2,
1838: searchedType3, searchedType4,
1839: searchedType5, SearchForward, el);
1840: if (el)
1.135 vatton 1841: {
1.148 vatton 1842: if (toc == NULL)
1.135 vatton 1843: {
1.148 vatton 1844: /* genetate the enclosing division */
1845: elType.ElTypeNum = HTML_EL_Division;
1846: TtaCreateElement (elType, doc);
1847: TtaGiveFirstSelectedElement (doc, &child, &firstChar, &i);
1848: if (child != ancest)
1.135 vatton 1849: {
1.148 vatton 1850: /* the div and its initial content is now created */
1.142 vatton 1851: toc = TtaGetTypedAncestor (child, elType);
1852: TtaRegisterElementDelete (child, doc);
1853: TtaRemoveTree (child, doc);
1.135 vatton 1854: }
1.142 vatton 1855: else
1.135 vatton 1856: {
1.148 vatton 1857: if (closeUndo)
1858: TtaCloseUndoSequence (doc);
1859: if (dispMode == DisplayImmediately)
1860: TtaSetDisplayMode (doc, dispMode);
1.149 ! vatton 1861: TtaDisplaySimpleMessage (CONFIRM, AMAYA, AM_NOT_ALLOWED);
1.148 vatton 1862: return;
1863: }
1864: if (toc)
1865: {
1866: /* it's the last created element */
1867: attrType.AttrTypeNum = HTML_ATTR_Class;
1868: attr = TtaNewAttribute (attrType);
1869: TtaAttachAttribute (toc, attr, doc);
1870: TtaSetAttributeText (attr, "toc", toc, doc);
1871: TtaRegisterAttributeCreate (attr, toc, doc);
1872: }
1873: }
1874: if (toc == NULL)
1875: el = NULL;
1876: else
1877: {
1878: /* does the element have an ID attribute already? */
1879: attrType.AttrTypeNum = HTML_ATTR_ID;
1880: attr = TtaGetAttribute (el, attrType);
1881: if (!attr)
1882: {
1883: /* generate the ID if it does't exist */
1884: CreateTargetAnchor (doc, el, TRUE, TRUE);
1.135 vatton 1885: attr = TtaGetAttribute (el, attrType);
1.148 vatton 1886: }
1887: i = TtaGetTextAttributeLength (attr) + 1;
1888: id = (char *)TtaGetMemory (i + 1);
1889: id[0] = '#';
1890: TtaGiveTextAttributeValue (attr, &id[1], &i);
1.114 vatton 1891:
1.148 vatton 1892: /* locate or generate the list */
1893: elType = TtaGetElementType (el);
1894: if (elType.ElTypeNum == HTML_EL_H2)
1895: {
1896: parent = toc;
1897: lH3 = lH4 = lH5 = lH6 = NULL;
1898: list = &lH2;
1899: }
1900: else if (elType.ElTypeNum == HTML_EL_H3)
1901: {
1902: if (lH2)
1903: parent = TtaGetLastChild (lH2);
1904: else
1905: parent = toc;
1906: lH4 = lH5 = lH6 = NULL;
1907: list = &lH3;
1908: }
1909: else if (elType.ElTypeNum == HTML_EL_H4)
1910: {
1911: if (lH3)
1912: parent = TtaGetLastChild (lH3);
1913: else if (lH2)
1914: parent = TtaGetLastChild (lH2);
1915: else
1916: parent = toc;
1917: lH5 = lH6 = NULL;
1918: list = &lH4;
1919: }
1920: else if (elType.ElTypeNum == HTML_EL_H5)
1921: {
1922: if (lH4)
1923: parent = TtaGetLastChild (lH4);
1924: else if (lH3)
1925: parent = TtaGetLastChild (lH3);
1926: else if (lH2)
1927: parent = TtaGetLastChild (lH2);
1928: else
1929: parent = toc;
1930: lH6 = NULL;
1931: list = &lH5;
1932: }
1933: else if (elType.ElTypeNum == HTML_EL_H6)
1934: {
1935: if (lH5)
1936: parent = TtaGetLastChild (lH5);
1937: else if (lH4)
1938: parent = TtaGetLastChild (lH4);
1939: else if (lH3)
1940: parent = TtaGetLastChild (lH3);
1941: else if (lH2)
1942: parent = TtaGetLastChild (lH2);
1943: else
1944: parent = toc;
1945: list = &lH6;
1946: }
1947:
1948: if (*list == NULL)
1949: {
1950: /* generate the list */
1951: *list = TtaNewElement (doc, ulType);
1952: child = TtaGetLastChild (parent);
1953: if (child)
1954: TtaInsertSibling (*list, child, FALSE, doc);
1955: else
1956: TtaInsertFirstChild (list, parent, doc);
1957: TtaRegisterElementCreate (*list, doc);
1958: }
1959: /* generate the list item */
1960: elType.ElTypeNum = HTML_EL_List_Item;
1961: item = TtaNewElement (doc, elType);
1962: /* generate the HTML_EL_Pseudo_paragraph */
1963: elType.ElTypeNum = HTML_EL_Pseudo_paragraph;
1964: parent = TtaNewElement (doc, elType);
1965: TtaInsertFirstChild (&parent, item, doc);
1966: /* generate the link anchor */
1967: elType.ElTypeNum = HTML_EL_Anchor;
1968: new_ = TtaNewElement (doc, elType);
1969: TtaInsertFirstChild (&new_, parent, doc);
1970: attrType.AttrTypeNum = HTML_ATTR_HREF_;
1971: attr = TtaNewAttribute (attrType);
1972: TtaAttachAttribute (new_, attr, doc);
1973: TtaSetAttributeText (attr, id, new_, doc);
1974: TtaFreeMemory (id);
1975: id = NULL;
1976: /* get a copy of the Hi contents */
1977: srce = TtaGetFirstChild (el);
1978: prev = NULL;
1979: parent = NULL;
1980: while (srce)
1981: {
1982: copyType = TtaGetElementType (srce);
1983: s = TtaGetSSchemaName (copyType.ElSSchema);
1984: while (srce && !TtaIsLeaf (copyType) &&
1985: !strcmp (s, "Template"))
1.142 vatton 1986: {
1.148 vatton 1987: /* copy the anchor contents instead of the anchor */
1988: if (parent == NULL)
1989: parent = srce;
1990: srce = TtaGetFirstChild (srce);
1991: if (srce)
1992: {
1993: copyType = TtaGetElementType (srce);
1994: s = TtaGetSSchemaName (copyType.ElSSchema);
1995: }
1.142 vatton 1996: }
1.148 vatton 1997: if (srce &&
1998: copyType.ElTypeNum == HTML_EL_Anchor &&
1999: copyType.ElSSchema == elType.ElSSchema)
1.142 vatton 2000: {
1.148 vatton 2001: /* copy the anchor contents instead of the anchor */
2002: if (parent == NULL)
2003: parent = srce;
2004: srce = TtaGetFirstChild (srce);
1.142 vatton 2005: }
1.148 vatton 2006: if (srce)
1.142 vatton 2007: {
1.148 vatton 2008: /* copy children of the next source */
2009: copy = TtaCopyTree (srce, doc, doc, new_);
2010: if (copy)
2011: {
2012: if (prev == NULL)
2013: /* this is the first copied element. Insert it before elem */
2014: TtaInsertFirstChild (©, new_, doc);
2015: else
2016: /* insert the new copied element after the element previously
2017: copied */
2018: TtaInsertSibling (copy, prev, FALSE, doc);
2019: prev = copy;
2020: }
2021: TtaNextSibling (&srce);
1.142 vatton 2022: }
1.148 vatton 2023: if (srce == NULL && parent)
1.142 vatton 2024: {
1.148 vatton 2025: /* copy children of an anchor */
2026: srce = parent;
2027: parent = NULL;
1.135 vatton 2028: if (srce)
1.148 vatton 2029: TtaNextSibling (&srce);
1.135 vatton 2030: }
2031: }
1.148 vatton 2032: child = TtaGetLastChild (*list);
2033: if (child)
2034: TtaInsertSibling (item, child, FALSE, doc);
2035: else
2036: TtaInsertFirstChild (&item, *list, doc);
2037: TtaRegisterElementCreate (item, doc);
1.135 vatton 2038: }
2039: }
1.114 vatton 2040: }
1.148 vatton 2041:
1.114 vatton 2042: if (closeUndo)
2043: TtaCloseUndoSequence (doc);
1.137 vatton 2044:
2045: if (toc == NULL)
1.142 vatton 2046: {
2047: if (dispMode == DisplayImmediately)
2048: TtaSetDisplayMode (doc, dispMode);
2049: TtaDisplaySimpleMessage (CONFIRM, AMAYA, AM_NO_HEADING_FOUND);
2050: }
1.137 vatton 2051: else
1.115 vatton 2052: {
1.137 vatton 2053: /* force a complete redisplay to apply CSS */
2054: TtaSetDisplayMode (doc, NoComputedDisplay);
2055: if (dispMode == DisplayImmediately)
2056: TtaSetDisplayMode (doc, dispMode);
2057: /* select the end of the toc */
2058: if (prev)
1.135 vatton 2059: {
1.137 vatton 2060: child = prev;
2061: while (child)
2062: {
2063: child = TtaGetLastChild (prev);
2064: if (child)
2065: prev = child;
2066: }
2067: elType = TtaGetElementType (prev);
2068: if (elType.ElTypeNum == HTML_EL_TEXT_UNIT)
2069: {
2070: i = TtaGetElementVolume (prev);
2071: TtaSelectString (doc, prev, i+1, i);
2072: }
2073: else
2074: TtaSelectElement (doc, prev);
1.135 vatton 2075: }
1.115 vatton 2076: }
1.114 vatton 2077: }
Webmaster