OOFILE  1.9
oofrpXML.cpp
Go to the documentation of this file.
1 // COPYRIGHT 1998 A.D. Software, All rights reserved
2 
3 // report-writer layer of OOFILE database
4 // renderer factories & renderers for XML output
5 
6 #include "oofpch_r.h" // for precompilation of report files
7 
8 #ifndef H_OOF3
9  #include "oof3.h" // knows a bit about fields
10 #endif
11 #ifndef H_OOFREP
12  #include "oofrep.h"
13 #endif
14 #ifndef H_OOFRPXML
15  #include "oofrpXML.h"
16 #endif
17 #ifndef H_OOFGRPHS
18  #include "oofGrphs.h"
19 #endif
20 #ifndef H_OOFIOS
21  #include "oofios.h"
22 #endif
23 #ifndef H_OOFRAM
24  #include "oofram.h"
25 #endif
26 #ifndef H_OOFXML
27  #include "oofxml.h"
28 #endif
29 
30 #if OOF_USE_ANSI_STREAMS
31  #include <iomanip>
32 #else
33  #include <iomanip.h>
34 #endif
35 
36 #include <stdio.h> // for tmpnam
37 
38 #ifdef OOF_MEM_DEBUG_LAST_INCLUDE
39  #include OOF_MEM_DEBUG_LAST_INCLUDE
40 #endif
41 
42 #ifndef OOF_NO_STDLIB
43  #ifndef std
44  using namespace std;
45  #endif
46 #endif
47 
48 #ifdef __MWERKS__
49  #if __option(mpwc_newline)
50  #pragma message("you are supposed to build this with 'Map newline to CR' unchecked!")
51  #endif
52 #endif
53 
54 
55 // -------------------------------------------------------
56 // O O F _ r e p X M L s t y l e V i s i t o r
57 // -------------------------------------------------------
67 public:
69  mIdentities(identities),
70  mIndent(mIdentities.getIndentString() ),
71  mSetThisIDanyway(false),
72  mAdornersEncountered(false)
73  {};
74 
75  bool adornersEncountered() const;
76 
77 protected:
78  virtual void VisitDrawable(oofRepDrawable*);
79  virtual void VisitIterableBandBody(oofRepBand*);
80  virtual void EnterLevel();
81  virtual void LeaveLevel();
82 
84  const oofString mIndent; // use const indent otherwise style strings zig-zag
85  bool mSetThisIDanyway, mAdornersEncountered;
86 };
87 
88 
89 inline bool
91 {
92  return mAdornersEncountered;
93 }
94 
95 
96 void
98 {
99 // IMPORTANT - this sets the ID referred to later by layout visitors
100 // so must be called before we visit to construct layouts
101 
102 // set the ID only if we write a style string
103 // but calculate it regardless
104  const oofString newID = mIdentities.getIDstring();
105  mIdentities.incrementID();
106 
107  const bool drawableHasAdorners = inDrawable->hasAdorners();
108  if (drawableHasAdorners)
109  mAdornersEncountered = true;
110 
111  // check if graph band and write settings string in styles
112  // pretty gross hack!!
113 #ifndef OOF_RTTI_ENABLED
114  error - RTTI required
115 #endif
116  oofRepGraphBand* theGrapher = dynamic_cast<oofRepGraphBand*>(inDrawable);
117  if (theGrapher) {
118  inDrawable->ID(newID);
120  << mIndent << mIndent // double-indent all style strings
121  << '#' << newID
122  << oofGraphSettings2CSS::emitCSSstyle(theGrapher->graph()->settings())
123  << '\n';
124  return; // ****** EARLY EXIT after graph special case
125  }
126 
127  oofRepTextStyle* theStyle = inDrawable->localTextStyle();
128  if (theStyle) {
129  inDrawable->ID(newID);
130 // write ID and style
132  << mIndent << mIndent // double-indent all style strings
133  << '#' << newID
135  << '\n';
136  }
137  else if (mSetThisIDanyway || drawableHasAdorners) {
138  mSetThisIDanyway = false;
139  inDrawable->ID(newID);
140  }
141 }
142 
143 
144 void
146 {
147  mSetThisIDanyway = true;
149 }
150 
151 
152 void
154 {
155  mIdentities.enterLevel();
156 }
157 
158 
159 void
161 {
162  mIdentities.leaveLevel();
163 }
164 
165 
166 // -------------------------------------------------------
167 // O O F _ X M L s c h e m a V i s i t o r
168 // -------------------------------------------------------
175 public:
177  mIdentities(identities)
178  {};
179 
180 protected:
181  virtual void VisitComplexBand(oofRepBand*);
182  virtual void VisitView(dbView*);
183 
184  void UniquifyTables(dbView*);
185 
186 // data storage
189  OOF_DummyString mDummyNames; // statically stored self-incrementing const char*'s
190 };
191 
192 
193 void
195 {
196 // default for all other bands which are presumed to have non-nested schemae
197  UniquifyTables(inView);
198  oofXMLDBWriter schemaWriter(oofRepStreamEnv::out(), inView, mIdentities);
199  schemaWriter.startSchema();
200  schemaWriter.endSchema();
201 }
202 
203 
204 void
206 {
207  dbView* theView = inBand->view();
208  UniquifyTables(theView);
209  oofXMLDBWriter schemaWriter(oofRepStreamEnv::out(), theView, mIdentities);
210 // within the boundary of this band's view, may have nested data
211 // hence the split start/endSchema
212 
213 // any views attached to headers or footers are OUTSIDE the data of
214 // the main view so not directly related to it
215 
216 // the following structural navigation is a modified copy of oofRepVisitor's method
217 // so needs updating if change report
218  OOF_mixIterableBand* iteratingInterface = inBand->asIterableBand();
219  OOF_mixBandWithSubBands* subBandInterface = inBand->asBandWithSubBands();
220 
221  mRep->incrementIteratingBandLevel();
222  if (subBandInterface && subBandInterface->headers().count()>0)
223  VisitBandHeaders(subBandInterface->headers());
224 
225  schemaWriter.startSchema();
226 
227 // data in breaks is related to a given record so nested inside the startSchema
228  if (iteratingInterface && iteratingInterface->headerBreaks().count()>0)
229  VisitBandHeaderBreaks(iteratingInterface->headerBreaks());
230 
231 // don't visit Body as we're accomplishing that with the start/endSchema here
232 
233  if (iteratingInterface && iteratingInterface->footerBreaks().count()>0)
234  VisitBandFooterBreaks(iteratingInterface->footerBreaks());
235 
236  schemaWriter.endSchema();
237 
238  if (subBandInterface && subBandInterface->footers().count()>0)
239  VisitBandFooters(subBandInterface->footers());
240  mRep->decrementIteratingBandLevel();
241 }
242 
243 
244 
245 
246 
247 void
249 {
250  dbTable* viewTable = inView->table();
251  if (viewTable) {
252  const unsigned long numTablesSeen = mKnownTables.count();
253  if (numTablesSeen>0) { // don't waste time with lookup on first table
254  oofString currentName = viewTable->tableName();
255  dbTable* knownTable = (dbTable*) mKnownTables[currentName]; // safe downcast
256  if (knownTable) {
257  // table may be encountered several times depending on how dbViews established
258  // particularly in multiple report, so clone it!
259  if (knownTable==viewTable) {
260  inView->cloneTable(); // tell the view to clone its table, do fixups
261  viewTable = inView->table();
262  assert(knownTable!=viewTable); // it better be different by now!
263  }
264  // make name unique by simply appending a rising count
265  currentName.convertNumber(numTablesSeen, 0, true); // append
266  viewTable->setName(currentName);
267  }
268  }
269  mKnownTables.append(viewTable);
270  }
271  else { // set name of view so it can be retrieved later
272  if (inView->name().isEmpty()) { // may have name set by user
273  inView->name( mDummyNames.nextDummy() );
274  }
275  }
276  // now fix any empty field names!
277  // note that if this causes a field to appear with a name above its column that was
278  // not wanted, setHeading can be used on the view to set a null overriding heading
279  const unsigned int numflds = inView->count();
280  for( unsigned int i=0; i < numflds; i++ ) {
281  dbField* fld = inView->writeableField(i);
282  if (fld->fieldName().isEmpty()) {
283  fld->setName( mDummyNames.nextDummy() );
284  }
285  }
286 }
287 
288 
289 // -------------------------------------------------------
290 // O O F _ X M L l a y o u t V i s i t o r
291 // -------------------------------------------------------
301 public:
303  mIdentities(identities)
304  {};
305 
306 protected:
307  virtual void VisitFirstPageHeaders(oofRepBandList&);
308  virtual void VisitFirstPageFooters(oofRepBandList&);
309  virtual void VisitPageHeaders(oofRepBandList&);
310  virtual void VisitPageFooters(oofRepBandList&);
311  virtual void VisitBandHeaders(oofRepBandList&);
312  virtual void VisitBandFooters(oofRepBandList&);
313  virtual void VisitBandHeaderBreaks(oofRepBreakList&);
314  virtual void VisitBandFooterBreaks(oofRepBreakList&);
315 
316 // core visit methods
317  virtual void VisitBandList(oofRepBandList&);
318  virtual void VisitBreakList(oofRepBreakList&);
319  virtual void VisitComplexBand(oofRepBand*);
320  virtual void VisitLayoutBand(oofRepLayoutBand*);
321  virtual void VisitDrawable(oofRepDrawable*);
322 
323  void WriteColumns(oofRepBand* inBand);
324 
325 // data storage
327 };
328 
329 
330 void
332 {
334  << mIdentities.getIndentString()
335  << "<header where='first'>\n";
336  VisitBandList(inBands);
338  << mIdentities.getIndentString()
339  << "</header>\n";
340 }
341 
342 
343 void
345 {
347  << mIdentities.getIndentString()
348  << "<footer where='first'>\n";
349  VisitBandList(inBands);
351  << mIdentities.getIndentString()
352  << "</footer>\n";
353 }
354 
355 
356 void
358 {
359  VisitBandHeaders(inBands); // uses same tags for page headers as view headers
360 }
361 
362 
363 void
365 {
366  VisitBandFooters(inBands); // uses same tags for page footers as view footers
367 }
368 
369 
370 void
372 {
373  oofRepStreamEnv::out() << mIdentities.getIndentString();
374  if (inBands.keepTogether())
375  oofRepStreamEnv::out() << "<header>\n";
376  else // default is ON, and simplifies XML
377  oofRepStreamEnv::out() << "<header keepTogether='false'>\n";
378  VisitBandList(inBands);
380  << mIdentities.getIndentString()
381  << "</header>\n";
382 }
383 
384 
385 void
387 {
388  oofRepStreamEnv::out() << mIdentities.getIndentString();
389  if (inBands.keepTogether())
390  oofRepStreamEnv::out() << "<footer>\n";
391  else // default is ON, and simplifies XML
392  oofRepStreamEnv::out() << "<footer keepTogether='false'>\n";
393  VisitBandList(inBands);
395  << mIdentities.getIndentString()
396  << "</footer>\n";
397 }
398 
399 
400 void
402 {
404  << mIdentities.getIndentString()
405  << "<headerBreaks>\n";
406  VisitBreakList(inBreaks);
408  << mIdentities.getIndentString()
409  << "</headerBreaks>\n";
410 }
411 
412 
413 void
415 {
417  << mIdentities.getIndentString()
418  << "<footerBreaks>\n";
419  VisitBreakList(inBreaks);
421  << mIdentities.getIndentString()
422  << "</footerBreaks>\n";
423 }
424 
425 
426 void
428 {
429  mIdentities.enterLevel();
431  mIdentities.leaveLevel();
432 }
433 
434 
435 void
437 {
438  mIdentities.enterLevel();
439  const unsigned long numBreaks = inBreaks.count();
440  for (unsigned long i=0; i<numBreaks; i++) {
441  oofRepBreak* theBreak = inBreaks.value(i);
442  assert(theBreak);
443  oofRepBand* theBand = theBreak->band();
444 
445  oofRepStreamEnv::out() << mIdentities.getIndentString();
446  if (theBreak->newPage())
447  oofRepStreamEnv::out() << "<break newPage='yes'>\n";
448  else
449  oofRepStreamEnv::out() << "<break>\n";
450  if (theBand) {
451  mIdentities.enterLevel();
452  VisitTypedBand(theBand);
453  mIdentities.leaveLevel();
454  } // break without band
455 
457  << mIdentities.getIndentString()
458  << "</break>\n";
459 
460  } // loop breaks
461  mIdentities.leaveLevel();
462 }
463 
464 
465 void
467 {
468  dbView* theView = inBand->view();
469  const oofString attribString( "source=", oofString::quoteString(oofTagMaker::encodeName( theView->name() )) );
472  "table",
473  mIdentities.getIndentString(),
474  inBand->ID(),
475  attribString
476  )
477  << '\n';
478 
479  mIdentities.enterLevel();
480  WriteColumns(inBand);
482  mIdentities.leaveLevel();
484  << oofTagMaker::makeClosingTag("table", mIdentities.getIndentString());
485 }
486 
487 
488 void
490 {
491  OOF_mixColumnarBand* columnarInterface = inBand->asColumnarBand();
492  if (!columnarInterface)
493  return;
494 
495  dbView* theView = inBand->view();
496  assert(theView);
497  oofColSizer* theSizer = theView->colSizer();
498  const oofString colIndent = mIdentities.getIndentString();
499  const unsigned long numCols = theView->count();
500  for (unsigned long col=0; col<numCols; col++) {
501  oofString attribString;
502  attribString.convertNumber(col, "number='%lu'"); // identify column by attribute
503 
504  oofRepCustomViewDrawer* customDrawer = columnarInterface->customDrawer(col);
505  bool writeColElement = (customDrawer!=0);
506 
507  bool overriddenHeading;
508  const oofString colHeading = theView->getHeading(col, &overriddenHeading);
509  writeColElement = writeColElement || overriddenHeading; // may have returned empty heading - user suppressing it!
510 
511  const unsigned long colFixedWidth = theSizer->fixedWidth(col);
512  const unsigned long colFixedPercentage = theSizer->fixedPercentage(col);
513  const bool writeWidth = ((colFixedWidth!=oofColSizer::kNotSet) || (colFixedPercentage!=oofColSizer::kNotSet));
514 
515  writeColElement = writeColElement || writeWidth;
516 
517  const oofColSizer::colAlignT colAlignment = theSizer->alignment(col);
518 
519  if (colAlignment!=oofColSizer::alignNatural) {
520  const oofColSizer::colAlignT colNaturalAlignment = oofColSizer::naturalAlignmentForField(theView->field(col).fieldType());
521  // check if they set it to natural for type without realising
522  if (colAlignment!=colNaturalAlignment) {
523  // use an attribute for alignment because it's not content
524  // and to match the attribute we use elsewhere
525  writeColElement = true;
526  switch(colAlignment){
528  attribString += " align='right'";
529  break;
530 
532  attribString += " align='centre'";
533  break;
534 
536  attribString += " align='justify'";
537  break;
538 
539  default:
540  attribString += " align='left'";
541  break;
542  }
543  } // alignment that's set doesn't match natural
544  } // un-natural alignment
545 
546  if (writeColElement) {
549  "column",
550  colIndent,
551  0, /* no ID as yet, will need if ever set text styles for column bodies */
552  attribString
553  )
554  << '\n';
555  mIdentities.enterLevel(); {
556  const oofString colContentIndent = mIdentities.getIndentString();
557  if (!colHeading.isEmpty()) {
559  colHeading,
560  "header",
561  colContentIndent
562  );/* no ID as yet, will need if ever set text styles for headings */
563  } // write a heading
564 
565  if (writeWidth) {
566  char widthStr[32];
567  if (colFixedWidth!=oofColSizer::kNotSet)
568  sprintf(widthStr, "%lu", colFixedWidth);
569  else
570  sprintf(widthStr, "%lu%%", colFixedPercentage); // include actual percent sign
571 
573  widthStr,
574  "width",
575  colContentIndent
576  ); // no ID as yet, will need if every set text styles per col
577 
578  } // write width
579 
580  if (customDrawer) {
582  customDrawer,
583  "customDrawer",
584  &mIdentities
585  );
586 
587  } // write customDrawer
588 
589  }
590  mIdentities.leaveLevel();
592  << oofTagMaker::makeClosingTag("column", colIndent);
593  } // some reason to write element
594  } // loop cols
595 }
596 
597 void
599 {
600  const oofString layoutIndent = mIdentities.getIndentString();
603  "box",
604  layoutIndent,
605  inBand->ID()
606  )
607  << '\n';
608 
609  mIdentities.enterLevel();
611  mIdentities.leaveLevel();
613  << oofTagMaker::makeClosingTag("box", layoutIndent);
614 }
615 
616 
617 void
619 {
620  inDrawable->describeLayout();
621 }
622 
623 
624 
625 
626 // -------------------------------------------------------
627 // O O F _ r e p X M L a d o r n e r V i s i t o r
628 // -------------------------------------------------------
639 // MUST be run before the layout visitor, to assign the ID's
640 public:
642  mIdentities(identities)
643  {};
644 
645 
646 protected:
647  virtual void VisitDrawable(oofRepDrawable*);
648  virtual void VisitAdorner(oofAdorner*);
649 
652 };
653 
654 
655 void
657 {
658  const oofString drawID = inDrawable->ID();
659  if (!drawID.isEmpty()) {
660  mParentIDattrib = oofString(" parentID = ", oofString::quoteString(drawID));
661  VisitAdornerList(inDrawable->adorners());
662  }
663 }
664 
665 
666 void
668 {
670  inAdorner,
671  "adorner",
672  &mIdentities,
673  0, // no ID for adorner itself
674  mParentIDattrib
675  );
676 }
677 
678 
679 // -------------------------------------------------------
680 // o o f R e p X M L s e t t i n g s
681 // -------------------------------------------------------
684 {
685  return new oofRepXMLsettings(*this);
686 }
687 
688 
689 // if subclassed to create different env which is subclass of oofRepXMLEnv,
690 // the following two constructors are where your class name would appear
691 oofRepXMLEnv*
693 {
694  return new oofRepXMLEnv(os);
695 }
696 
697 
698 oofRepXMLEnv*
699 oofRepXMLsettings::makeXMLenv(const char* filename)
700 {
701  return new oofRepXMLEnv(filename);
702 }
703 
704 
705 dbConnect*
707 {
708  return new dbConnect_ram;
709 }
710 
711 
712 void
714 {
715 // default location is current dir
716  char name[L_tmpnam];
717  tmpnam( name );
718  inConnect->newConnection(name);
719 }
720 
721 
722 oofString
724 {
725  return oofString("Report Document");
726 }
727 
728 
729 oofString
731 {
732  return oofString("xml");
733 }
734 
735 
736 
737 unsigned long
739 {
740  return 'TEXT';
741 }
742 
743 
744 
745 
746 
747 // -------------------------------------------------------
748 // o o f G r a p h S e t t i n g s 2 C S S
749 // -------------------------------------------------------
750 oofString
752 {
753  char scrapString[256];
754 
755  oofString styleRun ="{";
756  if(aGraphSetting->hasLegend())
757  styleRun += " hasLegend: true; ";
758  else
759  styleRun += " hasLegend: false; ";
760 
761  if(aGraphSetting->has3DEffect())
762  styleRun += " has3DEffect: true; ";
763  else
764  styleRun += " has3DEffect: false; ";
765 
766  if(aGraphSetting->hasTitle())
767  styleRun += "hasTitle: true; ";
768  else
769  styleRun += "hasTitle: false; ";
770 
771  if(aGraphSetting->hasValuesOverColumns())
772  styleRun += "hasValuesOverColumns: true; ";
773  else
774  styleRun += "hasValuesOverColumns: false; ";
775 
776  if(aGraphSetting->hasValuesNextToBars())
777  styleRun += "hasValuesNextToBars: true; ";
778  else
779  styleRun += "hasValuesNextToBars: false; ";
780 
781  if(aGraphSetting->hasXLabel())
782  styleRun += "hasXLabel: true; ";
783  else
784  styleRun += "hasXLabel: false; ";
785 
786  if(aGraphSetting->hasYLabel())
787  styleRun += "hasYLabel: true; ";
788  else
789  styleRun += "hasYLabel: false; ";
790 
791  if(aGraphSetting->hasXAxisTicks())
792  styleRun += "hasXAxisTicks: true; ";
793  else
794  styleRun += "hasXAxisTicks: false; ";
795 
796  if(aGraphSetting->hasYAxisTicks())
797  styleRun += "hasYAxisTicks: true; ";
798  else
799  styleRun += "hasYAxisTicks: false; ";
800 
801  if(aGraphSetting->hasXTickLabels())
802  styleRun += "hasXTickLabels: true; ";
803  else
804  styleRun += "hasXTickLabels: false; ";
805 
806  if(aGraphSetting->hasYTickLabels())
807  styleRun += "hasYTickLabels: true; ";
808  else
809  styleRun += "hasYTickLabels: false; ";
810 
811  styleRun += "titlePos: ";
812  styleRun += MakePosStateString(aGraphSetting->titlePos());
813 
814  styleRun += "XLabelPos: ";
815  styleRun += MakePosStateString(aGraphSetting->XLabelPos());
816 
817  styleRun += "YLabelPos: ";
818  styleRun += MakePosStateString(aGraphSetting->YLabelPos());
819 
820  sprintf(scrapString,"the3DEffectMultiplier: %1.3f ; ",aGraphSetting->the3DEffectMultiplier());
821  styleRun += scrapString;
822 
823  sprintf(scrapString,"legendOffset: %d; ",aGraphSetting->legendOffset());
824  styleRun += scrapString;
825 
826  sprintf(scrapString,"maxYLabelLen: %d ; ",aGraphSetting->maxYLabelLen());
827  styleRun += scrapString;
828 
829  sprintf(scrapString,"maxYTickLabelLen: %d ; ",aGraphSetting->maxYTickLabelLen());
830  styleRun += scrapString;
831 
832  sprintf(scrapString,"maxLegendLen: %d ; ",aGraphSetting->maxLegendLen());
833  styleRun += scrapString;
834 
835  sprintf(scrapString,"minorTickSize: %d ; ",aGraphSetting->minorTickSize());
836  styleRun += scrapString;
837 
838  sprintf(scrapString,"majorTickSize: %d ; ",aGraphSetting->majorTickSize());
839  styleRun += scrapString;
840 
841  sprintf(scrapString,"YAxisHeight: %d ; ",aGraphSetting->YAxisHeight());
842  styleRun += scrapString;
843 
844  styleRun += "intTickLabelMask: '";
845  styleRun += aGraphSetting->intTickLabelMask();
846  styleRun += "' ;";
847 
848  styleRun += "realTickLabelMask: '";
849  styleRun += aGraphSetting->realTickLabelMask();
850  styleRun += "' }";
851 
852  return styleRun;
853 }
854 
855 
856 oofString
857 oofGraphSettings2CSS::MakePosStateString(oofGeo::PositionState thePositionState)
858 {
859 // see oofCSS2GraphSettings::ParsePosString in oofriXML.cpp
860 
861  oofString thePositionStr;
862 
863  switch(thePositionState){
864  case oofGeo::posNone:
865  thePositionStr +="posNone ;";
866  break;
867  case oofGeo::posTop:
868  thePositionStr +="posTop ;";
869  break;
870  case oofGeo::posLeft:
871  thePositionStr += "posLeft ;";
872  break;
873  case oofGeo::posRight:
874  thePositionStr += "posRight ;";
875  break;
876  case oofGeo::posBottom:
877  thePositionStr += "posBottom ;";
878  break;
879  case oofGeo::posBelow:
880  thePositionStr += "posBelow ;";
881  break;
882  case oofGeo::posToLeft:
883  thePositionStr += "posToLeft ;";
884  break;
885  case oofGeo::posCentre:
886  thePositionStr += "posCentre ;";
887  break;
888  }
889  return thePositionStr;
890 }
891 
892 
893 // -------------------------------------------------------
894 // o o f R e p T e x t S t y l e 2 C S S
895 // -------------------------------------------------------
896 oofString
898 {
899  unsigned short fontSize;
900  short leading;
901  unsigned char style;
902  float lineHeight;
903 
904  const char * tempString;
905  bool FontNameHasASpace = false;
906  oofString theStyleRun;
907 
908  char scrapString[256];
909 
910  // start building the style
911  theStyleRun += "{";
912 
913  //theStyleRun += "{ " to the styleString
914  //set FontFamily to fontName()
915  // now add font-family
916  theStyleRun += "font-family: ";
917  //check for spaces
918  tempString = aStyleObject.fontName();
919  if(strstr(tempString," ")){
920  FontNameHasASpace = true;
921  theStyleRun += "'";
922  }
923 
924  theStyleRun += aStyleObject.fontName();
925  theStyleRun += "; " ;
926  if(FontNameHasASpace)
927  theStyleRun += "'" ;
928 
929  // fontsize
930  fontSize = aStyleObject.fontSize();
931  leading = aStyleObject.leading();
932  lineHeight = (fontSize+leading);
933  lineHeight = lineHeight/fontSize;
934  sprintf(scrapString,"line-height: %1.3f ; ",lineHeight);
935  //convertlineheight to a str and stick into Astr
936  //theStyleRun += "line-height: " ast "; "
937  theStyleRun += scrapString;
938  sprintf(scrapString,"font-size: %d ; ",fontSize);
939  theStyleRun += scrapString;
940 
941  //convertFontSize to a str and stick into Astr
942  //theStyleRun += :"font-size: "aStr" "pt ;"
943  style = aStyleObject.fontStyle();
944  makeStyleStrings(theStyleRun, aStyleObject.fontStyle());
945  //
946  theStyleRun += "color: rgb";
947  ostrstream colorString;
948  aStyleObject.color().extract(colorString);
949  oofString colorWeights = colorString;
950  theStyleRun += colorWeights;
951  theStyleRun += "; ";
952  theStyleRun += makeAlignmentString( aStyleObject.alignment());
953 
954  theStyleRun += "}";
955  return theStyleRun;
956 }
957 
958 
959 void
960 oofRepTextStyle2CSS::makeStyleStrings(oofString& theStyleRun, unsigned char textStyleNumber)
961 {
962  //function makeStyleStrings
963  //Passed a styleNumber unsigned char
964  //Returns an oofstr
965  //theStyleRun += "{ " to the styleString
966  if( textStyleNumber&bold ){
967  theStyleRun += "font-weight: bold; ";
968  }
969  if( textStyleNumber& italic ){
970  theStyleRun += "font-style: italic ;";
971  }
972  if( textStyleNumber& underline ){
973  theStyleRun += "text-decoration: underline; " ;
974  }
975  if( textStyleNumber& shadow ){
976  theStyleRun += "text-shadow: 0.2em 0.2em";
977  }
978  //if( stylenumber& outline ){
979  // theStyleRun += to"text-shadow: 0.2em 0.2em :" ;
980  //}
981  if( textStyleNumber & condense ){
982  theStyleRun += "font-stretch: condensed; ";
983  }
984  if( textStyleNumber& extend ){
985  theStyleRun += "font-stretch: expanded; ";
986 
987  }
988 }
989 
990 oofString
992 {
993  oofString alignString ="text-align: " ;
994  switch(inAlign){
996  alignString +="left" ;
997  break;
999  alignString +="center";
1000  break;
1002  alignString += "right";
1003  break;
1005  alignString += "justify";
1006  break;
1007  }
1008  return alignString;
1009 }
1010 
1011 // -------------------------------------------------------
1012 // o o f R e p o r t S e t t i n g s 2 C S S
1013 // -------------------------------------------------------
1014 // the caller after invoking this function must immmedialy
1015 // apphend defaultTextID to the current CSS style run string/stream
1016 // call then emit a css style on defaultTextStyle()
1017 oofString
1018 oofReportSettings2CSS::emitCSSstyle(const oofRepSettings* aReportSetting, const oofString& defaultTextID)
1019 {
1020  // apphend rp to strings to make unique from any possible standrad css identifier strings
1021  char scrapString[256];
1022  //oofString theDefaultTextStyle;
1023  oofString styleRun ="{";
1024  //oofRepTextStyle2CSS styleParser;
1025  sprintf(scrapString,"rpLineThickness: %d; ",aReportSetting->lineThickness());
1026  styleRun += scrapString;
1027 
1028  sprintf(scrapString,"rpPageHeight: %d ; ",aReportSetting->pageHeight());
1029  styleRun += scrapString;
1030 
1031  sprintf(scrapString,"rpPageWidth: %d ; ",aReportSetting->pageWidth());
1032  styleRun += scrapString;
1033 
1034  sprintf(scrapString,"rpBorderType: %d ; ",aReportSetting->borderType());
1035  styleRun += scrapString;
1036 
1037  sprintf(scrapString,"rpBandIndenting : %d ; ",aReportSetting->bandIndenting());
1038  styleRun += scrapString;
1039 
1040  sprintf(scrapString,"rpLeftMargin: %d ; ",aReportSetting->leftMargin());
1041  styleRun += scrapString;
1042 
1043  sprintf(scrapString,"rpRightMargin: %d ; ",aReportSetting->rightMargin());
1044  styleRun += scrapString;
1045 
1046  sprintf(scrapString,"rpTopMargin: %d ; ",aReportSetting->topMargin());
1047  styleRun += scrapString;
1048 
1049  sprintf(scrapString,"rpBottomMargin: %d ; ",aReportSetting->bottomMargin());
1050  styleRun += scrapString;
1051 
1052  sprintf(scrapString,"rpColSepWidth: %d ; ",aReportSetting->colSepWidth());
1053  styleRun += scrapString;
1054 
1055  sprintf(scrapString,"rpBlockVertSep: %d ; ",aReportSetting->blockVertSep());
1056  styleRun += scrapString;
1057 
1058  styleRun += "rpDefaultTextStyle: ";
1059  styleRun += defaultTextID;
1060  styleRun += "; ";
1061 
1062 // defaultPageHeaders skipped - written in <layout>
1063 // defaultPageFooters skipped
1064 
1065  sprintf(scrapString,"rpDrawHeadingsDownToLevel: %d ; ",aReportSetting->drawHeadingsDownToLevel());
1066  styleRun += scrapString;
1067 
1068  if(aReportSetting->printGraphsInMono())
1069  styleRun += "rpPrintGraphsInMono: true ; ";
1070  else
1071  styleRun += "rpPrintGraphsInMono: false ; ";
1072 
1073  if(aReportSetting->modalPreviewWindow())
1074  styleRun += "rpModalPreviewWindow: true ; ";
1075  else
1076  styleRun += "rpModalPreviewWindow: false ; ";
1077 
1078  sprintf(scrapString,"rpGraphBandMinSizePercent: %d ; ",aReportSetting->graphBandMinSizePercent());
1079  styleRun += scrapString;
1080 
1081 // XMLsettings skipped - application code sets function pointer
1082  styleRun += " }";
1083  return styleRun;
1084 }
1085 
1086 
1087 
1088 // ---------------------------------------
1089 // o o f R e p X M L E n v
1090 // ---------------------------------------
1091 oofRepXMLEnv::oofRepXMLEnv(ostream& os) :
1092  oofRepStreamEnv(os)
1093 {
1094 }
1095 
1096 
1097 oofRepXMLEnv::oofRepXMLEnv(const char* fileName) :
1098  oofRepStreamEnv(fileName)
1099 {}
1100 
1101 
1102 void
1104 {
1105 // now the magic bit.
1106 // by dereferencing this, we make an overriding function match against the virtual
1107 // method that takes an oofRepXMLEnv&.
1108 // The implication is that, if we add an environment, each drawable must have a makeRender
1109 // added to match, or it will not be rendered (the base empty method will be invoked).
1110 
1111 // eg: if we need to handle printing and previewing differently on the Mac, we would end up
1112 // with a makeRender(const oofRepMacPrint&) and makeRender(const oofRepMacGUIPreviewPP&)
1113 // for each oofRepDrawable
1114 
1115 // The alternative would be to have each environment know each drawable. That is far
1116 // less extensible - users can add their own drawables that we wouldn't know about,
1117 // so the environment classes wouldn't be closed for extension.
1118  drawable->makeRender(*this);
1119 }
1120 
1121 void
1123 {
1124  drawable->makeRender(*this);
1125 }
1126 
1127 // a little bit of RTTI which can be used to record what kind of render last
1128 // used, and could be used in switches if the above virtual multiple dispatch
1129 // technique wasn't being used instead
1132 {
1133  return eRenderType;
1134 }
1135 
1136 
1137 void
1139 {
1140 }
1141 
1142 
1143 void
1145 {
1146 }
1147 
1148 
1149 unsigned short
1151 {
1152 // Not relevant for XML output... dummy value used instead
1153  return 12;
1154 }
1155 
1156 
1157 unsigned long
1159 {
1160  // Not relevant for XML output... dummy value used instead
1161  return 840;
1162 }
1163 
1164 
1165 unsigned long
1167 {
1168  // Not relevant for XML output... dummy value used instead
1169  return 590;
1170 }
1171 
1172 
1173 void
1175 {
1176  mIdentities.reset(); // reset each time in case we rerun, so same ID's allocated
1177 
1178  oofRep* mainReport = oofRep::currentReport();
1179  oofRepMulti* multiRep = 0;
1180  if (mainReport->isMultiReport())
1181  multiRep = (oofRepMulti*) mainReport; // safe downcast
1182 
1183 // output XML header
1185 
1186 // output start of report
1187  if (multiRep) {
1188  char scrapStr[40];
1189  const int numSections = multiRep->count();
1190  sprintf(scrapStr," numSections='%d'",numSections);
1191  *mOut << "<report ID='1'" << scrapStr << ">\n";
1192  }
1193  else
1194  *mOut << "<report ID='1'>\n";
1195 
1196  mIdentities.enterLevel(); // within root element <report>
1197 
1198 // output unified schema for all report and sections
1199  {
1200  const oofString schemaIndent = mIdentities.getIndentString();
1201  *mOut << oofXMLDBWriter::schemaHeader(schemaIndent);
1202  mIdentities.enterLevel(); // want schema elements indented inside <schema>
1203  OOF_repXMLschemaVisitor schemaWriter(mIdentities);
1204  schemaWriter.visit(mainReport);
1206  *mOut << oofTagMaker::makeClosingTag("schema", schemaIndent);
1207  }
1208 
1209 // output layout and style for single reports
1210  if (multiRep)
1211  mSectionNumber=0;
1212  else
1213  StartReport("1");
1214 }
1215 
1216 
1217 void
1219 {
1220 // called before each section, regardless of settings
1221 // unlike drawSectionBreak which may not be called if no page breaks specified
1222  if (mSectionNumber>0)
1223  CloseSection();
1224 
1225  const oofString reportID = mIdentities.getIDstring();
1226  *mOut << oofTagMaker::makeOpeningTag("section",mIdentities.getIndentString(), reportID) << '\n';
1229  StartReport(reportID);
1230  mSectionNumber++;
1231 }
1232 
1233 
1234 void
1236 {
1239 }
1240 
1241 
1242 void
1244 {
1245  oofRep* rep = oofRep::currentReport();
1246 
1247  const oofString styleIndent = mIdentities.getIndentString();
1248  const oofString reportDefaultTextStyleID = mIdentities.getIDstring();
1249  mIdentities.incrementID(); // settings include a text style written separately with its own ID
1250 
1251  *mOut << oofTagMaker::makeOpeningTag("style", styleIndent) << '\n';
1252  OOF_repXMLstyleVisitor styleWriter(mIdentities);
1255  << styleIndent << styleIndent // double-indent all style strings
1256  << '#' << reportID
1257  << oofReportSettings2CSS::emitCSSstyle(rep->settings(), reportDefaultTextStyleID)
1258  << '\n'
1259 
1260  << styleIndent << styleIndent
1261  << '#' << reportDefaultTextStyleID
1263  << '\n';
1264  styleWriter.visit(rep);
1266  *mOut << oofTagMaker::makeClosingTag("style", styleIndent);
1267 
1268  if (styleWriter.adornersEncountered()) {
1269  *mOut << oofTagMaker::makeOpeningTag("adorners", styleIndent) << '\n';
1270  OOF_repXMLadornerVisitor adornerWriter(mIdentities);
1272  adornerWriter.visit(rep);
1274  *mOut << oofTagMaker::makeClosingTag("adorners", styleIndent);
1275  }
1276 
1277  *mOut << oofTagMaker::makeOpeningTag("layout", styleIndent) << '\n';
1278  OOF_repXMLlayoutVisitor layoutWriter(mIdentities);
1280  layoutWriter.visit(rep);
1282  *mOut << oofTagMaker::makeClosingTag("layout", styleIndent);
1283 }
1284 
1285 
1286 void
1288 {
1289  oofRep* mainReport = oofRep::currentReport();
1290  if (mainReport->isMultiReport())
1291  CloseSection();
1292 // output closing report tag
1293  *mOut << "</report>\n";
1294 }
1295 
1296 
1297 bool
1299 {
1300  return true;
1301 }
1302 
1303 
1304 // -------------------------------------------------------
1305 // o o f R e p T a g M a k e r
1306 // -------------------------------------------------------
1307 oofString
1308 oofRepTagMaker::makeLineTag(unsigned long height, const char* indentString, const char* /*idString*/)
1309 {
1310  char scrapString[32];
1311  oofString result = indentString;
1312  result += "<HR";
1313  sprintf(scrapString," height='%d'/>\n", height);
1314  result += scrapString;
1315  return result;
1316 }
1317 
1318 
1319 oofString
1320 oofRepTagMaker::makeSpaceTag(unsigned long height, const char* indentString, const char* /*idString*/)
1321 {
1322  char scrapString[32];
1323  oofString result = indentString;
1324  result += "<space";
1325  sprintf(scrapString," height='%d'/>\n", height);
1326  result +=scrapString;
1327  return result;
1328 }
1329 
1330 
1331 oofString
1332 oofRepTagMaker::makeBreakTag(const char* indentString)
1333 {
1334  return oofString(indentString, "<BR/>\n");
1335 }
1336 
1337 
1338 
1339 
1340 // -------------------------------------------------------
1341 // r e n d e r f a c t o r i e s
1342 // -------------------------------------------------------
1343 void
1345 {
1346  delete mRender; // assume if we're called and have existing it's wrong type
1347  oofRepViewBand_Render* theRender = new oofRepViewBand_XMLRender(this);
1348  mRender = theRender;
1349  mTableExtraRender = theRender;
1351 }
1352 
1353 
1354 void
1356 {
1357  MakeAnyRender();
1358 }
1359 
1360 
1361 void
1363 {
1364  delete mRender;
1365  mRender = new oofRepSpaceBand_XMLRender(this);
1366 }
1367 
1368 
1369 void
1371 {
1372  delete mRender;
1373  mRender = new oofRepGraphBand_XMLRender(this);
1374 }
1375 
1376 
1377 void
1379 {
1380  delete mRender;
1381  mRender = new oofRepLineBand_XMLRender(this);
1382 }
1383 
1384 
1385 void
1387 {
1388  delete mRender;
1389  mRender = new oofRepPictBand_XMLRender(this);
1390 }
1391 
1392 
1393 void
1395 {
1396  delete mRender;
1397  mRender = new oofRepLayoutBand_XMLRender(this);
1398 }
1399 
1400 
1401 void
1403 {
1404  delete mRender;
1405  mRender = new oofRepTextBlock_XMLRender(this);
1406 }
1407 
1408 
1409 void
1411 {
1412  delete mRender;
1413  mRender = new oofRepPictBlock_XMLRender(this);
1414 }
1415 
1416 
1417 void
1419 {
1420  delete mRender;
1422 }
1423 
1424 
1425 // -------------------------------------------------------
1426 // o o f R e p V i e w B a n d _ X M L R e n d e r
1427 // -------------------------------------------------------
1428 oofRepViewBand_XMLRender::oofRepViewBand_XMLRender(oofRepViewBand* b) :
1430 {
1431  oofRepXMLEnv* thisEnvir = (oofRepXMLEnv*)oofRep::currentReport()->environment(); // safe downcast
1432  oofIDfactory& identities = thisEnvir->getIdentities();
1433  mWriter = new oofXMLDBWriter(oofRepStreamEnv::out(), mOwner->view(), identities);
1434 }
1435 
1436 
1438 {
1439  delete mWriter;
1440 }
1441 
1442 
1443 oofRepRender*
1445 {
1446  return new oofRepViewBand_XMLRender((oofRepViewBand*)newOwner); // safe downcast
1447 }
1448 
1449 
1450 
1451 void
1452 oofRepViewBand_XMLRender::startTableBody(bool /*headersHaveChanged*/)
1453 {
1454  assert(mWriter); // created in ctor
1455  mWriter->startDatabase();
1456 }
1457 
1458 
1459 void
1461 {
1462  oofRep* theRep = oofRep::currentReport();
1463  mWriter->endDatabase();
1464 }
1465 
1466 
1467 void
1468 oofRepViewBand_XMLRender::draw() // draws data for just current record
1469 {
1470  assert(mWriter);
1471  mWriter->writeRecord();
1472 }
1473 
1474 
1475 
1476 
1477 // -------------------------------------------------------
1478 // o o f R e p L a y o u t B a n d _ X M L R e n d e r
1479 // -------------------------------------------------------
1480 oofRepRender*
1482 {
1483  return new oofRepLayoutBand_XMLRender((oofRepLayoutBand*)newOwner); // safe downcast
1484 }
1485 
1486 
1487 // -------------------------------------------------------
1488 // o o f R e p L i n e B a n d _ X M L R e n d e r
1489 // -------------------------------------------------------
1490 void
1492 {
1493  oofRepXMLEnv* thisEnvir = (oofRepXMLEnv*)oofRep::currentReport()->environment(); // safe downcast
1494  oofIDfactory& identities = thisEnvir->getIdentities();
1495  const unsigned long fixedHeight = mOwner->fixedHeight();
1497  fixedHeight,
1498  identities.getIndentString(),
1499  mOwner->ID()
1500  );
1501 }
1502 
1503 
1504 oofRepRender*
1506 {
1507  return new oofRepLineBand_XMLRender((oofRepLineBand*)newOwner); // safe downcast
1508 }
1509 
1510 
1511 // -------------------------------------------------------
1512 // o o f R e p P i c t B a n d _ X M L R e n d e r
1513 // -------------------------------------------------------
1514 oofRepRender*
1516 {
1517  return new oofRepPictBand_XMLRender((oofRepPictBand*)newOwner); // safe downcast
1518 }
1519 
1520 
1521 // -------------------------------------------------------
1522 // o o f R e p S p a c e B a n d _ X M L R e n d e r
1523 // -------------------------------------------------------
1524 void
1526 {
1527  oofRepXMLEnv* thisEnvir = (oofRepXMLEnv*)oofRep::currentReport()->environment(); // safe downcast
1528  oofIDfactory& identities = thisEnvir->getIdentities();
1529  const unsigned long fixedHeight = mOwner->fixedHeight();
1531  fixedHeight,
1532  identities.getIndentString(),
1533  mOwner->ID()
1534  );
1535 }
1536 
1537 
1538 oofRepRender*
1540 {
1541  return new oofRepSpaceBand_XMLRender((oofRepSpaceBand*)newOwner); // safe downcast
1542 }
1543 
1544 
1545 
1546 // -------------------------------------------------------
1547 // o o f R e p G r a p h B a n d _ X M L R e n d e r
1548 // -------------------------------------------------------
1549 void
1551 {
1552  oofRepXMLEnv* thisEnvir = (oofRepXMLEnv*)oofRep::currentReport()->environment(); // safe downcast
1553  oofIDfactory& identities = thisEnvir->getIdentities();
1554 
1555  const oofString srcName = mOwner->view()->name();
1556  oofString overlaySrcName;
1557 
1558  const dbView* overlayView = mOwner->view(1);
1559  if (overlayView) {
1560  overlaySrcName = overlayView->name();
1561  }
1562  char scrapString[256];
1563  const unsigned long height = mOwner->fixedHeight();
1564  const unsigned long gHeight = mOwner->originalGraphHeight();
1565  const unsigned long gWidth = mOwner->originalGraphWidth();
1566  const unsigned long numOverlaid = mOwner->numOverlaid();
1567  const oofString graphTitle = oofString::encodeEntity( mOwner->graph()->getTitle() );
1568  sprintf(scrapString," height='%d' graphWidth='%d' graphHeight='%d'",height, gWidth, gHeight);
1569 
1570 // we use a few temp oofStrings for faster construction of concatenated strings
1571  oofString attribString( " type=", oofString::quoteString(mOwner->graph()->getType()) );
1572 
1573  attribString += oofString( " source=", oofString::quoteString(oofTagMaker::encodeName(srcName)), scrapString );
1574 
1575  attribString += oofString( " title=", oofString::quoteString(graphTitle) );
1576 
1577 // optional attributes AT END!
1578  if (numOverlaid>0) {
1579  sprintf(scrapString," numOverlaid='%d'", numOverlaid);
1580  attribString += scrapString;
1581  }
1582  else if (!overlaySrcName.isEmpty()) {
1583  attribString += oofString( " overlaySource=", oofString::quoteString(oofTagMaker::encodeName(overlaySrcName)) );
1584  }
1585 
1587  "graph",
1588  identities.getIndentString(),
1589  mOwner->ID(),
1590  attribString,
1591  true // empty tag
1592  );
1593 }
1594 
1595 
1596 oofRepRender*
1598 {
1599  return new oofRepGraphBand_XMLRender((oofRepGraphBand*)newOwner); // safe downcast
1600 }
1601 
1602 
1603 void
1605 {
1606  oofRepXMLEnv* thisEnvir = (oofRepXMLEnv*)oofRep::currentReport()->environment(); // safe downcast
1607  dbView* graphView = mOwner->view();
1608  assert(graphView);
1609  oofXMLDBWriter graphWriter(oofRepStreamEnv::out(), graphView, thisEnvir->getIdentities());
1610  graphWriter.writeDatabase();
1611 
1612 
1613  graphView = mOwner->view(1); // 2nd view is overlayView if it exists
1614  if (graphView) {
1615  oofXMLDBWriter overlayWriter(oofRepStreamEnv::out(), graphView, thisEnvir->getIdentities());
1616  overlayWriter.writeDatabase();
1617  }
1618 }
1619 
1620 
1621 // -------------------------------------------------------
1622 // o o f R e p T e x t B l o c k _ X M L R e n d e r
1623 // -------------------------------------------------------
1624 void
1626 {
1627  oofRepXMLEnv* thisEnvir = (oofRepXMLEnv*)oofRep::currentReport()->environment(); // safe downcast
1628  oofIDfactory& identities = thisEnvir->getIdentities();
1629 
1630  oofRepBlock::blockAlignT blockAlign = mOwner->align();
1631  oofString attStr;
1632  if (blockAlign==oofRepBlock::alignRight)
1633  attStr = "align='right'";
1634  else if (blockAlign==oofRepBlock::alignCentre)
1635  attStr = "align='centre'";
1636 
1637  const unsigned long fixedBlockWidth = mOwner->fixedWidth();
1638  if (fixedBlockWidth>0)
1639  attStr.convertNumber(fixedBlockWidth, " fixedWidth='%d'", true); // append fixedWidth attribute
1640 
1643  mOwner->text(),
1644  "inline",
1645  identities.getIndentString(),
1646  mOwner->ID(),
1647  attStr
1648  );
1649 
1650  if( mOwner->moveDownAfter() ) {
1652  }
1653 }
1654 
1655 
1656 oofRepRender*
1658 {
1659  return new oofRepTextBlock_XMLRender((oofRepTextBlock*)newOwner); // safe downcast
1660 }
1661 
1662 
1663 // -------------------------------------------------------
1664 // o o f R e p P a g e N o B l o c k _ X M L R e n d e r
1665 // -------------------------------------------------------
1669 void
1671 {
1672  oofRepXMLEnv* thisEnvir = (oofRepXMLEnv*)oofRep::currentReport()->environment(); // safe downcast
1673  oofIDfactory& identities = thisEnvir->getIdentities();
1674 
1675  oofRepBlock::blockAlignT blockAlign = mOwner->align();
1676  const char* attStr = 0;
1677  if (blockAlign==oofRepBlock::alignRight)
1678  attStr = "align='right'";
1679  else if (blockAlign==oofRepBlock::alignCentre)
1680  attStr = "align='centre'";
1681 
1682  oofRepBracketedTextBlock* realOwner = (oofRepBracketedTextBlock*) mOwner; // safe downcast
1683  const oofString pageNoStr(realOwner->leadingText(), "^P", realOwner->trailingText());
1686  pageNoStr,
1687  "inline",
1688  identities.getIndentString(),
1689  mOwner->ID(),
1690  attStr
1691  );
1692 
1693  if( mOwner->moveDownAfter() ) {
1695  }
1696 }
1697 
1698 
1699 oofRepRender*
1701 {
1702  return new oofRepPageNoBlock_XMLRender((oofRepTextBlock*)newOwner); // safe downcast
1703 }
1704 
1705 
1706 
1707 // -------------------------------------------------------
1708 // o o f R e p P i c t B l o c k _ X M L R e n d e r
1709 // -------------------------------------------------------
1710 oofRepRender*
1712 {
1713  return new oofRepPictBlock_XMLRender((oofRepPictBlock*)newOwner); // safe downcast
1714 }
1715 
unsigned short drawHeadingsDownToLevel() const
Definition: oofrep3.cpp:515
virtual dbView * view(unsigned short whichView=0) const
Request a dbView which may be the source of data for the item.
Definition: oofrep2.cpp:680
static const char * xmlSimpleVersionString()
Definition: oofxml.cpp:267
Base environment for rendering to a text stream.
Definition: oofrep.h:446
Output description of oofRepLineBand.
Definition: oofrpXML.h:148
oofRepBreak * value(unsigned long) const
Definition: oofrep.h:2495
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1597
oofString leadingText() const
Definition: oofrep.h:2240
oofRepBreakList & footerBreaks()
Definition: oofrep.h:2124
void colSizer(oofColSizer *adoptedSizer)
Definition: oofsize.cpp:71
virtual unsigned short heightOfTextStyle(oofRepTextStyle *)
Definition: oofrpXML.cpp:1150
oofIDfactory & mIdentities
Definition: oofrpXML.cpp:650
oofRepSpaceBand_XMLRender(oofRepSpaceBand *b)
Definition: oofrpXML.h:114
bool hasYAxisTicks() const
Definition: oofSting.cpp:317
virtual ~oofRepViewBand_XMLRender()
Definition: oofrpXML.cpp:1437
virtual void VisitIterableBandBody(oofRepBand *)
Isolates these bands so more complex visitors can optimise their querying.
Definition: oofrep2.cpp:1690
unsigned char fontStyle() const
Definition: oofrep.h:2556
Used by oofRepXMLEnv::StartReport to visit all stylable items.
Definition: oofrpXML.cpp:66
Used by oofRepXMLEnv::StartReport to visit all report items and describe them in .
Definition: oofrpXML.cpp:300
Database backend for a single RAM-resident table.
Definition: oofram.h:26
Convenient mixin if you want to have a band which iterates and has breaks.
Definition: oofrep.h:918
oofString getIndentString()
Definition: oofxml.h:116
virtual OOF_mixIterableBand * asIterableBand()
Definition: oofrep1.cpp:1547
unsigned long count()
Count records in current selection.
Definition: oof1.h:2017
short leading() const
Definition: oofrep.h:2563
virtual void VisitDrawable(oofRepDrawable *)
Definition: oofrpXML.cpp:656
oofRepBandList & footers()
Definition: oofrep.h:2141
oofRepPageNoBlock_XMLRender(oofRepTextBlock *b)
Definition: oofrpXML.h:210
virtual void makeRender(const oofRepMacEnv &env)
Definition: oofrepMac.cpp:169
virtual const oofString & fieldName() const
Definition: oof3.h:769
visits all dbViews in a report.
Definition: oofrep.h:555
virtual void VisitBandHeaders(oofRepBandList &)
Definition: oofrpXML.cpp:371
virtual void LeaveLevel()
Definition: oofrpXML.cpp:160
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1505
bool hasLegend() const
Definition: oofSting.cpp:203
virtual unsigned long fixedHeight()
Definition: oofrep.h:2179
oofRepBreakList & headerBreaks()
Definition: oofrep.h:2117
bool modalPreviewWindow() const
Definition: oofrep3.cpp:555
virtual dbView * view(unsigned short whichView=0) const
Request a dbView which may be the source of data for the item.
Definition: oofrep2.cpp:272
Abstract base for anything drawn on report.
Definition: oofrep.h:860
Tries to hide the different platforms and version issues with standard IO.
unsigned long originalGraphHeight() const
Definition: oofrep.h:2700
oofIDfactory & mIdentities
Definition: oofrpXML.cpp:187
No output render.
Definition: oofrpXML.h:160
oofGeo::PositionState XLabelPos() const
Definition: oofSting.cpp:434
virtual void makeRender(const oofRepMacEnv &)
Definition: oofrepMac.cpp:137
Convenient mixin if your band is rendered in columns with custom drawing.
Definition: oofrep.h:980
virtual void VisitComplexBand(oofRepBand *)
Visit a band which is likely to provide one or more optional interfaces.
Definition: oofrpXML.cpp:466
OOF_DummyString mDummyNames
Definition: oofrpXML.cpp:189
virtual void VisitFirstPageHeaders(oofRepBandList &)
Definition: oofrpXML.cpp:331
unsigned long originalGraphWidth() const
Definition: oofrep.h:2693
virtual void VisitView(dbView *)
Definition: oofrpXML.cpp:194
oofRepEnvironment * environment() const
Definition: oofrep.h:1900
OOF_Dictionary mKnownTables
Definition: oofrpXML.cpp:188
virtual oofRepXMLEnv * makeXMLenv(std::ostream &)
unsigned short borderType() const
Definition: oofrep3.cpp:308
void StartReport(const oofString reportID)
Definition: oofrpXML.cpp:1243
OOF_repXMLstyleVisitor(oofIDfactory &identities)
Definition: oofrpXML.cpp:68
void incrementID()
Definition: oofxml.h:109
Output data contained within the dbView as nested elements.
Definition: oofrpXML.h:172
virtual void describeLayout()
Definition: oofrpXML.cpp:1550
void UniquifyTables(dbView *)
Definition: oofrpXML.cpp:248
Report that contains list of unrelated other reports as oofRepSection's.
Definition: oofrep.h:677
oofRepSpaceBand * mOwner
Definition: oofreprn.h:31
virtual dbConnect * makeTempConnection()
Definition: oofrpXML.cpp:706
oofRepCustomViewDrawer * customDrawer(unsigned short col)
Definition: oofrep2.cpp:172
static oofString makeBreakTag(const char *indentString=0)
Definition: oofrpXML.cpp:1332
virtual void VisitPageFooters(oofRepBandList &)
Definition: oofrpXML.cpp:364
oofIDfactory & mIdentities
Definition: oofrpXML.cpp:83
std::ostream * mOut
Definition: oofrep.h:457
Output description of the aligned text block as specified by oofRepTextBlock.
Definition: oofrpXML.h:196
No output render.
Definition: oofrpXML.h:220
void reset()
Definition: oofxml.cpp:43
std::stringstream ostrstream
Definition: oofios.h:49
Settings object for overriding behaviours of an instance of oofGraph.
Definition: oofSting.h:24
unsigned short minorTickSize() const
Definition: oofSting.cpp:534
virtual void VisitAdorner(oofAdorner *)
Definition: oofrpXML.cpp:667
virtual void VisitComplexBand(oofRepBand *)
Visit a band which is likely to provide one or more optional interfaces.
Definition: oofrpXML.cpp:205
const dbField & field(unsigned int) const
Definition: oofview.h:206
Abstract base for drawing text content with some bracketing text in an oofRepLayoutBand.
Definition: oofrep.h:1490
oofRepPictBlock_XMLRender(oofRepPictBlock *b)
Definition: oofrpXML.h:222
blockAlignT align() const
Definition: oofrep.h:2205
Most commonly used top band in a report.
Definition: oofrep.h:1283
unsigned long count() const
Definition: oofrep.h:2070
unsigned short graphBandMinSizePercent() const
Definition: oofrep3.cpp:575
unsigned short bottomMargin() const
Definition: oofrep3.cpp:401
virtual void endEnvironment()
Definition: oofrpXML.cpp:1287
oofAdornerList & adorners()
Definition: oofadorn.h:354
virtual void createTempConnectFiles(dbConnect *)
Definition: oofrpXML.cpp:713
virtual void makeRender(const oofRepMacEnv &env)
Definition: oofrepMac.cpp:177
static oofString makeClosingTag(const char *tag, const char *indentString=0)
Definition: oofxml.cpp:128
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1539
static oofString makeOpeningTag(const char *tag, const char *indentString=0, const char *ID=0, const char *otherAttributes=0, bool emptyTag=false)
Definition: oofxml.cpp:103
double the3DEffectMultiplier() const
Definition: oofSting.cpp:614
virtual void describeLayout()
central default call like draw() but still able to be overriden in extreme cases. ...
Definition: oofrep1.cpp:1265
unsigned long fixedPercentage(unsigned short colNum) const
Definition: oofsize.cpp:220
bool hasTitle() const
Definition: oofSting.cpp:241
void setName(const char *name)
Definition: oof3.cpp:195
bool hasYTickLabels() const
Definition: oofSting.cpp:355
const char * getType()
Definition: oofGrphs.cpp:170
Base rendering class.
Definition: oofrep.h:816
static oofString makeAlignmentString(oofColSizer::colAlignT)
Definition: oofrpXML.cpp:991
bool adornersEncountered() const
Definition: oofrpXML.cpp:90
void startDatabase()
Definition: oofxmldb.cpp:70
const char * getTitle()
Definition: oofGrphs.cpp:164
unsigned long count() const
Definition: oofrep.h:2285
OOF_repXMLadornerVisitor(oofIDfactory &identities)
Definition: oofrpXML.cpp:641
Output text with ^p bracketed text as specified by oofRepPageNoBlock.
Definition: oofrpXML.h:208
oofRepBand * band() const
Definition: oofrep.h:2513
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1515
virtual void VisitLayoutBand(oofRepLayoutBand *)
Definition: oofrep2.cpp:1738
virtual void startEnvironment()
Definition: oofrpXML.cpp:1174
oofRepPictBand_XMLRender(oofRepPictBand *b)
Definition: oofrpXML.h:162
Generate nestable Dewey Decimal-style ID's to easily provide unique XML ID attributes.
Definition: oofxml.h:24
Specify or calculate a set of column widths & alignments.
Definition: oofsize.h:51
static oofString encodeEntity(const oofString &)
Return a string encoded suitable for use in HTML or XML.
Definition: oofstr.cpp:1583
const oofRepSettings * settings() const
Definition: oofrep1.cpp:469
virtual void newConnection(const char *connectionName)=0
Output a tag using oofRepTagMaker::makeSpaceTag.
Definition: oofrpXML.h:112
void setName(const char *)
Definition: oof1.h:2401
virtual void VisitBandList(oofRepBandList &)
Definition: oofrpXML.cpp:427
bool hasAdorners() const
Definition: oofadorn.h:361
void name(const oofString &)
Definition: oofview.h:116
virtual void describeLayout()
Definition: oofrpXML.cpp:1625
virtual void makeRender(const oofRepMacEnv &env)
Definition: oofrepMac.cpp:145
oofColSizer::colAlignT alignment() const
Definition: oofrep.h:2577
Write a database to XML on iostream with included tag.
Definition: oofxmldb.h:174
unsigned short lineThickness() const
Definition: oofrep3.cpp:251
oofGeo::PositionState titlePos() const
Definition: oofSting.cpp:414
oofRepLayoutBand_XMLRender(oofRepLayoutBand *b)
Definition: oofrpXML.h:139
virtual void VisitLayoutBand(oofRepLayoutBand *)
Definition: oofrpXML.cpp:598
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1657
oofRepTextBlock * mOwner
Definition: oofreprn.h:175
void convertNumber(int, const char *printfMask=0, bool appendIt=false)
Definition: oofstr.cpp:882
GUI report-writer layer of OOFILE database.
unsigned short fontSize() const
Definition: oofrep.h:2548
unsigned short maxLegendLen() const
Definition: oofSting.cpp:514
virtual void VisitBandList(oofRepBandList &)
Definition: oofrep2.cpp:1612
void extract(std::ostream &) const
Definition: oofcolor.cpp:521
virtual unsigned long calcPageHeight()
Definition: oofrpXML.cpp:1158
Provide an iterable set of fields.
Definition: oofview.h:26
virtual void VisitDrawable(oofRepDrawable *)
Definition: oofrpXML.cpp:97
oofGraph * graph() const
Definition: oofrep.h:2672
bool hasYLabel() const
Definition: oofSting.cpp:394
List of bands attached to report or other bands, eg: page headers.
Definition: oofrep.h:292
unsigned short topMargin() const
Definition: oofrep3.cpp:382
void writeRecord()
Definition: oofxmldb.cpp:106
unsigned short bandIndenting() const
Definition: oofrep3.cpp:326
oofRepXMLEnv(std::ostream &)
virtual void finishConstruction()
Definition: oofrep.h:820
virtual bool newPage()
Definition: oofrep1.cpp:2108
virtual void changeTextStyle(oofRepTextStyle *)
Definition: oofrpXML.cpp:1144
bool isEmpty() const
Test based on either length or null pointer.
Definition: oofstr.h:413
bool keepTogether() const
Definition: oofrep.h:2347
Top level class for a report.
Definition: oofrep.h:571
virtual void VisitComplexBand(oofRepBand *)
Visit a band which is likely to provide one or more optional interfaces.
Definition: oofrep2.cpp:1704
Convenient mixin if you want to have a band with sub-bands.
Definition: oofrep.h:944
virtual void makeRender(const oofRepMacEnv &env)
Definition: oofrepMac.cpp:161
oofIDfactory & mIdentities
Definition: oofrpXML.cpp:326
void cloneTable(bool shareSelection=false)
Definition: oofview.cpp:152
void leaveLevel()
Definition: oofxml.cpp:51
void endDatabase()
Definition: oofxmldb.cpp:79
oofIDfactory & getIdentities()
Definition: oofrpXML.h:262
static std::ostream & out()
Definition: oofrep.h:2727
static oofString makeLineTag(unsigned long height, const char *indentString=0, const char *idString=0)
Definition: oofrpXML.cpp:1308
oofIDfactory mIdentities
Definition: oofrpXML.h:87
oofString trailingText() const
Definition: oofrep.h:2247
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1444
const oofString mIndent
Definition: oofrpXML.cpp:84
unsigned long oofRepRenderT
Definition: oofrep.h:113
virtual void VisitFirstPageFooters(oofRepBandList &)
Definition: oofrpXML.cpp:344
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1700
statically stored self-incrementing const char*'s
Definition: oof2.h:85
bool moveDownAfter() const
Indicate if a layout band should start a new row of blocks.
Definition: oofrep.h:2215
int mSectionNumber
Definition: oofrpXML.h:88
const oofString & tableName() const
Definition: oof1.h:2369
unsigned short maxYTickLabelLen() const
Definition: oofSting.cpp:494
virtual void VisitBreakList(oofRepBreakList &)
Definition: oofrpXML.cpp:436
Abstract base for user column drawer.
Definition: oofrep.h:1239
virtual void MakeAnyRender()
Definition: oofrep2.cpp:488
virtual void makeRender(const oofRepMacEnv &)
Definition: oofadorn.cpp:167
virtual oofString saveReportDocDescription()
Definition: oofrpXML.cpp:723
unsigned short rightMargin() const
Definition: oofrep3.cpp:363
const char * realTickLabelMask() const
Definition: oofSting.cpp:655
virtual void describeLayout()
Definition: oofrpXML.cpp:1491
const oofString & fontName() const
Definition: oofrep.h:2540
visits all report objects.
Definition: oofrep.h:484
Abstract base for rendering an oofRepViewBand.
Definition: oofreprn.h:129
virtual void EnterLevel()
Definition: oofrpXML.cpp:153
OOF_repXMLschemaVisitor(oofIDfactory &identities)
Definition: oofrpXML.cpp:176
virtual void drawPageBreak()
Definition: oofrpXML.cpp:1138
oofRepLineBand * mOwner
Definition: oofreprn.h:83
virtual void VisitBandFooterBreaks(oofRepBreakList &)
Definition: oofrpXML.cpp:414
static oofString makeSerializableElement(oofSerializable *, const char *tag, oofIDfactory *idFactory, bool writeID=false, const char *otherAttributes=0)
Definition: oofxmldb.cpp:300
Specify a fixed height band containing an oofGraph with additional height & width.
Definition: oofrep.h:1080
virtual OOF_mixColumnarBand * asColumnarBand()
Definition: oofrep1.cpp:1568
virtual void VisitPageHeaders(oofRepBandList &)
Definition: oofrpXML.cpp:357
unsigned int count() const
Definition: oof1.h:1498
virtual void makeRender(const oofRepMacEnv &env)
Definition: oofrepMac.cpp:122
Base class for persistent tables.
Definition: oof1.h:452
virtual void startTableBody(bool headersHaveChanged)
Definition: oofrpXML.cpp:1452
Portable highly capable string class.
Definition: oofstr.h:101
unsigned long fixedWidth()
Definition: oofrep.h:2229
virtual oofRepXMLsettings * clone()
Definition: oofrpXML.cpp:683
void WriteColumns(oofRepBand *inBand)
Definition: oofrpXML.cpp:489
virtual void makeRender(const oofRepMacEnv &env)
Definition: oofrepMac.cpp:110
Visit all report items that may be linked to database to add schema entries.
Definition: oofrpXML.cpp:174
static oofString emitCSSstyle(const oofRepTextStyle &)
Definition: oofrpXML.cpp:897
bool hasXAxisTicks() const
Definition: oofSting.cpp:298
virtual void makeRender(const oofRepMacEnv &)
Definition: oofrep1.cpp:1334
Settings object for overriding behaviours of an instance of oofRep.
Definition: oofrep.h:173
Specify a fixed-height band that contains a series of oofRepBlock's.
Definition: oofrep.h:1182
const oofColor & color() const
Definition: oofrep.h:2570
oofGeo::PositionState YLabelPos() const
Definition: oofSting.cpp:454
unsigned short majorTickSize() const
Definition: oofSting.cpp:554
oofRepGraphBand * mOwner
Definition: oofreprn.h:45
virtual void makeRender(const oofRepXMLEnv &env)
Definition: oofrpXML.cpp:1418
Cross-platform specification of text style.
Definition: oofrep.h:732
unsigned long numOverlaid() const
Definition: oofrep2.cpp:697
unsigned short colSepWidth() const
Definition: oofrep3.cpp:421
oofRepBandList & headers()
Definition: oofrep.h:2134
virtual void VisitDrawable(oofRepDrawable *)
Definition: oofrpXML.cpp:618
OOF_repXMLlayoutVisitor(oofIDfactory &identities)
Definition: oofrpXML.cpp:302
void CloseSection()
Definition: oofrpXML.cpp:1235
oofRepRender * mRender
Definition: oofrep.h:901
virtual unsigned long fixedHeight()
Definition: oofrep2.cpp:768
void writeDatabase()
Definition: oofxmldb.cpp:87
oofColSizer::colAlignT alignment(unsigned short colNum) const
Definition: oofsize.cpp:211
Used by oofRepXMLEnv::StartReport to visit all adornable items to serialise adorner descriptions...
Definition: oofrpXML.cpp:638
virtual void makeRender(const oofRepMacEnv &env)
Definition: oofrepMac.cpp:153
virtual void describeLayout()
straight copy of oofRepTextBlock_XMLRender version but with different text in the middle...
Definition: oofrpXML.cpp:1670
oofRepTextBlock_XMLRender(oofRepTextBlock *b)
Definition: oofrpXML.h:198
static oofString schemaHeader(const char *indentString)
Definition: oofxmldb.cpp:129
dbField * writeableField(unsigned int) const
Definition: oofview.h:214
const char * intTickLabelMask() const
Definition: oofSting.cpp:634
virtual bool preprocessesPageHeadersAndFooters() const
Definition: oofrpXML.cpp:1298
virtual dbView * view(unsigned short whichView=0) const
Request a dbView which may be the source of data for the item.
Definition: oofrep1.cpp:1253
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1711
virtual OOF_mixBandWithSubBands * asBandWithSubBands()
Definition: oofrep1.cpp:1554
Base object to derive adorners from.
Definition: oofadorn.h:32
unsigned short legendOffset() const
Definition: oofSting.cpp:594
Creates XML environment and encapsulates other settings.
Definition: oofrep.h:150
virtual void endTableBody()
Definition: oofrpXML.cpp:1460
No output render, OOF_repXMLlayoutVisitor::VisitLayoutBand describes this band.
Definition: oofrpXML.h:137
Specify output to XML stream.
Definition: oofrpXML.h:57
unsigned short maxYLabelLen() const
Definition: oofSting.cpp:474
virtual oofString saveReportDocFileExt()
Definition: oofrpXML.cpp:730
Write underlying data for graph to stream.
Definition: oofrpXML.h:124
unsigned short pageWidth() const
Definition: oofrep3.cpp:289
virtual OOF_fieldTypes fieldType() const =0
unsigned short leftMargin() const
Definition: oofrep3.cpp:344
oofRepGraphBand_XMLRender(oofRepGraphBand *b)
Definition: oofrpXML.h:126
oofRepTextStyle * defaultTextStyle() const
Definition: oofrep3.cpp:497
virtual void makeRender(const oofRepMacEnv &env)
Definition: oofrepMac.cpp:129
unsigned short pageHeight() const
Definition: oofrep3.cpp:270
static oofString makeSimpleBoundedElement(const char *body, const char *tag, const char *indentString=0, const char *ID=0, const char *otherAttributes=0, bool emptyTag=false)
Definition: oofxml.cpp:139
static oofRep * currentReport()
Definition: oofrep.h:2003
virtual unsigned long saveReportDocMacFileType()
Definition: oofrpXML.cpp:738
Specify a block to draw mono-styled text in an oofRepLayoutBand.
Definition: oofrep.h:1445
void enterLevel()
Definition: oofxml.h:102
static void makeStyleStrings(oofString &theStyleRun, unsigned char textStyle)
Definition: oofrpXML.cpp:960
virtual oofString text() const
Definition: oofrep2.cpp:915
Specify a fixed height band to draw an oofPict.
Definition: oofrep.h:1649
virtual void VisitIterableBandBody(oofRepBand *)
Isolates these bands so more complex visitors can optimise their querying.
Definition: oofrpXML.cpp:145
PositionState
Definition: oofGeos.h:45
Specify a fixed height band to draw a horizontal line black or grey in given thickness.
Definition: oofrep.h:1143
oofRepViewBand * mOwner
Definition: oofreprn.h:147
bool printGraphsInMono() const
Definition: oofrep3.cpp:535
unsigned long count() const
Definition: oofrep.h:2464
void endSchema()
Definition: oofxmldb.cpp:169
Specify a block to draw an oofPict in an oofRepLayoutBand.
Definition: oofrep.h:1516
virtual oofRepRenderT renderType() const
Definition: oofrpXML.cpp:1131
virtual void describeLayout()
Definition: oofrpXML.cpp:1525
bool hasValuesOverColumns() const
Definition: oofSting.cpp:260
oofString ID() const
Definition: oofrep.h:1848
virtual void visit(oofRep *)
Top-level that iterates all the others, encapsulating report structure.
Definition: oofrep2.cpp:1490
bool has3DEffect() const
Definition: oofSting.cpp:222
static oofString quoteString(const oofString &, char quoteChar='\'')
Definition: oofstr.cpp:1734
virtual unsigned long fixedHeight()
Definition: oofrep.h:2169
virtual unsigned long calcPageWidth()
Definition: oofrpXML.cpp:1166
dbTable * table() const
Definition: oofview.h:109
Calculation attached to an oofRepBand.
Definition: oofrep.h:1604
virtual bool isMultiReport() const
Definition: oofrep1.cpp:438
oofRepTextStyle * localTextStyle() const
Get style owned by this object.
Definition: oofrep.h:2654
oofRepLineBand_XMLRender(oofRepLineBand *b)
Definition: oofrpXML.h:150
virtual void VisitBandHeaderBreaks(oofRepBreakList &)
Definition: oofrpXML.cpp:401
unsigned long fixedWidth(unsigned short colNum) const
Definition: oofsize.cpp:203
Base class for persistent fields in dbTable's.
Definition: oof3.h:63
unsigned short blockVertSep() const
Definition: oofrep3.cpp:476
virtual void VisitBandFooters(oofRepBandList &)
Definition: oofrpXML.cpp:386
bool hasValuesNextToBars() const
Definition: oofSting.cpp:279
bool hasXLabel() const
Definition: oofSting.cpp:374
Specify a band which provides a vertical gap on the page.
Definition: oofrep.h:1050
static oofString emitCSSstyle(const oofGraphSettings *)
Definition: oofrpXML.cpp:751
static oofString makeSpaceTag(unsigned long height, const char *indentString=0, const char *idString=0)
Definition: oofrpXML.cpp:1320
Abstract base for report bands.
Definition: oofrep.h:1026
void startSchema()
creates a string containing the schema for a view, excluding the end tag, in case we nest other data...
Definition: oofxmldb.cpp:185
virtual void makeRenderDispatch(oofRepDrawable *) const
Definition: oofrpXML.cpp:1103
unsigned short YAxisHeight() const
Definition: oofSting.cpp:574
List of Breaks attached to a report band.
Definition: oofrep.h:368
virtual void startSection()
Definition: oofrpXML.cpp:1218
oofString getIDstring()
Definition: oofxml.cpp:59
Provides searchable dictionary of common OOFILE classes like dbTable.
Definition: oof1.h:159
bool hasXTickLabels() const
Definition: oofSting.cpp:336
virtual oofRepRender * clone(const oofRepDrawable *newOwner) const
Definition: oofrpXML.cpp:1481
static oofString encodeName(const oofString &)
Definition: oofxml.cpp:149
static oofString emitCSSstyle(const oofRepSettings *, const oofString &defaultTextID)
Definition: oofrpXML.cpp:1018
Abstract interface for database.
Definition: oof1.h:920
static oofColSizer::colAlignT naturalAlignmentForField(OOF_fieldTypes)
Definition: oofsize.cpp:249
oofString getHeading(unsigned int, bool *tellIfOverride=0) const
Definition: oofview.cpp:278