rvc/textobj.h

Go to the documentation of this file.

#ifndef INC_RVC_TEXTOBJ_H
#define INC_RVC_TEXTOBJ_H

#ifndef INC_RVC_OBJECT_H
   #include <rvc/object.h>
#endif

#ifndef INC_RVC_GETOBJFILTER_H
   #include <rvc/getobjfilter.h>
#endif


namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
struct TEXTINFO;
class TEXTHANDLE;
#endif

class TEXTOBJ : public RVC::OBJECT {
   public:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class GETOBJFILTER_HASTITLE;
      class GETOBJFILTER_ISSELECTABLE;
      friend class GETOBJFILTER_ISSELECTABLE;
      class MAKEPARMS;
      friend class MAKEPARMS;
      #endif
      
      TEXTOBJ (
         );

      TEXTOBJ (
         const RVC::TEXTOBJ& obj
         );

      virtual ~TEXTOBJ (
         );

      RVC::TEXTOBJ& operator= (
         const RVC::TEXTOBJ& rhs
         );

      INT32 Append (
         const MIUNICODE *line
         );

      INT32 Append (
         const MISTRING& string
         );

      static RVC::OBJTYPESET GetObjTypeSet (
         );
         
      static bool IsText (
         RVC::OBJTYPE ObjType
         );

      ERRVALUE Link (
         const RVC::OBJECT& parent,                         
         const RVC::DESCRIPTOR& Descriptor,                 
         const FILEPATH& LinkFile,                          
#ifdef RVC_CREDENTIALS_MANDATORY
         CHAR_ENCODING encoding,    
         const CREDENTIALS* Credentials 
#else
         CHAR_ENCODING encoding = CHAR_ENCODING_ISO_2022,   
         const CREDENTIALS* Credentials = 0                 
#endif
         );

      ERRVALUE Make (
         const RVC::OBJECT& parent,          
         const RVC::DESCRIPTOR& Descriptor,  
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS   
         );

      ERRVALUE Make (
         const RVC::OBJECT& parent,          
         const MAKEPARMS& MakeParms,
         const RVC::DESCRIPTOR& Descriptor,  
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS   
         );

      ERRVALUE Make (
         RVC::OBJITEM& ObjItem,              
#ifdef RVC_CREDENTIALS_MANDATORY
         const char* Source,              
         const CREDENTIALS* Credentials 
#else
         const char* Source = 0,             
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE Make (
         RVC::OBJITEM& ObjItem,              
         const MAKEPARMS& MakeParms,
#ifdef RVC_CREDENTIALS_MANDATORY
         const char* Source,              
         const CREDENTIALS* Credentials 
#else
         const char* Source = 0,             
         const CREDENTIALS* Credentials = 0  
#endif
         );

      ERRVALUE Read (
         MISTRING& string                 
         );

      ERRVALUE ReadLine (
         MISTRING& string                 
         );

      ERRVALUE Reset (
         );

      ERRVALUE Write (
         const MISTRING& string
         );

   protected:

      void GetMetadataFormat (UINT8& format) const;
      void GetExtraValue (UINT32 offset, UINT16& value) const;
      void GetExtraValue (UINT32 offset, UINT32& value) const;
      ERRVALUE Link (const RVC::OBJECT& parent, OBJMAKEPARMS& ObjMakeParms, const FILEPATH& LinkFile, CHAR_ENCODING encoding = CHAR_ENCODING_ISO_2022);
      ERRVALUE Make (const OBJECT& parent, OBJMAKEPARMS& ObjMakeParms);
      ERRVALUE OpenObject (OPENMODE OpenFlags, TEXTINFO& newinfo, int HeaderSize, int HeaderType, MDLGPARENT parent, const CREDENTIALS* Credentials);
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      
      class EXTRADATA {
         public:
            EXTRADATA () {}
            EXTRADATA (const EXTRADATA& rhs);
            EXTRADATA& operator=(const EXTRADATA& rhs);
            
            void Clear();
            
            void GetExtraValue (UINT32 offset, UINT8& value) const;
            void GetExtraValue (UINT32 offset, UINT16& value) const;
            void GetExtraValue (UINT32 offset, UINT32& value) const;
            
            bool IsEmpty () const { return (m_ExtraData.IsEmpty()); }
         
            void SetExtraValue (UINT32 offset, UINT8 value);
            void SetExtraValue (UINT32 offset, UINT16 value);
            void SetExtraValue (UINT32 offset, UINT32 value);
            
         private:
            SIMPLE_ARRAY<UINT8> m_ExtraData;
         };

      virtual ERRVALUE v_CloseObject ();
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsMultiObject () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenMode, MDLGPARENT parent, const CREDENTIALS* Credentials);
      virtual bool v_ValidateObjectType (const OBJTYPE otype) const;

      void SetupExtraHeaderData (const CREDENTIALS* Credentials) const;
      
      TEXTHANDLE* m_TextHandle;
      mutable EXTRADATA m_ExtraHeaderData;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class TEXTOBJ::GETOBJFILTER_ISSELECTABLE  : public GETOBJFILTER, private RVC::OBJECT::FILTER {
   public:
      GETOBJFILTER_ISSELECTABLE() {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool Filter (const RVC::OBJECT& Object);
      virtual bool v_HasSelectableSubObjects (const RVC::OBJITEM& objitem);
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class TEXTOBJ::GETOBJFILTER_HASTITLE : public TEXTOBJ::GETOBJFILTER_ISSELECTABLE {
   public:
      explicit GETOBJFILTER_HASTITLE (
         const MISTRING& Title
         );
         
      explicit GETOBJFILTER_HASTITLE (
         const char* Title,
         CHAR_ENCODING encoding = CHAR_ENCODING_ASCII
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MISTRING m_Title;
      
      virtual bool v_IsSelectable (const RVC::OBJITEM& objitem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class TEXTOBJ::MAKEPARMS {
   public:
      MAKEPARMS (
         RVC::OBJTYPE ObjType = RVC::OBJTYPE_Text
         );
   
      MAKEPARMS (
         const MAKEPARMS& rhs
         );
   
      MAKEPARMS (
         TEXTOBJ& TemplateObj
         );
   
      MAKEPARMS& operator= (
         const MAKEPARMS& rhs
         );
         
      RVC::OBJTYPE GetObjType (
         ) const { return (m_ObjType); }
         
      void SetObjType (
         RVC::OBJTYPE ObjType
         ) { m_ObjType = ObjType; }
         
   protected:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      void GetExtraValue (UINT32 offset, UINT8& value) const;
      void GetExtraValue (UINT32 offset, UINT16& value) const;
      void GetExtraValue (UINT32 offset, UINT32& value) const;
      void SetExtraValue (UINT32 offset, UINT8 value);
      void SetExtraValue (UINT32 offset, UINT16 value);
      void SetExtraValue (UINT32 offset, UINT32 value);
      #endif // GENERATING_DOXYGEN_OUTPUT
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      friend class TEXTOBJ;
      
      OBJTYPE m_ObjType;
      TEXTOBJ::EXTRADATA m_ExtraHeaderData;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     // End of RVC namespace

#endif   // INC_RVC_TEXT_H

---