utility.h

Go to the documentation of this file.

/*
 * Copyright 2003, 2004, 2005 Martin Fuchs
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 
 //
 // Explorer clone
 //
 // utility.h
 //
 // Martin Fuchs, 23.07.2003
 //
 
 // standard windows headers
#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN
#define WIN32_NO_STATUS
#define _INC_WINDOWS
#define COM_NO_WINDOWS_H
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winuser.h>
 
//#include <undocuser.h>
 
 // Unicode support
#if defined(UNICODE) && !defined(_UNICODE)
#define _UNICODE
#endif
#include <tchar.h>
 
#include <windowsx.h>   // for SelectBrush(), ListBox_SetSel(), SubclassWindow(), ...
#include <commctrl.h>
 
#include <objbase.h>
//#include <oleauto.h>  // for VARIANT
 
//#include <malloc.h>       // for alloca()
#include <assert.h>
//#include <stdlib.h>       // for _MAX_DIR, ...
#include <stdio.h>      // for sprintf()
//#include <time.h>
 
#ifdef __cplusplus
 
#ifdef _MSC_VER
#pragma warning(disable: 4786)  // disable warnings about too long debug information symbols
#endif
 
 // STL headers for strings and streams
#include <string>
#include <iostream>
using namespace std;
 
#endif /* __cplusplus */
 
#ifndef _MAX_PATH
#define _MAX_DRIVE  3
#define _MAX_FNAME  256
#define _MAX_DIR    _MAX_FNAME
#define _MAX_EXT    _MAX_FNAME
#define _MAX_PATH   260
#endif
 
#define W_VER_NT 0  // constant for HIWORD(GetVersion())>>14
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
#define for if (0) {} else for
 
#ifdef _countof
#define COUNTOF _countof
#else
#define COUNTOF(x)  (sizeof(x)/sizeof(x[0]))
#endif
 
 
#define BUFFER_LEN              2048
 
 
extern void _log_(LPCTSTR txt);
 
#define LOG(txt) _log_(txt)
 
 
#ifdef _MSC_VER
#define LONGLONGARG TEXT("I64")
#else
#define LONGLONGARG TEXT("L")
#endif
 
 
#ifndef _tcsrchr
#ifdef UNICODE
#define _tcsrchr wcsrchr
#else
#define _tcsrchr strrchr
#endif
#endif
 
#ifndef _stprintf
#ifdef UNICODE
#define _stprintf wcsprintf
#else
#define _stprintf sprintf
#endif
#endif
 
#define U2A(s, d, l) WideCharToMultiByte(CP_ACP, 0, s, -1, d, l, NULL, NULL)
#define U2nA(s, d, l) WideCharToMultiByte(CP_ACP, 0, s, l, d, l, NULL, NULL)
#define A2U(s, d, l) MultiByteToWideChar(CP_ACP, 0, s, -1, d, l)
#define A2nU(s, d, l) MultiByteToWideChar(CP_ACP, 0, s, l, d, l)
 
 
#ifdef __WINE__
#ifdef UNICODE
extern void _wsplitpath(const WCHAR* path, WCHAR* drv, WCHAR* dir, WCHAR* name, WCHAR* ext);
#else
extern void _splitpath(const CHAR* path, CHAR* drv, CHAR* dir, CHAR* name, CHAR* ext);
#endif
#define _tcsnicmp strncasecmp
#define _tcsicoll strcasecmp
#endif
 
#ifndef FILE_ATTRIBUTE_NOT_CONTENT_INDEXED
#define FILE_ATTRIBUTE_ENCRYPTED            0x00000040
#define FILE_ATTRIBUTE_SPARSE_FILE          0x00000200
#define FILE_ATTRIBUTE_REPARSE_POINT        0x00000400
#define FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  0x00002000
#endif
 
 
#define SetDlgCtrlID(hwnd, id) SetWindowLongPtr(hwnd, GWL_ID, id)
#define SetWindowStyle(hwnd, val) (DWORD)SetWindowLongPtr(hwnd, GWL_STYLE, val)
#define SetWindowExStyle(h, val) (DWORD)SetWindowLongPtr(hwnd, GWL_EXSTYLE, val)
#define Window_SetIcon(hwnd, type, hicon) (HICON)SendMessage(hwnd, WM_SETICON, type, (LPARAM)(hicon))
 
 
 // center window in respect to its parent window
extern void CenterWindow(HWND hwnd);
 
 // move window into visibility
extern void MoveVisible(HWND hwnd);
 
 // display error message
extern void display_error(HWND hwnd, DWORD error);
 
 // convert time_t to WIN32 FILETIME
extern BOOL time_to_filetime(const time_t* t, FILETIME* ftime);
 
 // search for windows of a specific classname
extern int find_window_class(LPCTSTR classname);
 
 // create a directory with all missing parent directories
BOOL RecursiveCreateDirectory(LPCTSTR path_in);
 
 // read DWORD value from registry
DWORD RegGetDWORDValue(HKEY root, LPCTSTR path, LPCTSTR valueName, DWORD def);
 
 // write DWORD value to registry
BOOL RegSetDWORDValue(HKEY root, LPCTSTR path, LPCTSTR valueName, DWORD value);
 
 // test for existing directory
BOOL exists_path(LPCTSTR path);
 
 
#ifdef __cplusplus
} // extern "C"
#endif
 
 
 // secure CRT functions
//@@ _MS_VER: temporarily needed for the ReactOS build environment
#if defined(__STDC_WANT_SECURE_LIB__) && defined(_MS_VER)   // for VS 2005: _MSC_VER>=1400
 
#define _stprintf_s1 _stprintf_s
#define _stprintf_s2 _stprintf_s
 
#else   // __STDC_WANT_SECURE_LIB__
 
#define strcpy_s(d, l, s) strcpy(d, s)
#define wcscpy_s(d, l, s) wcscpy(d, s)
#define wcsncpy_s(d, l, s, n) wcsncpy(d, s, n)
 
#if defined(_tcscpy) && !defined(_tcscpy_s)
#define _tcscpy_s(d, l, s) _tcscpy(d, s)
#endif
 
#if defined(_tsplitpath) && !defined(_tsplitpath_s)
#define _tsplitpath_s(f, d,dl, p,pl, n,nl, e,el) _tsplitpath(f, d, p, n, e)
#else
#define _wsplitpath_s(f, d,dl, p,pl, n,nl, e,el) _wsplitpath(f, d, p, n, e)
#define _splitpath_s(f, d,dl, p,pl, n,nl, e,el) _splitpath(f, d, p, n, e)
#endif
 
#define _stprintf_s1(b, l, f, p1) _stprintf(b, f, p1)
#define _stprintf_s2(b, l, f, p1,p2) _stprintf(b, f, p1,p2)
 
#endif  // __STDC_WANT_SECURE_LIB__
 
 
#ifdef __cplusplus
 
 // containers
#include <map>
#include <set>
#include <list>
#include <stack>
#include <vector>
 
 
/* not necessary with correct include file order for comdef.h ("<MS PSDK>\include" path first) */
#if _MSC_VER>=1300  // VS.Net
#define _NO_COMUTIL
#endif
 
 
#if defined(_MSC_VER) && !defined(_NO_COMUTIL)
 
 // COM utility headers
#include <comdef.h>
using namespace _com_util;
 
#endif  // _MSC_VER && !_NO_COMUTIL
 
 
 // launch a program or document file
extern BOOL launch_file(HWND hwnd, LPCTSTR cmd, UINT nCmdShow=SW_SHOWNORMAL, LPCTSTR parameters=NULL);
#ifdef UNICODE
extern BOOL launch_fileA(HWND hwnd, LPSTR cmd, UINT nCmdShow=SW_SHOWNORMAL, LPCSTR parameters=NULL);
#else
#define launch_fileA launch_file
#endif
 
 // call an DLL export like rundll32
extern BOOL RunDLL(HWND hwnd, LPCTSTR dllname, LPCSTR procname, LPCTSTR cmdline, UINT nCmdShow);
 
 // launch control panel applet
extern BOOL launch_cpanel(HWND hwnd, LPCTSTR applet);
 
 
struct CommonControlInit
{
    CommonControlInit(DWORD flags=ICC_LISTVIEW_CLASSES|ICC_TREEVIEW_CLASSES|ICC_BAR_CLASSES|ICC_PROGRESS_CLASS|ICC_COOL_CLASSES)
    {
        INITCOMMONCONTROLSEX icc = {sizeof(INITCOMMONCONTROLSEX), flags};
 
        InitCommonControlsEx(&icc);
    }
};
 
 
 
struct WaitCursor   
{
    WaitCursor()
    {
        _old_cursor = SetCursor(LoadCursor(0, IDC_WAIT));
    }
 
    ~WaitCursor()
    {
        SetCursor(_old_cursor);
    }
 
protected:
    HCURSOR _old_cursor;
};
 
 
struct WindowHandle
{
    WindowHandle(HWND hwnd=0)
     :  _hwnd(hwnd) {}
 
    operator HWND() const {return _hwnd;}
    HWND* operator&() {return &_hwnd;}
 
protected:
    HWND    _hwnd;
};
 
 
struct HiddenWindow : public WindowHandle
{
    HiddenWindow(HWND hwnd)
     :  WindowHandle(IsWindowVisible(hwnd)? hwnd: 0)
    {
        if (_hwnd)
            SetWindowPos(_hwnd, 0, 0, 0, 0, 0, SWP_HIDEWINDOW|SWP_NOREDRAW|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
    }
 
    ~HiddenWindow()
    {
        if (_hwnd)
            SetWindowPos(_hwnd, 0, 0, 0, 0, 0, SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
    }
};
 
 
 
struct CritSect : public CRITICAL_SECTION
{
    CritSect()
    {
        InitializeCriticalSection(this);
    }
 
    ~CritSect()
    {
        DeleteCriticalSection(this);
    }
};
 
 
 
struct Lock
{
    Lock(CritSect& crit_sect)
     :  _crit_sect(crit_sect)
    {
        EnterCriticalSection(&crit_sect);
    }
 
    ~Lock()
    {
        LeaveCriticalSection(&_crit_sect);
    }
 
protected:
    CritSect&   _crit_sect;
};
 
 
 
struct Thread
{
    Thread()
     :  _alive(false),
        _destroy(false)
    {
        _hThread = INVALID_HANDLE_VALUE;
        _evtFinish = CreateEvent(NULL, TRUE, FALSE, NULL);
    }
 
    virtual ~Thread()
    {
        Stop();
 
        CloseHandle(_evtFinish);
        CloseHandle(_hThread);
 
        if (_destroy)
            delete this;
    }
 
    void Start()
    {
        if (!_alive) {
            _alive = true;
            _hThread = CreateThread(NULL, 0, ThreadProc, this, 0, NULL);
        }
    }
 
    void Stop()
    {
        SetEvent(_evtFinish);
 
        if (_alive) {
            {
            Lock lock(_crit_sect);
            _alive = false;
            }
 
             // wait for finishing
            WaitForSingleObject(_hThread, INFINITE);
        }
    }
 
    virtual int Run() = 0;
 
    bool    is_alive() const {return _alive;}
 
    CritSect _crit_sect;
 
protected:
    static DWORD WINAPI ThreadProc(void* para);
 
    HANDLE  _hThread;
    HANDLE  _evtFinish;
    bool    _alive;
    bool    _destroy;
};
 
 
 // window utilities
 
struct ClientRect : public RECT
{
    ClientRect(HWND hwnd)
    {
        GetClientRect(hwnd, this);
    }
 
    operator LPRECT() {return this;}
 
    POINT& pos() {return *(LPPOINT)this;}
};
 
struct WindowRect : public RECT
{
    WindowRect(HWND hwnd)
    {
        GetWindowRect(hwnd, this);
    }
 
    operator LPRECT() {return this;}
 
    POINT& pos() {return *(LPPOINT)this;}
};
 
struct Point : public POINT
{
    Point(LONG x_, LONG y_)
    {
        x = x_;
        y = y_;
    }
 
     // constructor for being used in processing WM_MOUSEMOVE, WM_LBUTTONDOWN, ... messages
    Point(LPARAM lparam)
    {
        x = GET_X_LPARAM(lparam);
        y = GET_Y_LPARAM(lparam);
    }
 
    operator LPPOINT() {return this;}
};
 
 
inline void ClientToScreen(HWND hwnd, RECT* prect)
 {::ClientToScreen(hwnd,(LPPOINT)&prect->left); ::ClientToScreen(hwnd,(LPPOINT)&prect->right);}
 
inline void ScreenToClient(HWND hwnd, RECT* prect)
 {::ScreenToClient(hwnd,(LPPOINT)&prect->left); ::ScreenToClient(hwnd,(LPPOINT)&prect->right);}
 
 
struct FullScreenParameters
{
    FullScreenParameters()
     :  _mode(FALSE)
    {
    }
 
    BOOL    _mode;
    RECT    _orgPos;
    BOOL    _wasZoomed;
};
 
 
 // drawing utilities
 
struct PaintCanvas : public PAINTSTRUCT
{
    PaintCanvas(HWND hwnd)
     :  _hwnd(hwnd)
    {
        BeginPaint(hwnd, this);
    }
 
    ~PaintCanvas()
    {
        EndPaint(_hwnd, this);
    }
 
    operator HDC() const {return hdc;}
 
protected:
    HWND    _hwnd;
};
 
struct Canvas
{
    Canvas(HDC hdc) : _hdc(hdc) {}
 
    operator HDC() {return _hdc;}
 
protected:
    HDC _hdc;
};
 
struct WindowCanvas : public Canvas
{
    WindowCanvas(HWND hwnd)
     :  Canvas(GetDC(hwnd)), _hwnd(hwnd) {}
 
    ~WindowCanvas() {ReleaseDC(_hwnd, _hdc);}
 
protected:
    HWND    _hwnd;
};
 
 
 // double buffering classes
 
struct MemCanvas : public Canvas
{
    MemCanvas(HDC hdc=0)
     :  Canvas(CreateCompatibleDC(hdc)) {assert(_hdc);}
 
    ~MemCanvas() {DeleteDC(_hdc);}
};
 
struct SelectedBitmap
{
    SelectedBitmap(HDC hdc, HBITMAP hbmp)
     :  _hdc(hdc), _old_hbmp(SelectBitmap(hdc, hbmp)) {}
 
    ~SelectedBitmap() {DeleteObject(SelectBitmap(_hdc, _old_hbmp));}
 
protected:
    HDC     _hdc;
    HBITMAP _old_hbmp;
};
 
struct BufferCanvas : public MemCanvas
{
    BufferCanvas(HDC hdc, int x, int y, int w, int h)
     :  MemCanvas(hdc), _hdctarg(hdc),
        _x(x), _y(y), _w(w), _h(h),
        _bmp(_hdc, CreateCompatibleBitmap(hdc, w, h)) {}
 
    BufferCanvas(HDC hdc, const RECT& rect)
     :  MemCanvas(hdc), _hdctarg(hdc),
        _x(rect.left), _y(rect.top), _w(rect.right-rect.left), _h(rect.bottom-rect.top),
        _bmp(_hdc, CreateCompatibleBitmap(hdc, _w, _h)) {}
 
protected:
    HDC     _hdctarg;
    int     _x, _y, _w, _h;
    SelectedBitmap _bmp;
};
 
struct BufferedCanvas : public BufferCanvas
{
    BufferedCanvas(HDC hdc, int x, int y, int w, int h, DWORD mode=SRCCOPY)
     :  BufferCanvas(hdc, x, y, w, h), _mode(mode) {}
 
    BufferedCanvas(HDC hdc, const RECT& rect, DWORD mode=SRCCOPY)
     :  BufferCanvas(hdc, rect), _mode(mode) {}
 
    ~BufferedCanvas() {BitBlt(_hdctarg, _x, _y, _w, _h, _hdc, 0, 0, _mode);}
 
    DWORD   _mode;
};
 
struct BufferedPaintCanvas : public PaintCanvas, public BufferedCanvas
{
    BufferedPaintCanvas(HWND hwnd)
     :  PaintCanvas(hwnd),
        BufferedCanvas(PAINTSTRUCT::hdc, 0, 0, rcPaint.right, rcPaint.bottom)
    {
    }
 
    operator HDC() {return BufferedCanvas::_hdc;}
};
 
 
struct TextColor
{
    TextColor(HDC hdc, COLORREF color)
     : _hdc(hdc), _old_color(SetTextColor(hdc, color)) {}
 
    ~TextColor() {SetTextColor(_hdc, _old_color);}
 
protected:
    HDC      _hdc;
    COLORREF _old_color;
};
 
struct BkMode
{
    BkMode(HDC hdc, int bkmode)
     : _hdc(hdc), _old_bkmode(SetBkMode(hdc, bkmode)) {}
 
    ~BkMode() {SetBkMode(_hdc, _old_bkmode);}
 
protected:
    HDC      _hdc;
    COLORREF _old_bkmode;
};
 
struct FontSelection
{
    FontSelection(HDC hdc, HFONT hFont)
     : _hdc(hdc), _old_hFont(SelectFont(hdc, hFont)) {}
 
    ~FontSelection() {SelectFont(_hdc, _old_hFont);}
 
protected:
    HDC     _hdc;
    HFONT   _old_hFont;
};
 
struct BitmapSelection
{
    BitmapSelection(HDC hdc, HBITMAP hBmp)
     : _hdc(hdc), _old_hBmp(SelectBitmap(hdc, hBmp)) {}
 
    ~BitmapSelection() {SelectBitmap(_hdc, _old_hBmp);}
 
protected:
    HDC     _hdc;
    HBITMAP _old_hBmp;
};
 
struct BrushSelection
{
    BrushSelection(HDC hdc, HBRUSH hBrush)
     : _hdc(hdc), _old_hBrush(SelectBrush(hdc, hBrush)) {}
 
    ~BrushSelection() {SelectBrush(_hdc, _old_hBrush);}
 
protected:
    HDC     _hdc;
    HBRUSH  _old_hBrush;
};
 
 
struct PopupMenu
{
    PopupMenu()
     :  _hmenu(CreatePopupMenu())
    {
    }
 
    ~PopupMenu()
    {
        DestroyMenu(_hmenu);
    }
 
    PopupMenu(UINT nid);
 
    operator HMENU() {return _hmenu;}
 
    void Append(UINT id, LPCTSTR str, UINT flags=MF_STRING)
    {
        AppendMenu(_hmenu, flags, id, str);
    }
 
    int TrackPopupMenu(HWND hwnd, const POINT& pt, UINT flags=TPM_LEFTBUTTON|TPM_RIGHTBUTTON, LPTPMPARAMS tpm=NULL) {
     return TrackPopupMenuEx(_hmenu, flags, pt.x, pt.y, hwnd, tpm);
    }
 
    int PopupContextMenu(HWND hwnd, POINTS pos, UINT flags=TPM_LEFTBUTTON|TPM_RIGHTBUTTON) {
     POINT pt;
     pt.x = pos.x;
     pt.y = pos.y;
     return TrackPopupMenuEx(_hmenu, flags, pt.x, pt.y, hwnd, NULL);
    }
 
    int TrackPopupMenu(HWND hwnd, POINTS pos, UINT flags=TPM_LEFTBUTTON|TPM_RIGHTBUTTON) {
     POINT pt;
     pt.x = pos.x;
     pt.y = pos.y;
     ClientToScreen(hwnd, &pt);
     return TrackPopupMenuEx(_hmenu, flags, pt.x, pt.y, hwnd, NULL);
    }
 
    int TrackPopupMenuAtCursor(HWND hwnd, UINT flags=TPM_LEFTBUTTON) {
     POINT pt; GetCursorPos(&pt);
     return TrackPopupMenuEx(_hmenu, flags, pt.x, pt.y, hwnd, NULL);
    }
 
    int TrackPopupMenuAtPos(HWND hwnd, DWORD pos, UINT flags=TPM_LEFTBUTTON) {
     return TrackPopupMenuEx(_hmenu, flags, GET_X_LPARAM(pos), GET_Y_LPARAM(pos), hwnd, NULL);
    }
 
protected:
    HMENU _hmenu;
};
 
 
struct Variant : public VARIANT
{
    Variant() {VariantInit(this);}
    Variant(const VARIANT& var);
    Variant(const VARIANT* var);
    ~Variant();
 
    operator long() const;
    operator bool() const;
    operator VARIANT_BOOL() const;
    operator IDispatch*() const;
};
 
 
struct BStr
{
    BStr()
    {
        _p = NULL;
    }
 
    BStr(const BSTR s)
    {
        _p = SysAllocString(s);
    }
 
    BStr(LPCSTR s)
    {
        WCHAR b[BUFFER_LEN];
 
        if (s)
            _p = SysAllocStringLen(b, MultiByteToWideChar(CP_ACP, 0, s, -1, b, BUFFER_LEN)-1);
        else
            _p = NULL;
    }
 
    BStr(LPCWSTR s)
    {
        _p = SysAllocString(s);
    }
 
    BStr(const VARIANT& var)
     :  _p(NULL)
    {
        assign(var);
    }
 
    ~BStr()
    {
        SysFreeString(_p);
    }
 
    void assign(BSTR s);
    void assign(const VARIANT& var);
 
    operator BSTR() const
    {
        return _p? _p: (BSTR)L"";
    }
 
    int length() const
    {
        return _p? wcslen(_p): 0;
    }
 
protected:
    BSTR    _p;
};
 
 
struct String
#ifdef UNICODE
 : public wstring
#else
 : public string
#endif
{
#ifdef UNICODE
    typedef wstring super;
#else
    typedef string super;
#endif
 
    String() {}
 
    String(LPCTSTR s) {if (s) super::assign(s);}
    String(LPCTSTR s, int l) : super(s, l) {}
 
    String(const super& other) : super(other) {}
    String(const String& other) : super(other) {}
 
#ifdef UNICODE
    String(LPCSTR s) {assign(s);}
    String(LPCSTR s, int l) {assign(s, l);}
    String(const string& other) {assign(other.c_str());}
    String& operator=(LPCSTR s) {assign(s); return *this;}
    void assign(LPCSTR s) {if (s) {TCHAR b[BUFFER_LEN]; super::assign(b, MultiByteToWideChar(CP_ACP, 0, s, -1, b, BUFFER_LEN)-1);} else erase();}
    void assign(LPCSTR s, int l) {if (s) {TCHAR b[BUFFER_LEN]; super::assign(b, MultiByteToWideChar(CP_ACP, 0, s, l, b, BUFFER_LEN));} else erase();}
    void assign(const BStr& s) {int l = s.length(); super::assign(s, l);}
#else
    String(LPCWSTR s) {assign(s);}
    String(LPCWSTR s, int l) {assign(s, l);}
    String(const wstring& other) {assign(other.c_str());}
    String& operator=(LPCWSTR s) {assign(s); return *this;}
    void assign(LPCWSTR s) {if (s) {char b[BUFFER_LEN]; super::assign(b, WideCharToMultiByte(CP_ACP, 0, s, -1, b, BUFFER_LEN, 0, 0)-1);} else erase();}
    void assign(LPCWSTR s, int l) {if (s) {char b[BUFFER_LEN]; super::assign(b, WideCharToMultiByte(CP_ACP, 0, s, l, b, BUFFER_LEN, 0, 0));} else erase();}
    void assign(const BStr& s) {int l = s.length(); if (l) {char b[BUFFER_LEN]; super::assign(b, WideCharToMultiByte(CP_ACP, 0, s, l, b, BUFFER_LEN, 0, 0));} else erase();}
#endif
    String(const BStr& s) {assign(s);}
    String& operator=(const BStr& s) {assign(s); return *this;}
 
    String& operator=(LPCTSTR s) {if (s) super::assign(s); else erase(); return *this;}
    String& operator=(const super& s) {super::assign(s); return *this;}
    void assign(LPCTSTR s) {super::assign(s);}
    void assign(LPCTSTR s, int l) {super::assign(s, l);}
 
    operator LPCTSTR() const {return c_str();}
 
#ifdef UNICODE
    operator string() const {char b[BUFFER_LEN]; return string(b, WideCharToMultiByte(CP_ACP, 0, c_str(), -1, b, BUFFER_LEN, 0, 0)-1);}
#else
    operator wstring() const {WCHAR b[BUFFER_LEN]; return wstring(b, MultiByteToWideChar(CP_ACP, 0, c_str(), -1, b, BUFFER_LEN)-1);}
#endif
 
    LPTSTR str() {return (LPTSTR)data();}   
 
    String& printf(LPCTSTR fmt, ...)
    {
        va_list l;
        TCHAR b[BUFFER_LEN];
 
        va_start(l, fmt);
        super::assign(b, _vsntprintf(b, COUNTOF(b), fmt, l));
        va_end(l);
 
        return *this;
    }
 
    String& vprintf(LPCTSTR fmt, va_list l)
    {
        TCHAR b[BUFFER_LEN];
 
        super::assign(b, _vsntprintf(b, COUNTOF(b), fmt, l));
 
        return *this;
    }
 
    String& appendf(LPCTSTR fmt, ...)
    {
        va_list l;
        TCHAR b[BUFFER_LEN];
 
        va_start(l, fmt);
        super::append(b, _vsntprintf(b, COUNTOF(b), fmt, l));
        va_end(l);
 
        return *this;
    }
 
    String& vappendf(LPCTSTR fmt, va_list l)
    {
        TCHAR b[BUFFER_LEN];
 
        super::append(b, _vsntprintf(b, COUNTOF(b), fmt, l));
 
        return *this;
    }
 
    void toLower()
    {
        if (!empty())
            CharLower(str());
    }
};
 
#define _STRING_DEFINED
 
 
struct FmtString : public String
{
    FmtString(LPCTSTR fmt, ...)
    {
        va_list l;
 
        va_start(l, fmt);
        vprintf(fmt, l);
        va_end(l);
    }
};
 
 
#ifdef UNICODE
 
struct ANS
{
    ANS(LPCWSTR s)
    {
        int l = wcslen(s) + 1;
        _str = (LPSTR) malloc(2*l);
 
        if (WideCharToMultiByte(CP_ACP, 0, s, -1, _str, 2*l, 0, 0) <= 0)
            *_str = '\0';
    }
 
    ~ANS()
    {
        free(_str);
    }
 
    operator LPCSTR() {return _str;}
 
protected:
    LPSTR   _str;
};
 
#define UNC(x) ((LPCWSTR)(x))
 
#else
 
#define ANS(x) ((LPCSTR)(x))
 
struct UNC
{
    UNC(LPCSTR s)
    {
        int l = strlen(s) + 1;
        _str = (LPWSTR) malloc(2*l);
 
        if (_str && MultiByteToWideChar(CP_ACP, 0, s, -1, _str, l) <= 0)
            *_str = '\0';
    }
 
    ~UNC()
    {
        free(_str);
    }
 
    operator LPCWSTR() {return _str;}
 
protected:
    LPWSTR  _str;
};
 
#endif
 
 
 // determine windows version string
String get_windows_version_str();
 
 
template<typename FCT> struct DynamicFct
{
    DynamicFct(LPCTSTR moduleName, UINT ordinal)
    {
        HMODULE hModule = GetModuleHandle(moduleName);
 
        _fct = (FCT) GetProcAddress(hModule, (LPCSTR)ordinal);
    }
 
    DynamicFct(LPCTSTR moduleName, LPCSTR name)
    {
        HMODULE hModule = GetModuleHandle(moduleName);
 
        _fct = (FCT) GetProcAddress(hModule, name);
    }
 
    FCT operator*() const {return _fct;}
    operator bool() const {return _fct? true: false;}
 
protected:
    FCT _fct;
};
 
 
template<typename FCT> struct DynamicLoadLibFct
{
    DynamicLoadLibFct(LPCTSTR moduleName, UINT ordinal)
    {
        _hModule = LoadLibrary(moduleName);
 
        _fct = (FCT) GetProcAddress(_hModule, (LPCSTR)ordinal);
    }
 
    DynamicLoadLibFct(LPCTSTR moduleName, LPCSTR name)
    {
        _hModule = LoadLibrary(moduleName);
 
        _fct = (FCT) GetProcAddress(_hModule, name);
    }
 
    ~DynamicLoadLibFct()
    {
        FreeLibrary(_hModule);
    }
 
    FCT operator*() const {return _fct;}
    operator bool() const {return _fct? true: false;}
 
protected:
    HMODULE _hModule;
    FCT _fct;
};
 
 
struct Context
{
    Context(const char* ctx)
     :  _ctx(ctx)
    {
        _last = s_current;
        s_current = this;
    }
 
    Context(const char* ctx, LPCSTR obj)
     :  _ctx(ctx),
        _obj(obj)
    {
        _last = s_current;
        s_current = this;
    }
 
    Context(const char* ctx, LPCWSTR obj)
     :  _ctx(ctx),
        _obj(obj)
    {
        _last = s_current;
        s_current = this;
    }
 
    Context(const Context& other)
     :  _ctx(other._ctx),
        _obj(other._obj)
    {
        _last = NULL;
    }
 
    ~Context()
    {
        if (_last) {
            s_current = _last;
            _last = NULL;
        }
    }
 
    String toString() const;
    String getStackTrace() const;
 
    const char* _ctx;
    String  _obj;
 
    static Context& current() {return *s_current;}
 
protected:
    Context* _last;
 
    static Context* s_current;  
    static Context  s_main;
};
 
#define CONTEXT_OBJ __ctx__._obj
#define CONTEXT(c) Context __ctx__(c)
#define CURRENT_CONTEXT Context::current()
#define OBJ_CONTEXT(c, o) Context __ctx__(c, o)
 
 
extern bool SplitFileSysURL(LPCTSTR url, String& dir_out, String& fname_out);
 
 
#endif // __cplusplus