Annotation of Amaya/amaya/HTMLbook.c, revision 1.70
1.1 cvs 1: /*
2: *
3: * (c) COPYRIGHT MIT and INRIA, 1996.
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.49 cvs 12: * R. Guetari (W3C/INRIA) - Unicode and Windows version.
1.1 cvs 13: */
14:
15:
16: /* Included headerfiles */
17: #define THOT_EXPORT
18: #include "amaya.h"
1.44 cvs 19: #include "AHTURLTools_f.h"
1.1 cvs 20: #include "print.h"
1.51 cvs 21: #include "css.h"
1.1 cvs 22:
1.25 cvs 23: /* structure to register sub-documents in MakeBook function*/
24: typedef struct _SubDoc
25: {
26: struct _SubDoc *SDnext;
27: Element SDel;
1.36 cvs 28: STRING SDname;
1.25 cvs 29: }SubDoc;
30:
1.29 cvs 31: /* the structure used for the GetIncludedDocuments_callback function */
1.58 cvs 32: typedef struct _IncludeCtxt
1.53 cvs 33: {
1.58 cvs 34: Element div; /* enclosing element for the search */
35: Element link; /* current processed link */
36: STRING url; /* called url */
37: STRING name; /* the fragment name */
38: struct _IncludeCtxt *ctxt; /* the previous context */
39: } IncludeCtxt;
1.29 cvs 40:
1.55 cvs 41: /* shared with windialogapi.c */
42: ThotBool PrintURL;
43: ThotBool NumberLinks;
44: ThotBool WithToC;
45: ThotBool IgnoreCSS;
46:
1.25 cvs 47: static struct _SubDoc *SubDocs;
1.62 cvs 48: static CHAR_T PSdir[MAX_PATH];
1.53 cvs 49: static CHAR_T PPrinter[MAX_PATH];
50: static Document DocPrint;
1.2 cvs 51: static int PaperPrint;
52: static int ManualFeed;
53: static int PageSize;
1.1 cvs 54:
55: #include "init_f.h"
56: #include "HTMLactions_f.h"
57: #include "HTMLbook_f.h"
58: #include "HTMLedit_f.h"
1.25 cvs 59: #include "HTMLhistory_f.h"
1.51 cvs 60: #include "UIcss_f.h"
1.1 cvs 61:
1.31 cvs 62: #ifdef _WINDOWS
1.37 cvs 63: #include "wininclude.h"
1.31 cvs 64: #endif /* _WINDOWS */
65:
1.58 cvs 66: static ThotBool GetIncludedDocuments ();
1.1 cvs 67:
68: /*----------------------------------------------------------------------
1.16 cvs 69: RegisterSubDoc adds a new entry in SubDoc table.
70: ----------------------------------------------------------------------*/
71: #ifdef __STDC__
1.36 cvs 72: static void RegisterSubDoc (Element el, STRING url)
1.16 cvs 73: #else
74: static void RegisterSubDoc (el, url)
75: Element el;
1.36 cvs 76: STRING url;
1.16 cvs 77: #endif
78: {
79: struct _SubDoc *entry, *last;
80:
81: if (url == NULL || url[0] == EOS)
82: return;
83:
84: entry = TtaGetMemory (sizeof (struct _SubDoc));
85: entry->SDnext = NULL;
86: entry->SDel = el;
1.62 cvs 87: entry->SDname = TtaWCSdup (url);
1.16 cvs 88:
89: if (SubDocs == NULL)
90: SubDocs = entry;
91: else
92: {
93: last = SubDocs;
94: while (last->SDnext != NULL)
95: last = last->SDnext;
96: last->SDnext = entry;
97: }
98: }
99:
100:
101: /*----------------------------------------------------------------------
102: SearchSubDoc searches whether a document name is registered or not
103: within the SubDoc table.
104: Return the DIV element that correspond to the sub-document or NULL.
105: ----------------------------------------------------------------------*/
106: #ifdef __STDC__
1.36 cvs 107: static Element SearchSubDoc (STRING url)
1.16 cvs 108: #else
109: static Element SearchSubDoc (url)
1.36 cvs 110: STRING url;
1.16 cvs 111: #endif
112: {
113: Element el;
114: struct _SubDoc *entry;
1.47 cvs 115: ThotBool docFound;
1.16 cvs 116:
117: if (url == NULL || url[0] == EOS)
118: return (NULL);
119:
120: entry = SubDocs;
121: docFound = FALSE;
122: el = NULL;
123: while (!docFound && entry != NULL)
124: {
1.36 cvs 125: docFound = (ustrcmp (url, entry->SDname) == 0);
1.16 cvs 126: if (!docFound)
127: entry = entry->SDnext;
128: else
129: /* document found -> return the DIV element */
130: el = entry->SDel;
131: }
132: return (el);
133: }
134:
135: /*----------------------------------------------------------------------
136: FreeSubDocTable frees all entries in SubDoc table.
137: ----------------------------------------------------------------------*/
138: static void FreeSubDocTable ()
139: {
140: struct _SubDoc *entry, *last;
141:
142: entry = SubDocs;
143: while (entry != NULL)
144: {
145: last = entry;
146: entry = entry->SDnext;
147: TtaFreeMemory (last->SDname);
148: TtaFreeMemory (last);
149: }
150: SubDocs = NULL;
151: }
152:
153:
154:
155: /*----------------------------------------------------------------------
1.1 cvs 156: SetInternalLinks
1.8 cvs 157: Associate an InternalLink attribute with all anchor (A) elements of the
158: document which designate an element in the same document.
1.1 cvs 159: InternalLink is a Thot reference attribute that links a source and a
160: target anchor and that allows P schemas to display and print cross-references
161: ----------------------------------------------------------------------*/
162: #ifdef __STDC__
1.4 cvs 163: void SetInternalLinks (Document document)
1.1 cvs 164: #else
1.4 cvs 165: void SetInternalLinks (document)
1.1 cvs 166: Document document;
167: #endif
168: {
1.32 cvs 169: Element el, div, link, target, sibling;
170: ElementType elType, linkType;
1.16 cvs 171: Attribute HrefAttr, IntLinkAttr;
1.17 cvs 172: Attribute attr, ExtLinkAttr;
1.16 cvs 173: AttributeType attrType;
1.36 cvs 174: STRING text, ptr, url;
1.43 cvs 175: CHAR_T number[10];
176: CHAR_T value[MAX_LENGTH];
1.25 cvs 177: int length, i, volume;
178: int status, position;
1.47 cvs 179: ThotBool split;
1.1 cvs 180:
1.16 cvs 181: /* Remember the current status of the document */
182: status = TtaIsDocumentModified (document);
1.32 cvs 183: el = TtaGetMainRoot (document);
184: volume = TtaGetElementVolume (el);
185: elType = TtaGetElementType (el);
186: elType.ElTypeNum = HTML_EL_AnyLink;
1.16 cvs 187: attrType.AttrSSchema = elType.ElSSchema;
1.32 cvs 188: /* looks for all links in the document */
1.16 cvs 189: link = el;
190: while (link != NULL)
191: {
1.25 cvs 192: /* display the progression of the work */
193: el = link;
194: position = 0;
195: while (el != NULL)
196: {
197: sibling = el;
198: do
199: {
200: /* add volume of each previous element */
201: TtaPreviousSibling (&sibling);
202: if (sibling != NULL)
203: position += TtaGetElementVolume (sibling);
204: }
205: while (sibling != NULL);
206: el = TtaGetParent (el);
207: }
1.49 cvs 208: usprintf (number, TEXT("%d"), position*100/volume);
1.25 cvs 209: TtaSetStatus (document, 1, TtaGetMessage (AMAYA, AM_UPDATED_LINK), number);
210: TtaHandlePendingEvents ();
1.16 cvs 211: link = TtaSearchTypedElement (elType, SearchForward, link);
212: if (link != NULL)
1.32 cvs 213: /* a link has been found */
1.16 cvs 214: {
1.32 cvs 215: linkType = TtaGetElementType (link);
216: if (linkType.ElTypeNum == HTML_EL_Anchor)
217: attrType.AttrTypeNum = HTML_ATTR_HREF_;
218: else
219: attrType.AttrTypeNum = HTML_ATTR_cite;
1.16 cvs 220: HrefAttr = TtaGetAttribute (link, attrType);
221: attrType.AttrTypeNum = HTML_ATTR_InternalLink;
222: IntLinkAttr = TtaGetAttribute (link, attrType);
223: attrType.AttrTypeNum = HTML_ATTR_ExternalLink;
224: ExtLinkAttr = TtaGetAttribute (link, attrType);
225: if (HrefAttr == NULL)
1.32 cvs 226: /* this element is not a link (no href or cite attribute) */
1.16 cvs 227: /* remove attributes InternalLink and ExternalLink if they
228: are present */
229: {
1.8 cvs 230: if (IntLinkAttr != NULL)
1.16 cvs 231: TtaRemoveAttribute (link, IntLinkAttr, document);
232: if (ExtLinkAttr != NULL)
233: TtaRemoveAttribute (link, ExtLinkAttr, document);
234: }
235: else
1.32 cvs 236: /* this element has an HREF or cite attribute */
1.16 cvs 237: {
238: length = TtaGetTextAttributeLength (HrefAttr);
1.49 cvs 239: text = TtaAllocString (length + 1);
1.16 cvs 240: TtaGiveTextAttributeValue (HrefAttr, text, &length);
241:
242: /* does an external link become an internal link ? */
1.25 cvs 243: if (document == DocBook && SubDocs != NULL)
1.16 cvs 244: {
1.36 cvs 245: ptr = ustrrchr (text, '#');
1.16 cvs 246: url = text;
1.18 cvs 247: split = FALSE;
1.16 cvs 248: if (ptr == text)
249: /* a local link */
250: url = NULL;
1.17 cvs 251: else if (ptr != NULL)
1.16 cvs 252: {
253: /* split url and name part */
254: ptr[0] = EOS;
255: split = TRUE;
256: }
257:
258: /* Is it a sub-document */
259: div = SearchSubDoc (url);
260: if (split)
261: /* retore the mark */
262: ptr[0] = '#';
263:
264: if (div == NULL)
265: {
266: /* it's not a sub-document */
267: if (url == NULL)
268: /* a local link */
269: ptr = &text[1];
270: else
271: /* still an externa; link */
272: ptr = NULL;
273: }
274: else
275: {
276: /* this link becomes internal */
1.17 cvs 277: if (ptr != NULL)
1.16 cvs 278: {
1.17 cvs 279: /* get the target name */
1.36 cvs 280: ustrcpy (value, ptr);
281: length = ustrlen (value);
1.17 cvs 282: /* check whether the name changed */
283: i = 0;
284: target = SearchNAMEattribute (document, &value[1], NULL);
285: while (target != NULL)
1.16 cvs 286: {
1.17 cvs 287: /* is it the right NAME */
288: if (TtaIsAncestor (target, div))
289: target = NULL;
290: else
291: {
292: /* continue the search */
293: i++;
1.49 cvs 294: usprintf (&value[length], TEXT("%d"), i);
1.32 cvs 295: target = SearchNAMEattribute (document,
296: &value[1], NULL);
1.17 cvs 297: }
1.16 cvs 298: }
299: }
1.17 cvs 300: else
301: {
302: /* get the DIV name */
303: attrType.AttrTypeNum = HTML_ATTR_ID;
304: attr = TtaGetAttribute (div, attrType);
305: length = 200;
306: value[0] = '#';
307: TtaGiveTextAttributeValue (attr, &value[1], &length);
308: }
1.16 cvs 309: ptr = &value[1];
310: TtaSetAttributeText (HrefAttr, value, link, document);
311: }
312: }
313: else if (text[0] == '#')
314: ptr = &text[1];
315: else
316: ptr = NULL;
317:
318: if (ptr != NULL)
319: /* it's an internal link. Attach an attribute InternalLink */
320: /* to the link, if this attribute does not exist yet */
321: {
322: if (IntLinkAttr == NULL)
323: {
324: attrType.AttrTypeNum = HTML_ATTR_InternalLink;
325: IntLinkAttr = TtaNewAttribute (attrType);
326: TtaAttachAttribute (link, IntLinkAttr, document);
327: }
328: /* looks for the target element */
329: target = SearchNAMEattribute (document, ptr, NULL);
330: if (target != NULL)
331: /* set the Thot link */
1.32 cvs 332: TtaSetAttributeReference (IntLinkAttr, link, document,
333: target, document);
1.16 cvs 334: }
335: else
336: /* it's an external link */
337: {
338: /* Remove the InternalLink attribute if it is present */
339: if (IntLinkAttr != NULL)
340: TtaRemoveAttribute (link, IntLinkAttr, document);
341: /* create an ExternalLink attribute if there is none */
342: if (ExtLinkAttr == NULL)
343: {
344: attrType.AttrTypeNum = HTML_ATTR_ExternalLink;
345: ExtLinkAttr = TtaNewAttribute (attrType);
346: TtaAttachAttribute (link, ExtLinkAttr, document);
347: }
348: }
349: TtaFreeMemory (text);
350: }
351: }
352: }
353: /* Reset document status */
354: if (!status)
355: TtaSetDocumentUnmodified (document);
1.3 cvs 356: }
357:
358: /*----------------------------------------------------------------------
359: CheckPrintingDocument reinitialize printing parameters as soon as
360: the printing document changes.
361: ----------------------------------------------------------------------*/
362: #ifdef __STDC__
363: static void CheckPrintingDocument (Document document)
364: #else
365: static void CheckPrintingDocument (document)
366: Document document;
367: #endif
368: {
1.62 cvs 369: CHAR_T docName[MAX_LENGTH];
370: CHAR_T* ptr;
371: CHAR_T suffix[MAX_LENGTH];
1.3 cvs 372: int lg;
373:
1.53 cvs 374: if (DocPrint != document)
1.3 cvs 375: {
376: /* initialize print parameters */
1.53 cvs 377: DocPrint = document;
1.3 cvs 378:
379: /* define the new default PS file */
1.52 cvs 380: ptr = TtaGetEnvString ("APP_TMPDIR");
1.3 cvs 381: if (ptr != NULL && TtaCheckDirectory (ptr))
1.62 cvs 382: ustrcpy (PSdir, ptr);
1.44 cvs 383: else
1.62 cvs 384: ustrcpy (PSdir, TtaGetDefEnvString ("APP_TMPDIR"));
385: lg = ustrlen (PSdir);
386: if (PSdir[lg - 1] == WC_DIR_SEP)
387: PSdir[--lg] = WC_EOS;
1.44 cvs 388:
1.62 cvs 389: ustrcpy (docName, TtaGetDocumentName (document));
1.3 cvs 390: ExtractSuffix (docName, suffix);
1.62 cvs 391: usprintf (&PSdir[lg], TEXT("%c%s.ps"), WC_DIR_SEP, docName);
1.3 cvs 392: TtaSetPsFile (PSdir);
393: /* define the new default PrintSchema */
1.53 cvs 394: NumberLinks = FALSE;
395: WithToC = FALSE;
396: IgnoreCSS = FALSE;
397: PrintURL = TRUE;
1.61 cvs 398: TtaSetPrintSchema (TEXT(""));
1.3 cvs 399: /* no manual feed */
400: ManualFeed = PP_OFF;
401: TtaSetPrintParameter (PP_ManualFeed, ManualFeed);
402: }
403: }
404:
405:
406: /*----------------------------------------------------------------------
407: PrintAs prints the document using predefined parameters.
408: ----------------------------------------------------------------------*/
409: #ifdef __STDC__
1.45 cvs 410: static void PrintDocument (Document doc, View view)
1.3 cvs 411: #else /* __STDC__ */
1.45 cvs 412: static void PrintDocument (doc, view)
1.38 cvs 413: Document doc;
1.3 cvs 414: #endif /* __STDC__ */
415: {
1.34 cvs 416: AttributeType attrType;
417: Attribute attr;
418: Element el;
1.50 cvs 419: STRING files, dir;
420: CHAR_T viewsToPrint[MAX_PATH];
1.47 cvs 421: ThotBool status, textFile;
1.3 cvs 422:
1.38 cvs 423: textFile = (DocumentTypes[doc] == docText ||
424: DocumentTypes[doc] == docTextRO ||
425: DocumentTypes[doc] == docCSS ||
426: DocumentTypes[doc] == docCSSRO);
427:
428: CheckPrintingDocument (doc);
1.49 cvs 429: ustrcpy (viewsToPrint, TEXT("Formatted_view "));
1.53 cvs 430: if (!textFile && WithToC)
1.49 cvs 431: ustrcat (viewsToPrint, TEXT("Table_of_contents "));
1.53 cvs 432: if (!textFile && NumberLinks)
1.8 cvs 433: /* display numbered links */
1.3 cvs 434: {
1.8 cvs 435: /* associate an attribute InternalLink with all anchors refering
436: a target in the same document. This allows P schemas to work
437: properly */
1.53 cvs 438: SetInternalLinks (DocPrint);
1.3 cvs 439: if (PageSize == PP_A4)
1.61 cvs 440: TtaSetPrintSchema (TEXT("HTMLPLP"));
1.3 cvs 441: else
1.61 cvs 442: TtaSetPrintSchema (TEXT("HTMLPLPUS"));
1.49 cvs 443: ustrcat (viewsToPrint, TEXT("Links_view "));
1.32 cvs 444: }
445: else
446: {
447: if (PageSize == PP_A4)
1.38 cvs 448: {
449: if (textFile)
1.61 cvs 450: TtaSetPrintSchema (TEXT("TextFilePP"));
1.38 cvs 451: else
1.61 cvs 452: TtaSetPrintSchema (TEXT("HTMLPP"));
1.38 cvs 453: }
1.32 cvs 454: else
1.38 cvs 455: {
456: if (textFile)
1.61 cvs 457: TtaSetPrintSchema (TEXT("TextFilePPUS"));
1.38 cvs 458: else
1.61 cvs 459: TtaSetPrintSchema (TEXT("HTMLPPUS"));
1.38 cvs 460: }
1.3 cvs 461: }
1.34 cvs 462: /* post or remove the PrintURL attribute */
1.38 cvs 463: el = TtaGetMainRoot (doc);
464: status = TtaIsDocumentModified (doc);
465: attrType.AttrSSchema = TtaGetDocumentSSchema (doc);
466: if (textFile)
467: attrType.AttrTypeNum = TextFile_ATTR_PrintURL;
468: else
469: attrType.AttrTypeNum = HTML_ATTR_PrintURL;
1.34 cvs 470: attr = TtaGetAttribute (el, attrType);
1.53 cvs 471: if (attr == 0 && PrintURL)
1.34 cvs 472: {
473: attr = TtaNewAttribute (attrType);
1.38 cvs 474: TtaAttachAttribute (el, attr, doc);
1.34 cvs 475: }
1.50 cvs 476:
1.53 cvs 477: if (attr != 0 && !PrintURL)
1.38 cvs 478: TtaRemoveAttribute (el, attr, doc);
1.50 cvs 479: /* get the path dir where css files have to be stored */
1.53 cvs 480: if (textFile || IgnoreCSS)
1.50 cvs 481: files = NULL;
482: else
483: {
484: TtaGetPrintNames (&files, &dir);
485: /* store css files and get the list of names */
486: files = CssToPrint (doc, dir);
487: }
1.53 cvs 488: TtaPrint (DocPrint, viewsToPrint, files);
1.50 cvs 489: TtaFreeMemory (files);
1.34 cvs 490: if (!status)
1.38 cvs 491: TtaSetDocumentUnmodified (doc);
1.1 cvs 492: }
493:
1.45 cvs 494: /*----------------------------------------------------------------------
495: PrintAs prints the document using predefined parameters.
496: ----------------------------------------------------------------------*/
497: #ifdef __STDC__
498: void PrintAs (Document doc, View view)
499: #else /* __STDC__ */
500: void PrintAs (doc, view)
501: Document doc;
502: #endif /* __STDC__ */
503: {
504: #ifdef _WINDOWS
505: SetupAndPrint (doc, view);
506: #else /* _WINDOWS */
507: PrintDocument (doc, view);
508: #endif /* _WINDOWS */
509: }
1.1 cvs 510:
511: /*----------------------------------------------------------------------
512: CallbackImage manage returns of Picture form.
513: ----------------------------------------------------------------------*/
514: #ifdef __STDC__
1.36 cvs 515: void CallbackPrint (int ref, int typedata, STRING data)
1.1 cvs 516: #else /* __STDC__ */
517: void CallbackPrint (ref, typedata, data)
518: int ref;
519: int typedata;
1.36 cvs 520: STRING data;
1.1 cvs 521: #endif /* __STDC__ */
522: {
523: int val;
524:
525: val = (int) data;
1.53 cvs 526: switch (ref - BasePrint)
1.1 cvs 527: {
1.69 cvs 528: case FormPrint:
529: TtaDestroyDialogue (BasePrint + FormPrint);
1.1 cvs 530: switch (val)
531: {
532: case 1:
533: /* confirms the paper print option */
534: /* the other options are not taken into account without this
535: confirmation */
1.2 cvs 536: TtaSetPrintParameter (PP_Destination, PaperPrint);
537: TtaSetPrintParameter (PP_ManualFeed, ManualFeed);
538: TtaSetPrintParameter (PP_PaperSize, PageSize);
1.53 cvs 539: TtaSetPrintCommand (PPrinter);
1.2 cvs 540: TtaSetPsFile (PSdir);
1.40 cvs 541: /* update the environment variable */
1.53 cvs 542: TtaSetEnvString ("THOTPRINT", PPrinter, TRUE);
1.57 cvs 543: TtaSetEnvInt ("PAPERSIZE", PageSize, TRUE);
1.53 cvs 544: PrintDocument (DocPrint, 1);
1.1 cvs 545: break;
1.2 cvs 546: case 0:
1.40 cvs 547: PaperPrint = (TtaGetPrintParameter (PP_Destination)) ? PP_PRINTER : PP_PS;
1.2 cvs 548: ManualFeed = TtaGetPrintParameter (PP_ManualFeed);
549: PageSize = TtaGetPrintParameter (PP_PaperSize);
1.53 cvs 550: TtaGetPrintCommand (PPrinter);
1.2 cvs 551: TtaGetPsFile (PSdir);
552: break;
1.1 cvs 553: default:
554: break;
555: }
556: break;
1.69 cvs 557: case PrintOptions:
1.1 cvs 558: switch (val)
559: {
560: case 0:
561: /* Manual feed option */
1.2 cvs 562: if (ManualFeed == PP_ON)
563: ManualFeed = PP_OFF;
564: else
565: ManualFeed = PP_ON;
1.1 cvs 566: break;
567: case 1:
568: /* Toc option */
1.53 cvs 569: WithToC = !WithToC;
1.1 cvs 570: break;
571: case 2:
1.53 cvs 572: /* NumberLinks option */
573: NumberLinks = !NumberLinks;
1.34 cvs 574: case 3:
575: /* URL option */
1.53 cvs 576: PrintURL = !PrintURL;
577: break;
578: case 4:
579: /* CSS option */
580: IgnoreCSS = !IgnoreCSS;
1.1 cvs 581: break;
582: }
583: break;
1.69 cvs 584: case PaperFormat:
1.1 cvs 585: /* page size submenu */
586: switch (val)
587: {
588: case 0:
1.2 cvs 589: PageSize = PP_A4;
1.1 cvs 590: break;
591: case 1:
1.2 cvs 592: PageSize = PP_US;
1.1 cvs 593: break;
594: }
595: break;
1.69 cvs 596: case PrintSupport:
1.1 cvs 597: /* paper print/save PostScript submenu */
598: switch (val)
599: {
600: case 0:
1.2 cvs 601: if (PaperPrint == PP_PS)
1.1 cvs 602: {
1.2 cvs 603: PaperPrint = PP_PRINTER;
1.69 cvs 604: #ifndef _WINDOWS
605: TtaSetTextForm (BasePrint + PPrinterName, PPrinter);
606: #endif /* !_WINDOWS */
1.1 cvs 607: }
608: break;
609: case 1:
1.2 cvs 610: if (PaperPrint == PP_PRINTER)
1.1 cvs 611: {
1.2 cvs 612: PaperPrint = PP_PS;
1.54 cvs 613: # ifndef _WINDOWS
1.69 cvs 614: TtaSetTextForm (BasePrint + PPrinterName, PSdir);
1.54 cvs 615: # endif /* !_WINDOWS */
1.1 cvs 616: }
617: break;
618: }
619: break;
1.69 cvs 620: case PPrinterName:
1.1 cvs 621: if (data[0] != '\0')
1.2 cvs 622: if (PaperPrint == PP_PRINTER)
1.40 cvs 623: /* text capture zone for the printer name */
1.53 cvs 624: ustrncpy (PPrinter, data, MAX_PATH);
1.1 cvs 625: else
626: /* text capture zone for the name of the PostScript file */
1.36 cvs 627: ustrncpy (PSdir, data, MAX_PATH);
1.1 cvs 628: break;
629: }
630: }
631:
632: /*----------------------------------------------------------------------
633: ----------------------------------------------------------------------*/
634: #ifdef __STDC__
635: void InitPrint (void)
636: #else /* __STDC__ */
637: void InitPrint ()
638: #endif /* __STDC__ */
639: {
1.62 cvs 640: CHAR_T* ptr;
1.1 cvs 641:
1.53 cvs 642: BasePrint = TtaSetCallback (CallbackPrint, PRINT_MAX_REF);
643: DocPrint = 0;
1.1 cvs 644:
645: /* init printer variables */
646: /* read default printer variable */
1.52 cvs 647: ptr = TtaGetEnvString ("THOTPRINT");
1.1 cvs 648: if (ptr == NULL)
1.62 cvs 649: ustrcpy (PPrinter, TEXT(""));
1.1 cvs 650: else
1.62 cvs 651: ustrcpy (PPrinter, ptr);
1.57 cvs 652: TtaGetEnvInt ("PAPERSIZE", &PageSize);
1.2 cvs 653: PaperPrint = PP_PRINTER;
1.53 cvs 654: PrintURL = TRUE;
1.55 cvs 655: IgnoreCSS = FALSE;
1.2 cvs 656: TtaSetPrintParameter (PP_Destination, PaperPrint);
657: TtaSetPrintParameter (PP_PaperSize, PageSize);
1.53 cvs 658: TtaSetPrintCommand (PPrinter);
1.1 cvs 659: }
660:
661: /*----------------------------------------------------------------------
1.3 cvs 662: SetupAndPrint sets printing parameters and starts the printing process
1.1 cvs 663: ----------------------------------------------------------------------*/
664: #ifdef __STDC__
1.38 cvs 665: void SetupAndPrint (Document doc, View view)
1.1 cvs 666: #else
1.38 cvs 667: void SetupAndPrint (doc, view)
668: Document doc;
1.1 cvs 669: View view;
670: #endif
671: {
1.70 ! cvs 672: #ifndef _WINDOWS
! 673: CHAR_T bufMenu[MAX_LENGTH];
1.3 cvs 674: int i;
1.70 ! cvs 675: #endif /* !_WINDOWS */
1.47 cvs 676: ThotBool textFile;
1.38 cvs 677:
678: textFile = (DocumentTypes[doc] == docText ||
679: DocumentTypes[doc] == docTextRO ||
680: DocumentTypes[doc] == docCSS ||
681: DocumentTypes[doc] == docCSSRO);
1.1 cvs 682:
683: /* Print form */
1.38 cvs 684: CheckPrintingDocument (doc);
1.40 cvs 685:
686: /* read the values that the user may have changed thru
687: the configuration menu */
1.53 cvs 688: TtaGetPrintCommand (PPrinter);
1.40 cvs 689: PageSize = TtaGetPrintParameter (PP_PaperSize);
1.27 cvs 690:
1.70 ! cvs 691: #ifndef _WINDOWS
1.69 cvs 692: TtaNewSheet (BasePrint + FormPrint, TtaGetViewFrame (doc, view),
1.1 cvs 693: TtaGetMessage (LIB, TMSG_LIB_PRINT),
1.3 cvs 694: 1, TtaGetMessage (AMAYA, AM_BUTTON_PRINT), FALSE, 2, 'L', D_CANCEL);
1.1 cvs 695: i = 0;
696: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (LIB, TMSG_MANUAL_FEED));
1.36 cvs 697: i += ustrlen (&bufMenu[i]) + 1;
1.1 cvs 698: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_PRINT_TOC));
1.36 cvs 699: i += ustrlen (&bufMenu[i]) + 1;
1.1 cvs 700: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_NUMBERED_LINKS));
1.36 cvs 701: i += ustrlen (&bufMenu[i]) + 1;
1.34 cvs 702: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_PRINT_URL));
1.53 cvs 703: i += ustrlen (&bufMenu[i]) + 1;
704: sprintf (&bufMenu[i], "%s%s", "T", TtaGetMessage (AMAYA, AM_WITH_CSS));
1.69 cvs 705: TtaNewToggleMenu (BasePrint + PrintOptions, BasePrint + FormPrint,
1.53 cvs 706: TtaGetMessage (LIB, TMSG_OPTIONS), 5, bufMenu, NULL, FALSE);
1.2 cvs 707: if (ManualFeed == PP_ON)
1.69 cvs 708: TtaSetToggleMenu (BasePrint + PrintOptions, 0, TRUE);
1.55 cvs 709: else
1.69 cvs 710: TtaSetToggleMenu (BasePrint + PrintOptions, 0, FALSE);
711: TtaSetToggleMenu (BasePrint + PrintOptions, 1, WithToC);
712: TtaSetToggleMenu (BasePrint + PrintOptions, 2, NumberLinks);
713: TtaSetToggleMenu (BasePrint + PrintOptions, 3, PrintURL);
714: TtaSetToggleMenu (BasePrint + PrintOptions, 4, IgnoreCSS);
1.1 cvs 715:
716: /* Paper format submenu */
717: i = 0;
718: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_A4));
1.36 cvs 719: i += ustrlen (&bufMenu[i]) + 1;
1.1 cvs 720: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_US));
1.69 cvs 721: TtaNewSubmenu (BasePrint + PaperFormat, BasePrint + FormPrint, 0,
1.1 cvs 722: TtaGetMessage (LIB, TMSG_PAPER_SIZE), 2, bufMenu, NULL, FALSE);
1.2 cvs 723: if (PageSize == PP_US)
1.69 cvs 724: TtaSetMenuForm (BasePrint + PaperFormat, 1);
1.1 cvs 725: else
1.69 cvs 726: TtaSetMenuForm (BasePrint + PaperFormat, 0);
1.1 cvs 727:
728: /* Print to paper/ Print to file submenu */
729: i = 0;
730: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_PRINTER));
1.36 cvs 731: i += ustrlen (&bufMenu[i]) + 1;
1.1 cvs 732: sprintf (&bufMenu[i], "%s%s", "B", TtaGetMessage (LIB, TMSG_PS_FILE));
1.69 cvs 733: TtaNewSubmenu (BasePrint + PrintSupport, BasePrint + FormPrint, 0,
1.1 cvs 734: TtaGetMessage (LIB, TMSG_OUTPUT), 2, bufMenu, NULL, TRUE);
735: /* text capture zone for the printer name */
1.69 cvs 736: TtaNewTextForm (BasePrint + PPrinterName, BasePrint + FormPrint, NULL, 30, 1, FALSE);
1.1 cvs 737:
738: /* initialization of the PaperPrint selector */
1.2 cvs 739: if (PaperPrint == PP_PRINTER)
1.1 cvs 740: {
1.69 cvs 741: TtaSetMenuForm (BasePrint + PrintSupport, 0);
742: TtaSetTextForm (BasePrint + PPrinterName, PPrinter);
1.1 cvs 743: }
744: else
745: {
1.69 cvs 746: TtaSetMenuForm (BasePrint + PrintSupport, 1);
747: TtaSetTextForm (BasePrint + PPrinterName, PSdir);
1.1 cvs 748: }
749:
750: /* activates the Print form */
1.69 cvs 751: TtaShowDialogue (BasePrint+FormPrint, FALSE);
1.56 cvs 752: if (textFile) {
753: /* invalid dialogue entries */
1.69 cvs 754: TtaRedrawMenuEntry (BasePrint + PrintOptions, 1, NULL, -1, FALSE);
755: TtaRedrawMenuEntry (BasePrint + PrintOptions, 2, NULL, -1, FALSE);
1.56 cvs 756: }
1.70 ! cvs 757: #else /* _WINDOWS */
1.69 cvs 758: CreatePrintDlgWindow (TtaGetViewFrame (doc, view), PSdir);
1.70 ! cvs 759: #endif /* _WINDOWS */
1.1 cvs 760: }
761:
762: /*----------------------------------------------------------------------
763: SectionNumbering
764: Execute the "Section Numbering" command
765: ----------------------------------------------------------------------*/
766: #ifdef __STDC__
1.38 cvs 767: void SectionNumbering (Document doc, View view)
1.1 cvs 768: #else
1.38 cvs 769: void SectionNumbering (doc, view)
770: Document doc;
1.1 cvs 771: View view;
772: #endif
773: {
1.38 cvs 774: ChangeAttrOnRoot (doc, HTML_ATTR_SectionNumbering);
1.1 cvs 775: }
776:
777: /*----------------------------------------------------------------------
778: UpdateURLsInSubtree
779: Update NAMEs and URLs in subtree of el element, to take into account
780: the move from one document to another.
781: If a NAME attribute already exists in the new document, it is changed
782: to avoid duplicate names.
783: Transform the HREF and SRC attribute to make them independent from their
784: former base.
785: ----------------------------------------------------------------------*/
786: #ifdef __STDC__
787: static void UpdateURLsInSubtree (NotifyElement *event, Element el)
788: #else
789: static void UpdateURLsInSubtree (event, el)
790: NotifyElement *event;
791: Element el;
792: #endif
793: {
794: Element nextEl;
795:
796: nextEl = TtaGetFirstChild (el);
797: while (nextEl != NULL)
798: {
1.58 cvs 799: event->element = nextEl;
800: ElementPasted (event);
1.1 cvs 801: TtaNextSibling (&nextEl);
802: }
803: }
804:
805:
806: /*----------------------------------------------------------------------
807: MoveDocumentBody
1.58 cvs 808: Copy the elements contained in the BODY of the document sourceDoc at the
809: position of the element el in the document destDoc.
810: Delete the element containing el and all its empty ancestors.
1.1 cvs 811: If deleteTree is TRUE, copied elements are deleted from the source
812: document.
1.58 cvs 813: Return the root element that delimits the new inserted part (a div).
1.1 cvs 814: ----------------------------------------------------------------------*/
815: #ifdef __STDC__
1.58 cvs 816: static Element MoveDocumentBody (Element el, Document destDoc, Document sourceDoc, STRING target, STRING url, ThotBool deleteTree)
1.1 cvs 817: #else
1.58 cvs 818: static Element MoveDocumentBody (el, destDoc, sourceDoc, target, url, deleteTree)
819: Element el;
1.12 cvs 820: Document destDoc;
821: Document sourceDoc;
1.36 cvs 822: STRING target;
823: STRING url;
1.47 cvs 824: ThotBool deleteTree;
1.1 cvs 825: #endif
826: {
1.58 cvs 827: Element root, ancestor, elem, firstInserted, div;
1.12 cvs 828: Element lastInserted, srce, copy, old, parent, sibling;
829: ElementType elType;
830: NotifyElement event;
831: int checkingMode;
1.47 cvs 832: ThotBool isID;
1.1 cvs 833:
1.67 cvs 834: div = NULL;
1.13 cvs 835: if (target != NULL)
836: {
837: /* locate the target element within the source document */
838: root = SearchNAMEattribute (sourceDoc, target, NULL);
839: elType = TtaGetElementType (root);
1.58 cvs 840: isID = (elType.ElTypeNum != HTML_EL_Anchor && elType.ElTypeNum != HTML_EL_MAP);
1.13 cvs 841: }
842: else
843: {
844: isID = FALSE;
845: /* get the BODY element of source document */
846: root = TtaGetMainRoot (sourceDoc);
847: elType = TtaGetElementType (root);
848: elType.ElTypeNum = HTML_EL_BODY;
849: root = TtaSearchTypedElement (elType, SearchForward, root);
850: }
851:
852: if (root != NULL)
1.12 cvs 853: {
854: /* don't check the abstract tree against the structure schema */
855: checkingMode = TtaGetStructureChecking (destDoc);
856: TtaSetStructureChecking (0, destDoc);
1.58 cvs 857: /* get elem, the ancestor of el which is a child of a DIV or BODY
1.12 cvs 858: element in the destination document. The copied elements will be
859: inserted just before this element. */
1.58 cvs 860: elem = el;
1.12 cvs 861: do
1.1 cvs 862: {
1.12 cvs 863: ancestor = TtaGetParent (elem);
864: if (ancestor != NULL)
865: {
866: elType = TtaGetElementType (ancestor);
867: if (elType.ElTypeNum == HTML_EL_BODY ||
868: elType.ElTypeNum == HTML_EL_Division)
869: ancestor = NULL;
870: else
871: elem = ancestor;
872: }
1.1 cvs 873: }
1.12 cvs 874: while (ancestor != NULL);
875: parent = TtaGetParent (elem);
1.14 cvs 876:
877: /* insert a DIV element */
1.15 cvs 878: elType.ElTypeNum = HTML_EL_Division;
1.16 cvs 879: lastInserted = TtaNewElement (destDoc, elType);
880: TtaInsertSibling (lastInserted, elem, TRUE, destDoc);
1.58 cvs 881: /* this delimits the new inserted part of the document */
1.16 cvs 882: RegisterSubDoc (lastInserted, url);
1.42 cvs 883: CreateTargetAnchor (destDoc, lastInserted, FALSE);
1.58 cvs 884: div = lastInserted;
1.14 cvs 885:
1.12 cvs 886: /* do copy */
1.16 cvs 887: firstInserted = NULL;
1.17 cvs 888: if (isID)
889: srce = root;
890: else
891: srce = TtaGetFirstChild (root);
1.12 cvs 892: while (srce != NULL)
1.1 cvs 893: {
1.12 cvs 894: copy = TtaCopyTree (srce, sourceDoc, destDoc, parent);
895: if (copy != NULL)
896: {
1.16 cvs 897: if (firstInserted == NULL)
1.12 cvs 898: /* this is the first copied element. Insert it before elem */
899: {
1.16 cvs 900: TtaInsertFirstChild (©, lastInserted, destDoc);
1.12 cvs 901: firstInserted = copy;
902: }
903: else
904: /* insert the new copied element after the element previously
905: copied */
906: TtaInsertSibling (copy, lastInserted, FALSE, destDoc);
907: lastInserted = copy;
908: /* update the NAMEs and URLs in the copied element */
909: event.document = destDoc;
910: event.position = sourceDoc;
911: UpdateURLsInSubtree(&event, copy);
912: }
913: /* get the next element in the source document */
914: old = srce;
915: TtaNextSibling (&srce);
916: if (deleteTree)
917: TtaDeleteTree (old, sourceDoc);
1.13 cvs 918: /* Stop here if the target points to a specific element with an ID */
919: if (isID)
920: srce = NULL;
1.1 cvs 921: }
1.12 cvs 922:
923: /* delete the element(s) containing the link to the copied document */
1.58 cvs 924: /* delete the parent element of el and all empty ancestors */
925: elem = TtaGetParent (el);
1.12 cvs 926: do
1.1 cvs 927: {
1.12 cvs 928: sibling = elem;
929: TtaNextSibling (&sibling);
930: if (sibling == NULL)
931: {
932: sibling = elem;
933: TtaPreviousSibling (&sibling);
934: if (sibling == NULL)
935: elem = TtaGetParent (elem);
936: }
1.1 cvs 937: }
1.12 cvs 938: while (sibling == NULL);
939: TtaDeleteTree (elem, destDoc);
940: /* restore previous chacking mode */
1.47 cvs 941: TtaSetStructureChecking ((ThotBool)checkingMode, destDoc);
1.12 cvs 942: }
1.58 cvs 943: /* return the address of the new division */
944: return (div);
1.1 cvs 945: }
946:
1.29 cvs 947:
1.58 cvs 948: /*----------------------------------------------------------------------
949: CloseMakeBook
950: ----------------------------------------------------------------------*/
1.29 cvs 951: #ifdef __STDC__
1.58 cvs 952: static void CloseMakeBook (Document document)
953: #else
954: static void CloseMakeBook (document)
955: Document document;
956: #endif /* __STDC__ */
957:
958: {
959: ResetStop (document);
960: /* update internal links */
961: SetInternalLinks (document);
962: /* if the document changed force the browser mode */
963: if (SubDocs)
964: SetBrowserEditor (document);
965: /* remove registered sub-documents */
966: FreeSubDocTable ();
967: DocBook = 0;
968: TtaSetStatus (document, 1, TtaGetMessage (AMAYA, AM_DOCUMENT_LOADED), NULL);
969: }
970:
971:
972: /*----------------------------------------------------------------------
973: GetIncludedDocuments_callback finishes the GetIncludedDocuments procedure
974: ----------------------------------------------------------------------*/
975: #ifdef __STDC__
976: void GetIncludedDocuments_callback (int newdoc, int status,
977: STRING urlName,
978: STRING outputfile,
1.63 cvs 979: AHTHeaders *http_headers,
1.58 cvs 980: void * context)
1.29 cvs 981: #else /* __STDC__ */
1.58 cvs 982: void GetIncludedDocuments_callback (newdoc, status, urlName,
1.63 cvs 983: outputfile, http_headers,
1.58 cvs 984: context)
985: int newdoc;
986: int status;
1.36 cvs 987: STRING urlName;
988: STRING outputfile;
1.63 cvs 989: AHTHeaders *http_headers;
1.58 cvs 990: void *context;
1.29 cvs 991: #endif /* __STDC__ */
992: {
1.58 cvs 993: Element link, div;
994: IncludeCtxt *ctx, *prev;
1.57 cvs 995: STRING url, ptr;
1.58 cvs 996: ThotBool found = FALSE;
1.29 cvs 997:
998: /* restore GetIncludedDocuments's context */
1.58 cvs 999: ctx = (IncludeCtxt *) context;
1.29 cvs 1000: if (!ctx)
1001: return;
1002:
1.58 cvs 1003: div = NULL;
1.29 cvs 1004: link = ctx->link;
1.58 cvs 1005: ptr = ctx->name;
1.29 cvs 1006: url = ctx->url;
1.58 cvs 1007: if (url)
1.29 cvs 1008: {
1.58 cvs 1009: if (newdoc && newdoc != DocBook)
1.29 cvs 1010: {
1.58 cvs 1011: /* it's not the DocBook itself */
1012: /* copy the target document at the position of the link */
1013: TtaSetDocumentModified (DocBook);
1014: div = MoveDocumentBody (link, DocBook, newdoc, ptr, url,
1015: (ThotBool)(newdoc == IncludedDocument));
1.29 cvs 1016: }
1.58 cvs 1017: /* global variables */
1018: FreeDocumentResource (IncludedDocument);
1019: TtaCloseDocument (IncludedDocument);
1020: IncludedDocument = 0;
1.29 cvs 1021: }
1.58 cvs 1022:
1023: if (div != NULL)
1.29 cvs 1024: {
1.58 cvs 1025: /* new starting point for the search */
1026: ctx->link = div;
1027: found = GetIncludedDocuments (div, div, DocBook, ctx);
1.29 cvs 1028: }
1.58 cvs 1029: while (!found && ctx)
1030: {
1031: /* this sub-document has no more inclusion, examine the caller */
1032: div = ctx->div;
1033: link = ctx->link;
1034: prev = ctx->ctxt;
1035: TtaFreeMemory (url);
1.64 cvs 1036: url = NULL;
1.58 cvs 1037: TtaFreeMemory (ctx);
1038: ctx = prev;
1039: found = GetIncludedDocuments (div, link, DocBook, ctx);
1040: }
1041: if (!found)
1042: /* all links are now managed */
1043: CloseMakeBook (DocBook);
1.29 cvs 1044: }
1045:
1.1 cvs 1046: /*----------------------------------------------------------------------
1047: GetIncludedDocuments
1.58 cvs 1048: Look forward within the element el, starting from element link, for a
1049: link (A) with attribute rel="chapter" or rel="subdocument" and replace
1050: that link by the contents of the target document.
1051: Return TRUE if one inclusion is launched.
1.1 cvs 1052: ----------------------------------------------------------------------*/
1053: #ifdef __STDC__
1.58 cvs 1054: static ThotBool GetIncludedDocuments (Element el, Element link, Document document, IncludeCtxt *prev)
1.1 cvs 1055: #else
1.58 cvs 1056: static ThotBool GetIncludedDocuments (el, link, document, prev)
1057: Element el;
1058: Element link;
1059: Document document;
1060: IncludeCtxt *prev;
1.1 cvs 1061: #endif
1062: {
1.58 cvs 1063: ElementType elType;
1064: Attribute attr;
1065: AttributeType attrType;
1066: Document newdoc;
1067: IncludeCtxt *ctx = NULL;
1068: STRING text, ptr, url = NULL;
1.29 cvs 1069: int length;
1.58 cvs 1070: ThotBool found = FALSE;
1.29 cvs 1071:
1.58 cvs 1072: /* look for anchors with the attribute rel within the element el */
1073: attr = NULL;
1.61 cvs 1074: attrType.AttrSSchema = TtaGetSSchema (TEXT("HTML"), document);
1.58 cvs 1075: elType.ElSSchema = attrType.AttrSSchema;
1076: elType.ElTypeNum = HTML_EL_Anchor;
1.29 cvs 1077:
1.58 cvs 1078: /* Get only one included file each time */
1079: while (link && attr == NULL)
1.29 cvs 1080: {
1.58 cvs 1081: link = TtaSearchTypedElementInTree (elType, SearchForward, el, link);
1082: if (link)
1.29 cvs 1083: {
1.58 cvs 1084: attrType.AttrTypeNum = HTML_ATTR_REL;
1085: attr = TtaGetAttribute (link, attrType);
1086: }
1087: if (attr)
1088: {
1089: length = TtaGetTextAttributeLength (attr);
1.49 cvs 1090: text = TtaAllocString (length + 1);
1.58 cvs 1091: TtaGiveTextAttributeValue (attr, text, &length);
1092: /* Valid rel values are rel="chapter" or rel="subdocument" */
1093: if (ustrcasecmp (text, TEXT("chapter")) &&
1094: ustrcasecmp (text, TEXT("subdocument")))
1095: attr = NULL;
1.29 cvs 1096: TtaFreeMemory (text);
1097: }
1.58 cvs 1098:
1099: if (attr)
1100: {
1101: /* a link with attribute rel="Chapter" has been found */
1102: attrType.AttrTypeNum = HTML_ATTR_HREF_;
1103: attr = TtaGetAttribute (link, attrType);
1104: }
1105: if (attr)
1106: /* this link has an attribute HREF */
1107: {
1108: length = TtaGetTextAttributeLength (attr);
1109: text = TtaAllocString (length + 1);
1110: TtaGiveTextAttributeValue (attr, text, &length);
1111: ptr = ustrrchr (text, '#');
1112: url = text;
1113: if (ptr != NULL)
1114: {
1115: if (ptr == text)
1116: url = NULL;
1117: /* link to a particular position within a remote document */
1118: ptr[0] = EOS;
1119: ptr = &ptr[1];
1120: }
1121:
1122: if (url != NULL)
1123: /* this link designates an external document */
1124: {
1125: /* create a new document and loads the target document */
1.62 cvs 1126: IncludedDocument = TtaNewDocument (TEXT("HTML"), TEXT("tmp"));
1.58 cvs 1127: if (IncludedDocument != 0)
1128: {
1129: TtaSetStatus (document, 1, TtaGetMessage (AMAYA, AM_FETCHING), url);
1130: ctx = TtaGetMemory (sizeof (IncludeCtxt));
1131: ctx->div = el;
1132: ctx->link = link;
1133: ctx->url = url; /* the URL of the document */
1134: ctx->name = ptr;
1135: ctx->ctxt = prev; /* previous context */
1136: /* Get the reference of the calling document */
1137: SetStopButton (document);
1138: newdoc = GetHTMLDocument (url, NULL, IncludedDocument,
1139: document, CE_MAKEBOOK, FALSE,
1140: (void *) GetIncludedDocuments_callback,
1141: (void *) ctx);
1142: found = TRUE;
1143: }
1144: }
1145: else
1146: TtaFreeMemory (text);
1147: }
1.29 cvs 1148: }
1.58 cvs 1149: return (found);
1.1 cvs 1150: }
1151:
1152:
1153: /*----------------------------------------------------------------------
1154: MakeBook
1155: Replace all links in a document which have an attribute REL="chapter"
1.5 cvs 1156: or REL="subdocument" by the corresponding target document.
1.1 cvs 1157: ----------------------------------------------------------------------*/
1158: #ifdef __STDC__
1159: void MakeBook (Document document, View view)
1160: #else
1161: void MakeBook (document, view)
1162: Document document;
1163: View view;
1164: #endif
1165: {
1.58 cvs 1166: Element root, body;
1167: ElementType elType;
1.1 cvs 1168:
1.58 cvs 1169: /* stops all current transfers on this document */
1170: StopTransfer (document, 1);
1171: /* simulate a transfert in the main document */
1172: DocBook = document;
1173: IncludedDocument = 0;
1174: root = TtaGetMainRoot (document);
1175: elType = TtaGetElementType (root);
1176: elType.ElTypeNum = HTML_EL_BODY;
1177: body = TtaSearchTypedElement (elType, SearchForward, root);
1.29 cvs 1178:
1.58 cvs 1179: if (body)
1180: GetIncludedDocuments (body, body, document, NULL);
1.1 cvs 1181: }
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