include/atl/atlhtml.h

   1 // This is a part of the Active Template Library.
   2 // Copyright (C) Microsoft Corporation
   3 // All rights reserved.
   4 //
   5 // This source code is only intended as a supplement to the
   6 // Active Template Library Reference and related
   7 // electronic documentation provided with the library.
   8 // See these sources for detailed information regarding the
   9 // Active Template Library product.
  10
  11 #ifndef __ATLHTML_H__
  12 #define __ATLHTML_H__
  13
  14 #pragma once
  15
  16 #include <atlstr.h>
  17 #include <atlsiface.h>
  18 #include <atlconv.h>
  19
  20
  21
  22 #pragma pack(push,_ATL_PACKING)
  23 namespace ATL {
  24
  25 #define TAGF_NONE 0
  26 #define TAGF_HASEND 1
  27 #define TAGF_BLOCK  2
  28
  29
  30 struct ATL_HTML_TAG
  31 {
  32         LPCTSTR szTagName;
  33         UINT uFlags;
  34 };
  35
  36 enum ATL_HTML_TAGS {
  37         ATL_HTML_TAG_BODY,
  38         ATL_HTML_TAG_A,
  39         ATL_HTML_TAG_B,
  40         ATL_HTML_TAG_I,
  41         ATL_HTML_TAG_U,
  42         ATL_HTML_TAG_FONT,
  43         ATL_HTML_TAG_IMG,
  44         ATL_HTML_TAG_HR,
  45         ATL_HTML_TAG_BR,
  46         ATL_HTML_TAG_DIV,
  47         ATL_HTML_TAG_BLOCKQUOTE,
  48         ATL_HTML_TAG_ADDRESS,
  49         ATL_HTML_TAG_P,
  50         ATL_HTML_TAG_H1,
  51         ATL_HTML_TAG_H2,
  52         ATL_HTML_TAG_H3,
  53         ATL_HTML_TAG_H4,
  54         ATL_HTML_TAG_H5,
  55         ATL_HTML_TAG_H6,
  56         ATL_HTML_TAG_PRE,
  57         ATL_HTML_TAG_Q,
  58         ATL_HTML_TAG_SUB,
  59         ATL_HTML_TAG_SUP,
  60         ATL_HTML_TAG_INS,
  61         ATL_HTML_TAG_DEL,
  62         ATL_HTML_TAG_EM,
  63         ATL_HTML_TAG_STRONG,
  64         ATL_HTML_TAG_DFN,
  65         ATL_HTML_TAG_CODE,
  66         ATL_HTML_TAG_SAMP,
  67         ATL_HTML_TAG_KBD,
  68         ATL_HTML_TAG_VAR,
  69         ATL_HTML_TAG_CITE,
  70         ATL_HTML_TAG_ABBR,
  71         ATL_HTML_TAG_ACRONYM,
  72         ATL_HTML_TAG_OL,
  73         ATL_HTML_TAG_UL,
  74         ATL_HTML_TAG_LI,
  75         ATL_HTML_TAG_DL,
  76         ATL_HTML_TAG_DT,
  77         ATL_HTML_TAG_DD,
  78         ATL_HTML_TAG_TABLE,
  79         ATL_HTML_TAG_TR,
  80         ATL_HTML_TAG_TD,
  81         ATL_HTML_TAG_FORM,
  82         ATL_HTML_TAG_INPUT,
  83         ATL_HTML_TAG_SELECT,
  84         ATL_HTML_TAG_OPTION,
  85         ATL_HTML_TAG_HEAD,
  86         ATL_HTML_TAG_HTML,
  87         ATL_HTML_TAG_MAP,
  88         ATL_HTML_TAG_AREA,
  89         ATL_HTML_TAG_BASE,
  90         ATL_HTML_TAG_BDO,
  91         ATL_HTML_TAG_BIG,
  92         ATL_HTML_TAG_BUTTON,
  93         ATL_HTML_TAG_IFRAME,
  94         ATL_HTML_TAG_LABEL,
  95         ATL_HTML_TAG_LINK,
  96         ATL_HTML_TAG_META,
  97         ATL_HTML_TAG_NOFRAMES,
  98         ATL_HTML_TAG_NOSCRIPT,
  99         ATL_HTML_TAG_COL,
 100         ATL_HTML_TAG_COLGROUP,
 101         ATL_HTML_TAG_FIELDSET,
 102         ATL_HTML_TAG_LEGEND,
 103         ATL_HTML_TAG_TBODY,
 104         ATL_HTML_TAG_TEXTAREA,
 105         ATL_HTML_TAG_TFOOT,
 106         ATL_HTML_TAG_TH,
 107         ATL_HTML_TAG_TITLE,
 108         ATL_HTML_TAG_TT,
 109         ATL_HTML_TAG_SMALL,
 110         ATL_HTML_TAG_SPAN,
 111         ATL_HTML_TAG_OBJECT,
 112         ATL_HTML_TAG_PARAM,
 113         ATL_HTML_TAG_LAST };
 114
 115 extern __declspec(selectany) const ATL_HTML_TAG s_tags[] =
 116 {
 117         { _T("body"),  TAGF_HASEND | TAGF_BLOCK },
 118         { _T("a"), TAGF_HASEND },
 119         { _T("b"), TAGF_HASEND },
 120         { _T("i"), TAGF_HASEND },
 121         { _T("u"), TAGF_HASEND },
 122         { _T("font"), TAGF_HASEND },
 123         { _T("img"), TAGF_NONE },
 124         { _T("hr"), TAGF_NONE },
 125         { _T("br"), TAGF_NONE },
 126         { _T("div"), TAGF_HASEND | TAGF_BLOCK },
 127         { _T("blockquote"), TAGF_HASEND | TAGF_BLOCK },
 128         { _T("adress"), TAGF_HASEND },
 129         { _T("p"), TAGF_HASEND | TAGF_BLOCK },
 130         { _T("h1"), TAGF_HASEND | TAGF_BLOCK},
 131         { _T("h2"), TAGF_HASEND  | TAGF_BLOCK},
 132         { _T("h3"), TAGF_HASEND | TAGF_BLOCK },
 133         { _T("h4"), TAGF_HASEND | TAGF_BLOCK },
 134         { _T("h5"), TAGF_HASEND | TAGF_BLOCK },
 135         { _T("h6"), TAGF_HASEND | TAGF_BLOCK },
 136         { _T("pre"), TAGF_HASEND | TAGF_BLOCK },
 137         { _T("q"), TAGF_HASEND },
 138         { _T("sub"), TAGF_HASEND },
 139         { _T("sup"), TAGF_HASEND },
 140         { _T("ins"), TAGF_HASEND },
 141         { _T("del"), TAGF_HASEND },
 142         { _T("em"), TAGF_HASEND },
 143         { _T("strong"), TAGF_HASEND },
 144         { _T("dfn"), TAGF_HASEND },
 145         { _T("code"), TAGF_HASEND },
 146         { _T("samp"), TAGF_HASEND },
 147         { _T("kbd"), TAGF_HASEND },
 148         { _T("var"), TAGF_HASEND },
 149         { _T("cite"), TAGF_HASEND },
 150         { _T("abbr"), TAGF_HASEND },
 151         { _T("acronym"), TAGF_HASEND },
 152         { _T("ol"), TAGF_HASEND | TAGF_BLOCK },
 153         { _T("ul"), TAGF_HASEND | TAGF_BLOCK },
 154         { _T("li"), TAGF_HASEND },
 155         { _T("dl"), TAGF_HASEND | TAGF_BLOCK },
 156         { _T("dt"), TAGF_HASEND },
 157         { _T("dd"), TAGF_HASEND },
 158         { _T("table"), TAGF_HASEND },
 159         { _T("tr"), TAGF_HASEND },
 160         { _T("td"), TAGF_HASEND },
 161         { _T("form"), TAGF_HASEND },
 162         { _T("input"), TAGF_HASEND },
 163         { _T("select"), TAGF_HASEND },
 164         { _T("option"), TAGF_HASEND },
 165         { _T("head"), TAGF_HASEND | TAGF_BLOCK },
 166         { _T("html"), TAGF_HASEND | TAGF_BLOCK },
 167         { _T("map"), TAGF_HASEND | TAGF_BLOCK },
 168         { _T("area"), TAGF_BLOCK },
 169         { _T("base"), TAGF_BLOCK },
 170         { _T("bdo"), TAGF_HASEND },
 171         { _T("big"), TAGF_HASEND },
 172         { _T("button"), TAGF_HASEND },
 173         { _T("iframe"), TAGF_HASEND },
 174         { _T("label"), TAGF_HASEND },
 175         { _T("link"), TAGF_NONE },
 176         { _T("meta"), TAGF_BLOCK },
 177         { _T("noframes"), TAGF_BLOCK },
 178         { _T("noscript"), TAGF_BLOCK },
 179         { _T("col"), TAGF_BLOCK },
 180         { _T("colgroup"), TAGF_HASEND | TAGF_BLOCK },
 181         { _T("fieldset"), TAGF_HASEND | TAGF_BLOCK },
 182         { _T("legend"), TAGF_HASEND | TAGF_BLOCK },
 183         { _T("tbody"), TAGF_HASEND | TAGF_BLOCK },
 184         { _T("textarea"), TAGF_HASEND | TAGF_BLOCK },
 185         { _T("tfoot"), TAGF_HASEND | TAGF_BLOCK },
 186         { _T("th"), TAGF_HASEND | TAGF_BLOCK },
 187         { _T("title"), TAGF_HASEND | TAGF_BLOCK },
 188         { _T("tt"), TAGF_HASEND },
 189         { _T("small"), TAGF_HASEND },
 190         { _T("span"), TAGF_HASEND },
 191         { _T("object"), TAGF_HASEND | TAGF_BLOCK },
 192         { _T("param"), TAGF_NONE },
 193 };
 194
 195 class AtlHtmlAttrs
 196 {
 197 public:
 198         CString m_strAttrs;
 199
 200         AtlHtmlAttrs()
 201         {
 202
 203         }
 204
 205 #pragma warning(push)
 206 #pragma warning(disable : 4793)
 207         AtlHtmlAttrs(int nCount, ...)
 208         {
 209                 va_list args;
 210
 211                 va_start(args, nCount);
 212                 for (int i=0; i<nCount; i++)
 213                 {
 214                         LPCTSTR szName = va_arg(args, LPCTSTR);
 215                         LPCTSTR szVal = va_arg(args, LPCTSTR);
 216                         Add(szName, szVal);
 217                 }
 218                 va_end(args);
 219         }
 220 #pragma warning(pop)
 221
 222 #pragma warning(push)
 223 #pragma warning(disable : 4793)
 224         AtlHtmlAttrs(LPCTSTR szFormat, ...)
 225         {
 226                 if (!szFormat || !*szFormat)
 227                         return;
 228
 229                 va_list args;
 230
 231                 va_start(args, szFormat);
 232
 233                 CString strTmp;
 234                 strTmp.FormatV(szFormat, args);
 235                 va_end(args);
 236
 237                 m_strAttrs += _T(" ");
 238                 m_strAttrs += strTmp;
 239         }
 240 #pragma warning(pop)
 241
 242         BOOL Add(LPCTSTR szName, LPCTSTR szValue)
 243         {
 244                 if (szValue)
 245                         m_strAttrs.AppendFormat(_T(" %s=\"%s\""), szName, szValue);
 246                 else
 247                         m_strAttrs.AppendFormat(_T(" %s"), szName);
 248                 return TRUE;
 249         }
 250
 251 #pragma warning(push)
 252 #pragma warning(disable : 4793)
 253         void AddFormat(LPCTSTR szFormat, ...)
 254         {
 255                 va_list args;
 256
 257                 va_start(args, szFormat);
 258
 259                 CString strTmp;
 260                 strTmp.FormatV(szFormat, args);
 261                 va_end(args);
 262
 263                 m_strAttrs += _T(" ");
 264                 m_strAttrs += strTmp;
 265         }
 266 #pragma warning(pop)
 267
 268         void Set(LPCTSTR szAttrs)
 269         {
 270                 if (szAttrs)
 271                 {
 272                         m_strAttrs.Empty();
 273 #ifndef UNICODE
 274                         if (!isspace(static_cast<unsigned char>(szAttrs[0])))
 275 #else
 276                         if (!iswspace(szAttrs[0]))
 277 #endif
 278                                 m_strAttrs = _T(" ");
 279                         m_strAttrs += szAttrs;
 280                 }
 281         }
 282
 283         operator LPCTSTR()
 284         {
 285                 return m_strAttrs;
 286         }
 287
 288 };
 289
 290 class CStreamOnWriteStream : public IStream
 291 {
 292 public:
 293         IWriteStream *m_pWriteStream;
 294
 295         CStreamOnWriteStream()
 296         {
 297                 m_pWriteStream = NULL;
 298         }
 299
 300         void Init(IWriteStream *pWriteStream)
 301         {
 302                 m_pWriteStream = pWriteStream;
 303         }
 304
 305         // IUnknown methods
 306         STDMETHOD(QueryInterface)(REFIID riid, void **ppv)
 307         {
 308                 if (!ppv)
 309                         return E_POINTER;
 310
 311                 *ppv = NULL;
 312
 313                 if (IsEqualGUID(riid, IID_IUnknown) ||
 314                         IsEqualGUID(riid, IID_IStream) ||
 315                         IsEqualGUID(riid, IID_ISequentialStream))
 316                 {
 317                         *ppv = (IStream *) this;
 318                 }
 319                 if (!*ppv)
 320                         return E_NOINTERFACE;
 321                 return S_OK;
 322         }
 323
 324         ULONG __stdcall AddRef()
 325         {
 326                 return 1;
 327         }
 328
 329         ULONG __stdcall Release()
 330         {
 331                 return 1;
 332         }
 333
 334         // ISequentialStream methods
 335         HRESULT STDMETHODCALLTYPE Read(void * /*pDest*/, ULONG /*dwMaxLen*/, ULONG * /*pdwRead*/)
 336         {
 337                 return E_NOTIMPL;
 338         }
 339
 340         HRESULT STDMETHODCALLTYPE Write(const void *pv, ULONG cb, ULONG *pcbWritten)
 341         {
 342                 ATLASSUME(m_pWriteStream);
 343                 HRESULT hr = m_pWriteStream->WriteStream((const char *) pv, cb, pcbWritten);
 344                 return (hr==S_OK) ? S_OK : STG_E_WRITEFAULT;
 345         }
 346
 347         // IStream methods
 348         HRESULT STDMETHODCALLTYPE Seek(LARGE_INTEGER /*dlibMove*/, DWORD /*dwOrigin*/, ULARGE_INTEGER * /*plibNewPosition*/)
 349         {
 350                 return E_NOTIMPL;
 351         }
 352
 353         HRESULT STDMETHODCALLTYPE SetSize(ULARGE_INTEGER /*libNewSize*/)
 354         {
 355                 return E_NOTIMPL;
 356         }
 357
 358         HRESULT STDMETHODCALLTYPE CopyTo(IStream * /*pstm*/, ULARGE_INTEGER /*cb*/, ULARGE_INTEGER * /*pcbRead*/, ULARGE_INTEGER * /*pcbWritten*/)
 359         {
 360                 return E_NOTIMPL;
 361         }
 362
 363         HRESULT STDMETHODCALLTYPE Commit(DWORD /*grfCommitFlags*/)
 364         {
 365                 return E_NOTIMPL;
 366         }
 367
 368         HRESULT STDMETHODCALLTYPE Revert(void)
 369         {
 370                 return E_NOTIMPL;
 371         }
 372
 373         HRESULT STDMETHODCALLTYPE LockRegion(ULARGE_INTEGER /*libOffset*/, ULARGE_INTEGER /*cb*/, DWORD /*dwLockType*/)
 374         {
 375                 return E_NOTIMPL;
 376         }
 377
 378         HRESULT STDMETHODCALLTYPE UnlockRegion(ULARGE_INTEGER /*libOffset*/, ULARGE_INTEGER /*cb*/, DWORD /*dwLockType*/)
 379         {
 380                 return E_NOTIMPL;
 381         }
 382
 383         HRESULT STDMETHODCALLTYPE Stat(STATSTG * /*pstatstg*/, DWORD /*grfStatFlag*/)
 384         {
 385                 return E_NOTIMPL;
 386         }
 387
 388
 389         HRESULT STDMETHODCALLTYPE Clone(IStream ** /*ppstm*/)
 390         {
 391                 return E_NOTIMPL;
 392         }
 393 };
 394
 395 class CStreamFormatter
 396 {
 397 protected:
 398         CStreamOnWriteStream m_sows;
 399         IStream *m_pStream;
 400         BOOL m_bAddCRLF;
 401         BOOL m_bEmitUnicode;
 402         UINT m_nConversionCodepage;
 403
 404 public:
 405         CStreamFormatter()
 406         {
 407                 m_pStream = NULL;
 408                 m_bAddCRLF = TRUE;
 409                 m_bEmitUnicode = FALSE;
 410                 m_nConversionCodepage = _AtlGetConversionACP();
 411         }
 412
 413         void Initialize(IStream *pStream, BOOL bAddCRLF=TRUE)
 414         {
 415                 m_pStream = pStream;
 416                 m_bAddCRLF = bAddCRLF;
 417         }
 418
 419         void Initialize(IWriteStream *pWriteStream, BOOL bAddCRLF=TRUE)
 420         {
 421                 m_bAddCRLF = bAddCRLF;
 422                 m_sows.Init(pWriteStream);
 423                 m_pStream = &m_sows;
 424         }
 425
 426         void EmitUnicode(BOOL bEmitUnicode)
 427         {
 428                 m_bEmitUnicode = bEmitUnicode;
 429         }
 430
 431         void SetConversionCodepage(UINT nConversionCodepage)
 432         {
 433                 m_nConversionCodepage = nConversionCodepage;
 434         }
 435
 436         void AddCRLF(bool bNewVal)
 437         {
 438                 m_bAddCRLF = bNewVal;
 439         }
 440
 441         HRESULT WriteRaw(LPCTSTR szString, int nCount=-1)
 442         {
 443                 ATLENSURE_RETURN(szString != NULL);
 444                 if (!m_pStream)
 445                         return E_FAIL;
 446
 447                 if (m_bEmitUnicode)
 448                 {
 449 #ifdef _UNICODE
 450                         LPCWSTR sz = szString;
 451                         if (nCount == -1)
 452                                 nCount = (int) wcslen(szString);
 453 #else
 454                         CA2W sz(szString, m_nConversionCodepage);
 455                         nCount = (int) wcslen(sz);
 456 #endif
 457                         DWORD dwWritten;
 458                         return m_pStream->Write(sz, (DWORD) nCount*sizeof(WCHAR), &dwWritten);
 459                 }
 460                 else
 461                 {
 462 #ifdef _UNICODE
 463                         CW2A sz(szString, m_nConversionCodepage);
 464                         nCount = (int) strlen(sz);
 465 #else
 466                         LPCSTR sz = szString;
 467                         if (nCount == -1)
 468                                 nCount = (int) strlen(szString);
 469 #endif
 470                         DWORD dwWritten;
 471                         return m_pStream->Write(sz, (DWORD) nCount, &dwWritten);
 472                 }
 473         }
 474
 475         HRESULT StartTag(int nTagIndex, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 476         {
 477                 if (nTagIndex < 0 || nTagIndex >= ATL_HTML_TAG_LAST)
 478                         return E_INVALIDARG;
 479                 if (m_bAddCRLF && (s_tags[nTagIndex].uFlags & TAGF_BLOCK))
 480                         WriteRaw(_T("\r\n"));
 481                 HRESULT hr = StartTag(s_tags[nTagIndex].szTagName, szContent, szAttrs);
 482                 if (FAILED(hr))
 483                         return hr;
 484                 if (m_bAddCRLF && (s_tags[nTagIndex].uFlags & TAGF_BLOCK))
 485                         WriteRaw(_T("\r\n"));
 486                 return S_OK;
 487         }
 488
 489         HRESULT StartTag(LPCTSTR szTag, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 490         {
 491                 HRESULT hr;
 492                 hr = WriteRaw(_T("<"));
 493                 if (FAILED(hr))
 494                         return hr;
 495                 hr = WriteRaw(szTag);
 496                 if (FAILED(hr))
 497                         return hr;
 498                 hr = WriteAttributes(szAttrs);
 499                 if (FAILED(hr))
 500                         return hr;
 501                 hr = WriteRaw(_T(">"));
 502                 if (FAILED(hr))
 503                         return hr;
 504                 if (szContent && *szContent)
 505                 {
 506                         WriteRaw(szContent);
 507                         EndTag(szTag);
 508                 }
 509                 return S_OK;
 510         }
 511
 512         HRESULT EndTag(int nTagIndex)
 513         {
 514                 if (nTagIndex < 0 || nTagIndex >= ATL_HTML_TAG_LAST)
 515                         return E_INVALIDARG;
 516                 if (m_bAddCRLF && (s_tags[nTagIndex].uFlags & TAGF_BLOCK))
 517                         WriteRaw(_T("\r\n"));
 518                 HRESULT hr = EndTag(s_tags[nTagIndex].szTagName);
 519                 if (FAILED(hr))
 520                         return hr;
 521                 if (m_bAddCRLF && (s_tags[nTagIndex].uFlags & TAGF_BLOCK))
 522                         WriteRaw(_T("\r\n"));
 523                 return S_OK;
 524         }
 525
 526         HRESULT EndTag(LPCTSTR szTag)
 527         {
 528                 HRESULT hr = WriteRaw(_T("</"));
 529                 if (FAILED(hr))
 530                         return hr;
 531                 hr = WriteRaw(szTag);
 532                 if (FAILED(hr))
 533                         return hr;
 534                 return WriteRaw(_T(">"));
 535         }
 536
 537         HRESULT WriteAttributes(LPCTSTR szAttrs)
 538         {
 539                 if (szAttrs && szAttrs[0])
 540                 {
 541 #ifndef UNICODE
 542                         if (!isspace(static_cast<unsigned char>(szAttrs[0])))
 543 #else
 544                         if (!iswspace(szAttrs[0]))
 545 #endif
 546                                 WriteRaw(_T(" "));
 547                         return WriteRaw(szAttrs);
 548                 }
 549
 550                 return S_OK;
 551         }
 552
 553 #pragma warning(push)
 554 #pragma warning(disable : 4793)
 555         HRESULT WriteFormatted(LPCTSTR szFormat, ...)
 556         {
 557                 ATLASSERT(szFormat != NULL);
 558                 if (!m_pStream)
 559                         return E_FAIL;
 560
 561                 va_list args;
 562                 va_start(args, szFormat);
 563
 564
 565                 TCHAR buffFixed[1024];
 566                 CTempBuffer<TCHAR> buffHeap;
 567                 TCHAR *szTemp = buffFixed;
 568                 int nCount = _vstprintf_s((LPTSTR)szTemp, _countof(buffFixed), szFormat, args);
 569                 if (nCount < 0)
 570                 {
 571                         // we'll have to dynamically allocate the buffer
 572                         nCount = _vsctprintf(szFormat, args);
 573                         szTemp = NULL;
 574                         ATLTRY(szTemp = buffHeap.Allocate(nCount + 1));
 575                         if (!szTemp)
 576                                 return E_OUTOFMEMORY;
 577                         nCount = _vstprintf_s(szTemp, nCount+1, szFormat, args);
 578                 }
 579
 580                 va_end(args);
 581
 582                 if (nCount > 0)
 583                         return WriteRaw(szTemp, (DWORD) nCount);
 584                 return E_UNEXPECTED;
 585         }
 586 #pragma warning(pop)
 587 };
 588
 589 template <typename TData, int nMax=64>
 590 class CSimpleStack
 591 {
 592 public:
 593         int m_nTop;
 594         TData m_Data[nMax];
 595
 596         CSimpleStack()
 597         {
 598                 m_nTop = -1;
 599         }
 600
 601         bool IsEmpty()
 602         {
 603                 return (m_nTop == -1);
 604         }
 605
 606         bool Push(const TData *pData)
 607         {
 608                 if (m_nTop + 1 >= nMax)
 609                         return false;
 610
 611                 m_nTop++;
 612
 613                 m_Data[m_nTop] = *pData;
 614                 return true;
 615         }
 616
 617         bool Pop(TData *pData)
 618         {
 619                 if (m_nTop < 0)
 620                         return false;
 621
 622                 *pData = m_Data[m_nTop];
 623                 m_nTop--;
 624                 return true;
 625         }
 626 };
 627
 628
 629 struct HTML_SCHEME
 630 {
 631         CString strBgColor;
 632         CString strLinkColor;
 633         CString strVLinkColor;
 634         CString strALinkColor;
 635         CString strBackground;
 636         int nTopMargin;
 637         int nLeftMargin;
 638
 639         CString strTdBgColor;
 640         CString strTableBgColor;
 641         CString strTrBgColor;
 642
 643         HTML_SCHEME()
 644         {
 645                 nTopMargin = -1;
 646                 nLeftMargin = -1;
 647         }
 648 };
 649
 650 template <class T>
 651 class CHtmlGenBase : public CStreamFormatter
 652 {
 653 public:
 654         T* GetOuter()
 655         {
 656                 return static_cast<T*>(this);
 657         }
 658
 659         enum ATL_HTML_FORM_METHOD { ATL_HTML_FORM_METHOD_NONE=0, ATL_HTML_FORM_METHOD_GET, ATL_HTML_FORM_METHOD_POST, ATL_HTML_FORM_METHOD_MULTIPART };
 660
 661         CHtmlGenBase()
 662         {
 663                 m_nWidthPercent = -1;
 664                 m_nHeightPercent = -1;
 665                 m_nFormMethod = ATL_HTML_FORM_METHOD_NONE;
 666                 m_pScheme = NULL;
 667         }
 668
 669         void SetScheme(HTML_SCHEME *pScheme)
 670         {
 671                 m_pScheme = pScheme;
 672         }
 673
 674         HRESULT body(LPCTSTR szBgColor=NULL, LPCTSTR szBackground=NULL, LPCTSTR szTopMargin=NULL, LPCTSTR szLeftMargin=NULL,
 675                 LPCTSTR szAttrs=NULL)
 676         {
 677                 AtlHtmlAttrs Attrs;
 678                 Attrs.Set(szAttrs);
 679
 680                 if (szBgColor && *szBgColor)
 681                         Attrs.Add(_T("bgColor"), szBgColor);
 682                 else if (m_pScheme && m_pScheme->strBgColor.GetLength())
 683                         Attrs.Add(_T("bgColor"), m_pScheme->strBgColor);
 684
 685                 if (szBackground && *szBackground)
 686                         Attrs.Add(_T("background"), szBackground);
 687                 else if (m_pScheme && m_pScheme->strBackground.GetLength())
 688                         Attrs.Add(_T("background"), m_pScheme->strBackground);
 689
 690                 if (m_pScheme && m_pScheme->strLinkColor.GetLength())
 691                         Attrs.Add(_T("link"), m_pScheme->strLinkColor);
 692
 693                 if (m_pScheme && m_pScheme->strALinkColor.GetLength())
 694                         Attrs.Add(_T("alink"), m_pScheme->strALinkColor);
 695
 696                 if (m_pScheme && m_pScheme->strVLinkColor.GetLength())
 697                         Attrs.Add(_T("vlink"), m_pScheme->strVLinkColor);
 698
 699                 if (szTopMargin && *szTopMargin)
 700                         Attrs.Add(_T("topmargin"), szTopMargin);
 701                 else if (m_pScheme && m_pScheme->nTopMargin != -1)
 702                         Attrs.AddFormat(_T("topmargin=\"%d\""), m_pScheme->nTopMargin);
 703
 704                 if (szLeftMargin && *szLeftMargin)
 705                         Attrs.Add(_T("leftmargin"), szLeftMargin);
 706                 else if (m_pScheme && m_pScheme->nLeftMargin != -1)
 707                         Attrs.AddFormat(_T("leftmargin=\"%d\""), m_pScheme->nLeftMargin);
 708
 709                 return GetOuter()->StartTag(ATL_HTML_TAG_BODY, NULL, Attrs);
 710         }
 711
 712         HRESULT bodyEnd()
 713         {
 714                 return GetOuter()->EndTag(ATL_HTML_TAG_BODY);
 715         }
 716
 717         HRESULT a(LPCTSTR szHref, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 718         {
 719                 AtlHtmlAttrs Attrs;
 720                 Attrs.Set(szAttrs);
 721
 722                 if (m_strState.GetLength()==0)
 723                 {
 724                         if (szHref && *szHref)
 725                                 Attrs.Add(_T("href"), szHref);
 726                         return GetOuter()->StartTag(ATL_HTML_TAG_A, szContent, Attrs);
 727                 }
 728
 729                 const TCHAR *szQuestion = NULL;
 730                 if(szHref)
 731                         szQuestion = _tcschr(szHref, '?');
 732
 733                 CString strHref = szHref;
 734                 if (!szQuestion)
 735                         strHref.Append("?");
 736                 else
 737                         strHref.Append("&");
 738
 739                 strHref += m_strState;
 740
 741                 if (szHref && *szHref)
 742                         Attrs.Add(_T("href"), strHref);
 743
 744                 return GetOuter()->StartTag(ATL_HTML_TAG_A, szContent, Attrs);
 745         }
 746
 747         HRESULT aEnd()
 748         {
 749                 return GetOuter()->EndTag(ATL_HTML_TAG_A);
 750         }
 751
 752         HRESULT b(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 753         {
 754                 return GetOuter()->StartTag(ATL_HTML_TAG_B, szContent, szAttrs);
 755         }
 756
 757         HRESULT bEnd()
 758         {
 759                 return GetOuter()->EndTag(ATL_HTML_TAG_B);
 760         }
 761
 762         HRESULT i(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 763         {
 764                 return GetOuter()->StartTag(ATL_HTML_TAG_I, szContent, szAttrs);
 765         }
 766
 767         HRESULT iEnd()
 768         {
 769                 return GetOuter()->EndTag(ATL_HTML_TAG_I);
 770         }
 771
 772         HRESULT u(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 773         {
 774                 return GetOuter()->StartTag(ATL_HTML_TAG_U, szContent, szAttrs);
 775         }
 776
 777         HRESULT uEnd()
 778         {
 779                 return GetOuter()->EndTag(ATL_HTML_TAG_U);
 780         }
 781
 782         HRESULT font(LPCTSTR szFace, LPCTSTR szSize=NULL, LPCTSTR szColor=NULL, LPCTSTR szAttrs=NULL)
 783         {
 784                 AtlHtmlAttrs Attrs;
 785                 Attrs.Set(szAttrs);
 786                 if (szFace && *szFace)
 787                         Attrs.Add(_T("face"), szFace);
 788                 if (szSize && *szSize)
 789                         Attrs.Add(_T("size"), szSize);
 790                 if (szColor && *szColor)
 791                         Attrs.Add(_T("color"), szColor);
 792                 return GetOuter()->StartTag(ATL_HTML_TAG_FONT, NULL, Attrs);
 793         }
 794
 795         HRESULT font(COLORREF clrColor, LPCTSTR szAttrs=NULL)
 796         {
 797                 TCHAR szColor[8];
 798                 _stprintf_s(szColor, _countof(szColor), _T("#%02x%02x%02x"), GetRValue(clrColor),
 799                         GetGValue(clrColor), GetBValue(clrColor));
 800                 return GetOuter()->font(NULL, NULL, szColor, szAttrs);
 801         }
 802
 803         HRESULT fontEnd()
 804         {
 805                 return GetOuter()->EndTag(ATL_HTML_TAG_FONT);
 806         }
 807
 808         HRESULT img(LPCTSTR szSrc, LPCTSTR szAttrs=NULL)
 809         {
 810                 ATLASSERT(szSrc && *szSrc);
 811
 812                 AtlHtmlAttrs Attrs;
 813                 Attrs.Set(szAttrs);
 814
 815                 Attrs.Add(_T("src"), szSrc);
 816
 817                 return GetOuter()->StartTag(ATL_HTML_TAG_IMG, NULL, Attrs);
 818         }
 819
 820         HRESULT br(LPCTSTR szAttrs=NULL)
 821         {
 822                 return GetOuter()->StartTag(ATL_HTML_TAG_BR, NULL, szAttrs);
 823         }
 824
 825         HRESULT hr(LPCTSTR szAttrs=NULL)
 826         {
 827                 return GetOuter()->StartTag(ATL_HTML_TAG_HR, NULL, szAttrs);
 828         }
 829
 830         HRESULT div(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 831         {
 832                 return GetOuter()->StartTag(ATL_HTML_TAG_DIV, szContent, szAttrs);
 833         }
 834
 835         HRESULT divEnd()
 836         {
 837                 return GetOuter()->EndTag(ATL_HTML_TAG_DIV);
 838         }
 839
 840         HRESULT blockquote(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 841         {
 842                 return GetOuter()->StartTag(ATL_HTML_TAG_BLOCKQUOTE, szContent, szAttrs);
 843         }
 844
 845         HRESULT blockquoteEnd()
 846         {
 847                 return GetOuter()->EndTag(ATL_HTML_TAG_BLOCKQUOTE);
 848         }
 849
 850         HRESULT address(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 851         {
 852                 return GetOuter()->StartTag(ATL_HTML_TAG_ADDRESS, szContent, szAttrs);
 853         }
 854
 855         HRESULT addressEnd()
 856         {
 857                 return GetOuter()->EndTag(ATL_HTML_TAG_ADDRESS);
 858         }
 859
 860         HRESULT p(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 861         {
 862                 return GetOuter()->StartTag(ATL_HTML_TAG_P, szContent, szAttrs);
 863         }
 864
 865         HRESULT pEnd()
 866         {
 867                 return GetOuter()->EndTag(ATL_HTML_TAG_P);
 868         }
 869
 870         HRESULT h(int nLevel=1, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 871         {
 872                 if (nLevel < 1 || nLevel > 6)
 873                         return E_INVALIDARG;
 874                 return GetOuter()->StartTag(ATL_HTML_TAG_H1+nLevel-1, szContent, szAttrs);
 875         }
 876
 877         HRESULT hEnd(int nLevel=1)
 878         {
 879                 if (nLevel < 1 || nLevel > 6)
 880                         return E_INVALIDARG;
 881                 return GetOuter()->EndTag(ATL_HTML_TAG_H1+nLevel-1);
 882         }
 883
 884         HRESULT pre(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 885         {
 886                 return GetOuter()->StartTag(ATL_HTML_TAG_PRE, szContent, szAttrs);
 887         }
 888
 889         HRESULT preEnd()
 890         {
 891                 return GetOuter()->EndTag(ATL_HTML_TAG_PRE);
 892         }
 893
 894         HRESULT q(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 895         {
 896                 return GetOuter()->StartTag(ATL_HTML_TAG_Q, szContent, szAttrs);
 897         }
 898
 899         HRESULT qEnd()
 900         {
 901                 return GetOuter()->EndTag(ATL_HTML_TAG_Q);
 902         }
 903
 904         HRESULT sub(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 905         {
 906                 return GetOuter()->StartTag(ATL_HTML_TAG_SUB, szContent, szAttrs);
 907         }
 908
 909         HRESULT subEnd()
 910         {
 911                 return GetOuter()->EndTag(ATL_HTML_TAG_SUB);
 912         }
 913
 914         HRESULT sup(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 915         {
 916                 return GetOuter()->StartTag(ATL_HTML_TAG_SUP, szContent, szAttrs);
 917         }
 918
 919         HRESULT supEnd()
 920         {
 921                 return GetOuter()->EndTag(ATL_HTML_TAG_SUP);
 922         }
 923
 924         HRESULT ins(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 925         {
 926                 return GetOuter()->StartTag(ATL_HTML_TAG_INS, szContent, szAttrs);
 927         }
 928
 929         HRESULT insEnd()
 930         {
 931                 return GetOuter()->EndTag(ATL_HTML_TAG_INS);
 932         }
 933
 934         HRESULT del(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 935         {
 936                 return GetOuter()->StartTag(ATL_HTML_TAG_DEL, szContent, szAttrs);
 937         }
 938
 939         HRESULT delEnd()
 940         {
 941                 return GetOuter()->EndTag(ATL_HTML_TAG_DEL);
 942         }
 943
 944
 945         HRESULT em(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 946         {
 947                 return GetOuter()->StartTag(ATL_HTML_TAG_EM, szContent, szAttrs);
 948         }
 949
 950         HRESULT emEnd()
 951         {
 952                 return GetOuter()->EndTag(ATL_HTML_TAG_EM);
 953         }
 954
 955         HRESULT strong(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 956         {
 957                 return GetOuter()->StartTag(ATL_HTML_TAG_STRONG, szContent, szAttrs);
 958         }
 959
 960         HRESULT strongEnd()
 961         {
 962                 return GetOuter()->EndTag(ATL_HTML_TAG_STRONG);
 963         }
 964
 965         HRESULT dfn(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 966         {
 967                 return GetOuter()->StartTag(ATL_HTML_TAG_DFN, szContent, szAttrs);
 968         }
 969
 970         HRESULT dfnEnd()
 971         {
 972                 return GetOuter()->EndTag(ATL_HTML_TAG_DFN);
 973         }
 974
 975         HRESULT code(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 976         {
 977                 return GetOuter()->StartTag(ATL_HTML_TAG_CODE, szContent, szAttrs);
 978         }
 979
 980         HRESULT codeEnd()
 981         {
 982                 return GetOuter()->EndTag(ATL_HTML_TAG_CODE);
 983         }
 984
 985         HRESULT samp(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 986         {
 987                 return GetOuter()->StartTag(ATL_HTML_TAG_SAMP, szContent, szAttrs);
 988         }
 989
 990         HRESULT sampEnd()
 991         {
 992                 return GetOuter()->EndTag(ATL_HTML_TAG_SAMP);
 993         }
 994
 995         HRESULT kbd(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
 996         {
 997                 return GetOuter()->StartTag(ATL_HTML_TAG_KBD, szContent, szAttrs);
 998         }
 999
1000         HRESULT kbdEnd()
1001         {
1002                 return GetOuter()->EndTag(ATL_HTML_TAG_KBD);
1003         }
1004
1005         HRESULT var(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1006         {
1007                 return GetOuter()->StartTag(ATL_HTML_TAG_VAR, szContent, szAttrs);
1008         }
1009
1010         HRESULT varEnd()
1011         {
1012                 return GetOuter()->EndTag(ATL_HTML_TAG_VAR);
1013         }
1014
1015         HRESULT cite(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1016         {
1017                 return GetOuter()->StartTag(ATL_HTML_TAG_CITE, szContent, szAttrs);
1018         }
1019
1020         HRESULT citeEnd()
1021         {
1022                 return GetOuter()->EndTag(ATL_HTML_TAG_CITE);
1023         }
1024
1025         HRESULT abbr(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1026         {
1027                 return GetOuter()->StartTag(ATL_HTML_TAG_ABBR, szContent, szAttrs);
1028         }
1029
1030         HRESULT abbrEnd()
1031         {
1032                 return GetOuter()->EndTag(ATL_HTML_TAG_ABBR);
1033         }
1034
1035         HRESULT acronym(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1036         {
1037                 return GetOuter()->StartTag(ATL_HTML_TAG_ACRONYM, szContent, szAttrs);
1038         }
1039
1040         HRESULT acronymEnd()
1041         {
1042                 return GetOuter()->EndTag(ATL_HTML_TAG_ACRONYM);
1043         }
1044
1045
1046         HRESULT ol(LPCTSTR szAttrs=NULL)
1047         {
1048                 return GetOuter()->StartTag(ATL_HTML_TAG_OL, NULL, szAttrs);
1049         }
1050
1051         HRESULT ul(LPCTSTR szAttrs=NULL)
1052         {
1053                 return GetOuter()->StartTag(ATL_HTML_TAG_UL, NULL, szAttrs);
1054         }
1055
1056         HRESULT olEnd()
1057         {
1058                 return GetOuter()->EndTag(ATL_HTML_TAG_OL);
1059         }
1060
1061         HRESULT ulEnd()
1062         {
1063                 return GetOuter()->EndTag(ATL_HTML_TAG_UL);
1064         }
1065
1066         HRESULT li(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1067         {
1068                 return GetOuter()->StartTag(ATL_HTML_TAG_LI, szContent, szAttrs);
1069         }
1070
1071         HRESULT liEnd()
1072         {
1073                 return GetOuter()->EndTag(ATL_HTML_TAG_LI);
1074         }
1075
1076         HRESULT dl(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1077         {
1078                 return GetOuter()->StartTag(ATL_HTML_TAG_DL, szContent, szAttrs);
1079         }
1080
1081         HRESULT dlEnd()
1082         {
1083                 return GetOuter()->EndTag(ATL_HTML_TAG_DL);
1084         }
1085
1086         HRESULT dt(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1087         {
1088                 return GetOuter()->StartTag(ATL_HTML_TAG_DT, szContent, szAttrs);
1089         }
1090
1091         HRESULT dtEnd()
1092         {
1093                 return GetOuter()->EndTag(ATL_HTML_TAG_DT);
1094         }
1095
1096         HRESULT dd(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1097         {
1098                 return GetOuter()->StartTag(ATL_HTML_TAG_DD, szContent, szAttrs);
1099         }
1100
1101         HRESULT ddEnd()
1102         {
1103                 return GetOuter()->EndTag(ATL_HTML_TAG_DD);
1104         }
1105
1106         void SetSizePercent(int nWidth, int nHeight)
1107         {
1108                 m_nWidthPercent = nWidth;
1109                 m_nHeightPercent = nHeight;
1110         }
1111
1112         HRESULT table(int nBorderWidth=0, LPCTSTR szAttrs=NULL)
1113         {
1114                 AtlHtmlAttrs Attrs;
1115                 Attrs.Set(szAttrs);
1116
1117                 m_RowStack.Push(&m_tableState);
1118                 m_tableState.Clear();
1119
1120                 Attrs.AddFormat(_T("border=\"%d\""), nBorderWidth);
1121
1122                 if (m_nWidthPercent != -1)
1123                         Attrs.AddFormat(_T("width=\"%d%%\""), m_nWidthPercent);
1124                 if (m_nHeightPercent != -1)
1125                         Attrs.AddFormat(_T("height=\"%d%%\""), m_nHeightPercent);
1126
1127                 if (m_pScheme && m_pScheme->strTableBgColor.GetLength())
1128                         Attrs.Add(_T("bgcolor"), m_pScheme->strTableBgColor);
1129
1130                 m_nWidthPercent = -1;
1131                 m_nHeightPercent = -1;
1132                 return GetOuter()->StartTag(ATL_HTML_TAG_TABLE, NULL, Attrs);
1133         }
1134
1135         HRESULT tableEnd()
1136         {
1137                 if (m_tableState.m_bRowOpen)
1138                         GetOuter()->trEnd();
1139                 m_RowStack.Pop(&m_tableState);
1140                 return GetOuter()->EndTag(ATL_HTML_TAG_TABLE);
1141         }
1142
1143         HRESULT tr(LPCTSTR szAttrs=NULL)
1144         {
1145                 AtlHtmlAttrs Attrs;
1146                 Attrs.Set(szAttrs);
1147
1148                 if (m_RowStack.IsEmpty())
1149                         GetOuter()->table();
1150                 if (m_tableState.m_bRowOpen)
1151                         GetOuter()->trEnd();
1152                 m_tableState.m_bRowOpen = true;
1153
1154                 if (m_pScheme && m_pScheme->strTrBgColor.GetLength())
1155                         Attrs.Add(_T("bgcolor"), m_pScheme->strTrBgColor);
1156                 return GetOuter()->StartTag(ATL_HTML_TAG_TR, NULL, Attrs);
1157         }
1158
1159         HRESULT td(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1160         {
1161                 AtlHtmlAttrs Attrs;
1162                 Attrs.Set(szAttrs);
1163
1164                 if (!m_tableState.m_bRowOpen)
1165                         GetOuter()->tr();
1166                 m_tableState.m_bDataOpen = true;
1167                 if (m_pScheme && m_pScheme->strTdBgColor.GetLength())
1168                         Attrs.Add(_T("bgColor"), m_pScheme->strTdBgColor);
1169
1170                 HRESULT hr = GetOuter()->StartTag(ATL_HTML_TAG_TD, szContent, Attrs);
1171                 if (FAILED(hr))
1172                         return hr;
1173                 if (szContent)
1174                         m_tableState.m_bDataOpen = false;
1175                 return S_OK;
1176         }
1177
1178         HRESULT tdEnd()
1179         {
1180                 if (!m_tableState.m_bDataOpen)
1181                         return S_OK;
1182                 m_tableState.m_bDataOpen = false;
1183                 return GetOuter()->EndTag(ATL_HTML_TAG_TD);
1184         }
1185
1186         HRESULT trEnd()
1187         {
1188                 if (!m_tableState.m_bRowOpen)
1189                         return S_OK;
1190                 if (m_tableState.m_bDataOpen)
1191                         GetOuter()->tdEnd();
1192                 m_tableState.m_bRowOpen = false;
1193                 return GetOuter()->EndTag(ATL_HTML_TAG_TR);
1194         }
1195
1196         HRESULT form(LPCTSTR szAction, ATL_HTML_FORM_METHOD nMethod=ATL_HTML_FORM_METHOD_GET, LPCTSTR szAttrs=NULL)
1197         {
1198                 static const LPCTSTR s_szFormMethods[] = { NULL, _T("get"), _T("post"), _T("multipart-www-url-encoded") };
1199                 return GetOuter()->form(szAction, s_szFormMethods[nMethod], szAttrs);
1200         }
1201
1202         HRESULT form(LPCTSTR szAction, LPCTSTR szMethod, LPCTSTR szAttrs=NULL)
1203         {
1204                 AtlHtmlAttrs Attrs;
1205                 Attrs.Set(szAttrs);
1206
1207                 if (szAction && *szAction)
1208                         Attrs.Add(_T("action"), szAction);
1209                 if (szMethod && *szMethod)
1210                         Attrs.Add(_T("method"), szMethod);
1211
1212                 return GetOuter()->StartTag(ATL_HTML_TAG_FORM, NULL, Attrs);
1213         }
1214
1215         HRESULT input(LPCTSTR szType, LPCTSTR szName, LPCTSTR szValue, LPCTSTR szAttrs=NULL)
1216         {
1217                 AtlHtmlAttrs Attrs;
1218                 Attrs.Set(szAttrs);
1219
1220                 if (szType && *szType)
1221                         Attrs.Add(_T("type"), szType);
1222                 if (szName && *szName)
1223                         Attrs.Add(_T("name"), szName);
1224                 if (szValue && *szValue)
1225                         Attrs.Add(_T("value"), szValue);
1226                 return GetOuter()->StartTag(ATL_HTML_TAG_INPUT, NULL, Attrs);
1227         }
1228
1229         HRESULT submit(LPCTSTR szValue=NULL, LPCTSTR szName=NULL, LPCTSTR szAttrs=NULL)
1230         {
1231                 return input(_T("submit"), szName, szValue, szAttrs);
1232         }
1233
1234         HRESULT textarea(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1235         {
1236                 return GetOuter()->StartTag(ATL_HTML_TAG_TEXTAREA, szContent, szAttrs);
1237         }
1238
1239         HRESULT textareaEnd()
1240         {
1241                 return GetOuter()->EndTag(ATL_HTML_TAG_TEXTAREA);
1242         }
1243
1244         HRESULT formEnd()
1245         {
1246                 return GetOuter()->EndTag(ATL_HTML_TAG_FORM);
1247         }
1248
1249
1250         HRESULT select(LPCTSTR szName, BOOL bMultiple=FALSE, LPCTSTR szAttrs=NULL)
1251         {
1252                 ATLASSERT(szName && *szName);
1253
1254                 AtlHtmlAttrs Attrs;
1255                 Attrs.Set(szAttrs);
1256
1257                 Attrs.Add(_T("name"), szName);
1258                 if (bMultiple)
1259                         Attrs.Add(_T("multiple"), NULL);
1260                 return GetOuter()->StartTag(ATL_HTML_TAG_SELECT, NULL, Attrs);
1261         }
1262
1263         HRESULT option(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1264         {
1265                 return GetOuter()->StartTag(ATL_HTML_TAG_OPTION, szContent, szAttrs);
1266         }
1267
1268         HRESULT optionEnd()
1269         {
1270                 return GetOuter()->EndTag(ATL_HTML_TAG_OPTION);
1271         }
1272
1273         HRESULT selectEnd()
1274         {
1275                 return GetOuter()->EndTag(ATL_HTML_TAG_SELECT);
1276         }
1277
1278
1279         HRESULT head(LPCTSTR szAttrs=NULL)
1280         {
1281                 return GetOuter()->StartTag(ATL_HTML_TAG_HEAD, NULL, szAttrs);
1282         }
1283
1284         HRESULT headEnd()
1285         {
1286                 return GetOuter()->EndTag(ATL_HTML_TAG_HEAD);
1287         }
1288
1289         HRESULT html(LPCTSTR szAttrs=NULL)
1290         {
1291                 return GetOuter()->StartTag(ATL_HTML_TAG_HTML, NULL, szAttrs);
1292         }
1293
1294         HRESULT htmlEnd()
1295         {
1296                 return GetOuter()->EndTag(ATL_HTML_TAG_HTML);
1297         }
1298
1299         HRESULT map(LPCTSTR szName, LPCTSTR szAttrs=NULL)
1300         {
1301                 ATLASSERT(szName && *szName);
1302
1303                 AtlHtmlAttrs Attrs;
1304                 Attrs.Set(szAttrs);
1305
1306                 Attrs.Add(_T("name"), szName);
1307                 return GetOuter()->StartTag(ATL_HTML_TAG_MAP, NULL, Attrs);
1308         }
1309
1310         HRESULT mapEnd()
1311         {
1312                 return GetOuter()->EndTag(ATL_HTML_TAG_MAP);
1313         }
1314
1315         HRESULT area(LPCTSTR szAlt, LPCTSTR szHref=NULL, LPCTSTR szAttrs=NULL)
1316         {
1317                 AtlHtmlAttrs Attrs;
1318                 Attrs.Set(szAttrs);
1319
1320                 if (szAlt && *szAlt)
1321                         Attrs.Add(_T("alt"), szAlt);
1322                 if (szHref && *szHref)
1323                         Attrs.Add(_T("href"), szHref);
1324                 return GetOuter()->StartTag(ATL_HTML_TAG_AREA, NULL, Attrs);
1325         }
1326
1327         HRESULT base(LPCTSTR szHref, LPCTSTR szAttrs=NULL)
1328         {
1329                 ATLASSERT(szHref && *szHref);
1330
1331                 AtlHtmlAttrs Attrs;
1332                 Attrs.Set(szAttrs);
1333
1334                 Attrs.Add(_T("href"), szHref);
1335                 return GetOuter()->StartTag(ATL_HTML_TAG_BASE, NULL, Attrs);
1336         }
1337
1338         HRESULT bdo(LPCTSTR szDir, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1339         {
1340                 ATLASSERT(szDir&& *szDir);
1341
1342                 AtlHtmlAttrs Attrs;
1343                 Attrs.Set(szAttrs);
1344
1345                 Attrs.Add(_T("dir"), szDir);
1346                 return GetOuter()->StartTag(ATL_HTML_TAG_BDO, szContent, Attrs);
1347         }
1348
1349         HRESULT bdoEnd()
1350         {
1351                 return GetOuter()->EndTag(ATL_HTML_TAG_BDO);
1352         }
1353
1354         HRESULT big(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1355         {
1356                 return GetOuter()->StartTag(ATL_HTML_TAG_BIG, szContent, szAttrs);
1357         }
1358
1359         HRESULT bigEnd()
1360         {
1361                 return GetOuter()->EndTag(ATL_HTML_TAG_BIG);
1362         }
1363
1364         HRESULT button(LPCTSTR szName=NULL, LPCTSTR szValue=NULL, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1365         {
1366                 AtlHtmlAttrs Attrs;
1367                 Attrs.Set(szAttrs);
1368
1369                 if (szName && *szName)
1370                         Attrs.Add(_T("name"), szName);
1371                 if (szValue && *szValue)
1372                         Attrs.Add(_T("value"), szValue);
1373                 return GetOuter()->StartTag(ATL_HTML_TAG_BUTTON, szContent, Attrs);
1374         }
1375
1376         HRESULT buttonEnd()
1377         {
1378                 return GetOuter()->EndTag(ATL_HTML_TAG_BUTTON);
1379         }
1380
1381         HRESULT iframe(LPCTSTR szSrc=NULL, LPCTSTR szWidth=NULL, LPCTSTR szHeight=NULL, LPCTSTR szAttrs=NULL)
1382         {
1383                 AtlHtmlAttrs Attrs;
1384                 Attrs.Set(szAttrs);
1385
1386                 if (szSrc && *szSrc)
1387                         Attrs.Add(_T("src"), szSrc);
1388                 if (szWidth && *szWidth)
1389                         Attrs.Add(_T("width"), szWidth);
1390                 if (szHeight && *szHeight)
1391                         Attrs.Add(_T("height"), szHeight);
1392                 return GetOuter()->StartTag(ATL_HTML_TAG_IFRAME, NULL, Attrs);
1393         }
1394
1395         HRESULT iframeEnd()
1396         {
1397                 return GetOuter()->EndTag(ATL_HTML_TAG_IFRAME);
1398         }
1399
1400         HRESULT label(LPCTSTR szFor=NULL, LPCTSTR szAccessKey=NULL, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1401         {
1402                 AtlHtmlAttrs Attrs;
1403                 Attrs.Set(szAttrs);
1404
1405                 if (szFor && *szFor)
1406                         Attrs.Add(_T("for"), szFor);
1407                 if (szAccessKey && *szAccessKey)
1408                         Attrs.Add(_T("accesskey"), szAccessKey);
1409                 return GetOuter()->StartTag(ATL_HTML_TAG_LABEL, szContent, Attrs);
1410         }
1411
1412         HRESULT labelEnd()
1413         {
1414                 return GetOuter()->EndTag(ATL_HTML_TAG_LABEL);
1415         }
1416
1417         HRESULT link(LPCTSTR szRel=NULL, LPCTSTR szHref=NULL, LPCTSTR szAttrs=NULL)
1418         {
1419                 AtlHtmlAttrs Attrs;
1420                 Attrs.Set(szAttrs);
1421
1422                 if (szRel && *szRel)
1423                         Attrs.Add(_T("rel"), szRel);
1424                 if (szHref && *szHref)
1425                         Attrs.Add(_T("href"), szHref);
1426                 return GetOuter()->StartTag(ATL_HTML_TAG_LINK, NULL, Attrs);
1427         }
1428
1429         HRESULT meta(LPCTSTR szName=NULL, LPCTSTR szContent=NULL, LPCTSTR szHttpEquiv=NULL, LPCTSTR szAttrs=NULL)
1430         {
1431                 AtlHtmlAttrs Attrs;
1432                 Attrs.Set(szAttrs);
1433
1434                 if (szName && *szName)
1435                         Attrs.Add(_T("name"), szName);
1436                 if (szContent && *szContent)
1437                         Attrs.Add(_T("content"), szContent);
1438                 if (szHttpEquiv && *szHttpEquiv)
1439                         Attrs.Add(_T("http-equiv"), szHttpEquiv);
1440                 return GetOuter()->StartTag(ATL_HTML_TAG_META, NULL, Attrs);
1441         }
1442
1443         HRESULT noframes(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1444         {
1445                 return GetOuter()->StartTag(ATL_HTML_TAG_NOFRAMES, szContent, szAttrs);
1446         }
1447
1448         HRESULT noframesEnd()
1449         {
1450                 return GetOuter()->EndTag(ATL_HTML_TAG_NOFRAMES);
1451         }
1452
1453         HRESULT noscript(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1454         {
1455                 return GetOuter()->StartTag(ATL_HTML_TAG_NOSCRIPT, szContent, szAttrs);
1456         }
1457
1458         HRESULT noscriptEnd()
1459         {
1460                 return GetOuter()->EndTag(ATL_HTML_TAG_NOSCRIPT);
1461         }
1462
1463         HRESULT col(int nSpan=1, LPCTSTR szWidth=NULL, LPCTSTR szHeight=NULL, LPCTSTR szVAlign=NULL,
1464                 LPCTSTR szHAlign=NULL, LPCTSTR szAttrs=NULL)
1465         {
1466                 AtlHtmlAttrs Attrs;
1467                 Attrs.Set(szAttrs);
1468
1469
1470                 if (nSpan != 1)
1471                         Attrs.AddFormat(_T("span"), _T("\"%d\""), nSpan);
1472                 if (szWidth && *szWidth)
1473                         Attrs.Add(_T("width"), szWidth);
1474                 if (szHeight && *szHeight)
1475                         Attrs.Add(_T("height"), szHeight);
1476                 if (szVAlign && *szVAlign)
1477                         Attrs.Add(_T("valign"), szVAlign);
1478                 if (szHAlign && *szHAlign)
1479                         Attrs.Add(_T("align"), szHAlign);
1480                 return GetOuter()->StartTag(ATL_HTML_TAG_COL, NULL, Attrs);
1481         }
1482
1483         HRESULT colgroup(int nSpan=1, LPCTSTR szWidth=NULL, LPCTSTR szHeight=NULL, LPCTSTR szVAlign=NULL,
1484                 LPCTSTR szHAlign=NULL, LPCTSTR szAttrs=NULL)
1485         {
1486                 AtlHtmlAttrs Attrs;
1487                 Attrs.Set(szAttrs);
1488
1489                 if (nSpan != 1)
1490                         Attrs.AddFormat(_T("span"), _T("\"%d\""), nSpan);
1491                 if (szWidth && *szWidth)
1492                         Attrs.Add(_T("width"), szWidth);
1493                 if (szHeight && *szHeight)
1494                         Attrs.Add(_T("height"), szHeight);
1495                 if (szVAlign && *szVAlign)
1496                         Attrs.Add(_T("valign"), szVAlign);
1497                 if (szHAlign && *szHAlign)
1498                         Attrs.Add(_T("align"), szHAlign);
1499                 return GetOuter()->StartTag(ATL_HTML_TAG_COL, NULL, Attrs);
1500         }
1501
1502         HRESULT colgroupEnd()
1503         {
1504                 return GetOuter()->EndTag(ATL_HTML_TAG_COLGROUP);
1505         }
1506
1507         HRESULT fieldset(LPCTSTR szAttrs=NULL)
1508         {
1509                 return GetOuter()->StartTag(ATL_HTML_TAG_FIELDSET, NULL, szAttrs);
1510         }
1511
1512         HRESULT fieldsetEnd()
1513         {
1514                 return GetOuter()->EndTag(ATL_HTML_TAG_FIELDSET);
1515         }
1516
1517         HRESULT legend(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1518         {
1519                 return GetOuter()->StartTag(ATL_HTML_TAG_LEGEND, szContent, szAttrs);
1520         }
1521
1522         HRESULT legendEnd()
1523         {
1524                 return GetOuter()->EndTag(ATL_HTML_TAG_LEGEND);
1525         }
1526
1527         HRESULT tbody(LPCTSTR szAttrs=NULL)
1528         {
1529                 return GetOuter()->StartTag(ATL_HTML_TAG_TBODY, NULL, szAttrs);
1530         }
1531
1532         HRESULT tbodyEnd()
1533         {
1534                 return GetOuter()->StartTag(ATL_HTML_TAG_TBODY);
1535         }
1536
1537         HRESULT tfoot(LPCTSTR szAttrs=NULL)
1538         {
1539                 return GetOuter()->StartTag(ATL_HTML_TAG_TFOOT, NULL, szAttrs);
1540         }
1541
1542         HRESULT tfootEnd()
1543         {
1544                 return GetOuter()->StartTag(ATL_HTML_TAG_TFOOT);
1545         }
1546
1547         HRESULT th(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1548         {
1549                 if (!m_tableState.m_bRowOpen)
1550                         GetOuter()->tr();
1551                 m_tableState.m_bDataOpen = true;
1552                 return GetOuter()->StartTag(ATL_HTML_TAG_TH, szContent, szAttrs);
1553         }
1554
1555         HRESULT thEnd()
1556         {
1557                 ATLASSUME(m_tableState.m_bDataOpen);
1558                 m_tableState.m_bDataOpen = false;
1559                 return GetOuter()->EndTag(ATL_HTML_TAG_TH);
1560         }
1561
1562         HRESULT title(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1563         {
1564                 return GetOuter()->StartTag(ATL_HTML_TAG_TITLE, szContent, szAttrs);
1565         }
1566
1567         HRESULT titleEnd()
1568         {
1569                 return GetOuter()->EndTag(ATL_HTML_TAG_TITLE);
1570         }
1571
1572         HRESULT tt(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1573         {
1574                 return GetOuter()->StartTag(ATL_HTML_TAG_TT, szContent, szAttrs);
1575         }
1576
1577         HRESULT ttEnd()
1578         {
1579                 return GetOuter()->EndTag(ATL_HTML_TAG_TT);
1580         }
1581
1582         // unfortunately, we can't use small since it is defined as char
1583         // in rpcndr.h!
1584         HRESULT _small(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1585         {
1586                 return GetOuter()->StartTag(ATL_HTML_TAG_SMALL, szContent, szAttrs);
1587         }
1588
1589         HRESULT _smallEnd()
1590         {
1591                 return GetOuter()->EndTag(ATL_HTML_TAG_SMALL);
1592         }
1593
1594         HRESULT span(LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1595         {
1596                 return GetOuter()->StartTag(ATL_HTML_TAG_SPAN, szContent, szAttrs);
1597         }
1598
1599         HRESULT spanEnd()
1600         {
1601                 return GetOuter()->EndTag(ATL_HTML_TAG_SPAN);
1602         }
1603
1604         HRESULT object(LPCTSTR szClassId, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1605         {
1606                 AtlHtmlAttrs Attrs;
1607                 Attrs.Set(szAttrs);
1608                 if (szClassId && *szClassId)
1609                         Attrs.Add(_T("classid"), szClassId);
1610                 return GetOuter()->StartTag(ATL_HTML_TAG_OBJECT, szContent, Attrs);
1611         }
1612
1613         HRESULT object(REFCLSID rclsid, LPCTSTR szContent=NULL, LPCTSTR szAttrs=NULL)
1614         {
1615                 USES_CONVERSION_EX;
1616                 OLECHAR szClsid[64];
1617                 CString strClassId;
1618                 int i = StringFromGUID2(rclsid, szClsid, 64);
1619                 if (!i)
1620                         return E_FAIL;
1621                 szClsid[i-2] = 0; // don't want curly braces
1622                 strClassId.Format(_T("clsid:%s"), OLE2T_EX_DEF(szClsid+1));
1623                 return object(strClassId, szContent, szAttrs);
1624         }
1625
1626         HRESULT objectEnd()
1627         {
1628                 return GetOuter()->EndTag(ATL_HTML_TAG_OBJECT);
1629         }
1630
1631         HRESULT param(LPCTSTR szName, LPCTSTR szValue, LPCTSTR szAttrs=NULL)
1632         {
1633                 ATLASSERT(szName && *szName);
1634
1635                 AtlHtmlAttrs Attrs;
1636                 Attrs.Set(szAttrs);
1637
1638                 Attrs.Add(_T("name"), szName);
1639                 if (szValue && *szValue)
1640                         Attrs.Add(_T("value"), szValue);
1641                 return GetOuter()->StartTag(ATL_HTML_TAG_PARAM, NULL, Attrs);
1642         }
1643
1644 private:
1645         CString m_strState;
1646         HTML_SCHEME *m_pScheme;
1647
1648         struct TableState
1649         {
1650                 TableState() : m_bRowOpen(false), m_bDataOpen(false)
1651                 {
1652
1653                 }
1654
1655                 void Clear()
1656                 {
1657                         m_bRowOpen = false;
1658                         m_bDataOpen = false;
1659                 }
1660
1661                 bool m_bRowOpen;
1662                 bool m_bDataOpen;
1663         };
1664
1665         ATL_HTML_FORM_METHOD m_nFormMethod;
1666
1667         TableState m_tableState;
1668         CSimpleStack<TableState> m_RowStack;
1669
1670         int m_nWidthPercent;
1671         int m_nHeightPercent;
1672 };
1673
1674 class CHtmlGen : public CHtmlGenBase<CHtmlGen>
1675 {
1676 public:
1677 };
1678
1679 } // namespace ATL
1680 #pragma pack(pop)
1681
1682 #endif // __ATLHTML_H__