00001 #include "gHtmlHATypes.h"
00002 #include "gHtmlCtrl.h"
00003 #include "gstringext.h"
00004
00005 gHAType::gHAType (t_int16 aTypeId, char* strValue)
00006 : typeId( aTypeId ),
00007 sOrig( strValue ),
00008 sUnquoted( thisUnquotedStr( strValue ) )
00009 {
00010
00011 }
00012
00013 gHAType::~gHAType ()
00014 {
00015 }
00016
00017 bool gHAType::IsOk ()
00018 {
00019 return typeId>e_HAT_None && typeId<=e_HATp_EnumChoice;
00020 }
00021
00022 t_int16 gHAType::GetTypeId ()
00023 {
00024 return typeId;
00025 }
00026
00027 eHAttrType gHAType::GetType ()
00028 {
00029 ASSERTION(typeId<=e_HATp_EnumChoice,"GetType(1)");
00030 ASSERTION(typeId>e_HAT_None,"GetType(2)");
00031 return (eHAttrType)typeId;
00032 }
00033
00034 void gHAType::Reset ()
00035 {
00036 gList::Reset();
00037 }
00038
00039 int gHAType::Unquote (gString& sIn, gString& sResult)
00040 {
00041
00042 unsigned len = sIn.Length();
00043
00044 if ( len<2 ) return 0;
00045 if ( sIn[1]=='"' || sIn[1]=='\'' ) {
00046 if ( sIn[len]=='"' || sIn[len]=='\'') {
00047 if ( sIn[1]!=sIn[len] ) return -1;
00048 sResult.CopyFromTo( sIn, 2, len-1 );
00049 }
00050 }
00051 else {
00052 sResult = sIn;
00053 }
00054 return 0;
00055 }
00056
00057 char* gHAType::thisUnquotedStr (char* str)
00058 {
00059 gString s( str );
00060 Unquote( s, sAuxOut );
00061 return sAuxOut.Str();
00062 }
00063
00064 gHATypeGString::gHATypeGString (t_int16 aTypeId, char* strValue)
00065 : gHAType( aTypeId, strValue )
00066 {
00067 }
00068
00069 gHATypeGString::~gHATypeGString ()
00070 {
00071 }
00072
00073 gHATypeStringSingle::gHATypeStringSingle (t_int16 aTypeId, char* strValue)
00074 : gHATypeGString( aTypeId, strValue )
00075 {
00076 }
00077
00078 gHATypeStringSingle::~gHATypeStringSingle ()
00079 {
00080 }
00081
00082 bool gHATypeStringSingle::IsOk ()
00083 {
00084 if ( sUnquoted.Find( ' ' ) ) return false;
00085 return gHATypeGString::IsOk();
00086 }
00087
00088 gHATypeURI::gHATypeURI (char* strValue)
00089 : gHATypeStringSingle( e_HATp_URI, strValue )
00090 {
00091 }
00092
00093 gHATypeURI::~gHATypeURI ()
00094 {
00095 }
00096
00097 gHATypeSimple::gHATypeSimple (t_int16 aTypeId, char* strValue, t_int16 val)
00098 : gHAType( aTypeId, strValue ),
00099 v( val )
00100 {
00101 }
00102
00103 gHATypeSimple::~gHATypeSimple ()
00104 {
00105 }
00106
00107 bool gHATypeSimple::IsOk ()
00108 {
00109 return gHAType::IsOk() && v>=1;
00110 }
00111
00112 t_int32 gHATypeSimple::GetInt32 ()
00113 {
00114 DBGPRINT_WEBA2("{DBG: GetInt32as16bit()=%u}",v);
00115 return (t_int32)v;
00116 }
00117
00118 gHATypeSimple32::gHATypeSimple32 (t_int16 aTypeId, char* strValue, t_int32 val)
00119 : gHAType( aTypeId, strValue ),
00120 vS32( val )
00121 {
00122 if ( vS32==HATYPE_S32_INVALID_VAL ) {
00123 gStrControl::Self().ConvertToInt32( sUnquoted.Str(), vS32 );
00124 }
00125 }
00126
00127 gHATypeSimple32::~gHATypeSimple32 ()
00128 {
00129 }
00130
00131 bool gHATypeSimple32::IsOk ()
00132 {
00133 return vS32!=HATYPE_S32_INVALID_VAL;
00134 }
00135
00136 t_int32 gHATypeSimple32::GetInt32 ()
00137 {
00138 DBGPRINT_WEBA2("{DBG: GetInt32()=%ldLD}",(long)vS32);
00139 return vS32;
00140 }
00141
00142 gHATypeSimpleU32::gHATypeSimpleU32 (t_int16 aTypeId, char* strValue, t_uint32 val, bool isHex)
00143 : gHAType( aTypeId, strValue ),
00144 vU32( val )
00145 {
00146 char* str = sUnquoted.Str();
00147 if ( isHex ) {
00148 if ( ConvertHexStrToUInt32( str, vU32 )!=0 )
00149 vU32 = HATYPE_U32_INVALID_VAL;
00150 }
00151 else {
00152 if ( gStrControl::Self().ConvertToUInt32( str, vU32 )!=0 )
00153 vU32 = HATYPE_U32_INVALID_VAL;
00154 }
00155 }
00156
00157 gHATypeSimpleU32::~gHATypeSimpleU32 ()
00158 {
00159 }
00160
00161 bool gHATypeSimpleU32::IsOk ()
00162 {
00163 return vU32!=HATYPE_U32_INVALID_VAL;
00164 }
00165
00166 t_int32 gHATypeSimpleU32::GetInt32 ()
00167 {
00168 DBGPRINT_WEBA2("{DBG: GetInt32()=%luLU}",(unsigned long)vU32);
00169 if ( vU32>=(t_uint32)MAX_DUINT32 ) return -1;
00170 return (t_int32)vU32;
00171 }
00172
00173 int gHATypeSimpleU32::ConvertHexStrToUInt32 (char* strValue, t_uint32& val)
00174 {
00175
00176 if ( strValue==nil || strValue[0]==0 ) return -1;
00177 return gStrControl::Self().ConvertHexToUInt32( strValue, e_DigConvAny, val );
00178 }
00179
00180 gHATypeColor::gHATypeColor (char* strValue)
00181 : gHATypeSimpleU32( e_HATp_Color, strValue, 0, true )
00182 {
00183 DBGPRINT_MIN("DBG0::: color### [%s]:%ld\n",strValue,(long)vU32);
00184 if ( vU32==HATYPE_U32_INVALID_VAL ) {
00185 gStrControl::Self().ConvertHexToUInt32( sUnquoted.Str()+1, e_DigConvAny, vU32 );
00186 }
00187 DBGPRINT_MIN("DBG1::: color### [%s]:%ld\n",strValue,(long)vU32);
00188 }
00189
00190 gHATypeColor::~gHATypeColor ()
00191 {
00192 }
00193
00194 gHATypeLength::gHATypeLength (char* strValue)
00195 : gHATypeSimple32( e_HATp_Length, strValue, HATYPE_S32_INVALID_VAL ),
00196 percent( -1 )
00197 {
00198 unsigned len;
00199 if ( vS32==HATYPE_S32_INVALID_VAL ) {
00200 sAuxOut = sUnquoted;
00201 len = sAuxOut.Length();
00202 sAuxOut.Trim();
00203 if ( sAuxOut[len]=='%' ) {
00204 sAuxOut[len] = '\0';
00205 if ( gStrControl::Self().ConvertToInt32( sAuxOut.Str(), vS32 )==0 )
00206 percent = (int)vS32;
00207 }
00208 }
00209 }
00210
00211 gHATypeLength::~gHATypeLength ()
00212 {
00213 }
00214
00215 gHATypeGenLst::gHATypeGenLst (t_int16 aTypeId, char* strValue, short codeAttrSingle)
00216 : gHAType( aTypeId, strValue ),
00217 hAttrSingle( codeAttrSingle )
00218 {
00219 }
00220
00221 gHATypeGenLst::~gHATypeGenLst ()
00222 {
00223 }
00224
00225 gHATypeLstVal::gHATypeLstVal (t_int16 aTypeId, char* strValue, short codeAttrSingle)
00226 : gHATypeGenLst( aTypeId, strValue, codeAttrSingle )
00227 {
00228 }
00229
00230 gHATypeLstVal::~gHATypeLstVal ()
00231 {
00232 }
00233
00234
00235
00236 gHATypeLstStr::gHATypeLstStr (t_int16 aTypeId, char* strValue, short codeAttrSingle)
00237 : gHATypeGenLst( aTypeId, strValue, codeAttrSingle )
00238 {
00239 }
00240
00241 gHATypeLstStr::~gHATypeLstStr ()
00242 {
00243 }
00244
00245 gHATypeCharsets::gHATypeCharsets (char* strValue, short codeAttrSingle)
00246 : gHATypeLstStr( codeAttrSingle==e_HAT_Single ? e_HATp_Charset : codeAttrSingle, strValue, codeAttrSingle )
00247 {
00248 }
00249
00250 gHATypeCharsets::~gHATypeCharsets ()
00251 {
00252 }
00253
00254 gHATypeContentTypes::gHATypeContentTypes (char* strValue, short codeAttrSingle)
00255 : gHATypeLstStr( codeAttrSingle==e_HAT_Single ? e_HATp_ContentType : codeAttrSingle, strValue, codeAttrSingle )
00256 {
00257 }
00258
00259 gHATypeContentTypes::~gHATypeContentTypes ()
00260 {
00261 }
00262
00263 gHATypeStyleSheet::gHATypeStyleSheet (char* strValue)
00264 : gHATypeLstStr( e_HATp_StyleSheet, strValue, e_HAT_Single )
00265 {
00266 }
00267
00268 gHATypeStyleSheet::~gHATypeStyleSheet ()
00269 {
00270 }
00271
00272 gHATypeMultiLengths::gHATypeMultiLengths (char* strValue, short codeAttrSingle)
00273 : gHATypeLstVal( codeAttrSingle==e_HAT_Single ? e_HATp_MultiLength : codeAttrSingle, strValue, codeAttrSingle )
00274 {
00275 }
00276
00277 gHATypeMultiLengths::~gHATypeMultiLengths ()
00278 {
00279 }
00280
00281 gHATypeCDATA::gHATypeCDATA (char* strValue)
00282 : gHAType( e_HAT_CDATA, strValue )
00283 {
00284 }
00285
00286 gHATypeCDATA::~gHATypeCDATA ()
00287 {
00288 }
00289
00290 gHATypeID::gHATypeID (char* strValue)
00291 : gHAType( e_HAT_ID, strValue )
00292 {
00293 }
00294
00295 gHATypeID::~gHATypeID ()
00296 {
00297 }
00298
00299 gHATypeIDREF::gHATypeIDREF (char* strValue)
00300 : gHAType( e_HAT_IDREF, strValue )
00301 {
00302 }
00303
00304 gHATypeIDREF::~gHATypeIDREF ()
00305 {
00306 }
00307
00308 gHATypeIDREFS::gHATypeIDREFS (char* strValue)
00309 : gHAType( e_HAT_IDREFS, strValue )
00310 {
00311 }
00312
00313 gHATypeIDREFS::~gHATypeIDREFS ()
00314 {
00315 }
00316
00317 gHATypeNAME::gHATypeNAME (char* strValue)
00318 : gHAType( e_HAT_NAME, strValue )
00319 {
00320 }
00321
00322 gHATypeNAME::~gHATypeNAME ()
00323 {
00324 }
00325
00326 gHATypeNUMBER::gHATypeNUMBER (char* strValue)
00327 : gHATypeSimple32( e_HAT_NUMBER, strValue, HATYPE_S32_INVALID_VAL )
00328 {
00329 }
00330
00331 gHATypeNUMBER::~gHATypeNUMBER ()
00332 {
00333 }
00334
00335 gHATypePixels::gHATypePixels (char* strValue)
00336 : gHATypeSimple32( e_HATp_Pixels, strValue, HATYPE_S32_INVALID_VAL )
00337 {
00338 }
00339
00340 gHATypePixels::~gHATypePixels ()
00341 {
00342 }
00343
00344 gHATypeText::gHATypeText (char* strValue)
00345 : gHATypeGString( e_HATp_Text, strValue )
00346 {
00347 DBGPRINT_MIN("DBG: gHATypeText(%s)\n",strValue);
00348 }
00349
00350 gHATypeText::~gHATypeText ()
00351 {
00352 }
00353
00354 gHATypeFrameTarget::gHATypeFrameTarget (char* strValue)
00355 : gHATypeStringSingle( e_HATp_FrameTarget, strValue ),
00356 isBlank( sUnquoted.Match( "_blank", true ) )
00357 {
00358 }
00359
00360 gHATypeFrameTarget::~gHATypeFrameTarget ()
00361 {
00362 }
00363
00364 gHATypeEnum::gHATypeEnum (t_int16 aTypeId, char* strValue, t_int16 val)
00365 : gHATypeSimple( aTypeId, strValue, val )
00366 {
00367 if ( v>=1 ) sUnquoted.DownString();
00368 }
00369
00370 gHATypeEnum::gHATypeEnum (t_int16 aTypeId, char* strValue, gSmartList& lEnumStr)
00371 : gHATypeSimple( aTypeId, strValue, -1 )
00372 {
00373 unsigned pos = lEnumStr.MatchWhere( sUnquoted.Str() );
00374 v = (t_int16)pos;
00375
00376 if ( v>=1 ) sUnquoted.DownString();
00377 DBGPRINT_WEBA2("DBG: gHATypeEnum(%s|%s)=%d\n",strValue,GetStr(),v);
00378 }
00379
00380 gHATypeEnum::~gHATypeEnum ()
00381 {
00382 }
00383
00384