gHtmlHATypes.cpp

Go to the documentation of this file.
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  //Unquote( sOrig, sUnquoted );
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  // Return non-0 if any error exists
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  // Return 0 if o.k.
00176  if ( strValue==nil || strValue[0]==0 ) return -1;  // Not necessary: just for consistence
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  // Replace if o.k. by downcase (e.g. 'Center'(strValue)==>Center=>(sUnquoted)=>>center)
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 

Generated on Sat Aug 18 02:40:54 2007 for xpfweb_v2x lib by  doxygen 1.4.2