00001 #ifndef gHTML_HATYPES_X_H
00002 #define gHTML_HATYPES_X_H
00003
00004 #include "glistext.h"
00005
00006 #define e_HAT_Single 0
00007
00008 #define HATYPE_S32_INVALID_VAL MAX_DLINT32
00009 #define HATYPE_U32_INVALID_VAL MAX_DUINT32
00010
00011 enum eHAttrType {
00012 e_HAT_None,
00013 e_HAT_CDATA,
00014 e_HAT_ID,
00015 e_HAT_IDREF,
00016 e_HAT_IDREFS,
00017 e_HAT_NAME,
00018 e_HAT_NUMBER,
00019 e_HATp_CAlign,
00020 e_HATp_Character,
00021 e_HATp_Charset,
00022 e_HATp_Charsets,
00023 e_HATp_Color,
00024 e_HATp_ContentType,
00025 e_HATp_ContentTypes,
00026 e_HATp_Coords,
00027 e_HATp_DateTime,
00028 e_HATp_FrameTarget,
00029 e_HATp_HtmlVersion,
00030 e_HATp_IAlign,
00031 e_HATp_InputType,
00032 e_HATp_LAlign,
00033 e_HATp_LanguageCode,
00034 e_HATp_Length,
00035 e_HATp_LinkTypes,
00036 e_HATp_LIStyle,
00037 e_HATp_MediaDesc,
00038 e_HATp_MultiLength,
00039 e_HATp_MultiLengths,
00040 e_HATp_OLStyle,
00041 e_HATp_Pixels,
00042 e_HATp_Scope,
00043 e_HATp_Script,
00044 e_HATp_Shape,
00045 e_HATp_StyleSheet,
00046 e_HATp_TAlign,
00047 e_HATp_Text,
00048 e_HATp_TFrame,
00049 e_HATp_TRules,
00050 e_HATp_ULStyle,
00051 e_HATp_URI,
00052 e_HATp_EnumChoice = 254
00053 };
00054
00055 struct sHAttrType {
00056 t_int16 typeFamily;
00057 char* strType;
00058 eHAttrType hAttrType;
00059 short hAttrSingle;
00060 };
00061
00062 class gHAType : public gList {
00063 public:
00064 virtual ~gHAType () ;
00065
00066
00067 virtual bool IsOk () ;
00068
00069 virtual t_int16 GetTypeId () ;
00070 virtual eHAttrType GetType () ;
00071
00072 virtual char* GetStr () {
00073 return GetAttrStr();
00074 }
00075
00076 virtual char* GetAttrStr () {
00077 return sUnquoted.Str();
00078 }
00079
00080 virtual t_int32 GetInt32 () {
00081 return 0;
00082 }
00083
00084 virtual bool IsValue () {
00085 return false;
00086 }
00087
00088 virtual bool IsValueAbsolute () {
00089 return false;
00090 }
00091
00092
00093 virtual void Reset () ;
00094
00095 int Unquote (gString& sIn, gString& sResult) ;
00096
00097 protected:
00098 gHAType (t_int16 aTypeId, char* strValue) ;
00099 t_int16 typeId;
00100 gString sAuxOut;
00101 gString sOrig;
00102 gString sUnquoted;
00103
00104 char* thisUnquotedStr (char* str) ;
00105
00106 private:
00107
00108 gHAType (gHAType& ) ;
00109 gHAType& operator= (gHAType& ) ;
00110 };
00111
00112 class gHATypeGString : public gHAType {
00113 public:
00114 virtual ~gHATypeGString () ;
00115
00116 protected:
00117 gHATypeGString (t_int16 aTypeId, char* strValue) ;
00118
00119 private:
00120
00121 gHATypeGString (gHATypeGString& ) ;
00122 gHATypeGString& operator= (gHATypeGString& ) ;
00123 };
00124
00125 class gHATypeStringSingle : public gHATypeGString {
00126 public:
00127 virtual ~gHATypeStringSingle () ;
00128
00129
00130 virtual bool IsOk () ;
00131
00132 protected:
00133 gHATypeStringSingle (t_int16 aTypeId, char* strValue) ;
00134
00135 private:
00136
00137 gHATypeStringSingle (gHATypeStringSingle& ) ;
00138 gHATypeStringSingle& operator= (gHATypeStringSingle& ) ;
00139 };
00140
00141 class gHATypeURI : public gHATypeStringSingle {
00142 public:
00143 gHATypeURI (char* strValue) ;
00144 virtual ~gHATypeURI () ;
00145
00146 private:
00147
00148 gHATypeURI (gHATypeURI& ) ;
00149 gHATypeURI& operator= (gHATypeURI& ) ;
00150 };
00151
00152 class gHATypeSimple : public gHAType {
00153 public:
00154 virtual ~gHATypeSimple () ;
00155
00156
00157 t_int16 v;
00158
00159
00160 virtual bool IsOk () ;
00161
00162 virtual t_int32 GetInt32 () ;
00163
00164 virtual bool IsValue () {
00165 return true;
00166 }
00167
00168 protected:
00169 gHATypeSimple (t_int16 aTypeId, char* strValue, t_int16 val) ;
00170
00171 private:
00172
00173 gHATypeSimple (gHATypeSimple& ) ;
00174 gHATypeSimple& operator= (gHATypeSimple& ) ;
00175 };
00176
00177 class gHATypeSimple32 : public gHAType {
00178 public:
00179 virtual ~gHATypeSimple32 () ;
00180
00181
00182 t_int32 vS32;
00183
00184
00185 virtual bool IsOk () ;
00186
00187 virtual t_int32 GetInt32 () ;
00188
00189 virtual bool IsValue () {
00190 return true;
00191 }
00192
00193 protected:
00194 gHATypeSimple32 (t_int16 aTypeId, char* strValue, t_int32 val) ;
00195
00196 private:
00197
00198 gHATypeSimple32 (gHATypeSimple32& ) ;
00199 gHATypeSimple32& operator= (gHATypeSimple32& ) ;
00200 };
00201
00202 class gHATypeSimpleU32 : public gHAType {
00203 public:
00204 virtual ~gHATypeSimpleU32 () ;
00205
00206
00207 t_uint32 vU32;
00208
00209
00210 virtual bool IsOk () ;
00211
00212 virtual t_int32 GetInt32 () ;
00213
00214 virtual bool IsValue () {
00215 return true;
00216 }
00217
00218 int ConvertHexStrToUInt32 (char* strValue, t_uint32& val) ;
00219
00220 protected:
00221 gHATypeSimpleU32 (t_int16 aTypeId, char* strValue, t_uint32 val, bool isHex) ;
00222
00223 private:
00224
00225 gHATypeSimpleU32 (gHATypeSimpleU32& ) ;
00226 gHATypeSimpleU32& operator= (gHATypeSimpleU32& ) ;
00227 };
00228
00229 class gHATypeColor: public gHATypeSimpleU32 {
00230 public:
00231 gHATypeColor (char* strValue) ;
00232 virtual ~gHATypeColor () ;
00233
00234 private:
00235
00236 gHATypeColor (gHATypeColor& ) ;
00237 gHATypeColor& operator= (gHATypeColor& ) ;
00238 };
00239
00240 class gHATypeLength : public gHATypeSimple32 {
00241 public:
00242 gHATypeLength (char* strValue) ;
00243 virtual ~gHATypeLength () ;
00244
00245
00246 int percent;
00247
00248 virtual bool IsValueAbsolute () {
00249 return percent==-1;
00250 }
00251
00252 private:
00253
00254 gHATypeLength (gHATypeLength& ) ;
00255 gHATypeLength& operator= (gHATypeLength& ) ;
00256 };
00257
00258 class gHATypeGenLst : public gHAType {
00259 public:
00260 virtual ~gHATypeGenLst () ;
00261
00262
00263 short hAttrSingle;
00264
00265 protected:
00266 gHATypeGenLst (t_int16 aTypeId, char* strValue, short codeAttrSingle) ;
00267
00268 private:
00269
00270 gHATypeGenLst (gHATypeGenLst& ) ;
00271 gHATypeGenLst& operator= (gHATypeGenLst& ) ;
00272 };
00273
00274 class gHATypeLstStr : public gHATypeGenLst {
00275 public:
00276 virtual ~gHATypeLstStr () ;
00277
00278 protected:
00279 gHATypeLstStr (t_int16 aTypeId, char* strValue, short codeAttrSingle) ;
00280
00281 private:
00282
00283 gHATypeLstStr (gHATypeLstStr& ) ;
00284 gHATypeLstStr& operator= (gHATypeLstStr& ) ;
00285 };
00286
00287 class gHATypeLstVal : public gHATypeGenLst {
00288 public:
00289 virtual ~gHATypeLstVal () ;
00290
00291 virtual bool IsValue () {
00292 return hAttrSingle==e_HAT_Single;
00293 }
00294
00295 protected:
00296 gHATypeLstVal (t_int16 aTypeId, char* strValue, short codeAttrSingle) ;
00297
00298 private:
00299
00300 gHATypeLstVal (gHATypeLstVal& ) ;
00301 gHATypeLstVal& operator= (gHATypeLstVal& ) ;
00302 };
00303
00304 class gHATypeCharsets : public gHATypeLstStr {
00305 public:
00306 gHATypeCharsets (char* strValue, short codeAttrSingle) ;
00307 virtual ~gHATypeCharsets () ;
00308
00309 private:
00310
00311 gHATypeCharsets (gHATypeCharsets& ) ;
00312 gHATypeCharsets& operator= (gHATypeCharsets& ) ;
00313 };
00314
00315 class gHATypeContentTypes : public gHATypeLstStr {
00316 public:
00317 gHATypeContentTypes (char* strValue, short codeAttrSingle) ;
00318 virtual ~gHATypeContentTypes () ;
00319
00320 private:
00321
00322 gHATypeContentTypes (gHATypeContentTypes& ) ;
00323 gHATypeContentTypes& operator= (gHATypeContentTypes& ) ;
00324 };
00325
00326 class gHATypeStyleSheet : public gHATypeLstStr {
00327 public:
00328 gHATypeStyleSheet (char* strValue) ;
00329 virtual ~gHATypeStyleSheet () ;
00330
00331 private:
00332
00333 gHATypeStyleSheet (gHATypeStyleSheet& ) ;
00334 gHATypeStyleSheet& operator= (gHATypeStyleSheet& ) ;
00335 };
00336
00337 class gHATypeMultiLengths : public gHATypeLstVal {
00338 public:
00339 gHATypeMultiLengths (char* strValue, short codeAttrSingle) ;
00340 virtual ~gHATypeMultiLengths () ;
00341
00342 private:
00343
00344 gHATypeMultiLengths (gHATypeMultiLengths& ) ;
00345 gHATypeMultiLengths& operator= (gHATypeMultiLengths& ) ;
00346 };
00347
00348 class gHATypeCDATA : public gHAType {
00349 public:
00350 gHATypeCDATA (char* strValue) ;
00351 virtual ~gHATypeCDATA () ;
00352
00353 private:
00354
00355 gHATypeCDATA (gHATypeCDATA& ) ;
00356 gHATypeCDATA& operator= (gHATypeCDATA& ) ;
00357 };
00358
00359 class gHATypeID : public gHAType {
00360 public:
00361 gHATypeID (char* strValue) ;
00362 virtual ~gHATypeID () ;
00363
00364 private:
00365
00366 gHATypeID (gHATypeID& ) ;
00367 gHATypeID& operator= (gHATypeID& ) ;
00368 };
00369
00370 class gHATypeIDREF : public gHAType {
00371 public:
00372 gHATypeIDREF (char* strValue) ;
00373 virtual ~gHATypeIDREF () ;
00374
00375 private:
00376
00377 gHATypeIDREF (gHATypeIDREF& ) ;
00378 gHATypeIDREF& operator= (gHATypeIDREF& ) ;
00379 };
00380
00381 class gHATypeIDREFS : public gHAType {
00382 public:
00383 gHATypeIDREFS (char* strValue) ;
00384 virtual ~gHATypeIDREFS () ;
00385
00386 private:
00387
00388 gHATypeIDREFS (gHATypeIDREFS& ) ;
00389 gHATypeIDREFS& operator= (gHATypeIDREFS& ) ;
00390 };
00391
00392 class gHATypeNAME : public gHAType {
00393 public:
00394 gHATypeNAME (char* strValue) ;
00395 virtual ~gHATypeNAME () ;
00396
00397 private:
00398
00399 gHATypeNAME (gHATypeNAME& ) ;
00400 gHATypeNAME& operator= (gHATypeNAME& ) ;
00401 };
00402
00403 class gHATypeNUMBER : public gHATypeSimple32 {
00404 public:
00405 gHATypeNUMBER (char* strValue) ;
00406 virtual ~gHATypeNUMBER () ;
00407
00408 private:
00409
00410 gHATypeNUMBER (gHATypeNUMBER& ) ;
00411 gHATypeNUMBER& operator= (gHATypeNUMBER& ) ;
00412 };
00413
00414 class gHATypePixels : public gHATypeSimple32 {
00415 public:
00416 gHATypePixels (char* strValue) ;
00417 virtual ~gHATypePixels () ;
00418
00419 private:
00420
00421 gHATypePixels (gHATypePixels& ) ;
00422 gHATypePixels& operator= (gHATypePixels& ) ;
00423 };
00424
00425 class gHATypeText : public gHATypeGString {
00426 public:
00427 gHATypeText (char* strValue) ;
00428 virtual ~gHATypeText () ;
00429
00430 private:
00431
00432 gHATypeText (gHATypeText& ) ;
00433 gHATypeText& operator= (gHATypeText& ) ;
00434 };
00435
00436 class gHATypeFrameTarget : public gHATypeStringSingle {
00437 public:
00438 gHATypeFrameTarget (char* strValue) ;
00439 virtual ~gHATypeFrameTarget () ;
00440
00441 bool isBlank;
00442
00443 private:
00444
00445 gHATypeFrameTarget (gHATypeFrameTarget& ) ;
00446 gHATypeFrameTarget& operator= (gHATypeFrameTarget& ) ;
00447 };
00448
00449 class gHATypeEnum : public gHATypeSimple {
00450 public:
00451 gHATypeEnum (t_int16 aTypeId, char* strValue, t_int16 val=-1) ;
00452 gHATypeEnum (t_int16 aTypeId, char* strValue, gSmartList& lEnumStr) ;
00453 virtual ~gHATypeEnum () ;
00454
00455 private:
00456
00457 gHATypeEnum (gHATypeEnum& ) ;
00458 gHATypeEnum& operator= (gHATypeEnum& ) ;
00459 };
00460
00461 #endif //gHTML_HATYPES_X_H
00462