LCOV - code coverage report
Current view: directory - home/even/poppler-git/install/include/poppler - OptionalContent.h (source / functions) Found Hit Coverage
Test: gdal_filtered.info Lines: 5 5 100.0 %
Date: 2013-03-30 Functions: 4 4 100.0 %

       1                 : //========================================================================
       2                 : //
       3                 : // OptionalContent.h
       4                 : //
       5                 : // Copyright 2007 Brad Hards <bradh@kde.org>
       6                 : // Copyright 2008 Carlos Garcia Campos <carlosgc@gnome.org>
       7                 : //
       8                 : // Released under the GPL (version 2, or later, at your option)
       9                 : //
      10                 : //========================================================================
      11                 : 
      12                 : #ifndef OPTIONALCONTENT_H
      13                 : #define OPTIONALCONTENT_H
      14                 : 
      15                 : #ifdef USE_GCC_PRAGMAS
      16                 : #pragma interface
      17                 : #endif
      18                 : 
      19                 : #include "Object.h"
      20                 : #include "CharTypes.h"
      21                 : 
      22                 : class GooString;
      23                 : class GooList;
      24                 : class XRef;
      25                 : 
      26                 : class OptionalContentGroup;
      27                 : class OCDisplayNode;
      28                 : 
      29                 : //------------------------------------------------------------------------
      30                 : 
      31                 : class OCGs {
      32                 : public:
      33                 : 
      34                 :   OCGs(Object *ocgObject, XRef *xref);
      35                 :   ~OCGs();
      36                 : 
      37                 :   // Is OCGS valid?
      38              46 :   GBool isOk() { return ok; }
      39                 :   
      40                 :   bool hasOCGs();
      41               2 :   GooList *getOCGs() const { return optionalContentGroups; }
      42                 : 
      43                 :   OptionalContentGroup* findOcgByRef( const Ref &ref);
      44                 : 
      45                 :   // Get the root node of the optional content group display tree
      46                 :   // (which does not necessarily include all of the OCGs).
      47                 :   OCDisplayNode *getDisplayRoot();
      48                 : 
      49              23 :   Array* getOrderArray() 
      50              23 :     { return (order.isArray() && order.arrayGetLength() > 0) ? order.getArray() : NULL; }
      51                 :   Array* getRBGroupsArray() 
      52                 :     { return (rbgroups.isArray() && rbgroups.arrayGetLength()) ? rbgroups.getArray() : NULL; }
      53                 : 
      54                 :   bool optContentIsVisible( Object *dictRef );
      55                 : 
      56                 : private:
      57                 :   GBool ok;
      58                 : 
      59                 :   GBool evalOCVisibilityExpr(Object *expr, int recursion);
      60                 :   bool allOn( Array *ocgArray );
      61                 :   bool allOff( Array *ocgArray );
      62                 :   bool anyOn( Array *ocgArray );
      63                 :   bool anyOff( Array *ocgArray );
      64                 : 
      65                 :   GooList *optionalContentGroups;
      66                 : 
      67                 :   Object order;
      68                 :   Object rbgroups;
      69                 :   XRef *m_xref;
      70                 :   OCDisplayNode *display; // root node of display tree
      71                 : };
      72                 : 
      73                 : //------------------------------------------------------------------------
      74                 : 
      75                 : class OptionalContentGroup {
      76                 : public:
      77                 :   enum State { On, Off };
      78                 : 
      79                 :   // Values from the optional content usage dictionary.
      80                 :   enum UsageState {
      81                 :     ocUsageOn,
      82                 :     ocUsageOff,
      83                 :     ocUsageUnset
      84                 :   };
      85                 : 
      86                 :   OptionalContentGroup(Dict *dict);
      87                 : 
      88                 :   OptionalContentGroup(GooString *label);
      89                 : 
      90                 :   ~OptionalContentGroup();
      91                 : 
      92                 :   GooString* getName() const;
      93                 : 
      94                 :   Ref getRef() const;
      95                 :   void setRef(const Ref ref);
      96                 : 
      97                 :   State getState() { return m_state; };
      98              17 :   void setState(State state) { m_state = state; };
      99                 : 
     100                 :   UsageState getViewState() { return viewState; }
     101                 :   UsageState getPrintState() { return printState; }
     102                 : 
     103                 : private:
     104                 :   XRef *xref;
     105                 :   GooString *m_name;
     106                 :   Ref m_ref;
     107                 :   State m_state;
     108                 :   UsageState viewState;  // suggested state when viewing
     109                 :   UsageState printState; // suggested state when printing
     110                 : };
     111                 : 
     112                 : //------------------------------------------------------------------------
     113                 : 
     114                 : class OCDisplayNode {
     115                 : public:
     116                 : 
     117                 :   static OCDisplayNode *parse(Object *obj, OCGs *oc, XRef *xref, int recursion = 0);
     118                 :   OCDisplayNode();
     119                 :   ~OCDisplayNode();
     120                 : 
     121                 :   GooString *getName() { return name; }
     122                 :   OptionalContentGroup *getOCG() { return ocg; }
     123                 :   int getNumChildren();
     124                 :   OCDisplayNode *getChild(int idx);
     125                 : 
     126                 : private:
     127                 : 
     128                 :   OCDisplayNode(GooString *nameA);
     129                 :   OCDisplayNode(OptionalContentGroup *ocgA);
     130                 :   void addChild(OCDisplayNode *child);
     131                 :   void addChildren(GooList *childrenA);
     132                 :   GooList *takeChildren();
     133                 : 
     134                 :   GooString *name;    // display name (may be NULL)
     135                 :   OptionalContentGroup *ocg;  // NULL for display labels
     136                 :   GooList *children;    // NULL if there are no children
     137                 :         //   [OCDisplayNode]
     138                 : };
     139                 : 
     140                 : #endif

Generated by: LCOV version 1.7