//#ifndef UTILITIES_HPP_INCLUDED 
#include "StdAfx.h"                 // trying to resolve #include "utilities.hpp"
//#endif

#ifndef UTILITIES_HPP_INCLUDED 
    #error "You forgot to #include \"utilities.hpp\" in StdAfx.h"
#endif
#define UTILITIES_HPP_INCLUDED 

#include <Winsock2.h>
#pragma comment(lib, "Ws2_32.lib")

#pragma comment(lib, "version.lib")
#pragma comment(lib, "Wininet.lib")

//////////////////////////////////////////////////////////////////////////////////
//
//              Implementation part
//                                      UTILITIES
//
//
////////////////////////////////////////////////////////////////////////////////
critical_section_variable general_critical_section::m_cs;

////////////////////////////////////////////////////////////////////////////////
//
// CTextOfError_Formatter
//
CTextOfError_Formatter::CTextOfError_Formatter(const char _prfx[]/*=0*/) : prfx(_prfx)
{ 
    s << std::hex << std::boolalpha;; 
    if(prfx && *prfx)
        s << prfx << "<BR />";
}

CTextOfError_Formatter::CTextOfError_Formatter(const std::string& _prfx) : prfx(_prfx.c_str())
{ 
    s << std::hex << std::boolalpha;; 
    if(prfx && *prfx)
        s << prfx << "<BR />";
}

std::string CTextOfError_Formatter::getText(const char *er) 
{ 
    s << "<B>Runtime Error</B><BR /><B>Description: </B><DESCRIPTION>" << er << "</DESCRIPTION>";
    return s.str();
}

#if defined _MFC_VER
std::string CTextOfError_Formatter::getText(CException* e) 
{
    char  er[512];
    e->GetErrorMessage(er, sizeof er);
    s << "<B>MFC Error</B><BR /><B>Description: </B><DESCRIPTION>" << er << "</DESCRIPTION>";
    return s.str();
}
#endif

std::string CTextOfError_Formatter::getText(DWORD er) 
{ 
    s   << "<B>Last System Error=</B>0x" << er 
        << "<BR /><B>Description: </B><DESCRIPTION>" << textOfWin32Error(er) <<"</DESCRIPTION>";
    return s.str();
}

std::string CTextOfError_Formatter::getText(HRESULT hr) 
{
    s   << "<B>Type:</B> <TYPE>HRESULT</TYPE> = 0x" << (unsigned long) hr 
        << " <TYPE>";
    if     (hr==S_OK)       s << "Success OK</TYPE>";
    else if(hr==S_FALSE)    s << "General failure (success with FALSE return)</TYPE>";
    else 
    {
        s << (IS_ERROR(hr)? "Severe error.":"Success with code return") << " Code 0x" << SCODE_CODE(hr) 
            << "</TYPE><BR />";

        #define FACILITY_R_BIT  0x8000000
        if(bool bR = ((hr & FACILITY_R_BIT) !=0))
            s << "<NOTE>The value of this HRESULT is a message ID to display a string</NOTE><BR />";


        if(int fac= HRESULT_FACILITY(hr) >0)
        {
            fac =HRESULT_FACILITY(hr &(~(FACILITY_R_BIT|FACILITY_NT_BIT)));
            const char* pszFac ="Unknown or new type";
            switch(fac)
            {
            case FACILITY_NULL          :pszFac = "Null"                        ;break;
            case FACILITY_RPC           :pszFac = "RPC -- Remote Procedure Call";break;
            case FACILITY_DISPATCH      :pszFac = "DISPATCH"                    ;break;
            case FACILITY_STORAGE       :pszFac = "STORAGE"                     ;break;
            case FACILITY_ITF           :pszFac = "ITF - interface";
                //
                // NOTE: PSI AppStrg.dll makes up the 0x800-0x802 HRESULTs
                //
                switch(SCODE_CODE(hr))
                {
                case REGDB_E_CLASSNOTREG:
                    s << "<B>Description: </B><DESCRIPTION>Class is not registered</DESCRIPTION><BR />";
                    break;

                case 0x800:
                    s <<"<B>Source: </B><SOURCE>SessionObject</SOURCE><BR /><B>Description: </B>"
                        "<DESCRIPTION>Error of encrypting of SESSIONPARAM. B3000 Key Set or crypt.dll "
                        "might be missed or corrupted or SESSIONPARAM contains not valid data</DESCRIPTION>";
                    break;

                case 0x801:
                    s <<"<B>Source: </B><SOURCE>SessionObject</SOURCE><BR /><B>Description: </B>"
                        "<DESCRIPTION>Invalid key has been passed to APPSTRG's session object</DESCRIPTION>";
                    break;
                
                case 0x802:
                    s <<"<B>Source: </B><SOURCE>SessionObject</SOURCE><BR /><B>Description: </B>"
                        "<DESCRIPTION>Unable to decrypt session parameter (SessionID cookie is missing)</DESCRIPTION>";
                    break;
                }
                break;

            case FACILITY_WIN32         :pszFac = "WIN32";
                s << "<B>Description: </B><DESCRIPTION>" << textOfWin32Error(SCODE_CODE(hr)) << "</DESCRIPTION><BR />";
                break;

            case FACILITY_WINDOWS       :pszFac = "WINDOWS"                                     ;break;
            case FACILITY_SSPI          :pszFac = "SSPI -- Security Support Provider Interface" ;break;
            case FACILITY_CONTROL       :pszFac = "CONTROL";
                if(hr = HRESULT_CODE(CTL_E_PATHNOTFOUND))
                    s << "<B>Description: <B><DESCRIPTION>Path not found</DESCRIPTION><BR />";
                break;

            case FACILITY_CERT          :pszFac = "CERT -- certificate"                         ;break;
            case FACILITY_INTERNET      :pszFac = "INTERNET"                                    ;break;
            case FACILITY_MEDIASERVER   :pszFac = "MEDIASERVER"                                 ;break;
            case FACILITY_MSMQ          :pszFac = "MSMQ"                                        ;break;
            case FACILITY_SETUPAPI      :pszFac = "SETUPAPI"                                    ;break;
            case 16                     :pszFac = "SCARD"                                       ;break;
            case 17                     :pszFac = "MTS (id exist but not documented)"           ;break;
            case 109                    :pszFac = "VISUALCPP";                                  ;break;
            case 119                    :pszFac = "VDI (id exist but not documented)";          ;break;
            case 769                    :pszFac = "IC (id exist but not documented)";           ;break;
            case 2047                   :pszFac = "BACKUP";                                     ;break;
            case 2048                   :pszFac = "EDB";                                        ;break;
            case 2304                   :pszFac = "MDSI";                                       ;break;
            }

            s   <<  "<B>Source (facility=0x" << fac << (0 != (hr & FACILITY_NT_BIT)? ", mapped NT status value":"")
                <<  "):</B> <SOURCE>" << pszFac << " facility</SOURCE>"
                    "<BR /><B>Possible COM interpretation of the result: </B><BR />";
            textOfCOMError(_com_error(hr));
        }
    }
    return s.str();
}

std::string CTextOfError_Formatter::getText(const _com_error& er) 
{
    s << "<B>Type</B>: <TYPE>COM error</TYPE><BR />";
    textOfCOMError(er);
    return s.str();
}

std::string CTextOfError_Formatter::getText(const URL& url) 
{ 
    s << "<B>URL Source: </B><SOURCE TYPE=\"URL\">" << (std::string)url << "</SOURCE>";
    return s.str();
}

std::string CTextOfError_Formatter::getText(const std::exception& e) 
{ 
    s   << "<B>Source: </B><SOURCE>C++ standard std::exception</SOURCE></BR /><B>Description: </B><DESCRIPTION>"
        << e.what() << " </DESCRIPTION>";
    return s.str();
}

std::string CTextOfError_Formatter::textOfWin32Error(DWORD error_code/*=-1*/)
{
    if(error_code ==-1)
        error_code = ::GetLastError();
    char  *pBuf=0;
    DWORD dwSym = ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER,
                    0,
                    error_code,
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                    (LPTSTR) &pBuf,0, 0);
    if(pBuf ==0)
        return "Unknown System error";

    std::string ret(pBuf);
    ::LocalFree(HLOCAL(pBuf));
    return trim(ret);
}

void CTextOfError_Formatter::textOfCOMError(const _com_error& er) throw()
{
    try
    {
        const char  *pszMsg = er.ErrorMessage();
        _bstr_t bstrDsc = er.Description();
        _bstr_t bstrSrc = er.Source();
        char   *pszDsc = (char*) bstrDsc;
        char   *pszSrc = (char*) bstrSrc;
        if(pszMsg !=0 && pszMsg[0] !=0)
            s << "<B>Error Message: </B><DESCRIPTION>" << pszMsg << "</DESCRIPTION><BR />";

        if(pszDsc !=0 && pszDsc[0] !=0)
            s << "<B>Description: </B><DESCRIPTION>" << pszDsc << "</DESCRIPTION>";

        if(pszSrc !=0 && pszSrc[0] !=0)
            s << "<BR /><B>Source: </B><SOURCE>"    << pszSrc << "</SOURCE>";
    }
    catch(...)
    {
    }
}

//////////////////////////////////////////////////////////////////////////////////
// CRuntime_error
//
std::string CRuntime_error::extract(const char* sectionname) const
{
    std::string strResult;
    std::string open_tag("<");      open_tag.append(sectionname).append(">");   // opening tag
    std::string close_tag("</");    close_tag.append(sectionname).append(">");  // closing tag

    for(size_t pfb=0 , pfe=0 ; (pfb=_strText.find(open_tag,pfe)) !=std::string::npos ; pfe+=close_tag.length())
    {
        if(strResult.length() !=0)
            strResult +="\n<BR />\n";
        pfb +=open_tag.length();
        if((pfe =_strText.find(close_tag, pfb)) ==std::string::npos)
        {
            strResult.append(_strText, pfb, std::string::npos);
            break;
        }
        strResult.append(_strText, pfb, pfe-pfb);
    }
    return strResult;
}

std::string CRuntime_error::text() const    // removes tags
{
    std::string strResult = _strText;
    return replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(strResult, 
            "<BR />", "\n"), 
            "<gys:ERROR xmlns:gys=\"http://mywebpages.comcast.net/GeorgeSalnikov\">"), "</gys:ERROR>"), 
            "<DESCRIPTION>"), "</DESCRIPTION>"),
            "<SOURCE>"), "</SOURCE>"),
            "<NOTE>"), "</NOTE>"),
            "<B>"), "</B>"),
            "<I>"), "</I>");
}
    
std::string CRuntime_error::getContentAsHtml(const TraceStream* pts) const
{
    std::string strDesc = extract("DESCRIPTION");
    if(strDesc.empty())
        strDesc = "No description's been given. Click here for more information";

    std::string res; 
    res .append("<DIV STYLE='cursor:hand;font-size:larger;text-align:center;font-weight:bold' TITLE='Click here to show/hide the error details' "
                    "ONCLICK=\"var s=nextSibling.style;if(s.display!='block')s.display='block';else s.display='none';\">")
        .append(strDesc)
        .append("</DIV>"
                "<DIV STYLE=\"display:none;\"><HR />")
        .append(_strText);

    if(pts!=0)
    {
        std::string sTraceNote=pts->str();
        if(!sTraceNote.empty())
            res .append("<PRE STYLE=\"margin-left:1cm;padding:4mm;margin-right:1cm;background-color:menu;\"><B>Trace Notes:</B><BR />")
                .append(sTraceNote)
                .append("</PRE>");
    }
    res.append("</DIV>");
    return res;
}

std::string CRuntime_error::getContentAsHtml(const TraceStream& ts) const 
{ 
    return getContentAsHtml(&ts); 
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// CSeExceptionsTranslator
//
void __cdecl CSeExceptionsTranslator::SeTranslator(UINT nSeCode, _EXCEPTION_POINTERS* pExcPointers) throw(CRuntime_error)
{
    const char  *pszName ="???";
    switch(nSeCode)    
    {
    case EXCEPTION_ACCESS_VIOLATION:            pszName="access violation";         break;
    case EXCEPTION_DATATYPE_MISALIGNMENT:       pszName="datatype misalignment";    break;
    case EXCEPTION_BREAKPOINT:
#if 0   // defined(_DEBUG)
        se_translator_processor(nSeCode, pExcPointers); 
#endif
        pszName="breakpoint";
        break;

    case EXCEPTION_SINGLE_STEP: 
#if 0   // defined(_DEBUG)
        se_translator_processor(nSeCode, pExcPointers); 
#endif
        pszName="single step";
        break;

    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:       pszName="array bounds exceeded";    break;
    case EXCEPTION_FLT_DENORMAL_OPERAND:        pszName="flt denormal operand";     break;
    case EXCEPTION_FLT_DIVIDE_BY_ZERO:          pszName="flt divide by zero";       break;      
    case EXCEPTION_FLT_INEXACT_RESULT:          pszName="flt inexact result";       break;
    case EXCEPTION_FLT_INVALID_OPERATION:       pszName="flt invalid operation";    break;
    case EXCEPTION_FLT_OVERFLOW:                pszName="flt overflow";             break;
    case EXCEPTION_FLT_STACK_CHECK:             pszName="flt stack check";          break;
    case EXCEPTION_FLT_UNDERFLOW:               pszName="flt underflow";            break;
    case EXCEPTION_INT_DIVIDE_BY_ZERO:          pszName="int divide by zero";       break;
    case EXCEPTION_INT_OVERFLOW:                pszName="int overflow";             break;
    case EXCEPTION_PRIV_INSTRUCTION:            pszName="privilege instruction";    break;
    case EXCEPTION_IN_PAGE_ERROR:               pszName="in page error";            break;
    case EXCEPTION_ILLEGAL_INSTRUCTION:         pszName="illegal instruction";      break;
    case EXCEPTION_NONCONTINUABLE_EXCEPTION:    pszName="noncontinuable exception"; break;
    case EXCEPTION_STACK_OVERFLOW:              pszName="stack overflow";           break;
    case EXCEPTION_INVALID_DISPOSITION:         pszName="invalid disposition";      break;
    case EXCEPTION_GUARD_PAGE:                  pszName="guard page";               break;
    case EXCEPTION_INVALID_HANDLE:              pszName="invalid handle";           break;
    }

    std::ostringstream str;
    str <<  "<gys:ERROR xmlns:gys=\"http://mywebpages.comcast.net/yuriysalnikov\">"
            "<B>Source: </B><SOURCE>Unknown</SOURCE><BR /><B>Description: </B>"
            "<DESCRIPTION>SE Exception 0x" << std::hex << nSeCode << " (" 
        <<  pszName << ") at address 0x" 
        <<  pExcPointers->ExceptionRecord->ExceptionAddress
        <<  "</DESCRIPTION></gys:ERROR>";

    throw CRuntime_error(str.str());
}

void CSeExceptionsTranslator::se_translator_processor(unsigned int nSeCode, struct _EXCEPTION_POINTERS* pExcPointers)
{
    static _se_translator_function pOldSeFn=0;
    if(pOldSeFn ==0 && nSeCode ==1)
        pOldSeFn = _set_se_translator(SeTranslator);
    else if(pExcPointers !=0 && pOldSeFn !=0)
        pOldSeFn(nSeCode, pExcPointers);    // execute original se chain (aparantly on debugging interrupts)
    else if(nSeCode ==0 && pOldSeFn !=0)
    {
        _set_se_translator(pOldSeFn);       // restore old chain
        pOldSeFn =0;
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// dump
//
dump::dump(const void* pb, const void *pe, const int line_len, const bool bAscii) :
        terminator_(0) , pbeg_(reinterpret_cast<const unsigned char*>(pb)) , 
        pend_(reinterpret_cast<const unsigned char*>(pe)) , 
        line_len_(line_len) , bAscii_(bAscii) {;}
dump::dump(const void* p, const int len, const int line_len, const bool bAscii) :
        terminator_(0) , pbeg_(reinterpret_cast<const unsigned char*>(p)) , 
        pend_(len >=0 ? reinterpret_cast<const unsigned char*>(p)+len:0) , 
        line_len_(line_len) , bAscii_(bAscii) {;}
dump::dump(const char* p, const int line_len, const bool bAscii) :
        terminator_(0) , pbeg_(reinterpret_cast<const unsigned char*>(p)) , pend_(0) , 
        line_len_(line_len) , bAscii_(bAscii) {;}
dump::dump(const unsigned char* p, const int line_len, const bool bAscii) :
        terminator_(0) , pbeg_(reinterpret_cast<const unsigned char*>(p)) , pend_(0) , 
        line_len_(line_len) , bAscii_(bAscii) {;}
dump::dump(const std::string& s, const int line_len, const bool bAscii) :
        terminator_(0) , pbeg_(reinterpret_cast<const unsigned char*>(s.c_str())) , pend_(0) , 
        line_len_(line_len) , bAscii_(bAscii) {;}
    
std::ostream& dump::operator() (std::ostream& s)
{
    using namespace std;
    ios_base::fmtflags original_flags = s.flags(ios_base::hex);
    for(const unsigned char *pcur_ = pbeg_ ; doit(pcur_) ; )
    {
        string ascii;
        s << uppercase << setfill('0') << setw(8) << (void *) (pcur_) << ":";
        for(int j = 0 ; j <line_len_ && doit(pcur_) ; ++j , ++pcur_)
        {
            s << ' ' << setw(2) << (*pcur_ & 0xff);
            if(bAscii_)
                ascii += *pcur_;
        }
        if(bAscii_)
        {
            make_printable(ascii, '?');
            if((j=(line_len_ -j)*3) >0)
                ascii.insert(size_t(0), j, ' ');
            s << nouppercase << "   " << ascii;
        }
        s << '\n';
    }
    s.flags(original_flags);
    return s;
}

std::ostream& dump::dump_hex(std::ostream& os, const unsigned char* b, int len)
{
    for(int j = 0 ; j <len ; ++j)
        os << (j==0?" ":"") << std::setw(2) << b[j];
    return os;
}
    
bool dump::doit(const unsigned char* pcur_) const 
{
    return pend_ ==0? (*pcur_ !=terminator_) : (pcur_ <= pend_);
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// OutputDebug
//
bool OutputDebug::OutputDebugString(const char *pszBuf) 
{
    if(disabled())
        return false;
    
    if(pszBuf)
    {
        ::OutputDebugString(pszBuf);
#if defined(_DEBUG)
        OutputDebugStringToFileLog(pszBuf, ::strlen(pszBuf));
#endif
    }
    return true;
}

bool OutputDebug::OutputDebugString(const std::string& strBuf) 
{
    if(disabled())
        return false;
    if(strBuf.length() >0)
    {
        ::OutputDebugString(strBuf.c_str());
#if defined(_DEBUG)
        OutputDebugStringToFileLog(strBuf.c_str(), strBuf.length());
#endif
    }
    return true;
}
bool& OutputDebug::disabled() 
{
    // the C++ language guarantees to initialize a static variable once on the first use of it
    #if defined(_DEBUG)
        static bool bDisabled= false;
    #else
        //
        // allow only 6 hours maximum of continuing debugging in production version
        //
        static CTimer timer;
        static bool bDisabled= true;
        if(bDisabled)
            timer.start();
        else if(timer() > (6L *60L* 1000L))
            bDisabled = true;

    #endif
    return bDisabled;
}
std::string OutputDebug::getHtmlFormOfDisabled(std::string strName, std::string strInclude)
{
    return "<INPUT ID=idDebugging TYPE=CHECKBOX VALUE='checked' NAME="+strName+(disabled()?" CHECKED ":" ")+
            strInclude + "><LABEL FOR=idDebugging>Disable Debug Output. You have to have a local or remote access "
                         "to the computer to see the Debug output</LABEL>";
}

bool OutputDebug::OutputDebugStringToFileLog(const char  *pszBuf, int dwLen, const char* pszFileName)
{
    if(pszBuf ==0 || dwLen <=0)
        return true;
        
    HANDLE hFile = ::CreateFile(pszFileName, GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_DELETE, 
                            0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED, 0);
    if(hFile == INVALID_HANDLE_VALUE)
        return false;
    OVERLAPPED overlapped = { 0, 0, ::GetFileSize(hFile,NULL), 0, 0 };
    DWORD dwSize = 0;
    ::WriteFile(hFile, pszBuf, dwLen, &dwSize, &overlapped);
    ::CloseHandle(hFile);
    return true;
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// OutputDebugStream
//
int OutputDebugStream::buf::output_buffer()
{
    int n = pptr() - pbase();               // how many symbols to write out
    if(n >0)    // && !OutputDebugStream::disabled())
    {
        _buffer[n] = _buffer[n+1] = '\0';       // we reserved enough space for two more symbols
        if(_buffer[n-1] != '\n') 
            _buffer[n] = '\n';
        OutputDebug::OutputDebugString(static_cast<const char*>(_buffer));
    }
    pbump(-n);
    return n;
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// TraceStream
//
TraceStream::TraceStream(const char* p) : std::basic_ostream<char>(_buf=make_buf()) 
{ 
    if(_buf!=0)
        *this << CTimer::strCurrentTime("vvvvvvvvvvvvv Begin trace <B>%X</B> ") << (p==0?"":p) 
                << ". Thread " << ::GetCurrentThreadId() << " vvvvvvvvvvvvvvv\n";
}
TraceStream::~TraceStream() 
{ 
    if(_buf!=0)
    {
        *this << CTimer::strCurrentTime("^^^^^^^^^^^^^ End trace <B>%X</B> ^^^^^^^^^^^^^\n\n");
        OutputDebug::OutputDebugString(_buf->str());
        delete _buf; 
    }
}
std::string TraceStream::getHtmlFormOfNumberOfTracingHistory(const std::string& strName, const std::string& strInclude)
{
    return "<INPUT ID=idTracing TYPE=INPUT VALUE='"+int_to_string(size_of_history_list())+"' NAME="+strName+
            " " +strInclude +"><LABEL FOR=idTracing>Number of lines of tracing history</LABEL>";
}
int TraceStream::size_of_history_list(int n)
{
    if(n >=0)
        get_History_container().resize(size_t(n));
    return (int) get_History_container().max_size();
}

TraceStream::buf::~buf()
{ 
    std::string s =str();
    if(!OutputDebug::disabled())
        OutputDebug::OutputDebugString(s);

    if(size_of_history_list() >0)
        TraceStream::put_into_history_list(s); 
}

/*history_container& TraceStream::get_History_container() 
{
    static history_container hs;
    return hs;
}*/
/////////////////////////////////////////////////////////////////////////////////////////
//
// EventStream
//
int EventStream::buf::output_buffer()
{
    int n = pptr() - pbase();               // how many symbols to write out
    if(n >0 && _h)
    {
        _buffer[n] = _buffer[n+1] = '\0';       // we reserved enough space for two more symbols
        const char* rgsz[] = { _buffer };
        ::ReportEvent(_h, _type,0,0,0,1,0,rgsz,0);
    }

    //
    // also copy out the event to the debug window and into history list
    //
    bool bOutputDebug=!OutputDebug::disabled();
    bool bTrace=TraceStream::size_of_history_list() >0?true:false;
    if(bOutputDebug || bTrace)
    {
        if(_buffer[n-1] == '\n') 
            _buffer[n-1] = 0;

        std::string s(_pName);
        s.append(": ******** Event type ").append(EventTypeName(_type)).append(CTimer::strCurrentTime("%X\n"))
                .append(_buffer).append(" *******\n");
        if(bOutputDebug)
            OutputDebug::OutputDebugString(s);

        if(bTrace)
            TraceStream::put_into_history_list(s);
    }

    pbump(-n);  // bump down the buffer to 0-length resetting one
    return n;
}
const char* EventStream::EventTypeName(long type, const char* const* names)
{
    static const char * const defaultNames[] = 
    { "OK", "Error", "Warning", "Inform", "Audit OK", "Audit fail", "UNKNOWN"}; 
    if(names ==0) names = defaultNames;
    switch(type)
    {
    case EVENTLOG_SUCCESS:          return names[0];
    case EVENTLOG_ERROR_TYPE:       return names[1];
    case EVENTLOG_WARNING_TYPE:     return names[2];
    case EVENTLOG_INFORMATION_TYPE: return names[3];
    case EVENTLOG_AUDIT_SUCCESS:    return names[4];
    case EVENTLOG_AUDIT_FAILURE:    return names[5];
    default:                        return names[6];
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// URL
//
bool URL::crack()
{
    //
    // I dont check if there has been any change to THIS string since last cracking and do the crack
    // again. If InternetCrackUrl will prove to be unefficient it's possible to keep a copy last 
    // cracked string and make a comparison with THIS string prior to cracking
    //
    trim(*this);
    _urlComponents.dwStructSize = sizeof _urlComponents;

    _urlComponents.lpszScheme = 0;
    _urlComponents.lpszHostName = 0;
    _urlComponents.lpszUserName = 0;
    _urlComponents.lpszPassword = 0;
    _urlComponents.lpszUrlPath = 0;
    _urlComponents.lpszExtraInfo = 0;

    _urlComponents.nPort = 0;               // preset port to invalid value
    _urlComponents.dwSchemeLength = 1;      // these lines set which components should be cracked out 
    _urlComponents.dwHostNameLength = 1;
    _urlComponents.dwUserNameLength = 1;
    _urlComponents.dwPasswordLength = 1;
    _urlComponents.dwUrlPathLength = 1;
    _urlComponents.dwExtraInfoLength = 1;

    return ::InternetCrackUrl(data(), length(), 0, &_urlComponents) !=0? true : false;
//  if(!InternetCrackUrl(data(), length(), 0, &_urlComponents) !=0) dothrow();
//      return true;
}

std::string URL::escape(const std::string& s)
{
    std::ostringstream str;
    str << std::hex << std::uppercase << std::setfill('0');
    for(int i = 0 ; i < s.length() ; ++i)
    {
        static const std::string strCharSet="0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                            "'=:;@$-_.+!*()/";
        if(strCharSet.find(s[i]) ==std::string::npos)
            str << "%" << std::setw(2) << (s[i] & 0xff);
        else
            str << s[i];
    }
    return str.str();
}
std::string URL::canonicalize(const std::string& s, DWORD flags)
{
    DWORD dwSize = s.length() + (flags&ICU_DECODE? 0 : s.length()/4) ;
    std::string res(dwSize, 0);
    if(!::InternetCanonicalizeUrl(s.c_str(), const_cast<char*>(res.c_str()), &dwSize, flags))
    {
        if(::GetLastError() != ERROR_INSUFFICIENT_BUFFER)
            return std::string();
        res.resize(dwSize);
        if(!::InternetCanonicalizeUrl(s.c_str(), const_cast<char*>(res.c_str()), &dwSize, flags))
            return std::string();
    }
    res.resize(dwSize);
    return res;
}

std::string URL::combine(std::string sUrl_1, std::string sUrl_2, DWORD dwFlags) throw(CRuntime_error)
{
    std::string sFullUrl(sUrl_1.length() + sUrl_2.length() + 128, 0); 
    DWORD lnFullUrl = sFullUrl.length();
    if(!::InternetCombineUrl(sUrl_1.c_str(), sUrl_2.c_str(), const_cast<char*>(sFullUrl.data()), &lnFullUrl, dwFlags))
    {
        DWORD err=::GetLastError();
        if(err !=ERROR_INSUFFICIENT_BUFFER)
            throw CRuntime_error("<B>Note: </B><NOTE>InternetCombineUrl failed</NOTE>", err);
        sFullUrl.resize(lnFullUrl);
        if(!::InternetCombineUrl(sUrl_1.c_str(), sUrl_2.c_str(), const_cast<char*>(sFullUrl.data()), &lnFullUrl, dwFlags))
            throw CRuntime_error("<B>Note: </B><NOTE>InternetCombineUrl failed</NOTE>", ::GetLastError());
    }
    sFullUrl.resize(lnFullUrl);
    return sFullUrl;
}

std::string URL::getDomainFromHost(const std::string& strHost, int nLevel) throw(CRuntime_error)
{
    for(int pos = -1 ; (pos = strHost.rfind('.', pos)) >0 && (--nLevel) >0 ; --pos)
        ;
    if(pos == npos)
        throw CRuntime_error(std::string("<B>Host name: </B><NOTES>") +strHost+"</NOTES>", "Invalid domain name for host");
    return strHost.substr(pos);
}
int URL::getPortNumber()    
{
    if(!crack())
        return 0;
    return _urlComponents.nPort; 
}
bool URL::putPortNumber(int port)   
{ 
    _urlComponents.nPort = port; 
    return createUrl(length()+10); 
}

std::string URL::getString(LPTSTR* buf, DWORD* len) 
{ 
    return !crack() || *len ==0 ? std::string() : std::string(*buf, *len); 
}
bool URL::putString(std::string s, LPTSTR* buf, DWORD* len) 
{
    if(!crack())            // before adding info in url crack it down to the pieces ??
        return false;

    *len = s.length();
    *buf = const_cast<char*>(s.data());
    return createUrl(length() + s.length() +1);
}
bool URL::createUrl(DWORD dwSize)
{
    std::string res(dwSize, 0);
    if(!::InternetCreateUrl(&_urlComponents, 0, const_cast<char*>(res.data()), &dwSize))
    {
        if(::GetLastError() !=ERROR_INSUFFICIENT_BUFFER)
            return false;       // dothrow();
        res.resize(dwSize, 0);
        if(!::InternetCreateUrl(&_urlComponents, 0, const_cast<char*>(res.data()), &dwSize))
            return false;       // dothrow
    }
    res.resize(dwSize);
    assign(res);
    return crack();
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// clsid
//
clsid& clsid::operator= (const clsid& n)
{
    ::memcpy(static_cast<CLSID*>(this), static_cast<const CLSID*>(&n), sizeof CLSID);
    _hr = n._hr;
    _sname = n._sname;
    return *this;
}
clsid& clsid::operator= (const char  *name)
{
    _hr = CO_E_CLASSSTRING;         // pre-reset it to wrong state
    ::memset(static_cast<CLSID*>(this), 0, sizeof CLSID);
    if(name==0 || name[0] !='{')
        _sname.erase() , *this;
    if(name[0]==0)      // no name given -> create_new GUID
        return create_new();
    _sname = name;
    _bstr_t n(name);
    _hr = ::CLSIDFromString((wchar_t*)n, static_cast<CLSID*>(this));
    return *this;
}

clsid& clsid::operator= (const CLSID& id) throw(CRuntime_error)
{
    BSTR olestr = ::SysAllocStringLen(0, 39);
    if(olestr == 0)
        throw CRuntime_error("Source: <SOURCE>clsid</SOURCE>", "No memory");
    _hr = S_OK;
    ::memcpy(static_cast<CLSID*>(this), &id, sizeof CLSID);
    ::StringFromGUID2(static_cast<GUID&>(*this), olestr, 39);
    _sname = _bstr_t(olestr, false).operator const char  * ();
    return *this;
}

clsid& clsid::create_new()
{
    GUID guid;
    ::memset(&guid, 0, sizeof GUID);
    ::CoCreateGuid(&guid);
    return operator=(guid);
}
clsid& clsid::reset()
{ 
     _hr = S_OK;
     _sname ="{00000000-0000-0000-0000-000000000000}";
    ::memset(static_cast<CLSID*>(this),0,sizeof CLSID); 
    return *this;
}

bool clsid::valid(const std::string& n)
{
    return  n.length() ==38  
        &&  n[0]=='{' && n[37]=='}'  
        &&  n[9]=='-' && n[14] =='-' && n[19]=='-' && n[24]=='-' 
        &&  n.find_first_not_of("0123456789ABCDEFabcdef",  1, 8) !=n.npos 
        &&  n.find_first_not_of("0123456789ABCDEFabcdef", 10, 4) !=n.npos 
        &&  n.find_first_not_of("0123456789ABCDEFabcdef", 15, 4) !=n.npos 
        &&  n.find_first_not_of("0123456789ABCDEFabcdef", 20, 4) !=n.npos 
        &&  n.find_first_not_of("0123456789ABCDEFabcdef", 25, 8) !=n.npos;
}

std::ostream& clsid::getInformationOnCOMAsHtml(std::ostream& os, bool bShowInfoOnFile) const throw(CRuntime_error)
{
//  static const char bol[] = "<TR><TD ALIGN=right>", del[] = "</TD><TD><NOBR>", eol[] = "</NOBR></TD></TR>";
    RegistryKey reg (HKEY_CLASSES_ROOT, ("AppID\\"+_sname).c_str(), KEY_READ);  //KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS);
    RegistryKey reg2(HKEY_CLASSES_ROOT, ("CLSID\\"+_sname).c_str(), KEY_READ);  //KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS);

    os<<"<TABLE STYLE='BORDER:none;MARGINS:0;PADDING:0' CELLSPACING=0 COLS=1>"
        "<THEAD><TR><TH>" << _sname << "</TH></TR></THEAD>";

    if(!reg.Valid() && !reg2.Valid())
        return os << "<TR><TD>COM " << _sname << " is not registered</TD></TR></TABLE>";

    if(reg.Valid())
        reg.getInformationAsHtml(os << "<TR><TD>", "<FONT FACE=WINGDINGS>1</FONT> HKEY_CLASSES_ROOT\\") << "</TD></TR>";

    if(reg2.Valid())
    {
        reg2.getInformationAsHtml(os << "<TR><TD>", "<FONT FACE=WINGDINGS>1</FONT> HKEY_CLASSES_ROOT\\") << "</TD></TR>";
        if(bShowInfoOnFile)
        {
            std::string server;
            if((server=RegistryKey::GetStringValue(HKEY_CLASSES_ROOT, "CLSID\\"+_sname+"\\LocalServer32")).empty())
                if((server=RegistryKey::GetStringValue(HKEY_CLASSES_ROOT, "CLSID\\"+_sname+"\\InprocServer32")).empty())
                    if((server=RegistryKey::GetStringValue(HKEY_CLASSES_ROOT, "CLSID\\"+_sname+"\\LocalServer")).empty())
                        server=RegistryKey::GetStringValue(HKEY_CLASSES_ROOT, "CLSID\\"+_sname+"\\InprocServer");

            os << "<THEAD><TR><TH>Information on COM server</TH></TR></THEAD>";
            if(server.empty())
                os << "<TR><TD>The COM object is not local or inproc server</TD></TR>";
            else
            {   
                FileInformation(server) .getFileInformationAsHtml(os<<"<TR><TD ALIGN=CENTER>") << "</TD></TR>"; 
                FileVersion(server)     .getFileVersionAsHtml    (os<<"<TR><TD ALIGN=CENTER>") << "</TD></TR>";
            }
        }
    }
    os << "</TABLE>";
    return os;
}


/////////////////////////////////////////////////////////////////////////////////////////
//
// progid
//
progid::progid(const char *n1, const char* n2, ...)     // multiple attempts to init
{ 
    va_list args;
    va_start(args, n1);
    for(const char *n = n1 ; n !=0 && n[0] !=0 ; n = va_arg(args, const char*))
        if(init(n))
            break;
    va_end(args);
}
progid& progid::operator= (const progid& n)
{
    ::memcpy(static_cast<CLSID*>(this), static_cast<const CLSID*>(&n), sizeof CLSID);
//      _hr = n._hr;
    _sname = n._sname;
    _bRegistered = n._bRegistered;
    return *this;
}
progid& progid::operator= (const CLSID& id) throw(CRuntime_error)
{
    reset();
    BSTR bstrID;
    if(::ProgIDFromCLSID(id, &bstrID) ==S_OK)
    {
        _sname = _bstr_t(bstrID, false).operator const char  * ();
        ::memcpy(static_cast<CLSID*>(this), &id, sizeof CLSID);
        _bRegistered = true;
    }
    return *this;
}

progid& progid::create_new()
{
    GUID guid;
    ::memset(&guid, 0, sizeof GUID);
    ::CoCreateGuid(&guid);
    return operator=(guid);
}
progid& progid::reset()
{ 
//      _hr = CO_E_CLASSSTRING;         // pre-reset it to wrong state
     _sname.erase();
    ::memset(static_cast<CLSID*>(this),0,sizeof CLSID); 
    _bRegistered =false;
    return *this;
}
bool progid::valid(const std::string& n)
{ 
    return n.length() !=0 && n.length() <=39 && !::isdigit(n[0]) &&
        n.find_first_not_of(".0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")!=n.npos;
}

bool progid::init(const char *name)
{
    reset();
    if(name==0 || name[0]==0)
        return false;

    _sname = name;
    std::string strCLSID;
    if(clsid::valid(_sname))
        strCLSID = _sname;
    else
    {
        RegistryKey reg(HKEY_LOCAL_MACHINE, ("SOFTWARE\\Classes\\"+_sname+"\\CLSID").c_str(), KEY_QUERY_VALUE);
        if(!reg.Valid())
            return false;
        strCLSID = reg.GetStringValue("");
    }
    clsid cls(strCLSID.c_str());
    if(!cls.valid())
        return false;

    ::memcpy(static_cast<CLSID*>(this), &cls, sizeof CLSID);
    return _bRegistered = true;
}

std::ostream& progid::getInformationOnCOMAsHtml(std::ostream& os, bool bShowInfoOnFile) const
{
    os<<"<TABLE STYLE='BORDER:none;MARGINS:0;PADDING:0' CELLSPACING=0 COLS=1>"
        "<THEAD><TR><TH>" << _sname << "</TH></TR></THEAD>";    
    if(!registered())
        return os << "<TR><TD>COM object is not registered: " 
            << RegistryKey(HKEY_LOCAL_MACHINE, ("SOFTWARE\\Classes\\"+_sname+"\\CLSID").c_str(), KEY_QUERY_VALUE).LastError()
            << "</TD></TR></TABLE>";

    RegistryKey reg(HKEY_LOCAL_MACHINE, ("SOFTWARE\\Classes\\"+_sname).c_str(), KEY_READ);
    if(reg.Valid())
        reg.getInformationAsHtml(os << "<TR><TD>", "<FONT FACE=WINGDINGS>1</FONT> HKEY_LOCAL_MACHINE\\") << "</TD></TR>";
    else
        os << "<TR><TD>Error of openning HKEY_LOCAL_MACHINE\\SOFTWARE\\Classes\\" << _sname << ". " << reg.LastError() << "</TD></TR>";
    return clsid(*this).getInformationOnCOMAsHtml(os<<"<TR><TD ALIGN=CENTER>", bShowInfoOnFile) << "</TD></TR></TABLE>";
}


/////////////////////////////////////////////////////////////////////////////////////////
//
// HTML
//
std::string HTML::escape(const std::string& s)
{
    std::ostringstream str;
    //str << std::hex << std::uppercase << std::setfill('0');
    for(int i = 0 ; i < s.length() ; ++i)
    {
        static const std::string strCharSet= "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$-_.+!*'()/";
        if(strCharSet.find(s[i]) ==std::string::npos)
            str << "&#" << /*std::setw(2) << */(s[i] & 0xff) <<";";
        else
            str << s[i];
    }
    return str.str();
}

std::string HTML::str()             // closes BODY and HTML if they are not there
{
    static const char  BODY_tag [] = "<BODY>";
    static const char  HTML_tag [] = "<HTML>";
    std::string r = static_cast<std::ostringstream&>(*this).str();
    if(std::find_first_of(r.begin(), r.end(),BODY_tag,BODY_tag+lengthof(BODY_tag),
                    char_less_than_ignore_case::compare_symbols) !=r.end())
        r +="</BODY>";
    if(std::find_first_of(r.begin(), r.end(), HTML_tag, HTML_tag+lengthof(HTML_tag),
                        char_less_than_ignore_case::compare_symbols) !=r.end())
        r +="</HTML>";
    return r;
}

//
// convert 'this' content into invisile SPAN with 'id'; the content will popup in modal HTML browser
//
std::string HTML::makeModalDialogSPAN(std::string id)
{
    return "<SPAN ID='"+ id + "' STYLE='display:none'>"
        +   strSTYLE()
        +   static_cast<std::ostringstream&>(*this).str() 
        +   "</SPAN>"
            "<SCRIPT><!--\n"
            "window.showModalDialog('about:'+escape('<HTML><TITLE>Mainframe logon error</TITLE><BODY><DIV>'+__error.innerHTML+'</DIV /></BODY></HTML>'), '','dialogWidth:500px;status:no;scrollbars:yes,scroll:yes;help:no;resizable:yes;');\n"
            "//--></SCRIPT>"
            ;
}
void HTML::Init(const std::string& style, const std::string& script)
{
    if(!_strTitle.empty() || !style.empty() || !script.empty())
        *this << strHTMLBegin() << style << script << "<TITLE>" +_strTitle + "</TITLE></HEAD><BODY>";
}

std::string HTML::strRedirect(URL& url)
{
    return "top.location.href='" + static_cast<std::string&>(url) + "';";
}
std::string HTML::strHTMLBegin()
{
    static const std::string r("\r\n\r\n<HTML><HEAD><META HTTP-EQUIV=\"Expires\" CONTENT=\"-1\"></META>");
    return r;
}
std::string HTML::strHTMLEnd()
{
    static const std::string r("</BODY></HTML>");
    return r;
}
std::string HTML::strHTMLPasswordSubmitButtons(std::string name)
{
    return  "<INPUT TYPE=PASSWORD VALUE='' NAME=" + name + " ID=idPassword>"
            "<LABEL FOR=idPassword>Password to submit the changes</LABEL>"
            "<BR /><INPUT TYPE=SUBMIT> <INPUT TYPE=RESET>";
}
HTML& HTML::FloatingAdvertisement(HTML& s, const char* content, const char* title)
{
    s   <<  "<DIV STYLE='text-align:right;border:\"1mm ridge\";position:absolute;"
//                          "top:expression(document.body.scrollTop+document.body.clientHeight-offsetHeight);"
                        "top:expression(document.body.scrollTop+offsetHeight+document.body.clientTop-offsetHeight);"
                        "left:expression(document.body.scrollLeft+document.body.clientWidth-offsetWidth);'"
                " ONMOUSEOVER='firstChild.style.display=\"none\";lastChild.style.display=\"block\";'"
                " ONMOUSEOUT='firstChild.style.display=\"block\";lastChild.style.display=\"none\";'>"
            "<DIV STYLE='font-size:larger;font-weight:bolder;color:maroon;'>"
        <<  title
        <<  "</DIV><DIV STYLE='display:\"none\";background-color:\"floralwhite\";'> "
        <<  content
        <<  "</DIV></DIV>";
    return s;
}
std::string HTML::strAHREF(const std::string& href, const std::string& label)
{
    return "<A HREF='" + href+"'>"+(label.empty()? href:label) + "</A>";
}

const std::string& HTML::strSTYLE()
{
    static const std::string r(
        "<STYLE><!--\r\n"
        "BODY{BACKGROUND-COLOR:floralwhite;PADDING:5mm;}"
        "TABLE{BACKGROUND-COLOR:wheat;MARGIN:2mm;BORDER:outset;}"
        "TD{PADDING-LEFT:3mm;PADDING-RIGHT:3mm;}"
        "THEAD{BACKGROUND-COLOR:thistle;}"
        ".COLLAPSABLE{CURSOR:SW-resize;TEXT-DECORATION:underline}"
        ".MESSAGE{COLOR:salmon;}"
        "H1{TEXT-ALIGN:center;}"
        "A:hover{CURSOR:hand;TEXT-DECORATION:underline;}"
        "PRE{MARGIN-LEFT:1cm;PADDING:4mm;MARGIN-RIGHT:1cm;BACKGROUND-COLOR:menu;}"
        "H2{TEXT-ALIGN:center;}"
        "HR{COLOR:INDIGO;height:1cm;}"
        "P{TEXT-INDENT:1cm;FONT-SIZE:x-small;COLOR:lightgray;}\r\n"
        "--></STYLE>");
    return r;
}

const std::string& HTML::strSCRIPT()
{
    static const std::string r(
    //
    //document.onreadystatechange=new Function("if(document.readyState=='complete')InitOnmouseover('H1,DL',DoCollapsableHeader);");
    //
        "<SCRIPT><!--\r\n"
        "function InitOnmouseover(tags,func){"
            "tags=tags.split(',');"
            "for(j=0 ; j < tags.length ; ++j){"
                "var c=document.all.tags(tags[j]);"
                "for(i=0 ; i < c.length ; ++i)"
                    "c[i].onmouseover=func;"
            "}"
        "}"
        "function DoCollapsableHeader(){"
            "var e=event.srcElement;"
            "switch(event.type){"
            "case 'mouseover':e.className='COLLAPSABLE';"
                "if(!e.__Inited){"
                    "e.onclick=DoCollapsableHeader;"
                    "e.onmouseout=DoCollapsableHeader;"
                    "e.__Inited=true;"
                "}"
                "break;"
            "case 'mouseout':e.className='';break;"
            "case 'click':ShowHide(e.nextSibling);break;"
            "}"
        "}\n"

        "function ShowInModalWindow(s,action){"
            "var w=window.showModalDialog('about:'+escape(s),'','dialogWidth:400px;status:no;scrollbars:yes,scroll:yes;help:no;resizable:yes;');"
            "if(action && w.returnValue)eval(action);"
        "}\r\n"
        "function ShowHide(e){if(e&&e.style)e.style.display=e.style.display==''||e.style.display=='block'?'none':'block';}\n"
        "function Show(e){if(e&&e.style)e.style.display='block';}\n"
        "function Hide(e){if(e&&e.style)e.style.display='none';}\n"
        "function GetCookie(key){"
            "var C=document.cookie;"
            "C=C.split(';');"
            "for(var i=0; i < C.length; ++i){"
                "var pair=C[i].split('=');"
                "var k=unescape(pair[0]);\n"
                "k=k.replace(/\\s(.+)/,'$1');\n"
                "if(key==k)"
                    "return pair.length>1?unescape(pair[1].replace(/\\s(.+)/,'$1')):'';"
            "}"
            "return '';"
        "}\n"
        "function DomXpl(){"
            "var t=window.parent?window.parent:self;"
            "if(!t.aIEDOMs)"
                "t.aIEDOMs=new Array();"
            "var o=new ActiveXObject('IEDomExplorer.Document');"
            "o.exploreDispatch(t);"
            "t.aIEDOMs.push(o);"
        "}\n"
        "function SetCookie (n,v,e,p,d,s){"
            "document.cookie=n+'='+escape(v)+((e)?'; expires='+e.toGMTString():'')+"
            "((p)?'; path='+p:'')+((d)?'; domain='+d:'')+((s)?'; secure':'');"
        "}\n"
//
//  TODO: check why the next does not work
//
//          "function DeleteCookie(n,p,d){\n"
//              "if(GetCookie(n))\n"
//              "   document.cookie=n+'='+((p)?'; path='+p:'')+((d)?'; domain='+d:'')+'; expires=Thu, 01-Jan-70 00:00:01 GMT';\n"
//          "}\r\n"
        //
        //catching error situations
        // 
        "window.onerror=__fnErrorTrap;\n"
        "function __fnErrorTrap(Msg,Url,Line){"
            "oErrorLog.innerHTML='<B>Browser has thrown to exception:</B><P><B>Error: </B>'+Msg+"
                                    "'<BR /><B>Line: </B>'+Line+"
                                    "'<BR /><B>URL: </B>'+Url+'<BR></P>';"
            "return false;"
        "}"
        "\n//--></SCRIPT>"
        );
    return r;
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// CStatistics
//
CStatistics::CStatistics() : _disabled(false) 
{ 
    ::time(&_start_time); 
    disable(0); 
}

std::string CStatistics::getHtmlFormOfDisabled(std::string strName, std::string strInclude)
{
    return "<INPUT TYPE=CHECKBOX NAME="+strName + (_disabled?" CHECKED ":" ") + strInclude
        + " ID=idStatDisable VALUE='checked'><LABEL FOR=idStatDisable>Disable Statistics</LABEL>";
}
std::string CStatistics::getHtmlFormOfResetAll(std::string strName, std::string strInclude)
{
    return "<INPUT TYPE=CHECKBOX VALUE='checked' ID=idStatResetAll "+strInclude + " NAME="+ strName 
            + "><LABEL FOR=idStatResetAll>Reset All Statistics</LABEL>";
}

long CStatistics::disable(long d)
{
    static const std::string key("Statistics disabled <B>(1-disabled)</B>");
    critical_section guard(_cs); (void) guard;
    if(d>=0)
        _map[key] =(_disabled = (d>0))? 1:0;
    return (long) _map[key];
}

statistics<long> CStatistics::assign(const char *key, long value)
{
    if(_disabled)
        return long_statistics_invalid();
    critical_section guard(_cs); (void) guard;
    return _map[key] =value;
}

void CStatistics::minmax(std::string key, long value)
{
    if(_disabled)
        return;
    critical_section guard(_cs); (void) guard;
    _map[key+". Minimum value"].less_equal(value);
    _map[key+". Maximum value"].greater_equal(value);
}

//
// sets key+last_fixed, key+minimum, key+maximum, key+integral, key+average, key+number_of_occurences
//
void CStatistics::full(const std::string& key, long value)
{
    if(_disabled)
        return;
    critical_section guard(_cs); (void) guard;
    _map[key+". Last fixed value"].assign(value);
    _map[key+". Minimum value"].less_equal(value);
    _map[key+". Maximum value"].greater_equal(value);
    _map[key+". Integral value"] +=value;
    _map[key+". Number of requests"] +=1;
    _map[key+". Average value"] =_map[key+". Integral value"] / _map[key+". Number of requests"];
}

//
// counts +-value of key+last_fixed_value, and key+maximum_value. Cannot go down of zerro
//
void CStatistics::count(const std::string& key, long value=+1)
{
    if(_disabled)
        return;
    critical_section guard(_cs); (void) guard;
    long_statistics& last = _map[key+". Last fixed value"];
    last +=value;
    if(value >0)
        _map[key+". Maximum value"].greater_equal(long(last));
    else 
        if(long(last) <0)
            last =0;
}

statistics<long> CStatistics::greater_equal(const char  *key, long value)
{
    if(_disabled)
        return long_statistics_invalid();
    critical_section guard(_cs); (void) guard;
    return _map[key].greater_equal(value);
}
statistics<long> CStatistics::less_or_equal(const char  *key, long value)
{
    if(_disabled)
        return long_statistics_invalid();
    critical_section guard(_cs); (void) guard;
    return _map[key].less_equal(value);
}
statistics<long> CStatistics::maximum(const char  *key, long value)
{
    if(_disabled)
        return long_statistics_invalid();
    critical_section guard(_cs); (void) guard;
    return _map[key].maximum(value);
}
statistics<long> CStatistics::minimum(const char  *key, long value)
{
    if(_disabled)
        return long_statistics_invalid();
    critical_section guard(_cs); (void) guard;
    return _map[key].minimum(value);
}
statistics<long> CStatistics::increment(const char  *key)
{
    if(_disabled)
        return long_statistics_invalid();
    critical_section guard(_cs); (void) guard;
    return ++(_map[key]);
}
statistics<long> CStatistics::decrement(const char  *key)
{
    if(_disabled)
        return long_statistics_invalid();
    critical_section guard(_cs); (void) guard;
    return --(_map[key]);
}

//
// read-only acccess to statistics
//
void CStatistics::reset()
{
    critical_section guard(_cs); (void) guard;
    long num_resets = (long) _map["Number (and time of last) <B>statistics resets</B>"];
    for(TMap::iterator iter=_map.begin() ; iter != _map.end() ; ++iter)
        iter->second.reset();
    assign("Number (and time of last) <B>statistics resets</B>", num_resets+1);
}

statistics<long> CStatistics::reset(const char  *key)
{
    critical_section guard(_cs); (void) guard;
    return _map[key].reset();
}
statistics<long> CStatistics::operator[](const char  *key)
{
    critical_section guard(_cs); (void) guard;
    return _map[key];
}

//
// stream/string outputs
//
std::ostream& CStatistics::getStatistics(std::ostream&os, const char*pszBOL,const char*pszDelim1, const char*pszDelim2, const char*pszEOL)
{
    critical_section guard(_cs); (void) guard;
    for(TMap::iterator iter =_map.begin() ; iter != _map.end() ; ++iter)
    {
        TMap::value_type& val = *iter;
        os  << pszBOL << val.first << pszDelim1;
        if(val.second.is_valid())
            os << (long) val.second << pszDelim2  << time_to_string(val.second.changed_on()) << pszEOL;
        else
            os << "reset value" << pszDelim2  << "value has not been changed yet" << pszEOL;
    }
    return os;
}
std::ostream& CStatistics::getTimeInformation(std::ostream& os, const char* pszBOL, const char* pszDelim,
                                                const char* pszEOL)
{
    time_t loctime;
    ::time(&loctime);

    long secs = loctime - _start_time;      // total
    long totalmins = secs /60L;             // total
    long totalhours = secs/ (60L * 60L);    // total
    long days = secs / (24L *60L *60L);     // total
    long hours = totalhours - days*24L;
    long mins = totalmins - totalhours*60L;
    secs -= totalmins *60L;

    os  << pszBOL << "Time of starting "    << pszDelim << time_to_string(_start_time)  << pszEOL 
        << pszBOL << "Current Time "        << pszDelim << time_to_string(loctime)      << pszEOL 
        << pszBOL << "Since start elapsed " << pszDelim  
            << days << " days, " << hours << " hours, " << mins << " minutes, and " 
            << secs << " seconds" << pszEOL;

    return os;
}

std::ostream& CStatistics::getStatisticsAsPartOfHtmlTable(std::ostream& os)
{
    getStatistics(os, "<TR><TD>", "</TD><TD ALIGN=RIGHT><B>", "</B></TD><TD>", "</TD></TR>");
    return os;
}

std::ostream& CStatistics::getStatisticsAsHtml(std::ostream& os)
{
    getTimeInformation(os, "", "<B>", "</B><BR />");
    os << "<TABLE BORDER CELLSPACING=0><THEAD><TD>Name</TD><TD>Value</TD><TD>Time of last fixation</TD></THEAD>";
    getStatisticsAsPartOfHtmlTable(os);
    os <<   "</TABLE>"
            "<P STYLE='font-size:x-small'><B>NOTE: </B>Whereas the Windows ® operating system is a preemptive "
            "one, timing values may include the time the process itself or a working thread of the process had been "
            "waiting for processor time, and thereupon should be considered as real-world real-time values</P>";
    return os;
}
std::ostream& CStatistics::getStatistics(std::ostream& os)
{
    return getStatistics(getTimeInformation(os), ""," = ",", time of last fixation: ", "\r\n");
}

std::string CStatistics::getStatistics(const char*pszBOL,const char*pszDelim1,const char*pszDelim2,const char*pszEOL)
{
    std::ostringstream s; getStatistics(s, pszBOL, pszDelim1, pszDelim2, pszEOL); return s.str();
}
std::string CStatistics::getTimeInformation(const char* pszBOL, const char* pszDelim, const char* pszEOL)
{
    std::ostringstream s; getTimeInformation(s, pszBOL, pszDelim, pszEOL); return s.str();
}
std::string CStatistics::getStatisticsAsHtml()
{
    HTML s; return (std::string) getStatistics(s); 
}
std::string CStatistics::time_to_string(time_t t, const char* pszFormat)
{
    return t==0? std::string("value has not been changed yet") : CTimer::strLocalTime(t, pszFormat);
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// RegistryKey
//
RegistryKey::RegistryKey(const RegistryKey& copy, const char *szSubFolderName,
                    REGSAM sAccess, 
                    DWORD option,
                    LPSECURITY_ATTRIBUTES psSecur)
{ 
    Init(); 
    operator= (copy);
    if(szSubFolderName != NULL)
        Open(NULL, szSubFolderName, sAccess, option, psSecur);
}

RegistryKey::RegistryKey(HKEY hParentKey, const char *szSubFolderName, 
                REGSAM sAccess, 
                DWORD option, 
                LPSECURITY_ATTRIBUTES psSecur)
{
    Init();
    Open(hParentKey, szSubFolderName, sAccess, option, psSecur);
}

bool RegistryKey::Open(HKEY hParentKey, const char *szSubFolderName, 
                REGSAM sAccess, 
                DWORD dwOption, 
                LPSECURITY_ATTRIBUTES psSecur)
{
    if((m_hParentKey = hParentKey) ==0)
        m_hParentKey = m_hKey;
    else
        Close();    // reusing this class
    
    m_sAccess = sAccess;
    
    if(ERROR_SUCCESS != (m_err = ::RegCreateKeyEx(m_hParentKey,
                szSubFolderName, 0,
                NULL, // "", // class name ?? is it subkey name in hParentKey\szSubFolderName ??
                dwOption,
                sAccess,
                psSecur,                            // *security 
                &m_hKey,
                &m_dwDisp)))
        return false;
    ::RegQueryInfoKey(m_hKey, 0, 0, 0, &iNumSubKeys, &iMaxSubKeyLen,
                            &iMaxClassLen, &iValues, &iMaxValueNameLen,
                            &iMaxValueLen,&iSecurityDescriptor, 
                            &LastWriteTime);

    Init(szSubFolderName, dwOption, sAccess, psSecur);
    return true;
}


void RegistryKey::Close()
{
    if(m_hKey != 0)
        ::RegCloseKey(m_hKey);
    Init();
}

RegistryKey& RegistryKey::operator= (const RegistryKey& from)
{
    Close();
    m_hKey = from.m_hKey;
    m_hParentKey = from.m_hParentKey;
    m_dwDisp = from.m_dwDisp;
    m_err = from .m_err;
    Init(from.m_strSubFolderName.c_str(), from.m_dwOption, from.m_sAccess, from.m_psSecur);
    return *this;
}


// deletes this key and all the data it contens
bool RegistryKey::Delete()
{
    DeleteAllKeys();
    DeleteAllValues();
    if(ERROR_SUCCESS != ::RegDeleteKey(m_hParentKey, m_strSubFolderName.c_str()))
        return false;
    Init();
    return true;
}

// deletes all the values or this key
bool RegistryKey::DeleteAllValues()
{
    char  szValue[MAX_PATH];        // MAX_VALUE_NAME];     
    DWORD cValue = MAX_PATH;    //MAX_VALUE_NAME;
    for(bool res = true ; ERROR_SUCCESS ==::RegEnumValue(m_hKey, 0, szValue, &cValue, 0,0,0,0) ; )
        res &= (ERROR_SUCCESS == ::RegDeleteValue(m_hKey, szValue));
    return res; // all of the values were deleted successfuly?
}

// deletes the subkey(s) (including underlaying data)
bool RegistryKey::DeleteAllKeys()
{
    char  chKey[MAX_PATH]; 
    for(bool res=true ; ERROR_SUCCESS == ::RegEnumKey(m_hKey, 0, chKey, MAX_PATH) ; )
    {
        RegistryKey subKey(*this, chKey);
        res &= subKey.Delete();
    }
    return res; // all of the keys were deleted successfuly?
}


//
// get/set/delete value suit
//
bool RegistryKey::SetValue(const char* szValName, int iValue)
{
    return SetValue(szValName, reinterpret_cast<const BYTE*>(&iValue), sizeof(iValue), REG_DWORD);
}

bool RegistryKey::SetValue(const char* szValName, const char* pValue)
{
    return SetValue(szValName, reinterpret_cast<const BYTE*>(pValue), strlen(pValue), REG_SZ);
}

bool RegistryKey::SetValue(const char* szValName, const BYTE* pValue, int iValueLen, DWORD dwValType)
{
    if(m_hKey == NULL || ERROR_SUCCESS != (m_err = ::RegSetValueEx(m_hKey, szValName, 0, 
                                                                dwValType, pValue, iValueLen)))
        return false; //throw m_err;
    return true;
}   

//
// 
//

RegistryKey::Value::Value(DWORD tp, const std::vector<unsigned char>& buf, int len) : type_(tp) , value(buf) 
{
    if(len >=0)
        value.resize(len, char());
}

RegistryKey::Value& RegistryKey::Value::operator=(const RegistryKey::Value& x)
{
    type_ = x.type();
    value.assign(x.value.begin(), x.value.end());
    return *this;
} 

std::ostream& RegistryKey::Value::output(std::ostream& os, DWORD dwType, const unsigned char* bVal, int lenVal)
{
    if(bVal ==0 || lenVal ==0)
        return os;

    std::ios_base::fmtflags oldfl = os.flags();
    switch(dwType)
    {
    case REG_BINARY: case REG_DWORD_BIG_ENDIAN:
        dump::dump_hex(os, &bVal[0], lenVal); break;

    case REG_DWORD: // case REG_DWORD_LITTLE_ENDIAN:                    //A 32-bit number. 
        os << std::hex << *(DWORD*)(&bVal[0]); break;   

//  case REG_QWORD: case REG_QWORD_LITTLE_ENDIAN:
//      os << std::hex << *(__int64*)(&bVal[0]); break; 
        
    case REG_RESOURCE_LIST:
        os << "Resource list: "; dump::dump_hex(os, &bVal[0], lenVal); break;

    case REG_LINK:
        os << "A Unicode symbolic link: "; dump::dump_hex(os, &bVal[0], lenVal); break;

    case REG_EXPAND_SZ:
        {
            std::vector<char> val(::ExpandEnvironmentStrings((const char*)bVal, 0, 0));
            ::ExpandEnvironmentStrings((const char*)bVal, &val[0], val.size());
            os << &val[0]; 
        }
        break;

    case REG_SZ: 
        os << bVal; break;

    case REG_MULTI_SZ: // An array of null-terminated strings, terminated by two null characters.  vector
        for(const unsigned char* bEnd = bVal +lenVal ; bVal <bEnd && bVal[1] !='\0' ; bVal = std::find(bVal, bEnd, '\0')+1)
            os << (bVal[0]=='\0'? "" : "\n") << bVal;
        break;
    }
    os.setf(oldfl);
    return os;
}

RegistryKey::Value::operator DWORD () const
{
    if(type_ ==REG_DWORD)
        return *(DWORD*)(&value[0]); 
    std::stringstream translator;
    output(translator);
    DWORD ret =0;
    translator >> ret;
    return ret;
}

bool RegistryKey::GetValue(const char* szValName, Value& val) const
{
    if(m_hKey == 0)
        return val.clear() , false;
    val.type_= REG_NONE;
    DWORD dwType = REG_NONE;
    val.value.resize(iMaxValueLen);
    DWORD dwSize = val.value.size();
    if(::RegQueryValueEx(m_hKey, szValName, 0, &dwType, &val.value[0], &dwSize) !=ERROR_SUCCESS)
        return false;
    val.type_= dwType;
    val.value.resize(dwSize);
    return true;
}

DWORD RegistryKey::GetDWORDValue(const char* szValName) const
{
    DWORD dwVal=0xBADBAD;
    DWORD dwSize = sizeof dwVal;
    DWORD dwValType =REG_NONE;
    if(m_hKey != 0)
        ::RegQueryValueEx(m_hKey, szValName, 0, &dwValType, (unsigned char*)&dwVal, &dwSize);
    return dwValType == REG_DWORD ? dwVal : -1;
}

void RegistryKey::EnumerateKeys(std::vector<std::string>& subkeys) const
{
    if(m_hKey ==0)
        return;
    std::vector<char> sName(iMaxSubKeyLen +MAX_PATH);
    for(DWORD dwIndex=0 ; dwIndex < iNumSubKeys ; ++dwIndex)
    {
        DWORD lenName = sName.size();  // size of value name buffer
        FILETIME ft;
        if(ERROR_SUCCESS !=::RegEnumKeyEx(  m_hKey,     // handle to key to enumerate
                                            dwIndex,    // subkey index
                                            &sName[0],  // subkey name
                                            &lenName,   // size of subkey buffer
                                            0,          // reserved
                                            0,          // class string buffer
                                            0,          // size of class string buffer
                                            &ft))       // last write time
            continue;
        subkeys.push_back(std::string(&sName[0], lenName));
    }
}

std::ostream& RegistryKey::getInformationAsHtml(std::ostream& os, const char* pszNamePrefix) const
{
    os  <<  "<TABLE WIDTH=100% BORDER CELLSPACING=0 COLS=2>"
            "<THEAD><TR><TD>" << pszNamePrefix << m_strSubFolderName << "</TD><TD>Modified: "
                << CTimer::FileTimeAsHtml(LastWriteTime) << "</TD></TR></THEAD>";
    EnumerateValuesAsHtmlTBODY(os);
    std::vector<std::string> subkeys;
    EnumerateKeys(subkeys);
    for(int i = 0 ; i < subkeys.size() ; ++i)
    {
        RegistryKey reg(m_hKey, subkeys[i].c_str(), m_sAccess);
        os << "<TR><TD COLSPAN=2 STYLE='PADDING-LEFT=1cm'>";
        if(reg.Valid())
            reg.getInformationAsHtml(os, "<FONT FACE=WINGDINGS>1</FONT> ");
        else
            os << "Error openning registry key " << subkeys[i] << ". " << reg.LastError();
        os << "</TD></TR>";
    }
    os << "</TABLE>";
    return os;
}

//
// helper to read a value at once
//
std::string RegistryKey::GetStringValue(HKEY hParentKey, const std::string& strSubFolderName, const char  *szValName)
{
    RegistryKey rk(hParentKey, strSubFolderName.c_str(), KEY_QUERY_VALUE, REG_OPTION_NON_VOLATILE, 0);
    return (std::string) rk.GetValue(szValName);
}

/*
typedef std::map<std::string, Value> Values;

void EnumerateValues(Values& m) const
{
    if(m_hKey ==0)
        return;
    std::vector<char> sName(iMaxValueNameLen);
    std::vector<unsigned char> bVal(iMaxValueLen);
    for(DWORD dwIndex=0 ; dwIndex < iValues ; ++dwIndex)
    {
        DWORD lenName = sName.size();  // size of value name buffer
        DWORD lenVal = bVal.size();  // size of value name buffer
        DWORD dwType = REG_NONE;

        if(ERROR_SUCCESS !=::RegEnumValue(m_hKey, dwIndex, &sName[0], &lenName, 0, &dwType, &bVal[0], &lenVal))
            continue;
        m.insert(std::pair<std::string, Value>(std::string(&sName[0], lenName), Value(dwType, bVal, lenVal)));
    }
}

std::ostream& EnumerateValues(std::ostream& os, const char* bol, const char  *del, const char* eol) const
{
    Values v;
    EnumerateValues(v);
    for(Values::const_iterator it = v.begin() ; it != v.end() ; ++it)
    {
        os << bol << it->first << del ;
        it->second.output(os) << eol;
    }
    return os;
}
*/
void RegistryKey::Init()
{
    m_hKey = NULL;
    m_dwDisp = 0;
    m_err = ERROR_SUCCESS;
    iNumSubKeys=0;
    iMaxSubKeyLen=0;
    iMaxClassLen=0;
    iValues=0;
    iMaxValueNameLen=0;
    iMaxValueLen=0;
    iSecurityDescriptor =0;
}
void RegistryKey::Init(const char *szSubFolderName, DWORD dwOption, REGSAM sAccess, LPSECURITY_ATTRIBUTES psSecur)
{
    m_strSubFolderName = szSubFolderName;
    m_dwOption = dwOption;
    m_sAccess = sAccess;
    m_psSecur = psSecur;
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// ThisComputer
//
std::ostream& ThisComputer::OSInfo(std::ostream& s, const char*bol, const char*dm1, const char*dm2, const char*eol)
{

#if(WINVER < 0x0500)    //!defined(VER_NT_WORKSTATION)
    #define VER_NT_WORKSTATION              0x0000001
    #define VER_NT_DOMAIN_CONTROLLER        0x0000002
    #define VER_NT_SERVER                   0x0000003
    #define VER_SERVER_NT                       0x80000000
    #define VER_WORKSTATION_NT                  0x40000000
    #define VER_SUITE_SMALLBUSINESS             0x00000001
    #define VER_SUITE_ENTERPRISE                0x00000002
    #define VER_SUITE_BACKOFFICE                0x00000004
    #define VER_SUITE_COMMUNICATIONS            0x00000008
    #define VER_SUITE_TERMINAL                  0x00000010
    #define VER_SUITE_SMALLBUSINESS_RESTRICTED  0x00000020
    #define VER_SUITE_EMBEDDEDNT                0x00000040
    #define VER_SUITE_DATACENTER                0x00000080
    #define VER_SUITE_SINGLEUSERTS              0x00000100
    #define VER_SUITE_PERSONAL                  0x00000200
    #define VER_SUITE_SERVERAPPLIANCE           0x00000400

    typedef struct _OSVERSIONINFOEX {
      DWORD dwOSVersionInfoSize;
      DWORD dwMajorVersion;
      DWORD dwMinorVersion;
      DWORD dwBuildNumber;
      DWORD dwPlatformId;
      char  szCSDVersion[ 128 ];
      WORD wServicePackMajor;
      WORD wServicePackMinor;
      WORD wSuiteMask;
      BYTE wProductType;
      BYTE wReserved;
    } OSVERSIONINFOEX;
    OSVERSIONINFOEX  vi;
#endif

    ::ZeroMemory(&vi, sizeof OSVERSIONINFOEX);
    vi.dwOSVersionInfoSize  = sizeof OSVERSIONINFOEX;

    if(!::GetVersionEx((OSVERSIONINFO *)&vi))               // GetVersionEx using the OSVERSIONINFOEX
    {
        vi.dwOSVersionInfoSize  = sizeof OSVERSIONINFO; // ditto using OSVERSIONINFO
        if(!::GetVersionEx ( (OSVERSIONINFO *) &vi)) 
            throw CRuntime_error("<B>Source: </B><SOURCE>GetVersion of OS</SOURCE>", ::GetLastError());
    }
    
    s << bol << "OS Platform" << dm1;
    if (vi.dwPlatformId == VER_PLATFORM_WIN32_NT)
    {   
        if(vi.dwOSVersionInfoSize ==sizeof OSVERSIONINFOEX)
        {
            s   << "Windows " << (vi.dwMajorVersion <= 4? "NT":(vi.dwMajorVersion == 5 && vi.dwMinorVersion > 0)? "XP":"2000") 
                << (    vi.wProductType==VER_NT_WORKSTATION?        " Professional":
                        vi.wProductType==VER_NT_DOMAIN_CONTROLLER?  " Domain Controller":
                        vi.wProductType==VER_NT_SERVER?             " Server": "")
                << dm2 << eol << bol << "Suite" << dm1
            ;
            if(vi.wSuiteMask & VER_SUITE_DATACENTER)    s << "Data Center. ";
            if(vi.wSuiteMask & VER_SUITE_ENTERPRISE)    s << "Advanced Server. ";
            if(vi.wSuiteMask & VER_SUITE_BACKOFFICE)    s << "Microsoft Backoffice. ";
            if(vi.wSuiteMask & VER_SUITE_SMALLBUSINESS) s << "Microsoft Small Business Server. ";
            if(vi.wSuiteMask & VER_SUITE_SMALLBUSINESS_RESTRICTED)  s << "Microsoft Small Business Server - Restrictive Client License. ";
            if(vi.wSuiteMask & VER_SUITE_TERMINAL)      s << "Terminal Server. ";
            if(vi.wSuiteMask & VER_SUITE_PERSONAL)      s << "Workstation Personal. ";
            s << dm2 << eol;
        }
        else        // there is no direct way of telling is it workstation or server version. There we need to check in the registry.
        {
            if(vi.dwMajorVersion <= 4)                                  s << "Windows NT";
            else if(vi.dwMajorVersion == 5 && vi.dwMinorVersion == 0)   s << "Windows 2000";
            else if (vi.dwMajorVersion == 5 && vi.dwMinorVersion > 0)   s << "Windows XP (Whistler)";

            s   << " - " << RegistryKey::GetStringValue(HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Control\\ProductOptions", "ProductType") << eol;
        }

        s   << bol << "Version" << dm1 << vi.dwMajorVersion << "." << vi.dwMinorVersion << dm2 << eol
            << bol << "Build"   << dm1 << vi.dwBuildNumber                              << dm2 << eol
            ;
    }
    else if (vi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS)
    {
        if ((vi.dwMajorVersion > 4) || ((vi.dwMajorVersion == 4) &&
            (vi.dwMinorVersion > 0)))
        {
            s << (vi.dwMinorVersion < 90? "Windows 98":"Windows ME");
        }
        else
            s << "Windows 95";

        s   << dm2 << eol
            << bol << "Version" << dm1 << vi.dwMajorVersion << "." << vi.dwMinorVersion << dm2 << eol
            << bol << "Build"   << dm1 << (DWORD)(LOBYTE(LOWORD(vi.dwBuildNumber))) << dm2 << eol
            ;
    }
    else if (vi.dwPlatformId == VER_PLATFORM_WIN32s)
        s << "Windows 32s or Windows 3.1" << dm2 << eol;
    else
        s << "??? " << vi.dwPlatformId << dm2 << eol;
    

    if(vi.szCSDVersion[0] !='\0')
        s << bol << "Service Pack" << dm1 << vi.szCSDVersion << dm2
                        << "vers." << vi.wServicePackMajor << "." << vi.wServicePackMinor << eol;
    return s;
}

std::ostream& ThisComputer::CPUFromRegistryInfo(std::ostream& s, const char*bol, const char*dm1, const char*dm2, const char*eol, const char*separator)
{
    RegistryKey regCPUs(HKEY_LOCAL_MACHINE, "Hardware\\Description\\System\\CentralProcessor\\", KEY_READ);
    std::vector<std::string> vecCPUs;
    regCPUs.EnumerateKeys(vecCPUs);
    for(int i = 0 ; i < vecCPUs.size() ; ++i)
    {
        RegistryKey regCPU(regCPUs, vecCPUs[i].c_str(), KEY_QUERY_VALUE);
        if(!regCPU.Valid())
            continue;
        s   << separator
        << bol << "CPU Identifier"  << dm1 << regCPU.GetStringValue("Identifier")       << dm2 << "CPU " <<vecCPUs[i] << ". Info taking from the registry" << eol
        << bol << "CPU Vendor"      << dm1 << regCPU.GetStringValue("VendorIdentifier")     << dm2 << "..ditto" << eol
        << bol << "CPU speed"       << dm1 << "~" << regCPU.GetDWORDValue("~MHz") << "MHz"  << dm2 << "..ditto" << eol
        ;
    }
    return s;
}

std::ostream& ThisComputer::CPUInfo(std::ostream& s, const char*bol, const char*dm1, const char*dm2, const char*eol)
{
    SYSTEM_INFO sysInfo;
    ::GetSystemInfo (&sysInfo);                         // Get the hardware information

    const char  *pt="Unknown";                          // the processor type
    switch(sysInfo.dwProcessorType)
    {
    case PROCESSOR_INTEL_386:       pt="Intel 386";     break;
    case PROCESSOR_INTEL_486:       pt="Intel 486";     break;
    case PROCESSOR_INTEL_PENTIUM:   pt="Intel Pentium"; break;
    case PROCESSOR_MIPS_R4000:      pt="MIPS";          break;
    case PROCESSOR_ALPHA_21064:     pt="Alpha";         break;
    }

    const char  *at="Unknown (unavailable on Windows 95)";  // the Architecture type
    const char  *pl="Unknown (unavailable on Windows 95)";  // the Processor level
    char  plbuf[100];
    std::stringstream sr;
    switch(sysInfo.wProcessorArchitecture)
    {
    case PROCESSOR_ARCHITECTURE_INTEL:
        at="Pentium";
        switch(sysInfo.wProcessorLevel)
        {
        case 3:
            pl="Intel 80386";
            sr << "Step " << int (HIBYTE(sysInfo.wProcessorRevision) -'A') << "." << int LOBYTE(sysInfo.wProcessorRevision);
            break;

        case 4:
            pl="Intel 80486";
            sr << "Step " << int (HIBYTE(sysInfo.wProcessorRevision) -'A') << "." << int LOBYTE(sysInfo.wProcessorRevision);
            break;

        case 5:
            pl=::IsProcessorFeaturePresent(PF_MMX_INSTRUCTIONS_AVAILABLE)? "Pentium MMX":"Pentium";
            sr << "Model " << int HIBYTE(sysInfo.wProcessorRevision) << ", Stepping " << int LOBYTE(sysInfo.wProcessorRevision);
            break;

        case 6:
            pl="Pentium (II/Pro)";
            sr << "Model " << int HIBYTE(sysInfo.wProcessorRevision) << ", Stepping " << int LOBYTE(sysInfo.wProcessorRevision);
            break;
        }
        break;

    case PROCESSOR_ARCHITECTURE_MIPS:
        at="MIPS";
        pl=(sysInfo.wProcessorLevel == 0004)? "MIPS R4000" : ::itoa(sysInfo.wProcessorLevel, plbuf, 10);
        sr << int LOBYTE(sysInfo.wProcessorRevision);
        break;

    case PROCESSOR_ARCHITECTURE_ALPHA:
        at="Alpha";
        pl=::itoa(sysInfo.wProcessorLevel, plbuf, 10);
        sr << "Model A+" << int HIBYTE(sysInfo.wProcessorRevision) << ", Pass " << int LOBYTE(sysInfo.wProcessorRevision);
        break;

    case PROCESSOR_ARCHITECTURE_PPC:
        at="PPC";
        switch (sysInfo.wProcessorLevel)
        {
        case 1: pl="PPC 601";   break;
        case 3: pl="PPC 603";   break;
        case 4: pl="PPC 604";   break;
        case 6: pl="PPC 603+";  break;
        case 9: pl="PPC 604+";  break;
        case 20:pl="PPC 620";   break;
        }
        break;
        sr << int HIBYTE(sysInfo.wProcessorRevision) << "." << int LOBYTE(sysInfo.wProcessorRevision);

    case PROCESSOR_ARCHITECTURE_UNKNOWN:
        at="Unknown";
        pl="Unknown";
        break;
    }

    s   << bol << "Processor type"          << dm1 << pt                                << dm2 << eol
        << bol << "Architecture"            << dm1 << at                                << dm2 << eol
        << bol << "Processor level"         << dm1 << pl                                << dm2 << eol
        << bol << "Processor revision"      << dm1 << sr.str()                      << dm2 << eol
        << bol << "Number of processors"    << dm1 << sysInfo.dwNumberOfProcessors  << dm2 << eol
        << bol << "Active processor mask"   << dm1 << std::hex << sysInfo.dwActiveProcessorMask << dm2 << "hex" << eol
        << bol << "Page Size"               << dm1 << std::dec << sysInfo.dwPageSize      << dm2 << "dec" << eol
        << bol << "Min Application address" << dm1 << std::hex << sysInfo.lpMinimumApplicationAddress  << dm2 << eol
        << bol << "Max Application address" << dm1 << std::hex << sysInfo.lpMaximumApplicationAddress  << dm2 << eol
        << std::dec;
    return s;
}

std::ostream& ThisComputer::MemoryInfo(std::ostream& s, const char*bol, const char*dm1, const char*dm2, const char*eol)
{
    MEMORYSTATUS memoryStatus;
    memset (&memoryStatus, sizeof MEMORYSTATUS, 0);
    memoryStatus.dwLength = sizeof MEMORYSTATUS;
    ::GlobalMemoryStatus (&memoryStatus);
                                                                        //
    std::locale old_locale(s.imbue(std::locale("American_USA.1252")));  // change locale to the USA one to set thousands separator to ','
    s   << std::fixed << std::dec                                       //
        << bol << "Physical Total"      << dm1 << memoryStatus.dwTotalPhys << dm2 << "bytes" << eol
        << bol << "Physical Available"  << dm1 << memoryStatus.dwAvailPhys << dm2 << "bytes" << eol
        << bol << "Physical In Use"     << dm1 << "~ " << memoryStatus.dwMemoryLoad << "%" 
                    << dm2 <<   "Windows NT 3.1 or 4.0: The percentage of the last 1000 pages of physical memory that is in use. "
                                "Windows 2000: The percentage of total physical memory that is in use"
                    << eol
        << bol << "Pages Total" << dm1 << memoryStatus.dwTotalPageFile 
                    << dm2 <<   "Total possible size, in bytes, of the paging file. "
                                "Note that this number does not represent the actual physical size of the paging file on disk" 
                    << eol
        << bol << "Pages Available to this process" << dm1 << memoryStatus.dwAvailPageFile 
                    << dm2 <<   "Size, in bytes, of space available in the paging file. The operating system can enlarge the paging file from time to time. "
                                "The value shows the difference between the size of current committed memory and the current size of the paging file "
                                "(it does not show the largest possible size of the paging file)"
                    << eol
        << bol << "Virtual Total of process"    << dm1 << memoryStatus.dwTotalVirtual 
                    << dm2 <<   "Total size, in bytes, of the user mode portion of the virtual address space of the calling process" 
                    << eol
        << bol << "Virtual Available to this process"   << dm1 << memoryStatus.dwAvailVirtual 
                    << dm2 <<   "Size, in bytes, of unreserved and uncommitted memory in the user mode portion of the virtual address space of the calling process" 
                    << eol
        ;
    s.imbue(old_locale);    // restore locale
    return s;
}

std::ostream& ThisComputer::print_size(std::ostream& s, DWORD l, DWORD h)
{   
    std::locale old_locale(s.imbue(std::locale("American_USA.1252")));  // change locale to the USA one to set thousands separator to ','
    h = l /1000000000L +h*4L;
    l = l %1000000000L;
    if(h !=0)
        s << h <<",";
    s << l;
    s.imbue(old_locale);    // restore locale
    return s;
}

bool ThisComputer::VolumeInfo(std::ostream& s, const char  sC[], const char*bol, const char*dm1, const char*dm2, const char*eol,
                        const char* yes, const char* no)
{
    UINT type=::GetDriveType(sC);
    char  *pszType;
    switch(type)
    {
    case DRIVE_REMOVABLE: pszType ="The disk can be removed from the drive"; break;
    case DRIVE_FIXED: pszType ="The disk cannot be removed from the drive"; break;
    case DRIVE_REMOTE: pszType ="The drive is a remote (network) drive"; break;
    case DRIVE_CDROM: pszType ="The drive is a CD-ROM drive"; break;
    case DRIVE_RAMDISK: pszType ="The drive is a RAM disk"; break;
    case DRIVE_NO_ROOT_DIR: //pszType ="The root path is invalid. For example, no volume is mounted at the path"; break;
    default: return false;
    }

    s <<bol<<"Volume name" <<dm1<<sC << dm2 << pszType << eol;
    if(type ==DRIVE_REMOTE)
        return true;

    char  VolumeNameBuffer[256];            // volume name buffer
    DWORD VolumeSerialNumber;           // volume serial number
    DWORD MaximumComponentLength;       // maximum file name length
    DWORD FileSystemFlags;              // file system options
    char  FileSystemNameBuffer[256];        // file system name buffer
    if(!::GetVolumeInformation(sC, VolumeNameBuffer, sizeof VolumeNameBuffer, &VolumeSerialNumber,
                                &MaximumComponentLength, &FileSystemFlags, 
                                FileSystemNameBuffer, sizeof FileSystemNameBuffer))
        return true;

    s   <<std::fixed << std::dec
        <<bol<<"Serial number"                  <<dm1<<VolumeSerialNumber       << dm2 << eol
        <<bol<<"File name length"               <<dm1<<MaximumComponentLength   << dm2 << "maximum file name length in bytes"<< eol
        <<bol<<"File system"                    <<dm1<<FileSystemNameBuffer     << dm2 << "name of file system" << eol
        <<bol<<"File system options:"           <<eol<< std::boolalpha
        <<bol<<"FS_CASE_IS_PRESERVED"           <<dm1<<(FileSystemFlags&FS_CASE_IS_PRESERVED!=0?yes:no)         <<dm2<<"The file system preserves the case of file names when it places a name on disk" << eol
        <<bol<<"FS_CASE_SENSITIVE"              <<dm1<<(FileSystemFlags&FS_CASE_SENSITIVE!=0?yes:no)            <<dm2<<"The file system supports case-sensitive file names" << eol
        <<bol<<"FS_UNICODE_STORED_ON_DISK"      <<dm1<<(FileSystemFlags&FS_UNICODE_STORED_ON_DISK!=0?yes:no)    <<dm2<<"The file system supports Unicode in file names as they appear on disk" << eol
        <<bol<<"FS_PERSISTENT_ACLS"             <<dm1<<(FileSystemFlags&FS_PERSISTENT_ACLS!=0?yes:no)           <<dm2<<"The file system preserves and enforces ACLs. For example, NTFS preserves and enforces ACLs, and FAT does not" << eol
        <<bol<<"FS_FILE_COMPRESSION"            <<dm1<<(FileSystemFlags&FS_FILE_COMPRESSION!=0?yes:no)          <<dm2<<"The file system supports file-based compression" << eol
        <<bol<<"FS_VOL_IS_COMPRESSED"           <<dm1<<(FileSystemFlags&FS_VOL_IS_COMPRESSED!=0?yes:no)         <<dm2<<"The specified volume is a compressed volume; for example, a DoubleSpace volume" << eol
//          <<bol<<"FILE_NAMED_STREAMS"             <<dm1<<(FileSystemFlags&FILE_NAMED_STREAMS!=0?yes:no)           <<dm2<<"The file system supports named streams" << eol
//          <<bol<<"FILE_READ_ONLY_VOLUME"          <<dm1<<(FileSystemFlags&FILE_READ_ONLY_VOLUME!=0?yes:no)        <<dm2<<"Whistler: The specified volume is read-only" << eol
        <<bol<<"FILE_SUPPORTS_ENCRYPTION"       <<dm1<<(FileSystemFlags&FILE_SUPPORTS_ENCRYPTION!=0?yes:no)     <<dm2<<"The file system supports the Encrypted File System (EFS)" << eol
        <<bol<<"FILE_SUPPORTS_OBJECT_IDS"       <<dm1<<(FileSystemFlags&FILE_SUPPORTS_OBJECT_IDS!=0?yes:no)     <<dm2<<"The file system supports object identifiers" << eol
        <<bol<<"FILE_SUPPORTS_REPARSE_POINTS"   <<dm1<<(FileSystemFlags&FILE_SUPPORTS_REPARSE_POINTS!=0?yes:no) <<dm2<<"The file system supports reparse points" << eol
        <<bol<<"FILE_SUPPORTS_SPARSE_FILES"     <<dm1<<(FileSystemFlags&FILE_SUPPORTS_SPARSE_FILES!=0?yes:no)   <<dm2<<"The file system supports sparse files" << eol
        <<bol<<"FILE_VOLUME_QUOTAS"             <<dm1<<(FileSystemFlags&FILE_VOLUME_QUOTAS!=0?yes:no)           <<dm2<<"The file system supports disk quotas" << eol
        ;

    ULARGE_INTEGER FreeBytesAvailable;      // bytes available to caller
    ULARGE_INTEGER TotalNumberOfBytes;      // bytes on disk
    ULARGE_INTEGER TotalNumberOfFreeBytes;  // free bytes on disk

    if(!::GetDiskFreeSpaceEx(sC, &FreeBytesAvailable, &TotalNumberOfBytes, &TotalNumberOfFreeBytes))
        return true;
    s   <<bol<<"Free bytes available"   <<dm1; print_size(s, FreeBytesAvailable)        <<dm2<<"bytes available to this program" << eol
        <<bol<<"Total available"        <<dm1; print_size(s, TotalNumberOfBytes)        <<dm2<<"bytes on disk" << eol
        <<bol<<"Total free bytes"       <<dm1; print_size(s, TotalNumberOfFreeBytes)    <<dm2<<"free bytes on disk" << eol
        ;
    return true;
}

std::ostream& ThisComputer::VolumesInfo(std::ostream& s, const char*bol, const char*dm1, const char*dm2, const char*eol, const char* separator,
                                    const char* yes, const char* no)
{
    for(char  sC[] = "A:\\" ; sC[0] <='Z' ; ++sC[0])
        if(VolumeInfo(s, sC, bol, dm1, dm2, eol, yes, no))
            s << separator;
    return s;
}

#ifdef _PSAPI_H_    // PSAPI is not a part of WINDOWS but a SDK dll

std::ostream& ThisComputer::ProcessInfo(std::ostream& s, DWORD id, const char* bol, const char *dl1, const char *dl2, const char *eol)
{
    HANDLE hProc = ::OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ, FALSE, id);
    if(hProc ==0)
        return s;
    try
    {
        HMODULE hMod;
        DWORD cbMods=0;
        std::vector<char> path(MAX_PATH *2, 0);
        if(::EnumProcessModules(hProc, &hMod, sizeof HMODULE, &cbMods))
            ::GetModuleBaseName(hProc, hMod, &path[0], path.size());

        s   <<bol<< "Process"   <<dl1<< &path[0]    <<dl2<< (hProc==::GetCurrentProcess()? "Current process":"") << eol
            <<bol<< "PID"       <<dl1<< id          <<dl2<< eol
            ;

        FileTime starttime, exittime, kerneltime, usertime;
        if(!::GetProcessTimes(hProc, &starttime, &exittime, &kerneltime, &usertime))
        {
            s   <<bol<< "Start time"    <<dl1<< starttime.AsString()    <<dl2           <<eol 
                <<bol<< "Exit time"     <<dl1<< exittime.AsString()     <<dl2           <<eol 
                <<bol<< "Kernel time"   <<dl1<< kerneltime.mls()        <<dl2<< "mls"   <<eol
                <<bol<< "Process time"  <<dl1<< usertime.mls()          <<dl2<< "mls"   <<eol
                ;
        }

        PROCESS_MEMORY_COUNTERS pmc;
        if(!::GetProcessMemoryInfo(hProc, &pmc, sizeof pmc))
        {
            s   <<bol<<"Process Memory"             <<dl1<< dl2 << eol
                <<bol<<"PageFaultCount"             <<dl1<< pmc.PageFaultCount              <<dl2<<"dec" <<eol
                <<bol<<"PeakWorkingSetSize"         <<dl1<< pmc.PeakWorkingSetSize          <<dl2<<"dec" <<eol
                <<bol<<"WorkingSetSize"             <<dl1<< pmc.WorkingSetSize              <<dl2<<"dec" <<eol
                <<bol<<"QuotaPeakPagedPoolUsage"    <<dl1<< pmc.QuotaPeakPagedPoolUsage     <<dl2<<"dec" <<eol
                <<bol<<"QuotaPagedPoolUsage"        <<dl1<< pmc.QuotaPagedPoolUsage         <<dl2<<"dec" <<eol
                <<bol<<"QuotaPeakNonPagedPoolUsage" <<dl1<< pmc.QuotaPeakNonPagedPoolUsage  <<dl2<<"dec" <<eol
                <<bol<<"QuotaNonPagedPoolUsage"     <<dl1<< pmc.QuotaNonPagedPoolUsage      <<dl2<<"dec" <<eol
                <<bol<<"PagefileUsage"              <<dl1<< pmc.PagefileUsage               <<dl2<<"dec" <<eol
                <<bol<<"PeakPagefileUsage"          <<dl1<< pmc.PeakPagefileUsage           <<dl2<<"dec" <<eol
                ;
        }
        //
        // get and show all the modules in process
        //
        std::vector<HMODULE> vecMods(cbMods /= sizeof HMODULE);
        if(::EnumProcessModules(hProc, &hMod, sizeof HMODULE, &cbMods))
        {
            s <<bol<<"Process's Modules:" << eol;
            for(int i=0 ; i < vecMods.size() ; ++i)
            {
                path.assign(path.size(), 0);        // reset vector
                if(::GetModuleFileName(vecMods[i], &path[0], path.size()) >0)
                    s << bol << std::hex << "0x" <<vecMods[i] << path << eol;
            }
        }

    }
    catch(...)
    {
    }
    ::CloseHandle(hProc);
    return s;
}

std::ostream& ThisComputer::ProcessesInfo(std::ostream& s, const char*bol, const char*dm1, const char*dm2, const char*eol, const char* separator)
{   

    std::vector<DWORD> ids(4000);       // reserv for 4000 processes
    DWORD cb;
    ::EnumProcesses(&ids[0], ids.size(), &cb);
    cb /=sizeof DWORD;

    for(int i = 0 ; i < cb ; ++i)
        ProcessInfo(s, ids[i], bol, dm1, dm2, eol);
}

#endif

std::ostream& ThisComputer::MisceleniousInfo(std::ostream& s, const char*bol, const char*dm1, const char*dm2, const char*eol) throw(CRuntime_error)
{
    char  szBuffer[MAX_COMPUTERNAME_LENGTH + 1];
    DWORD dwSize = sizeof szBuffer;

    //
    // TODO use GetComputerNameEx for Windows 2000
    //
    if(::GetComputerName (szBuffer, &dwSize))
        s << bol << "Computer Name" << dm1 << szBuffer << dm2 << "The NetBIOS name of the computer" << eol;

    char  *pszDomainName = ::getenv("USERDOMAIN");
    if(pszDomainName !=0)
        s << bol << "Domain Name" << dm1 << pszDomainName  << dm2 << "The Domain name (taking from environment)" << eol;

//"HKLM\\SOFTWARE\\Microsoft\Windows NT\\CurrentVersion\\Winlogon\\CachePrimaryDomain"

    char  *pszLogonServer = ::getenv("LOGONSERVER");
    if(pszLogonServer !=0)
        s << bol << "Logon Server Name" << dm1 << pszLogonServer  << dm2 << "DNS server name (taking from environment)" << eol;

    dwSize = sizeof szBuffer;
    if(::GetUserName(szBuffer, &dwSize))
        s << bol << "User Name" << dm1 << szBuffer << dm2 << "The name of the user currently logged onto the system" << eol;

    char  szVal[MAX_PATH];
    if((DWORD)::GetLocaleInfo (LOCALE_SYSTEM_DEFAULT, LOCALE_SENGCOUNTRY, szVal, sizeof szVal) <= sizeof szVal)
        s << bol << "Country" << dm1 << szVal << dm2 << "The country/region set for the system" << eol;

    if((DWORD)::GetLocaleInfo (LOCALE_SYSTEM_DEFAULT, LOCALE_SENGLANGUAGE, szVal, sizeof szVal) <= sizeof szVal)
        s << bol << "Language" << dm1 << szVal << dm2 << "The language set for the system" << eol;

    TIME_ZONE_INFORMATION info;
    if(TIME_ZONE_ID_INVALID != ::GetTimeZoneInformation(&info))
        s << bol << "Time Zone" << dm1 << (char*)_bstr_t(info.StandardName) << dm2 << eol;

    return s;
}
std::ostream& ThisComputer::NetworkInfo(std::ostream& s, const char*bol, const char*dm1, const char*dm2, const char*eol, const char* separator) throw(CRuntime_error)
{
    //
    // IP addresses
    //
    char szHostName[MAX_PATH];
    if(::gethostname(szHostName, sizeof szHostName) == 0)
    {
        s << bol << "Host name" << dm1 << szHostName << dm2 << "The computer may have more than IP addresses. See gethostname for more information" << eol;
        struct hostent *pHost = ::gethostbyname(szHostName);        // Get host adresses
        if(pHost !=0)
        {
            s << bol << pHost->h_name << dm1;
            for(int i = 0 ; pHost->h_addr_list[i] !=0 ; ++i)
            {
                s << (i >0? "<BR><NOBR>" : "<NOBR>");
                for(int j = 0 ; j < pHost->h_length ; ++j)
                    s << (j >0? "." : "") << (unsigned int)((unsigned char*)pHost->h_addr_list[i])[j];
                s << "</NOBR>";
            }
            s << dm2;
            for(i = 0 ; pHost->h_aliases[i] !=0 ; ++i)
                s << (i >0? "<BR>" : "") <<  "<NOBR>Alias " << pHost->h_aliases[i] <<"</NOBR>";
            s << eol;
        }
    }

    RegistryKey regNetworkCards(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards\\", KEY_READ);
    std::vector<std::string> cards;
    regNetworkCards.EnumerateKeys(cards);
    for(int i = 0 ; i < cards.size() ; ++i)
    {
        RegistryKey regNetworkCard(regNetworkCards, cards[i].c_str(), KEY_QUERY_VALUE);
        if(!regNetworkCard.Valid())
            continue;
        s << separator << bol << "Network card" << dm1 << regNetworkCard.GetStringValue("Description") << dm2 << "Card " << cards[i];
        std::string strServiceName = regNetworkCard.GetStringValue("ServiceName");
        if(strServiceName.empty())
        {
            s  << ". The card is not in use" << eol;
            continue;
        }

        RegistryKey reg(HKEY_LOCAL_MACHINE, ("SYSTEM\\CurrentControlSet\\Services\\"+strServiceName+"\\Parameters\\TcpIp").c_str(), KEY_QUERY_VALUE);
        s   << eol
            << bol << "DHCP IP address" << dm1 << reg.GetStringValue("DhcpIPAddress") << dm2 << "Taken from registry for aforementioned network card" << eol
            << bol << "IP address" << dm1 << reg.GetStringValue("IPAddress") << dm2 << "..ditto" << eol
            << bol << "Enable DHCP" << dm1 << reg.GetDWORDValue("EnableDHCP") << dm2 << "..ditto" << eol
            << bol << "DHCP server" << dm1 << reg.GetStringValue("DhcpServer") << dm2 << "..ditto" << eol
            << bol << "DHCP Default Gateway" << dm1 << reg.GetStringValue("DhcpDefaultGateway") << dm2 << "..ditto" << eol
            << bol << "Subnet mask" << dm1 << reg.GetStringValue("DhcpSubnetMask") << dm2 << "..ditto" << eol
        ;
    }
    return s;
}

std::ostream& ThisComputer::Information(std::ostream& s)
{
    s <<    "<TABLE BORDER CELLSPACING=0>"
            "<THEAD><TR><TH COLSPAN=3>Computer:</TH></TR></THEAD>";
    MisceleniousInfo(s, "<TR><TD ALIGN=RIGHT>", "</TD><TD>", "</TD><TD STYLE='font-size:x-small'>", "</TD></TR>");

    s << "<THEAD><TR><TH COLSPAN=3>Operating System:</TH></TR></THEAD>";
    OSInfo(s, "<TR><TD ALIGN=RIGHT>", "</TD><TD>", "</TD><TD STYLE='font-size:x-small'>", "</TD></TR>");

    s << "<THEAD><TR><TH COLSPAN=3>CPU(s):</TH></TR></THEAD>";
    CPUInfo(s, "<TR><TD ALIGN=RIGHT>", "</TD><TD>", "</TD><TD STYLE='font-size:x-small'>", "</TD></TR>");
    CPUFromRegistryInfo(s, "<TR><TD ALIGN=RIGHT>", "</TD><TD>", "</TD><TD STYLE='font-size:x-small'>", "</TD></TR>",
                            "<TR><TD COLSPAN=3 ALIGN=CENTER> </TD></TR>");

    s << "<THEAD><TR><TH COLSPAN=3>Memory:</TH></TR></THEAD>";
    MemoryInfo(s, "<TR><TD ALIGN=RIGHT>", "</TD><TD>", "</TD><TD STYLE='font-size:x-small'>", "</TD></TR>");

#ifdef _PSAPI_H_    // PSAPI is not a part of WINDOWS but a SDK dll
    s << "<THEAD><TR><TH COLSPAN=3>Processes:</TH></TR></THEAD>";
    ProcessesInfo(s, "<TR><TD ALIGN=RIGHT>", "</TD><TD>", "</TD><TD STYLE='font-size:x-small'>", "</TD></TR>", 
                    "<TR><TD COLSPAN=3 ALIGN=CENTER> </TD></TR>");
#endif

    s << "<THEAD><TR><TH COLSPAN=3>Network:</TH></TR></THEAD>";
    NetworkInfo(s, "<TR><TD ALIGN=RIGHT>", "</TD><TD>", "</TD><TD STYLE='font-size:x-small'>", "</TD></TR>",
                            "<TR><TD COLSPAN=3 ALIGN=CENTER> </TD></TR>");


    s << "<THEAD><TR><TH COLSPAN=3>Volumes:</TH></TR></THEAD>";
    VolumesInfo(s, "<TR><TD ALIGN=RIGHT>", "</TD><TD>", "</TD><TD STYLE='font-size:x-small'>", "</TD></TR>", 
                    "<TR><TD COLSPAN=3 ALIGN=CENTER> </TD></TR>", "v", " ");

    s<< "<THEAD><TR><TH COLSPAN=3>Internet explorer:</TH></TR></THEAD>"
        "<TR><TD COLSPAN=3 ALIGN=CENTER>";
    InternetExplorer::getFullInformationAsHtml(s);
    s << "</TD></TR>";

    return s << "</TABLE>";
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// FileInformation
//
/*
FileInformation& FileInformation::operator=(const FileInformation& x) 
{ 
    ::memcpy(static_cast<FILE_INFORMATION_STRUCTURE*>(this), static_cast<const FILE_INFORMATION_STRUCTURE*>(&x), 
                sizeof FILE_INFORMATION_STRUCTURE); 
    return *this;
}
bool FileInformation::operator==(const FILE_INFORMATION_STRUCTURE& x) const 
{ 
    return ::memcmp(static_cast<const FILE_INFORMATION_STRUCTURE*>(this), &x, sizeof FILE_INFORMATION_STRUCTURE) ==0; 
}
*/
bool FileInformation::init(HMODULE hFile)
{
    char  filename[_MAX_PATH];      // get module file name
    return ::GetModuleFileName(hFile, filename, _MAX_PATH) <= 0? false : init(filename);
}

bool FileInformation::init(const char *pszFilename)
{
    zerroing();
    HANDLE h=::FindFirstFile(pszFilename, static_cast<FILE_INFORMATION_STRUCTURE*>(this));
    return h==INVALID_HANDLE_VALUE? false : (::FindClose(h) !=0);
}

std::ostream& FileInformation::getFileInformationAsHtml(std::ostream& os)
{
    os<<"<TABLE BORDER=1 CELLSPACING=0 COLS=3><THEAD><TR><TH COLSPAN=3>" << HTML::escape(cFileName) << "</TH></TR></THEAD>";
    if(!exist())
        return os << "<TR><TD COLSPAN=3>Information on file is not available</TD></TR></TABLE>";

    os<<"<THEAD><TR><TH ALIGN=RIGHT>Name</TH><TH ALIGN=LEFT>Value</TH><TH ALIGN=LEFT>Comment</TH></TR></THEAD>"
        "<TR><TD ALIGN=RIGHT>Created</TD><TD><NOBR>" << CTimer::FileTimeAsHtml(ftCreationTime) << "</NOBR></TD><TD ROWSPAN=3 STYLE='font-size:x-small'>Not all file systems can record these values and not all file systems record them in the same manner. F.e., "
                                                                                    "on Windows NT FAT, create time has a resolution of 10 milliseconds, write time has a resolution of 2 seconds, and access time has a resolution of 1 day "
                                                                                    "(really, the access date). On NTFS, access time has a resolution of 1 hour. FAT records times on disk in local time, while NTFS records times on disk in UTC, "
                                                                                    "so it is not affected by changes in time zone or daylight saving time</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Modified</TD><TD><NOBR>" << CTimer::FileTimeAsHtml(ftLastWriteTime) << "</NOBR></TD></TR>"
        "<TR><TD ALIGN=RIGHT>Accessed</TD><TD><NOBR>" << CTimer::FileTimeAsHtml(ftLastAccessTime) << "</NOBR></TD></TR>"
    ;
        
    if(nFileSizeHigh !=0)
    {
        long double fileSize = double(nFileSizeHigh)*(double(ULONG_MAX)+1) +double(nFileSizeLow);
        os << "<TR><TD ALIGN=RIGHT>Size</TD><TD>" << fileSize << "</TD><TD>bytes</TD></TR>";
    }
    else
    {
        std::locale old_locale(os.imbue(std::locale("American_USA.1252"))); // change locale to the USA one to set thousands separator to ','
        os << std::fixed << "<TR><TD ALIGN=RIGHT>Size</TD><TD>" << nFileSizeLow << "</TD><TD>bytes</TD></TR>";
        os.imbue(old_locale);   // restore locale 
    }
        
    os<<"<TR><TD ALIGN=RIGHT><NOBR>Alternate name</NOBR></TD><TD>" << (cAlternateFileName[0]==0?" ":cAlternateFileName) << "</TD><TD STYLE='font-size:x-small'>short 8.3 (filename.ext) file name format (MS-DOS name)</TD></TR>"
//          "<TR><TD ALIGN=RIGHT><NOBR>Volume Serial Number</NOBR></TD><TD><B>" << dwVolumeSerialNumber << "</B></TD><TD STYLE='font-size:x-small'>volume where this file resides in</TD></TR>"
//          "<TR><TD ALIGN=RIGHT><NOBR>Number of links</NOBR></TD><TD><B>"  << nNumberOfLinks << "</B></TD><TD STYLE='font-size:x-small'>number of links to this file. For the FAT file system this member is always 1</TD></TR>"
//          "<TR><TD ALIGN=RIGHT><NOBR>System Index</NOBR></TD><TD><B>" << std::hex << nFileIndexHigh << std::setfill('0') << std::setw(8) << nFileIndexLow << "</B></TD><TD STYLE='font-size:x-small'> (hex) unique ID the system assigned to this file on opening</TD></TR>"
        "<THEAD><TR><TH COLSPAN=3 ALIGN=LEFT>Attributes:</TH></TR></THEAD>"
        "<TR><TD ALIGN=RIGHT>Archive"                   "</TD><TD>" << attribute(FILE_ATTRIBUTE_ARCHIVE)    << "</TD><TD STYLE='font-size:x-small'>marked by an application for backup or removal</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Readonly"                  "</TD><TD>" << attribute(FILE_ATTRIBUTE_READONLY)   << "</TD><TD STYLE='font-size:x-small'>applications can read the file but cannot write to or delete it</TD></TR>"
        "<TR><TD ALIGN=RIGHT>System"                    "</TD><TD>" << attribute(FILE_ATTRIBUTE_SYSTEM)     << "</TD><TD STYLE='font-size:x-small'>part of (or is used exclusively by) the operating system</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Compressed"                "</TD><TD>" << attribute(FILE_ATTRIBUTE_COMPRESSED) << "</TD><TD STYLE='font-size:x-small'>data in file or directory is compressed</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Directory"                 "</TD><TD>" << attribute(FILE_ATTRIBUTE_DIRECTORY)  << "</TD><TD> </TD></TR>"
        "<TR><TD ALIGN=RIGHT>Encrypted"                 "</TD><TD>" << attribute(FILE_ATTRIBUTE_ENCRYPTED)  << "</TD><TD STYLE='font-size:x-small'>data in the file or directory is encrypted</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Hidden"                    "</TD><TD>" << attribute(FILE_ATTRIBUTE_HIDDEN)     << "</TD><TD STYLE='font-size:x-small'>not visible in an ordinary directory listing</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Normal"                    "</TD><TD>" << attribute(FILE_ATTRIBUTE_NORMAL)     << "</TD><TD STYLE='font-size:x-small'>file has no other attributes. This attribute is valid only if used alone</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Offline"                   "</TD><TD>" << attribute(FILE_ATTRIBUTE_OFFLINE)        << "</TD><TD STYLE='font-size:x-small'>data is not immediately available (the file data has been physically moved to offline storage)</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Reparse point</NOBR>""</TD><TD>" << attribute(FILE_ATTRIBUTE_REPARSE_POINT)  << "</TD><TD STYLE='font-size:x-small'>file has an associated reparse point</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Sparse file</NOBR>"  "</TD><TD>" << attribute(FILE_ATTRIBUTE_SPARSE_FILE)    << "</TD><TD STYLE='font-size:x-small'>file is a sparse file</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Temporary"                 "</TD><TD>" << attribute(FILE_ATTRIBUTE_TEMPORARY)      << "</TD><TD STYLE='font-size:x-small'>file is being used for temporary storage</TD></TR>"
        "</TABLE>"
        ;
    return os;
}
std::ostream& FileInformation::getFileInformation(std::ostream& os)
{
    os <<"File name: "  << cFileName << "\r\n";
    if(!exist())
    {
        os << "File does not exist\r\n";
        return os;
    }

    long double fileSize = double(nFileSizeHigh)*(double(ULONG_MAX)+1) +double(nFileSizeLow);
    os<<"Modified: "        << CTimer::FileTimeAsHtml(ftLastWriteTime)              << "\r\n"
        "Accessed: "        << CTimer::FileTimeAsHtml(ftLastAccessTime)         << "\r\n"
        ;
    os<<"Size (bytes): "    << std::setprecision(0) << fileSize << "\r\n"
        "Alternate name: "  << (cAlternateFileName[0]==0?"":cAlternateFileName) << "; short 8.3 (filename.ext) file name format (MS-DOS name)\r\n"
//          "Volume Serial Number: "    << dwVolumeSerialNumber << "; volume where this file resides in\r\n"
//          "Number of links: " << nNumberOfLinks << "; number of links to this file. For the FAT file system this member is always 1\r\n"
//          "System Index (hex): "  << nFileIndexHigh << std::setfill('0') << std::setw(8) << nFileIndexLow << "; unique ID the system assigned to this file on opening\r\n"
        "Attributes:\r\n"
        "  Archive       " << attribute(FILE_ATTRIBUTE_ARCHIVE)         << "; marked by an application for backup or removal\r\n"
        "  Readonly      " << attribute(FILE_ATTRIBUTE_READONLY)        << "; applications can read the file but cannot write to or delete it\r\n"
        "  System        " << attribute(FILE_ATTRIBUTE_SYSTEM)          << "; part of (or is used exclusively by) the operating system\r\n"
        "  Compressed    " << attribute(FILE_ATTRIBUTE_COMPRESSED)      << "; data in file or directory is compressed\r\n"
        "  Directory     " << attribute(FILE_ATTRIBUTE_DIRECTORY)       << "\r\n"
        "  Encrypted     " << attribute(FILE_ATTRIBUTE_ENCRYPTED)       << "; data in the file or directory is encrypted\r\n"
        "  Hidden        " << attribute(FILE_ATTRIBUTE_HIDDEN)          << "; not visible in an ordinary directory listing\r\n"
        "  Normal        " << attribute(FILE_ATTRIBUTE_NORMAL)          << "; file has no other attributes. This attribute is valid only if used alone\r\n"
        "  Offline       " << attribute(FILE_ATTRIBUTE_OFFLINE)         << "; data is not immediately available (the file data has been physically moved to offline storage)\r\n"
        "  Reparse point " << attribute(FILE_ATTRIBUTE_REPARSE_POINT)   << "; file has an associated reparse point\r\n"
        "  Sparse file   " << attribute(FILE_ATTRIBUTE_SPARSE_FILE)     << "; file is a sparse file\r\n"
        "  Temporary     " << attribute(FILE_ATTRIBUTE_TEMPORARY)       << "; file is being used for temporary storage\r\n"
        ;
    return os;
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// FileVersion
//
bool FileVersion::init(HMODULE lib)
{
    m_strFileName = "";
    char  filename[_MAX_PATH];      // get module file name
    return ::GetModuleFileName(lib, filename, _MAX_PATH) <= 0? false : init(filename);
}
bool FileVersion::init(const char* modulename)
{
    zerroing();
    m_strFileName = modulename;
    m_translation.charset = 1252;       // default = ANSI code page

    DWORD dwDummyHandle; // will always be set to zero
    DWORD len = ::GetFileVersionInfoSize(const_cast<char*>(modulename), &dwDummyHandle);
    if(len <= 0)
        return false;

    delete [] m_pVersionInfo;
    m_pVersionInfo = new BYTE[len]; // allocate version info
    if(!::GetFileVersionInfo(const_cast<char*>(modulename), 0, len, m_pVersionInfo))
        return false;

    LPVOID lpvi;
    UINT iLen;
    if(!::VerQueryValue(m_pVersionInfo, "\\", &lpvi, &iLen))
        return false;

    ::memcpy(static_cast<VS_FIXEDFILEINFO*>(this), lpvi, sizeof VS_FIXEDFILEINFO);

    //
    // Get translation info. Note: VerQueryValue could return a value > 4, in which case
    // mulitple languages are supported and VerQueryValue returns an array of langID/codepage 
    // pairs and you have to decide which to use.
    //
    if(::VerQueryValue(m_pVersionInfo, "\\VarFileInfo\\Translation", &lpvi, &iLen) && iLen >= 4) 
        m_translation = *(TRANSLATION*)lpvi;

    return dwSignature == VS_FFI_SIGNATURE;
}

std::string FileVersion::value(const char* lpKeyName) const
{
    std::string sVal;
    if(m_pVersionInfo==0)
        return sVal;

    // To get a string value must pass query in the form
    //    "\StringFileInfo\<langID><codepage>\keyname"
    std::ostringstream query;
    query   << "\\StringFileInfo\\" << std::setfill('0') << std::hex << std::setw(4) 
            << m_translation.langID << std::setw(4) << m_translation.charset << "\\" << lpKeyName;

    char  *pVal;
    UINT iLenVal;
    if(::VerQueryValue(m_pVersionInfo, const_cast<char*>(query.str().c_str()), (LPVOID*)&pVal, &iLenVal))
        sVal = pVal;
    return sVal;
}

std::string FileVersion::getValueAsHtml(const char* lpKeyName) const
{
    std::string sVal(value(lpKeyName));
    return sVal.empty() ? std::string(" ") : HTML::escape(sVal);
}

std::string FileVersion::getCreatedTimeAsHtml() const
{
//      ft.dwLowDateTime = dwFileDateLS; 
//      ft.dwHighDateTime = dwFileDateMS;
    return FileTime(dwFileDateLS, dwFileDateMS).AsHtml();

}
std::string FileVersion::getCreatedTimeAsString() const
{
    FILETIME ft={ dwFileDateLS, dwFileDateMS };
    return CTimer::FileTimeAsString(ft);
}

std::string FileVersion::getFlagsInfoAsHtml() const
{
    DWORD f = dwFileFlagsMask & dwFileFlags; 
    std::string s("<UL STYLE='MARGIN-LEFT:0'>");
    if(f & VS_FF_DEBUG)
        s += "<LI>The file contains debugging information or is compiled with debugging features enabled</LI>";
    if(f & VS_FF_INFOINFERRED)
        s += "<LI>The file's version structure was created dynamically (some of the version information may be incorrect)</LI>"; 
    if(f & VS_FF_PATCHED)
        s +="<LI>The file has been modified and is not identical to the original shipping file of the same version number</LI>";
    if(f & VS_FF_PRERELEASE)
        s +="<LI>The file is a development version, not a commercially released product</LI>";
    if(f & VS_FF_PRIVATEBUILD)
        s +="<LI>The file was not built using standard release procedures. See <B>Private Build</B> for more info</LI>"; 
    if(f & VS_FF_SPECIALBUILD)
        s +="<LI>The file was built by the original company using standard release procedures but is a variation "
            "of the normal file of the same version number. See <B>Special Build</B> for more info</LI>"; 
    return s +="</UL>";
}

std::ostream& FileVersion::getFlagsInfoAsHtml(std::ostream& s) const
{
    DWORD f = dwFileFlagsMask & dwFileFlags;
    s << "<UL>";
    if(f & VS_FF_DEBUG)
        s << "<LI>The file contains debugging information or is compiled with debugging features enabled</LI>";
    if(f & VS_FF_INFOINFERRED)
        s << "<LI>The file's version structure was created dynamically (some of the version information may be incorrect)</LI>"; 
    if(f & VS_FF_PATCHED)
        s <<"<LI>The file has been modified and is not identical to the original shipping file of the same version number</LI>";
    if(f & VS_FF_PRERELEASE)
        s <<"<LI>The file is a development version, not a commercially released product</LI>";
    if(f & VS_FF_PRIVATEBUILD)
        s <<"<LI>The file was not built using standard release procedures. See <B>Private Build</B> for more info</LI>"; 
    if(f & VS_FF_SPECIALBUILD)
        s <<"<LI>The file was built by the original company using standard release procedures but is a variation "
            "of the normal file of the same version number. See <B>Special Build</B> for more info</LI>"; 
    return s << "</UL>";
}
//
// stream/string output
//
std::ostream& FileVersion::getFileVersionAsHtml(std::ostream& os) const
{
    DWORD f = dwFileFlagsMask & dwFileFlags; 
    os<<"<TABLE BORDER=1 COLS=2 CELLSPACING=0>"
        "<THEAD><TR><TH COLSPAN=2>" << m_strFileName << "</TH></TR></THEAD>";

    if(!valid())
        return os << "<TR><TD COLSPAN=2>Version information is not available</TD></TR></TABLE>";
    
    os<<"<THEAD><TR><TD ALIGN=RIGHT><B>Name</B></TD><TD><B>Value</B></TD></TR></THEAD>"
        "<TR><TD ALIGN=RIGHT>Created"                       "</TD><TD>" << getCreatedTimeAsString()         << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT>Flags"                         "</TD><TD>" << getFlagsInfoAsHtml()             << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>File Description</NOBR></TD><TD>"    << getValueAsHtml("FileDescription")<< "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Original Filename</NOBR></TD><TD>"   << getValueAsHtml("OriginalFilename")<< "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Production Name</NOBR></TD><TD>"     << getValueAsHtml("ProductName")    << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Production Version</NOBR></TD><TD>"  << getValueAsHtml("ProductVersion") << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>File Version</NOBR></TD><TD>"        << getValueAsHtml("FileVersion")    << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Internal Name</NOBR></TD><TD>"       << getValueAsHtml("InternalName")   << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Company Name</NOBR></TD><TD>"        << getValueAsHtml("CompanyName")    << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Comments</NOBR></TD><TD>"            << getValueAsHtml("Comments")       << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Legal Copyright</NOBR></TD><TD>"     << getValueAsHtml("LegalCopyright") << "</TD></TR>"
        "<TR><TD ALIGN=RIGHT><NOBR>Legal Trademarks</NOBR></TD><TD>"    << getValueAsHtml("LegalTrademarks")<< "</TD></TR>";

    if(f & VS_FF_PRIVATEBUILD)
        os << "<TR><TD ALIGN=RIGHT><NOBR>Private Build</NOBR></TD><TD>" << getValueAsHtml("PrivateBuild")   << "</TD></TR>";
    if(f & VS_FF_SPECIALBUILD)
        os << "<TR><TD ALIGN=RIGHT><NOBR>Special Build</NOBR></TD><TD>" << getValueAsHtml("SpecialBuild")   << "</TD></TR>";

    return os << "</TABLE>";
}
std::ostream& FileVersion::getFileVersion(std::ostream& os) const
{
    DWORD f = dwFileFlagsMask & dwFileFlags; 
    os  <<  "File name: "           << m_strFileName                    << "\r\n"
            "Created: "             << getCreatedTimeAsHtml()           << "\r\n"
            "Flags: "               << (dwFileFlagsMask & dwFileFlags)  << "\r\n"
            "File Description: "    << value("FileDescription")         << "\r\n"
            "Original Filename: "   << value("OriginalFilename")        << "\r\n"
            "Production Name: "     << value("ProductName")             << "\r\n"
            "Production Version: "  << value("ProductVersion")          << "\r\n"
            "File Version: "        << value("FileVersion")             << "\r\n"
            "Internal Name: "       << value("InternalName")            << "\r\n"
            "Company Name: "        << value("CompanyName")             << "\r\n"
            "Comments: "            << value("Comments")                << "\r\n"
            "Legal Copyright: "     << value("LegalCopyright")          << "\r\n"
            "Legal Trademarks: "    << value("LegalTrademarks")         << "\r\n";

    if(f&VS_FF_PRIVATEBUILD) os << "Private Build: " << value("PrivateBuild") << "\r\n";
    if(f&VS_FF_SPECIALBUILD) os << "Special Build: " << value("SpecialBuild") << "\r\n";
    return os;
}

//////////////////////////////////////////////////////////////////////////////////////////////
//
/*
//
// starting Internet explorer
//
IDispatch* InternetExplorer::OnStartIE() 
{
    //
    // Create an instance of Internet Explorer 4.0
    //
    HRESULT hr = ::CoCreateInstance(CLSID_InternetExplorer, NULL, CLSCTX_LOCAL_SERVER, 
                            IID_IWebBrowser2, (void**)&m_pIE);
    if(FAILED(hr))
        return;

    //
    // Set up the event sink
    //
    BOOL bAdvised = AfxConnectionAdvise(m_pIE, DIID_DWebBrowserEvents2,
                             m_pIE4Events->GetInterface(&IID_IUnknown),
                             TRUE, &m_dwCookie);

    TRACE("Advise for DWebBrowserEvents2 %s\n", bAdvised ? "succeeded" : "failed");

    m_pIE->put_Visible(VARIANT_TRUE);       // Make IE4 visible

    _variant_t vtEmpty;
    m_pIE->Navigate(url.c_str(), &vtEmpty, &vtEmpty, &vtEmpty, &vtEmpty);
}

*/
std::string InternetExplorer::PathToExecutable()
{
    std::string str= RegistryKey::GetStringValue(HKEY_CLASSES_ROOT, "http\\shell\\open\\command");
    if(!str.empty())
    {
        if(str[0] =='\"')
            str.erase(0,1), str.erase(str.find('\"'));
        else
            str.erase(str.find(' '));
    }
    return str;
}

std::ostream& InternetExplorer::getFullInformationAsHtml(std::ostream& os)
{
    RegistryKey reg (HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Internet Explorer", KEY_QUERY_VALUE);
    RegistryKey reg2(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", KEY_QUERY_VALUE);
    os <<   "<H2>Internet explorer (info from registry)</H2>"
            "<TABLE BORDER CELLSPACING=0 COLS=2><TBODY>"
//          "<TR><TD>Version<TD>"   << HTML::escape(reg.GetStringValue("Version"))          << " "
//                                  << HTML::escape(reg.GetStringValue("CustomizedVersion"))<< " "
//                                  << HTML::escape(reg2.GetStringValue("MinorVersion"))    << "</TD></TR>"
            "<THEAD><TR><TD COLSPAN=2>HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Internet Explorer</TD></TR></THEAD>";
    
    reg.EnumerateValuesAsHtmlTBODY(os);
    os << "<THEAD><TR><TD COLSPAN=2>HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings</TD></TR></THEAD>";
    reg2.EnumerateValuesAsHtmlTBODY(os);
    os << "</TBODY></TABLE>";

    std::string str = PathToExecutable();
    FileInformation (str).getFileInformationAsHtml(os);
    FileVersion     (str).getFileVersionAsHtml(os);
    return os;
}
#pragma comment(lib, "Version.lib")
#pragma comment(lib, "WinInet.lib")
#pragma comment(lib, "Shell32.lib")

HINSTANCE InternetExplorer::ShellExecute(const URL& url)
{
    return ::ShellExecute(0, "open", PathToExecutable().c_str(), url.c_str(), 0, SW_SHOWNORMAL);
}

void InternetExplorer::Open(const URL& url) throw(CRuntime_error)
{
    HINSTANCE hinst = ShellExecute(url);
    DWORD err = (DWORD)hinst;
    if(err <=32)
        throw CRuntime_error("<B>Description: </B><DESCRIPTION>Failed to launch Internet Explorer</DESCRIPTION>", err);
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// text_files_cache
//
void text_files_cache::clear()
{
    critical_section mapGuard(s_csTextFiles);
    s_mapTextFiles.clear();
    s_mapTextFilesInformation.clear();
}

std::string text_files_cache::get_contents(const std::string& filename)
{
    critical_section mapGuard(s_csTextFiles);   // CS to guard map
    TmapTextFiles::iterator it = s_mapTextFiles.find(filename);
    if(it != s_mapTextFiles.end())
        return it->second.c_str();      // make a copy of the string since it might be thread-crossing

    //      mapGuard.unlock();                  // release the map while preparing the file
    std::string strError = "<B>File: </B><SOURCE>" + filename + "</SOURCE>";
    FileInformation info(get_information(filename));
    if(!info.exist())
        throw CRuntime_error(strError.c_str(), "File does not exist");
    
    HANDLE hFileRaw = ::CreateFile( filename.c_str(), 
                                    GENERIC_READ, 
                                    FILE_SHARE_READ | FILE_SHARE_WRITE,
                                    (LPSECURITY_ATTRIBUTES) 0, 
                                    OPEN_EXISTING,
                                    FILE_ATTRIBUTE_READONLY,
                                    (HANDLE) 0);

    strError += "<BR /><B>Notes: <NOTES>Error on reading</NOTES>";
    DWORD dwSize, dwRead;
    handle<HANDLE> hFile;
    if(hFileRaw ==INVALID_HANDLE_VALUE || !(hFile=hFileRaw).valid() || (dwSize = ::GetFileSize((HANDLE) hFile, 0)) == INVALID_FILE_SIZE)
        throw CRuntime_error(strError.c_str(), ::GetLastError());

    //
    // TODO: implement read-out data chunk by chunk and pending input
    //
    std::string strData(dwSize, ' ');
    if(!::ReadFile((HANDLE) hFile, const_cast<char*>(strData.data()), dwSize, &dwRead, 0))
        throw CRuntime_error(strError.c_str(), ::GetLastError());

    //      mapGuard.lock();                    // hold up the map to cache..
    s_mapTextFiles[filename] = strData;
    return std::string(strData.c_str());
}

FileInformation text_files_cache::get_information(const std::string& filename)
{
    critical_section mapGuard(s_csTextFiles);   // CS to guard map
    TmapTextFilesInformation::iterator it = s_mapTextFilesInformation.find(filename);
    if(it != s_mapTextFilesInformation.end())
        return it->second;
    
    FileInformation info(filename);
    if(info.exist())
        s_mapTextFilesInformation[filename] = info;
    return info;
}

HTML& text_files_cache::getFileInformation(HTML& os, std::string filename)
{
    TmapTextFilesInformation::iterator it;
    critical_section mapGuard(s_csTextFiles);   // CS to guard map
    if(!filename.empty())
    {
        if((it = s_mapTextFilesInformation.find(filename)) != s_mapTextFilesInformation.end())
            it->second.getFileInformation(os) << "<P>Keyed as <B>" << it->first << "</B></P>";
    }
    else    // dump all the info into stream
    {
        for(it=s_mapTextFilesInformation.begin() ; it != s_mapTextFilesInformation.end() ; ++it)
            it->second.getFileInformation(os)  << "<P>Keyed as <B>" << it->first << "</B></P>";
    }       
    return os;
}
std::string text_files_cache::getHtmlFormClearCache(std::string strName, std::string strInclude)
{
    return "<INPUT ID=idClearFileCache TYPE=CHECKBOX VALUE='checked' NAME="+strName +" "+
            strInclude +"><LABEL FOR=idClearFileCache>Clear File cache</LABEL>";
}
/////////////////////////////////////////////////////////////////////////////////////////
//
// text_file
//
text_file& text_file::replace(const std::string& f, const std::string& r, int n)
{
    for(size_type pos =0 ; n-- >0 && (pos =find(f, pos)) != npos ; pos +=r.length())
        static_cast<std::string*>(this)->replace(pos, f.length(), r);
    return *this;
}
text_file& text_file::replace_or_append(const std::string& f, const std::string& r)
{
    size_type pos(find(f));
    if(pos !=npos)
        static_cast<std::string&>(*this).replace(pos, f.length(), r);
    else
        static_cast<std::string&>(*this).append("<DIV STYLE='font-size:x-large;text-align:center;color:red;background-color:white;'>")
                                        .append(r);
    return *this;
}
text_file& text_file::insert(const std::string& f, const std::string& r, int n)
{ 
    for(size_type pos =0 ; n-- >0 && (pos =find(f, pos)) != npos ; pos +=f.length() +r.length())
        static_cast<std::string*>(this)->insert(pos +f.length(), r);
    return *this;
}

text_files_cache& text_file::get_cache()
{
    static text_files_cache s_cache;
    return s_cache;
}

std::string text_file::text(const std::string& filename) throw(CRuntime_error)
{
    return get_cache().get_contents(filename);
}


HTML& text_file::information(HTML& os, const std::string& filename) throw(CRuntime_error)
{
    return get_cache().getFileInformation(os, filename);
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// CSV_parser
//
CSV_parser& CSV_parser::set_max_size(size_t m) throw(CRuntime_error)
{ 
    if((_max_size = min(static_cast<string_vector&>(*this).max_size(), m)) ==0)
        throw CRuntime_error("Source: <SOURCE>CSV_parser</SOURCE>", "set_max_size to zerro");
    return *this;
}
CSV_parser& CSV_parser::add(const std::string& str)
{
    //
    // if(_parsed >=max_size)
    //      TODO: ?throw on _parsed == max_size?
    //
    for(unsigned p=0 , p0=0 ; (p = str.find(pszDelim, p0)) !=str.npos ; p0 =p +1)
        if(_parsed++ < _max_size)
            push_back(str.substr(p0, p - p0));
        else
        {
            push_back(str.substr(p +1));
            return *this;
        }
    //
    // there is no delimiters anymore in the string, so add the rest of string to CVS
    //
    if(p ==str.npos && _parsed < _max_size) 
    {
        ++_parsed;
        push_back(str.substr(p0));
    }
    return *this;
}

std::string CSV_parser::getAsString(unsigned beg, unsigned end) const 
{
    std::string s;
    for(end = min(end, size()) ; beg < end ; ++beg)
    {
        if(!s.empty())
            s +=pszDelim;
        s +=value_of(beg);
    }
    return s;

}

/////////////////////////////////////////////////////////////////////////////////////////
//
//                   implementation of WIN32_thread
//
WIN32_thread::~WIN32_thread()
{ 
    terminate(3000);
}

DWORD WINAPI WIN32_thread_starter(LPVOID pthread_t)
{
    WIN32_thread * p = reinterpret_cast<WIN32_thread*>(pthread_t);
    DWORD res = p->thread_body();
    ::CloseHandle(p->m_hThread);
    p->m_hThread = 0;
    p->m_ThreadID = 0;
    return res;
}

void WIN32_thread::start(bool bYield)
{
    if(m_hThread ==0)
    {
        m_hThread = ::CreateThread( NULL,   // security attributes
                                    0,      // stack size (default value)
                    reinterpret_cast<DWORD (WINAPI *)(LPVOID)> (WIN32_thread_starter), // start point of thread
                                    this,   // parameters (this pointer)
                                    0,      // flags
                                    &m_ThreadID);

//#pragma message(MESSAGE_ANCHOR "Uncomment the following")
        if(bYield)
            ::Sleep(50);    //::SwitchToThread();
    }
}

void WIN32_thread::terminate(int mls_timeout)
{
    if(m_ThreadID ==0)              // restart the thread if it has not had been started yet
        return;         
    ::PostThreadMessage(m_ThreadID,                 // thread identifier
                        WM_QUIT,                    // message
                        0,                          // first message parameter
                        0);                         // second message parameter

    if(::WaitForSingleObject(m_hThread, mls_timeout) ==WAIT_TIMEOUT)
        ::TerminateThread(m_hThread, -01); // -1 exit code

    ::CloseHandle(m_hThread);
    m_hThread = 0;
    m_ThreadID = 0;
}
    
void WIN32_thread::post_WIN32_message(UINT msg, WPARAM wpar, LPARAM lpar)
{
    if(m_ThreadID ==0)              // restart the thread if it has not had been started yet
        start(true);                // .. yield this thread to let posted thread run
    ::PostThreadMessage(m_ThreadID, msg, wpar, lpar);
}

UINT WIN32_thread::get_WIN32_message(MSG& msg, UINT first_message, UINT last_message)
{
    ::memset(&msg, 0, sizeof msg); 
    ::GetMessage(&msg,                  // message information
                    0,                  // handle to window (thread itself)
                    first_message,
                    last_message);
    return msg.message;
}