source: main/trunk/greenstone2/runtime-src/src/recpt/browsetoolsclass.cpp@ 21743

Last change on this file since 21743 was 21743, checked in by kjdon, 13 years ago

should be using assocfilepath instead of archivedir

  • Property svn:keywords set to Author Date Id Revision
File size: 33.2 KB
Line 
1
2/**********************************************************************
3 *
4 * browsetools.cpp --
5 * Copyright (C) 1999 The New Zealand Digital Library Project
6 *
7 * A component of the Greenstone digital library software
8 * from the New Zealand Digital Library Project at the
9 * University of Waikato, New Zealand.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 * $Id: browsetoolsclass.cpp 21743 2010-03-01 00:04:36Z kjdon $
26 *
27 *********************************************************************/
28
29#include "browsetoolsclass.h"
30#include "recptprototools.h"
31#include "OIDtools.h"
32#include "gsdlunicode.h"
33
34#if defined(GSDL_USE_IOS_H)
35# if defined(__WIN32__)
36# include <strstrea.h> // vc4
37# else
38# include <strstream.h>
39# endif
40#else
41# include <sstream>
42#endif
43
44
45browsetoolsclass::browsetoolsclass()
46{
47}
48
49browsetoolsclass::~browsetoolsclass()
50{
51}
52
53// output_controls displays the detach, expand/contract contents,
54// expand/contract text and highlighting/no highlighting buttons
55
56void browsetoolsclass::output_controls(cgiargsclass &args, const text_tarray &ibuttons,
57 recptproto *collectproto, displayclass &disp,
58 outconvertclass &outconvert, ostream &textout,
59 ostream &logout)
60{
61 if (args["u"] != "1") {
62
63 FilterResponse_t response;
64 text_tarray metadata;
65 text_tarray buttons;
66
67 text_tarray::const_iterator here = ibuttons.begin();
68 text_tarray::const_iterator end = ibuttons.end();
69
70 while (here != end) {
71
72 if (*here == "Detach")
73 buttons.push_back ("_document:imagedetach_");
74 else if(*here == "Print")
75 buttons.push_back ("_document:imageprint_");
76 else if (*here == "Highlight") {
77 if (args["hl"] == "1")
78 buttons.push_back ("_document:imagenohighlight_");
79 else
80 buttons.push_back ("_document:imagehighlight_");
81 } else if (*here == "Expand Contents") {
82 if (args["gc"] == "1")
83 buttons.push_back ("_document:imagecontracttoc_");
84 else
85 buttons.push_back ("_document:imageexpandtoc_");
86 } else if (*here == "Expand Text") {
87 if (args.getintarg("gt"))
88 buttons.push_back ("_document:imagecontracttext_");
89 else
90 buttons.push_back ("_document:imageexpandtext_");
91 }
92 ++here;
93 }
94
95 here = buttons.begin();
96 end = buttons.end();
97 while (here != end) {
98 textout << outconvert << disp << *here;
99 ++here;
100 }
101 }
102}
103
104text_t browsetoolsclass::get_cover_image()
105{
106 return "_httpprefix_/collect/[collection]/index/assoc/{Or}{[parent(Top):assocfilepath],[assocfilepath]}/cover.jpg";
107}
108
109// at the moment this just writes out the html to display
110// the cover image (assuming it's called cover.jpg)
111// this whole thing should be done with a call to the collection
112// server which would send a link to the cover image if there
113// was one otherwise send title, author and stuff
114void browsetoolsclass::output_cover_image(cgiargsclass &args, recptproto *collectproto,
115 displayclass &disp, outconvertclass &outconvert,
116 ostream &textout, ostream &logout)
117{
118 if (args["d"].empty()) return;
119
120 textout << outconvert << disp << "_document:coverimage_";
121}
122
123void browsetoolsclass::output_titles(cgiargsclass &args, recptproto *collectproto,
124 browsermapclass *browsermap, formatinfo_t &formatinfo,
125 displayclass &disp, outconvertclass &outconvert,
126 ostream &textout, ostream &logout)
127{
128 if (args["d"].empty()) return;
129
130 text_tset metadata;
131 bool getParents;
132 FilterResponse_t response;
133
134 format_t *formatlistptr = new format_t();
135 parse_formatstring (formatinfo.DocumentHeading, formatlistptr, metadata, getParents);
136
137 if (!get_info (args["d"], args["c"], args["l"], metadata, getParents, collectproto, response, logout))
138 return;
139
140 text_tmap options;
141 if (formatinfo.AllowExtendedOptions) {
142 load_extended_options(options, args, browsermap, formatinfo,
143 collectproto, disp, outconvert, logout);
144 }
145 textout << outconvert << disp
146 << get_formatted_string (args["c"],collectproto, response.docInfo[0], disp,
147 formatlistptr, options, logout);
148}
149
150void browsetoolsclass::recurse_contents(ResultDocInfo_t &section, cgiargsclass &args, bool fulltoc,
151 browserclass *bptr, text_tset &metadata, bool &getParents,
152 format_t *formatlistptr, format_tmap &formatlistmap,
153 formatinfo_t &formatinfo, browsermapclass *browsermap,
154 int tabcount, recptproto *collectproto, displayclass &disp,
155 outconvertclass &outconvert, ostream &textout, ostream &logout)
156{
157 text_t formatstring;
158
159 bool is_classify = false;
160 if (args["d"].empty() || fulltoc) is_classify = true;
161
162 // output this section
163 bool use_table = is_table_content (formatlistptr);
164 tabcount += bptr->output_section_group (section, args, args["c"], tabcount, formatlistptr, use_table,
165 metadata, getParents, collectproto, disp, outconvert,
166 textout, logout);
167
168 text_t classification;
169 if (!is_classify) classification = "Document";
170 else get_top (args["cl"], classification);
171
172 int haschildren = section.metadata["haschildren"].values[0].getint();
173 const text_t &doctype = section.metadata["doctype"].values[0];
174 text_t classifytype = section.metadata["childtype"].values[0];
175 // HLists and DateLists are displayed as VLists when contents
176 // are expanded, Paged documents are displayed as HLists
177 if (classifytype == "HList" || classifytype == "DateList") classifytype = "VList";
178 if (classifytype == "Paged") classifytype = "HList";
179
180 // recurse through children
181 if ((haschildren == 1) && (!is_classify || fulltoc || doctype == "classify")) {
182
183 // get browser for displaying children
184 bptr = browsermap->getbrowser (classifytype);
185 bptr->load_metadata_defaults (metadata);
186
187 // get the formatstring if there is one
188 if (!get_formatstring (classification, classifytype,
189 formatinfo.formatstrings, formatstring))
190 formatstring = bptr->get_default_formatstring();
191
192 format_tmap::const_iterator it = formatlistmap.find (formatstring);
193 // check if formatlistptr is cached
194 if (it != formatlistmap.end()) formatlistptr = (*it).second;
195 else {
196 formatlistptr = new format_t();
197 parse_formatstring (formatstring, formatlistptr, metadata, getParents);
198 formatlistmap[formatstring] = formatlistptr;
199 }
200
201 FilterResponse_t tmp;
202 get_children (section.OID, args["c"], args["l"], metadata, getParents, collectproto, tmp, logout);
203 ResultDocInfo_tarray::iterator thisdoc = tmp.docInfo.begin();
204 ResultDocInfo_tarray::iterator lastdoc = tmp.docInfo.end();
205
206 while (thisdoc != lastdoc) {
207 recurse_contents (*thisdoc, args, fulltoc, bptr, metadata, getParents,
208 formatlistptr, formatlistmap, formatinfo, browsermap,
209 tabcount, collectproto, disp, outconvert, textout, logout);
210 ++thisdoc;
211 }
212 }
213}
214
215
216// expanded_contents recurses through all contents. there's a special case
217// for an HList when contents are expanded (i.e. it's displayed as a VList)
218//
219// if we're inside a document we expand all contents from the top (unless
220// expand_from_current_level is true), if we're at classification level we'll just
221// expand out those contents below the current one
222
223void browsetoolsclass::expanded_contents(cgiargsclass &args, int tabcount, bool fulltoc,
224 browsermapclass *browsermap, formatinfo_t &formatinfo,
225 recptproto *collectproto, displayclass &disp,
226 outconvertclass &outconvert, ostream &textout,
227 ostream &logout, bool expand_from_current_level)
228{
229 if (args["d"].empty() && args["cl"].empty()) return;
230 text_t OID;
231
232 FilterResponse_t response;
233 bool getParents = false;
234 text_tset metadata;
235 text_t classifytype, classification, formatstring;
236
237 if (!args["d"].empty())
238 {
239 // document level
240 if (fulltoc)
241 {
242 get_top(args["cl"], OID);
243 classification = OID;
244 }
245 else
246 {
247 classification = "Document";
248 if (expand_from_current_level)
249 {
250 OID = args["d"];
251 }
252 else
253 {
254 // Always expand document level from top, unless
255 // expand_from_current_level is true.
256 get_top(args["d"], OID);
257 }
258 }
259 }
260 else
261 {
262 // classification level
263 OID = args["cl"];
264 get_top(args["cl"], classification);
265 }
266
267 // get classifytype of this level
268 text_t tOID;
269 if (is_top(OID)) {
270 classifytype = "thistype";
271 tOID = OID;
272 } else {
273 classifytype = "childtype";
274 tOID = get_parent (OID);
275 }
276 metadata.insert (classifytype);
277
278 if (!get_info (tOID, args["c"], args["l"], metadata, getParents, collectproto, response, logout))
279 return;
280 classifytype = response.docInfo[0].metadata[classifytype].values[0];
281 // if we still don't have a classifytype we'll use the default
282 if (classifytype.empty()) {
283 browserclass *bptr = browsermap->get_default_browser ();
284 classifytype = bptr->get_browser_name ();
285 }
286
287 // HLists are displayed as VLists when contents are expanded,
288 // Paged documents are displayed as HLists
289 if (classifytype == "HList") {
290 classifytype = "VList";
291 text_t pOID = get_parent (OID);
292 if (!pOID.empty()) {
293 OID = pOID;
294 // this is assuming that top levels are always 'Invisible' !!!
295 if (is_top (OID)) classifytype = "Invisible";
296 }
297 }
298 if (classifytype == "Paged") classifytype = "HList";
299
300 metadata.erase (metadata.begin(), metadata.end());
301
302 // metadata elements needed by recurse_contents
303 metadata.insert ("childtype");
304 metadata.insert ("doctype");
305 metadata.insert ("haschildren");
306
307 // load up metadata array with browser defaults
308 browserclass *bptr = browsermap->getbrowser (classifytype);
309 bptr->load_metadata_defaults (metadata);
310
311 // get the formatstring if there is one or use the browsers default
312 if (!get_formatstring (classification, classifytype,
313 formatinfo.formatstrings, formatstring))
314 formatstring = bptr->get_default_formatstring();
315
316 format_t *formatlistptr = new format_t();
317 parse_formatstring (formatstring, formatlistptr, metadata, getParents);
318
319 // protocol call
320 if (!get_info (OID, args["c"], args["l"], metadata, getParents, collectproto, response, logout))
321 return;
322
323 format_tmap formatlistmap;
324 formatlistmap[formatstring] = formatlistptr;
325
326 recurse_contents (response.docInfo[0], args, fulltoc, bptr, metadata,
327 getParents, formatlistptr, formatlistmap, formatinfo, browsermap,
328 tabcount, collectproto, disp, outconvert, textout, logout);
329
330 // clean up format list pointers
331 format_tmap::const_iterator here = formatlistmap.begin();
332 format_tmap::const_iterator end = formatlistmap.end();
333 while (here != end) {
334 delete (*here).second;
335 ++here;
336 }
337}
338
339void browsetoolsclass::load_formatstring(const text_t &classifytype, text_tset &metadata,
340 bool &getParents, const text_t &classification,
341 browsermapclass *browsermap, formatinfo_t &formatinfo,
342 format_tmap &formatlistmap)
343{
344 text_t formatstring;
345
346 // load up metadata array with browser defaults
347 browserclass *bptr = browsermap->getbrowser (classifytype);
348 bptr->load_metadata_defaults (metadata);
349
350 // get the formatstring if there is one or use the browsers default
351 if (!get_formatstring (classification, classifytype,
352 formatinfo.formatstrings, formatstring))
353 formatstring = bptr->get_default_formatstring();
354
355 // see if it's cached
356 format_tmap::const_iterator it = formatlistmap.find (formatstring);
357 if (it == formatlistmap.end()) {
358 format_t *formatlistptr = new format_t();
359 parse_formatstring (formatstring, formatlistptr, metadata, getParents);
360 formatlistmap[formatstring] = formatlistptr;
361 }
362}
363
364void browsetoolsclass::load_formatstrings(FilterResponse_t &response, text_tset &metadata,
365 bool &getParents, const text_t &classification,
366 browsermapclass *browsermap, formatinfo_t &formatinfo,
367 format_tmap &formatlistmap)
368{
369 text_tset cache;
370
371 ResultDocInfo_tarray::iterator thisdoc = response.docInfo.begin();
372 ResultDocInfo_tarray::iterator lastdoc = response.docInfo.end();
373
374 while (thisdoc != lastdoc) {
375
376 if (is_top ((*thisdoc).OID)) {
377 load_formatstring ((*thisdoc).metadata["thistype"].values[0], metadata,
378 getParents, classification, browsermap, formatinfo,
379 formatlistmap);
380 }
381
382 // sometimes childtype is not set - why??
383 if ((*thisdoc).metadata.find("childtype") != (*thisdoc).metadata.end()) {
384 text_t &childtype = (*thisdoc).metadata["childtype"].values[0];
385
386 text_tset::const_iterator it = cache.find (childtype);
387 if (it == cache.end()) {
388 load_formatstring (childtype, metadata, getParents, classification,
389 browsermap, formatinfo, formatlistmap);
390 cache.insert (childtype);
391 }
392 }
393 ++thisdoc;
394 }
395}
396
397void browsetoolsclass::output_parents(FilterResponse_t &response, cgiargsclass &args,
398 browsermapclass *browsermap, formatinfo_t &formatinfo,
399 format_tmap &formatlistmap, const text_t &classification,
400 int &tabcount, text_tset &metadata, bool &getParents,
401 recptproto *collectproto, displayclass &disp,
402 outconvertclass &outconvert, ostream &textout,
403 ostream &logout)
404{
405 format_t *formatlistptr = NULL;
406 text_t classifytype, formatstring;
407 bool use_table, first = true;
408 ResultDocInfo_tarray::iterator thisparent = response.docInfo.begin();
409 ResultDocInfo_tarray::iterator lastparent = response.docInfo.end();
410 while (thisparent != lastparent) {
411
412 // get classifytype of this level
413 if (is_top ((*thisparent).OID)) classifytype = (*thisparent).metadata["thistype"].values[0];
414 else if (!first && (*(thisparent-1)).metadata.find("childtype") != (*(thisparent-1)).metadata.end()) classifytype = (*(thisparent-1)).metadata["childtype"].values[0];
415
416 // if we still don't have a classifytype we'll use the default
417 if (classifytype.empty()) {
418 browserclass *bptr = browsermap->get_default_browser ();
419 classifytype = bptr->get_browser_name ();
420 }
421
422 browserclass *bptr = browsermap->getbrowser (classifytype);
423
424 // get the formatstring if there is one or use the browsers default
425 if (!get_formatstring (classification, classifytype,
426 formatinfo.formatstrings, formatstring))
427 formatstring = bptr->get_default_formatstring();
428
429 // see if it's cached
430 format_tmap::const_iterator it = formatlistmap.find (formatstring);
431 if (it != formatlistmap.end()) formatlistptr = (*it).second;
432 else {
433 logout << "browsetools error\n";
434 return;
435 }
436
437 use_table = is_table_content (formatlistptr);
438 tabcount += bptr->output_section_group (*thisparent, args, args["c"], tabcount, formatlistptr,
439 use_table, metadata, getParents, collectproto,
440 disp, outconvert, textout, logout);
441 first = false;
442 ++thisparent;
443 }
444}
445
446void browsetoolsclass::contracted_contents(cgiargsclass &args, int tabcount, bool fulltoc,
447 browsermapclass *browsermap, formatinfo_t &formatinfo,
448 recptproto *collectproto, displayclass &disp,
449 outconvertclass &outconvert, ostream &textout,
450 ostream &logout)
451{
452 FilterResponse_t response;
453 text_tset metadata;
454 bool getParents = false;
455 text_t formatstring;
456 text_tarray parents;
457 text_t OID = args["d"];
458 text_t classification = "Document";
459
460 // if we're not outputting the TOC for a valid OID, then we should be giving
461 // the TOC of a classification
462 if (OID.empty()) {
463 OID = args["cl"];
464 get_top (OID, classification);
465 }
466 // if we're to give the full TOC of a document, get the parent for the whole
467 // document now
468 else if (fulltoc)
469 get_top (args["cl"], classification);
470
471 bool haschildren = has_children (OID, args["c"], args["l"], collectproto, logout);
472
473 if ((!args["d"].empty()) && fulltoc)
474 get_parents_array (args["cl"] + ".fc", parents);
475 if (haschildren) get_parents_array (OID + ".fc", parents);
476 else get_parents_array (OID, parents);
477
478 if (!parents.empty()) {
479 // get classifytypes of each parent
480 metadata.insert ("thistype");
481 metadata.insert ("childtype");
482 metadata.insert("mdtype");
483
484 if (!get_info (parents, args["c"], args["l"], metadata, getParents, collectproto, response, logout))
485 return;
486
487 // get formatstrings for all parents
488 format_tmap formatlistmap;
489 load_formatstrings (response, metadata, getParents, classification,
490 browsermap, formatinfo, formatlistmap);
491
492 if (!get_info (parents, args["c"], args["l"], metadata, getParents, collectproto, response, logout))
493 return;
494
495 // display each parent
496 output_parents (response, args, browsermap, formatinfo, formatlistmap,
497 classification, tabcount, metadata, getParents,
498 collectproto, disp, outconvert, textout, logout);
499
500 metadata.erase (metadata.begin(), metadata.end());
501
502 // clean up cached format list pointers
503 format_tmap::const_iterator here = formatlistmap.begin();
504 format_tmap::const_iterator end = formatlistmap.end();
505 while (here != end) {
506 delete (*here).second;
507 ++here;
508 }
509 }
510
511 // get childrens classifytype
512 text_t classifytype;
513 int numparents = response.docInfo.size();
514 if (!parents.empty() && (response.docInfo[numparents-1].metadata.find("childtype") != response.docInfo[numparents-1].metadata.end()))
515 classifytype = response.docInfo[numparents-1].metadata["childtype"].values[0];
516 else {
517 // use the default
518 browserclass *bptr = browsermap->get_default_browser ();
519 classifytype = bptr->get_browser_name ();
520 }
521
522 // load up metadata array with browser defaults
523 browserclass *bptr = browsermap->getbrowser (classifytype);
524 bptr->load_metadata_defaults (metadata);
525
526 if (classifytype == "DateList") {
527 // get the mdtype
528 text_t datelist = "Date";
529 if (!parents.empty() && (response.docInfo[0].metadata.find("mdtype") != response.docInfo[0].metadata.end())) {
530 datelist = response.docInfo[0].metadata["mdtype"].values[0];
531 }
532 args.setarg("dm", datelist);
533 text_tarray dates;
534 splitchar(datelist.begin(), datelist.end(), ',', dates);
535 text_tarray::iterator begin = dates.begin();
536 text_tarray::iterator end = dates.end();
537 while (begin!= end) {
538 metadata.insert(*begin);
539 begin++;
540 }
541
542 }
543
544 // get the formatstring if there is one or use the browsers default
545 if (!get_formatstring (classification, classifytype,
546 formatinfo.formatstrings, formatstring))
547 formatstring = bptr->get_default_formatstring();
548
549 format_t *formatlistptr = new format_t();
550 parse_formatstring (formatstring, formatlistptr, metadata, getParents);
551
552 if (haschildren)
553 get_children (OID, args["c"], args["l"], metadata, getParents,
554 collectproto, response, logout);
555 else if (!is_top(OID)) {
556 get_children (OID + ".pr", args["c"], args["l"], metadata, getParents,
557 collectproto, response, logout);
558 haschildren = true;
559 }
560
561 // display children
562 if (haschildren) {
563 bool use_table = is_table_content (formatlistptr);
564 bptr->output_section_group (response, args, args["c"], tabcount, formatlistptr, use_table,
565 metadata, getParents, collectproto, disp, outconvert,
566 textout, logout);
567 }
568 delete formatlistptr;
569}
570
571/**
572 * This function outputs contents of a classifier to the reader
573 * including parent levels
574 */
575void browsetoolsclass::expand_show_contents(cgiargsclass &args, int tabcount, bool fulltoc,
576 browsermapclass *browsermap, formatinfo_t &formatinfo,
577 recptproto *collectproto, displayclass &disp,
578 outconvertclass &outconvert, ostream &textout,
579 ostream &logout)
580{
581 int coloffset = 0;
582 text_tarray parents;
583 FilterResponse_t response;
584 text_t OID = args["d"];
585 if (OID.empty()) OID = args["cl"];
586
587 bool haschildren = has_children(OID, args["c"], args["l"], collectproto, logout);
588
589 // get parents list
590 if (!is_top(OID)) get_parents_array(OID, parents);
591 if (args["d"].empty() || haschildren || parents.empty()) parents.push_back(OID);
592
593 // if inside a book top title is needed
594 if (!args["d"].empty())
595 {
596 coloffset = 1;
597 text_t classification, classifytype, formatstring, topOID = parents[0];
598 text_tset metadata;
599 format_t *formatlistptr = new format_t();
600 bool use_table, getParents = false;
601
602 get_top(args["cl"], classification);
603
604 // getting information about top OID
605 metadata.insert("thistype");
606
607 get_info(topOID, args["c"], args["l"], metadata, getParents, collectproto, response, logout);
608 if (!response.docInfo[0].metadata["thistype"].values.empty())
609 {
610 classifytype = response.docInfo[0].metadata["thistype"].values[0];
611 }
612
613 browserclass *bptr = browsermap->getbrowser (classifytype);
614
615 if (classifytype.empty())
616 {
617 bptr = browsermap->get_default_browser();
618 }
619
620 // get the formatstring if there is one or use the browsers default
621 if (!get_formatstring(classification, classifytype, formatinfo.formatstrings, formatstring))
622 {
623 formatstring = bptr->get_default_formatstring();
624 }
625
626 parse_formatstring(formatstring, formatlistptr, metadata, getParents);
627
628 metadata.insert("doctype");
629 metadata.insert("haschildren");
630
631 get_info(topOID, args["c"], args["l"], metadata, getParents, collectproto, response, logout);
632
633 // ouput top OID section
634 use_table = is_table_content(formatlistptr);
635 bptr->output_section_group(response.docInfo[0], args, args["c"], tabcount, formatlistptr, use_table,
636 metadata, getParents, collectproto, disp, outconvert, textout, logout);
637 }
638
639 recurse_contents_levels(parents, args, coloffset, tabcount, fulltoc, browsermap,
640 formatinfo, collectproto, disp, outconvert, textout, logout);
641}
642
643void browsetoolsclass::recurse_contents_levels(text_tarray &parents, cgiargsclass &args, int coloffset, int tabcount,
644 bool fulltoc, browsermapclass *browsermap, formatinfo_t &formatinfo,
645 recptproto *collectproto, displayclass &disp, outconvertclass &outconvert,
646 ostream &textout, ostream &logout)
647{
648 FilterResponse_t response;
649 text_tset metadata;
650 text_t OID, formatstring, classification, classifytype;;
651 bool use_table, getParents = false;
652 int haschildren = 0;
653 format_t *formatlistptr = new format_t();
654
655 // display children for last level
656 if (tabcount == (parents.size() - 1))
657 {
658 // setting metadata fields
659 metadata.insert ("thistype");
660 metadata.insert ("childtype");
661 metadata.insert ("haschildren");
662
663 OID = parents[tabcount];
664 get_info(OID, args["c"], args["l"], metadata, getParents, collectproto, response, logout);
665 get_top(OID, classification);
666
667 if (!response.docInfo.empty())
668 {
669 haschildren = response.docInfo[0].metadata["haschildren"].values[0].getint();
670 }
671
672 // get childrens classifytype
673 if (!response.docInfo.empty())
674 {
675 classifytype = response.docInfo[0].metadata["childtype"].values[0];
676 }
677 else
678 {
679 // use the default
680 browserclass *bptr = browsermap->get_default_browser();
681 classifytype = bptr->get_browser_name();
682 }
683
684 // load up metadata array with browser defaults
685 browserclass *bptr = browsermap->getbrowser(classifytype);
686 bptr->load_metadata_defaults(metadata);
687
688 // get the formatstring if there is one or use the browsers default
689 if (!get_formatstring(classification, classifytype, formatinfo.formatstrings, formatstring))
690 {
691 formatstring = bptr->get_default_formatstring();
692 }
693
694 parse_formatstring(formatstring, formatlistptr, metadata, getParents);
695
696 if (haschildren)
697 {
698 get_children(OID, args["c"], args["l"], metadata, getParents,
699 collectproto, response, logout);
700 }
701 else if (!is_top(OID))
702 {
703 get_children(OID + ".pr", args["c"], args["l"], metadata, getParents,
704 collectproto, response, logout);
705 haschildren = true;
706 }
707
708 // display children
709 if (haschildren)
710 {
711 use_table = is_table_content (formatlistptr);
712 bptr->output_section_group(response, args, args["c"], coloffset + tabcount, formatlistptr, use_table,
713 metadata, getParents, collectproto, disp, outconvert, textout, logout);
714 }
715 }
716 else
717 {
718 text_t pOID;
719 OID = parents[tabcount];
720 get_top(OID, classification);
721
722 // load metadata fields
723 metadata.insert("thistype");
724 metadata.insert("childtype");
725 metadata.insert("haschildren");
726 metadata.insert("doctype");
727
728 if (tabcount) pOID = parents[tabcount-1];
729 else pOID = OID;
730 get_info(pOID, args["c"], args["l"], metadata, getParents, collectproto, response, logout);
731
732 // get classifytype of this level
733 if (is_top (pOID)) classifytype = response.docInfo[0].metadata["childtype"].values[0];
734 else classifytype = response.docInfo[0].metadata["thistype"].values[0];
735
736 // if we still don't have a classifytype we'll use the default
737 if (classifytype.empty())
738 {
739 browserclass *bptr = browsermap->get_default_browser();
740 classifytype = bptr->get_browser_name();
741 }
742
743 browserclass *bptr = browsermap->getbrowser (classifytype);
744
745 // get the formatstring if there is one or use the browsers default
746 if (!get_formatstring (classification, classifytype, formatinfo.formatstrings, formatstring))
747 {
748 formatstring = bptr->get_default_formatstring();
749 }
750
751 // parse format string
752 parse_formatstring(formatstring, formatlistptr, metadata, getParents);
753
754 use_table = is_table_content(formatlistptr);
755
756 get_children(OID, args["c"], args["l"], metadata, getParents, collectproto, response, logout);
757
758 ResultDocInfo_tarray::iterator thissibling = response.docInfo.begin();
759 ResultDocInfo_tarray::iterator lastsibling = response.docInfo.end();
760
761 while (thissibling != lastsibling)
762 {
763 bptr->output_section_group(*thissibling, args, args["c"], coloffset + tabcount, formatlistptr,
764 use_table, metadata, getParents, collectproto,
765 disp, outconvert, textout, logout);
766
767 if ((*thissibling).OID == parents[tabcount+1])
768 {
769 recurse_contents_levels(parents, args, coloffset, tabcount+1, fulltoc, browsermap,
770 formatinfo, collectproto, disp, outconvert,textout, logout);
771 }
772 ++thissibling;
773 }
774 }
775 delete formatlistptr;
776}
777
778/**
779 * This function outputs the contents of a classifier list to the reader -
780 * the document will in fact be empty, so this does the "real" output
781 */
782void browsetoolsclass::output_toc(cgiargsclass &args, browsermapclass *browsermap,
783 formatinfo_t &formatinfo, recptproto *collectproto,
784 displayclass &disp, outconvertclass &outconvert,
785 ostream &textout, ostream &logout)
786{
787 if (!args["d"].empty() && formatinfo.AllowExtendedOptions) {
788 // If AllowExtendedOptions is set and we're viewing a document,
789 // DocumentButtons, DocumentContent, and DocumentImages are effectively
790 // disabled. We just output the DocumentHeading format string and
791 // return
792 output_titles(args, collectproto, browsermap, formatinfo, disp, outconvert, textout, logout);
793 return;
794 }
795
796 int tabcount = 0;
797 bool fulltoc = false;
798 text_t cl_top, full_toc;
799 if (args["cl"] != "search") {
800 // see if there's a FullTOC string
801 get_top (args["cl"], cl_top);
802 if (get_formatstring (cl_top, "FullTOC", formatinfo.formatstrings, full_toc))
803 if (full_toc == "true") fulltoc = true;
804 }
805
806 // get the cover image (if there is one) and the control buttons
807 // if we're inside a book
808 if ((!fulltoc) && (!args["d"].empty())) {
809 if (formatinfo.DocumentImages) {
810 textout << outconvert << "<div class=\"heading_image\">\n";
811 output_cover_image(args, collectproto, disp, outconvert, textout, logout);
812 textout << outconvert << "</div>\n";
813 } else if (formatinfo.DocumentTitles) {
814 textout << outconvert << "<div class=\"heading_title\">\n";
815 output_titles(args, collectproto, browsermap, formatinfo, disp, outconvert, textout, logout);
816 textout << outconvert << "</div>\n";
817 }
818 textout << outconvert << "<div class=\"buttons\" id=\"toc_buttons\">\n";
819 if (args["u"] != "1") {
820 output_controls (args, formatinfo.DocumentButtons, collectproto, disp,
821 outconvert, textout, logout);
822 }
823 textout << outconvert << "</div>\n\n";
824 }
825
826 if (formatinfo.DocumentContents || args["d"].empty()) {
827 if (args["d"].empty()) {
828 disp.setmacro("tocopenextra", "document", "id=\"" + cl_top + "\"");
829 } else {
830 disp.setmacro("tocopenextra", "document", "");
831 }
832
833 textout << outconvert << disp << "_document:tocopen_\n";
834 if (args.getintarg("gc") == 1)
835 {
836 // expanded table of contents
837 expanded_contents(args, tabcount, fulltoc, browsermap, formatinfo,
838 collectproto, disp, outconvert, textout, logout, false);
839 }
840 else if (args.getintarg("gc") == 2)
841 {
842 // expand visible levels of table of contents
843 expand_show_contents(args, tabcount, fulltoc, browsermap, formatinfo,
844 collectproto, disp, outconvert, textout, logout);
845 }
846 else
847 {
848 // contracted table of contents
849 contracted_contents(args, tabcount, fulltoc, browsermap, formatinfo,
850 collectproto, disp, outconvert, textout, logout);
851 }
852 textout << outconvert << disp << "_document:tocclose_\n";
853 }
854}
855
856void browsetoolsclass::load_extended_options(text_tmap &options, cgiargsclass &args, browsermapclass *browsers,
857 formatinfo_t &formatinfo, recptproto *collectproto,
858 displayclass &disp, outconvertclass &outconvert, ostream &logout)
859{
860 options["DocImage"] = get_cover_image();
861
862#if defined(GSDL_USE_IOS_H)
863 ostrstream *tmpstr = new ostrstream();
864#else
865 ostringstream *tmpstr = new ostringstream(ostringstream::binary);
866#endif
867
868 if (args["gc"] == "1")
869 {
870 expanded_contents(args, 0, false, browsers, formatinfo, collectproto,
871 disp, outconvert, *tmpstr, logout, false);
872 }
873 else
874 {
875 contracted_contents(args, 0, false, browsers, formatinfo,
876 collectproto, disp, outconvert, *tmpstr, logout);
877 }
878#if defined(GSDL_USE_IOS_H)
879 char *t = tmpstr->str();
880 text_t tmp;
881 tmp.setcarr(t, tmpstr->pcount());
882 delete [] t;
883#else
884 text_t tmp = (char *)(tmpstr->str().c_str());
885#endif
886 int len = tmp.size();
887 char *ctmp = tmp.getcstr();
888 utf8inconvertclass utf82text_t;
889 utf82text_t.setinput(ctmp, len);
890 convertclass::status_t status;
891 utf82text_t.convert(tmp, status);
892 options["DocTOC"] = tmp;
893 delete []ctmp;
894 delete tmpstr;
895
896 options["DocumentButtonDetach"] = "_document:imagedetach_";
897 if (args["hl"] == "1")
898 {
899 options["DocumentButtonHighlight"] = "_document:imagenohighlight_";
900 }
901 else
902 {
903 options["DocumentButtonHighlight"] = "_document:imagehighlight_";
904 }
905 if (args["gc"] == "1")
906 {
907 options["DocumentButtonExpandContents"] = "_document:imagecontracttoc_";
908 }
909 else
910 {
911 options["DocumentButtonExpandContents"] = "_document:imageexpandtoc_";
912 }
913 if (args["gt"] == "1")
914 {
915 options["DocumentButtonExpandText"] = "_document:imagecontracttext_";
916 }
917 else
918 {
919 options["DocumentButtonExpandText"] = "_document:imageexpandtext_";
920 }
921}
Note: See TracBrowser for help on using the repository browser.