window.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
 //
 // window.h
 //
 // Martin Fuchs, 23.07.2003
 //
 
 
typedef set<HWND> WindowSet;
 
 
 /*
    Classes are declared using "struct", not "class" because the default
    access mode is "public". This way we can list the member functions in a
    natural order without explicitly specifying any access mode at the begin
    of the definition.
    First are public constructors and destructor, then public member functions.
    After that we list protected member varibables and functions. If needed,
    private implemenation varibales and functions are positioned at the end.
 */
 
 
struct ChildWndInfo
{
    ChildWndInfo(HWND hmdiclient)
     :  _hmdiclient(hmdiclient) {}
 
    HWND    _hmdiclient;
};
 
 
struct Window : public WindowHandle
{
    Window(HWND hwnd);
    virtual ~Window();
 
 
    typedef map<HWND,Window*> WindowMap;
 
    typedef Window* (*CREATORFUNC)(HWND);
    typedef Window* (*CREATORFUNC_INFO)(HWND, const void*);
 
    static HWND Create(CREATORFUNC creator,
                DWORD dwExStyle, LPCTSTR lpClassName, LPCTSTR lpWindowName,
                DWORD dwStyle, int x, int y, int w, int h,
                HWND hwndParent=0, HMENU hMenu=0/*, LPVOID lpParam=0*/);
 
    static HWND Create(CREATORFUNC_INFO creator, const void* info,
                DWORD dwExStyle, LPCTSTR lpClassName, LPCTSTR lpWindowName,
                DWORD dwStyle, int x, int y, int w, int h,
                HWND hwndParent=0, HMENU hMenu=0/*, LPVOID lpParam=0*/);
 
    static Window* create_mdi_child(const ChildWndInfo& info, const MDICREATESTRUCT& mcs, CREATORFUNC_INFO creator);
//  static Window* create_property_sheet(struct PropertySheetDialog* ppsd, CREATORFUNC creator, const void* info);
 
    static LRESULT CALLBACK WindowWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
    static INT_PTR CALLBACK DialogProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
 
    static Window* get_window(HWND hwnd);
#ifndef _MSC_VER
    template<typename CLASS> static CLASS* get_window(HWND hwnd) {return static_cast<CLASS*>(get_window(hwnd));}
#define GET_WINDOW(CLASS, hwnd) Window::get_window<CLASS>(hwnd)
#endif
 
    static void register_pretranslate(HWND hwnd);
    static void unregister_pretranslate(HWND hwnd);
    static BOOL pretranslate_msg(LPMSG pmsg);
 
    static void register_dialog(HWND hwnd);
    static void unregister_dialog(HWND hwnd);
    static BOOL dispatch_dialog_msg(LPMSG pmsg);
 
    static int  MessageLoop();
 
 
    LRESULT SendParent(UINT nmsg, WPARAM wparam=0, LPARAM lparam=0);
    LRESULT PostParent(UINT nmsg, WPARAM wparam=0, LPARAM lparam=0);
 
    static void CancelModes();
 
 
protected:
    virtual LRESULT Init(LPCREATESTRUCT pcs);                           // WM_CREATE processing
    virtual LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
    virtual int     Command(int id, int code);                          // WM_COMMAND processing
    virtual int     Notify(int id, NMHDR* pnmh);                        // WM_NOTIFY processing
 
    static Window* create_controller(HWND hwnd);
 
 
    static WindowMap    s_wnd_map;
 
    static const void*  s_new_info;
    static CREATORFUNC  s_window_creator;
 
 
    struct StaticWindowData {
        CritSect    _map_crit_sect;
        CritSect    _create_crit_sect;
    };
 
    static StaticWindowData& GetStaticWindowData();
 
 
     // MDI child creation
    static HHOOK s_hcbtHook;
    static LRESULT CALLBACK MDICBTHookProc(int code, WPARAM wparam, LPARAM lparam);
    static LRESULT CALLBACK PropSheetCBTHookProc(int code, WPARAM wparam, LPARAM lparam);
 
    static WindowSet s_pretranslate_windows;
    static WindowSet s_dialogs;
};
 
#ifdef UNICODE
#define NFR_CURRENT NFR_UNICODE
#else
#define NFR_CURRENT NFR_ANSI
#endif
 
 
#ifdef _MSC_VER
template<typename CLASS> struct GetWindowHelper
{
    static CLASS* get_window(HWND hwnd) {
        return static_cast<CLASS*>(Window::get_window(hwnd));
    }
};
#define GET_WINDOW(CLASS, hwnd) GetWindowHelper<CLASS>::get_window(hwnd)
#endif
 
 
template<typename CLASS> struct TypeCheck
{
    static CLASS* dyn_cast(Window* wnd)
        {return dynamic_cast<CLASS*>(wnd);}
};
 
#define WINDOW_DYNAMIC_CAST(CLASS, hwnd) \
    TypeCheck<CLASS>::dyn_cast(Window::get_window(hwnd))
 
 
struct SubclassedWindow : public Window
{
    typedef Window super;
 
    SubclassedWindow(HWND);
 
protected:
    WNDPROC _orgWndProc;
 
    static LRESULT CALLBACK SubclassedWndProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
 
    virtual LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
    virtual int     Command(int id, int code);
    virtual int     Notify(int id, NMHDR* pnmh);
};
 
 
template<typename WND_CLASS> struct WindowCreator
{
    static WND_CLASS* window_creator(HWND hwnd)
    {
        return new WND_CLASS(hwnd);
    }
};
 
#define WINDOW_CREATOR(WND_CLASS) \
    ((Window::CREATORFUNC) WindowCreator<WND_CLASS>::window_creator)
 
 
template<typename WND_CLASS, typename INFO_CLASS> struct WindowCreatorInfo
{
    static WND_CLASS* window_creator(HWND hwnd, const void* info)
    {
        return new WND_CLASS(hwnd, *static_cast<const INFO_CLASS*>(info));
    }
};
 
#define WINDOW_CREATOR_INFO(WND_CLASS, INFO_CLASS) \
    ((Window::CREATORFUNC_INFO) WindowCreatorInfo<WND_CLASS, INFO_CLASS>::window_creator)
 
 
struct WindowClass : public WNDCLASSEX
{
    WindowClass(LPCTSTR classname, UINT style=0, WNDPROC wndproc=Window::WindowWndProc);
 
    ATOM Register()
    {
        if (!_atomClass)
            _atomClass = RegisterClassEx(this);
 
        return _atomClass;
    }
 
    operator ATOM() {return Register();}
 
     // return LPCTSTR for the CreateWindowEx() parameter
    operator LPCTSTR() {return (LPCTSTR)(int)Register();}
 
protected:
    ATOM    _atomClass;
};
 
struct BtnWindowClass : public WindowClass
{
    BtnWindowClass(LPCTSTR classname, UINT style=0, WNDPROC wndproc=Window::WindowWndProc)
     :  WindowClass(classname, style, wndproc)
    {
        hbrBackground = (HBRUSH)(COLOR_BTNFACE+1);
    }
};
 
struct IconWindowClass : public WindowClass
{
    IconWindowClass(LPCTSTR classname, UINT nid, UINT style=0, WNDPROC wndproc=Window::WindowWndProc);
};
 
 
 // private message constants
#define PM_DISPATCH_COMMAND     (WM_APP+0x00)
#define PM_TRANSLATE_MSG        (WM_APP+0x01)
 
 
#define SPLIT_WIDTH         5
#define DEFAULT_SPLIT_POS   300
#define COLOR_SPLITBAR      LTGRAY_BRUSH
 
 
struct MenuInfo
{
    HMENU   _hMenuView;
};
 
#define PM_FRM_GET_MENUINFO     (WM_APP+0x02)
 
#define Frame_GetMenuInfo(hwnd) ((MenuInfo*)SNDMSG(hwnd, PM_FRM_GET_MENUINFO, 0, 0))
 
 
struct PreTranslateWindow : public Window
{
    typedef Window super;
 
    PreTranslateWindow(HWND);
    ~PreTranslateWindow();
};
 
 
 
struct ChildWindow : public PreTranslateWindow
{
    typedef PreTranslateWindow super;
 
    ChildWindow(HWND hwnd, const ChildWndInfo& info);
 
    static ChildWindow* create(const ChildWndInfo& info, const RECT& rect, CREATORFUNC_INFO creator,
                                LPCTSTR classname, LPCTSTR title=NULL, DWORD style=0);
 
    bool    go_to(LPCTSTR url);
 
protected:
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
 
    virtual void resize_children(int cx, int cy);
    virtual String jump_to_int(LPCTSTR url) = 0;
 
protected:
    MenuInfo*_menu_info;
 
    WindowHandle _left_hwnd;
    WindowHandle _right_hwnd;
    int     _focus_pane;        // 0: left  1: right
 
    int     _split_pos;
    int     _last_split;
 
    HWND    _hwndFrame;
    String  _statusText;
    String  _url;
 
    stack<String> _url_history;
 
    void    set_url(LPCTSTR url);
};
 
#define PM_SETSTATUSTEXT        (WM_APP+0x1E)
 
 
struct DialogWindow : public Window
{
    typedef Window super;
 
    DialogWindow(HWND hwnd)
     :  super(hwnd)
    {
        register_dialog(hwnd);
    }
 
    ~DialogWindow()
    {
        unregister_dialog(_hwnd);
    }
};
 
 
struct Dialog : public Window
{
    typedef Window super;
 
    Dialog(HWND);
    ~Dialog();
 
    static int DoModal(UINT nid, CREATORFUNC creator, HWND hwndParent=0);
    static int DoModal(UINT nid, CREATORFUNC_INFO creator, const void* info, HWND hwndParent=0);
 
protected:
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
    int     Command(int id, int code);
};
 
 
#define PM_FRM_CALC_CLIENT      (WM_APP+0x03)
#define Frame_CalcFrameClient(hwnd, prt) ((BOOL)SNDMSG(hwnd, PM_FRM_CALC_CLIENT, 0, (LPARAM)(PRECT)prt))
 
#define PM_JUMP_TO_URL          (WM_APP+0x25)
#define PM_URL_CHANGED          (WM_APP+0x26)
 
 
struct PropSheetPage : public PROPSHEETPAGE
{
    PropSheetPage(UINT nid, Window::CREATORFUNC dlg_creator);
 
    void    init(struct PropertySheetDialog*);
 
protected:
    friend struct PropSheetPageDlg;
 
    Window::CREATORFUNC _dlg_creator;
};
 
 
struct PropertySheetDialog : public PROPSHEETHEADER
{
    PropertySheetDialog(HWND owner);
 
    void    add(PropSheetPage& psp);
    int     DoModal(int start_page=0);
 
    HWND    GetCurrentPage();
 
protected:
    typedef vector<PROPSHEETPAGE> Vector;
    Vector  _pages;
    HWND    _hwnd;
};
 
 
struct PropSheetPageDlg : public Dialog
{
    typedef Dialog super;
 
    PropSheetPageDlg(HWND);
 
protected:
    friend struct PropertySheetDialog;
    friend struct PropSheetPage;
 
    static INT_PTR CALLBACK DialogProc(HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam);
 
    int Command(int id, int code);
};
 
 
/*
struct PropertySheetDlg : public SubclassedWindow
{
    typedef SubclassedWindow super;
 
    PropertySheetDlg(HWND hwnd) : super(hwnd) {}
};
*/
 
 
 // Layouting of resizable windows
 
enum RESIZE_FLAGS {
    MOVE_LEFT   = 0x1,
    MOVE_RIGHT  = 0x2,
    MOVE_TOP    = 0x4,
    MOVE_BOTTOM = 0x8,
 
    MOVE_X  =  MOVE_LEFT | MOVE_RIGHT,
    MOVE_Y  =  MOVE_TOP | MOVE_BOTTOM,
    RESIZE_X=  MOVE_RIGHT,
    RESIZE_Y=  MOVE_BOTTOM,
 
    MOVE    = MOVE_X   | MOVE_Y,
    RESIZE  = RESIZE_X | RESIZE_Y
};
 
struct ResizeEntry
{
    ResizeEntry(UINT id, int flags)
     : _id(id), _flags(flags) {}
 
    ResizeEntry(HWND hwnd, int flags)
     : _id(GetDlgCtrlID(hwnd)), _flags(flags) {}
 
    UINT    _id;
    int     _flags;
};
 
 
struct ResizeManager : public std::list<ResizeEntry>
{
    typedef std::list<ResizeEntry> super;
 
    ResizeManager(HWND hwnd);
 
    void Add(UINT id, int flags)
        {push_back(ResizeEntry(id, flags));}
 
    void Add(HWND hwnd, int flags)
        {push_back(ResizeEntry(hwnd, flags));}
 
    void HandleSize(int cx, int cy);
    void Resize(int dx, int dy);
 
    void SetMinMaxInfo(LPMINMAXINFO lpmmi)
    {
        lpmmi->ptMinTrackSize.x = _min_wnd_size.cx;
        lpmmi->ptMinTrackSize.y = _min_wnd_size.cy;
    }
 
    SIZE    _min_wnd_size;
 
protected:
    HWND    _hwnd;
    SIZE    _last_size;
};
 
 
template<typename BASE> struct ResizeController : public BASE
{
    typedef BASE super;
 
    ResizeController(HWND hwnd)
     :  super(hwnd),
        _resize_mgr(hwnd)
    {
    }
 
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
    {
        switch(nmsg) {
          case PM_FRM_CALC_CLIENT:
            GetClientSpace((PRECT)lparam);
            return TRUE;
 
          case WM_SIZE:
            if (wparam != SIZE_MINIMIZED)
                _resize_mgr.HandleSize(LOWORD(lparam), HIWORD(lparam));
            goto def;
 
          case WM_GETMINMAXINFO:
            _resize_mgr.SetMinMaxInfo((LPMINMAXINFO)lparam);
            goto def;
 
          default: def:
            return super::WndProc(nmsg, wparam, lparam);
        }
    }
 
    virtual void GetClientSpace(PRECT prect)
    {
         if (!IsIconic(this->_hwnd)) {
            GetClientRect(this->_hwnd, prect);
         } else {
            WINDOWPLACEMENT wp;
            GetWindowPlacement(this->_hwnd, &wp);
            prect->left = prect->top = 0;
            prect->right = wp.rcNormalPosition.right-wp.rcNormalPosition.left-
                2*(GetSystemMetrics(SM_CXSIZEFRAME)+GetSystemMetrics(SM_CXEDGE));
            prect->bottom = wp.rcNormalPosition.bottom-wp.rcNormalPosition.top-
                2*(GetSystemMetrics(SM_CYSIZEFRAME)+GetSystemMetrics(SM_CYEDGE))-
                GetSystemMetrics(SM_CYCAPTION)-GetSystemMetrics(SM_CYMENUSIZE);
        }
    }
 
protected:
    ResizeManager _resize_mgr;
};
 
 
struct Button : public WindowHandle
{
    Button(HWND parent, LPCTSTR text, int left, int top, int width, int height,
            int id, DWORD flags=WS_VISIBLE|WS_CHILD|BS_PUSHBUTTON, DWORD exStyle=0);
};
 
 
struct Static : public WindowHandle
{
    Static(HWND parent, LPCTSTR text, int left, int top, int width, int height,
            int id, DWORD flags=WS_VISIBLE|WS_CHILD|SS_SIMPLE, DWORD ex_flags=0);
};
 
 
 // control color message routing for ColorStatic and HyperlinkCtrl
 
#define PM_DISPATCH_CTLCOLOR    (WM_APP+0x08)
 
template<typename BASE> struct CtlColorParent : public BASE
{
    typedef BASE super;
 
    CtlColorParent(HWND hwnd)
     : super(hwnd) {}
 
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
    {
        switch(nmsg) {
          case WM_CTLCOLOR:
          case WM_CTLCOLORBTN:
          case WM_CTLCOLORDLG:
          case WM_CTLCOLORSCROLLBAR:
          case WM_CTLCOLORSTATIC: {
            HWND hctl = (HWND) lparam;
            return SendMessage(hctl, PM_DISPATCH_CTLCOLOR, wparam, nmsg);
          }
 
          default:
            return super::WndProc(nmsg, wparam, lparam);
        }
    }
};
 
 
#define PM_DISPATCH_DRAWITEM    (WM_APP+0x09)
 
template<typename BASE> struct OwnerDrawParent : public BASE
{
    typedef BASE super;
 
    OwnerDrawParent(HWND hwnd)
     : super(hwnd) {}
 
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
    {
        switch(nmsg) {
          case WM_DRAWITEM:
            if (wparam) {   // should there be drawn a control?
                HWND hctl = GetDlgItem(this->_hwnd, wparam);
 
                if (hctl)
                    return SendMessage(hctl, PM_DISPATCH_DRAWITEM, wparam, lparam);
            } /*else        // or is it a menu entry?
                ; */
 
            return 0;
 
          default:
            return super::WndProc(nmsg, wparam, lparam);
        }
    }
};
 
 
struct OwnerdrawnButton : public SubclassedWindow
{
    typedef SubclassedWindow super;
 
    OwnerdrawnButton(HWND hwnd)
     :  super(hwnd) {}
 
protected:
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
 
    virtual void DrawItem(LPDRAWITEMSTRUCT dis) = 0;
};
 
extern void DrawGrayText(HDC hdc, LPRECT pRect, LPCTSTR text, int dt_flags);
 
 
/* not yet used
struct ColorButton : public OwnerdrawnButton
{
    typedef OwnerdrawnButton super;
 
    ColorButton(HWND hwnd, COLORREF textColor)
     :  super(hwnd), _textColor(textColor) {}
 
protected:
    virtual void DrawItem(LPDRAWITEMSTRUCT dis);
 
    COLORREF _textColor;
};
*/
 
 
struct FlatButton : public OwnerdrawnButton
{
    typedef OwnerdrawnButton super;
 
    FlatButton(HWND hwnd)
     : super(hwnd), _active(false) {}
 
    FlatButton(HWND owner, int id)
     : super(GetDlgItem(owner, IDOK)), _active(false) {}
 
protected:
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
    virtual void DrawItem(LPDRAWITEMSTRUCT dis);
 
    COLORREF _textColor;
    COLORREF _activeColor;
    bool    _active;
};
 
 
struct PictureButton : public OwnerdrawnButton
{
    typedef OwnerdrawnButton super;
 
    PictureButton(HWND hwnd, HICON hIcon, HBRUSH hbrush=GetSysColorBrush(COLOR_BTNFACE), bool flat=false)
     :  super(hwnd), _hIcon(hIcon), _hBmp(0), _hBrush(hbrush), _flat(flat)
    {
        _cx = 16;
        _cy = 16;
    }
 
    PictureButton(HWND hparent, int id, HICON hIcon, HBRUSH hbrush=GetSysColorBrush(COLOR_BTNFACE), bool flat=false)
     :  super(GetDlgItem(hparent, id)), _hIcon(hIcon), _hBmp(0), _hBrush(hbrush), _flat(flat)
    {
        _cx = 16;
        _cy = 16;
    }
 
    PictureButton(HWND hwnd, HBITMAP hBmp, HBRUSH hbrush=GetSysColorBrush(COLOR_BTNFACE), bool flat=false)
     :  super(hwnd), _hIcon(0), _hBmp(hBmp), _hBrush(hbrush), _flat(flat)
    {
        BITMAP bmp;
        GetObject(hBmp, sizeof(bmp), &bmp);
        _cx = bmp.bmWidth;
        _cy = bmp.bmHeight;
    }
 
    PictureButton(HWND hparent, int id, HBITMAP hBmp, HBRUSH hbrush=GetSysColorBrush(COLOR_BTNFACE), bool flat=false)
     :  super(GetDlgItem(hparent, id)), _hIcon(0), _hBmp(hBmp), _hBrush(hbrush), _flat(flat)
    {
        BITMAP bmp;
        GetObject(hBmp, sizeof(bmp), &bmp);
        _cx = bmp.bmWidth;
        _cy = bmp.bmHeight;
    }
 
protected:
    virtual void DrawItem(LPDRAWITEMSTRUCT dis);
 
    HICON   _hIcon;
    HBITMAP _hBmp;
    HBRUSH  _hBrush;
 
    int     _cx;
    int     _cy;
 
    bool    _flat;
};
 
 
struct ColorStatic : public SubclassedWindow
{
    typedef SubclassedWindow super;
 
    ColorStatic(HWND hwnd, COLORREF textColor=RGB(255,0,0), HBRUSH hbrush_bkgnd=0, HFONT hfont=0)
     :  super(hwnd),
        _textColor(textColor),
        _hbrush_bkgnd(hbrush_bkgnd),
        _hfont(hfont)
    {
    }
 
    ColorStatic(HWND owner, int id, COLORREF textColor=RGB(255,0,0), HBRUSH hbrush_bkgnd=0, HFONT hfont=0)
     :  super(GetDlgItem(owner, id)),
        _textColor(textColor),
        _hbrush_bkgnd(hbrush_bkgnd),
        _hfont(hfont)
    {
    }
 
protected:
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
    {
        if (nmsg == PM_DISPATCH_CTLCOLOR) {
            HDC hdc = (HDC) wparam;
 
            SetTextColor(hdc, _textColor);
 
            if (_hfont)
                SelectFont(hdc, _hfont);
 
            if (_hbrush_bkgnd)
                return (LRESULT)_hbrush_bkgnd;
            else {
                SetBkMode(hdc, TRANSPARENT);
                return (LRESULT)GetStockBrush(HOLLOW_BRUSH);
            }
        } else
            return super::WndProc(nmsg, wparam, lparam);
    }
 
    COLORREF    _textColor;
    HBRUSH      _hbrush_bkgnd;
    HFONT       _hfont;
};
 
 
 
struct HyperlinkCtrl : public SubclassedWindow
{
    typedef SubclassedWindow super;
 
    HyperlinkCtrl(HWND hwnd, COLORREF colorLink=RGB(0,0,255), COLORREF colorVisited=RGB(128,0,128));
    HyperlinkCtrl(HWND owner, int id, COLORREF colorLink=RGB(0,0,255), COLORREF colorVisited=RGB(128,0,128));
 
    ~HyperlinkCtrl();
 
    String  _cmd;
 
protected:
    COLORREF _textColor;
    COLORREF _colorVisited;
    HFONT    _hfont;
    HCURSOR _crsr_link;
 
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam);
 
    void init();
 
    bool LaunchLink()
    {
        if (!_cmd.empty()) {
            HINSTANCE hinst = ShellExecute(GetParent(_hwnd), _T("open"), _cmd, 0, 0, SW_SHOWNORMAL);
            return (INT_PTR)hinst > HINSTANCE_ERROR;
        }
 
        return true;
    }
};
 
 
struct ToolTip : public WindowHandle
{
    typedef WindowHandle super;
 
    ToolTip(HWND owner);
 
    void activate(BOOL active=TRUE)
    {
        SendMessage(_hwnd, TTM_ACTIVATE, active, 0);
    }
 
    void add(HWND hparent, HWND htool, LPCTSTR txt=LPSTR_TEXTCALLBACK, LPARAM lparam=0)
    {
        TOOLINFO ti = {
            sizeof(TOOLINFO), TTF_SUBCLASS|TTF_IDISHWND|TTF_TRANSPARENT, hparent, (UINT_PTR)htool,
            {0,0,0,0}, 0, (LPTSTR)txt, lparam
        };
 
#ifdef UNICODE  
        if (!SendMessage(_hwnd, TTM_ADDTOOLW, 0, (LPARAM)&ti))
            SendMessage(_hwnd, TTM_ADDTOOLA, 0, (LPARAM)&ti);
#else
        if (!SendMessage(_hwnd, TTM_ADDTOOLA, 0, (LPARAM)&ti))
            SendMessage(_hwnd, TTM_ADDTOOLW, 0, (LPARAM)&ti);
#endif
    }
 
    void add(HWND hparent, UINT id, const RECT& rect, LPCTSTR txt=LPSTR_TEXTCALLBACK, LPARAM lparam=0)
    {
        TOOLINFO ti = {
            sizeof(TOOLINFO), TTF_SUBCLASS|TTF_TRANSPARENT, hparent, id,
            {rect.left,rect.top,rect.right,rect.bottom}, 0, (LPTSTR)txt, lparam
        };
 
#ifdef UNICODE
        if (!SendMessage(_hwnd, TTM_ADDTOOLW, 0, (LPARAM)&ti))
            SendMessage(_hwnd, TTM_ADDTOOLA, 0, (LPARAM)&ti);
#else
        if (!SendMessage(_hwnd, TTM_ADDTOOLA, 0, (LPARAM)&ti))
            SendMessage(_hwnd, TTM_ADDTOOLW, 0, (LPARAM)&ti);
#endif
    }
 
    void remove(HWND hparent, HWND htool)
    {
        TOOLINFO ti = {
            sizeof(TOOLINFO), TTF_IDISHWND, hparent, (UINT_PTR)htool,
            {0,0,0,0}, 0, 0, 0
        };
 
        SendMessage(_hwnd, TTM_DELTOOL, 0, (LPARAM)&ti);
    }
 
    void remove(HWND hparent, UINT id)
    {
        TOOLINFO ti = {
            sizeof(TOOLINFO), 0, hparent, id,
            {0,0,0,0}, 0, 0, 0
        };
 
        SendMessage(_hwnd, TTM_DELTOOL, 0, (LPARAM)&ti);
    }
};
 
 
inline int ListView_GetItemData(HWND list_ctrl, int idx)
{
    LV_ITEM item;
 
    item.mask = LVIF_PARAM;
    item.iItem = idx;
 
    if (!ListView_GetItem(list_ctrl, &item))
        return 0;
 
    return item.lParam;
}
 
inline int ListView_FindItemPara(HWND list_ctrl, LPARAM param)
{
    LVFINDINFO fi;
 
    fi.flags = LVFI_PARAM;
    fi.lParam = param;
 
    return ListView_FindItem(list_ctrl, (unsigned)-1, &fi);
}
 
inline int ListView_GetFocusedItem(HWND list_ctrl)
{
    int idx = ListView_GetItemCount(list_ctrl);
 
    while(--idx >= 0)
        if (ListView_GetItemState(list_ctrl, idx, LVIS_FOCUSED))
            break;
 
    return idx;
}
 
 
struct ListSort : public WindowHandle
{
    ListSort(HWND hwndListview, PFNLVCOMPARE compare_fct);
 
    void    toggle_sort(int idx);
    void    sort();
 
    int     _sort_crit;
    bool    _direction;
 
protected:
    PFNLVCOMPARE _compare_fct;
 
    static int CALLBACK CompareFunc(LPARAM lparam1, LPARAM lparam2, LPARAM lparamSort);
};
 
 
inline LPARAM TreeView_GetItemData(HWND hwndTreeView, HTREEITEM hItem)
{
    TVITEM tvItem;
 
    tvItem.mask = TVIF_PARAM;
    tvItem.hItem = hItem;
 
    if (!TreeView_GetItem(hwndTreeView, &tvItem))
        return 0;
 
    return tvItem.lParam;
}
 
 
enum {TRAYBUTTON_LEFT=0, TRAYBUTTON_RIGHT, TRAYBUTTON_MIDDLE};
 
#define PM_TRAYICON     (WM_APP+0x20)
 
#define WINMSG_TASKBARCREATED   TEXT("TaskbarCreated")
 
#define WINMSG_SHELLHOOK        TEXT("SHELLHOOK")
 
 
struct TrayIcon
{
    TrayIcon(HWND hparent, UINT id)
     :  _hparent(hparent), _id(id) {}
 
    ~TrayIcon()
        {Remove();}
 
    void    Add(HICON hIcon, LPCTSTR tooltip=NULL)
        {Set(NIM_ADD, _id, hIcon, tooltip);}
 
    void    Modify(HICON hIcon, LPCTSTR tooltip=NULL)
        {Set(NIM_MODIFY, _id, hIcon, tooltip);}
 
    void    Remove()
    {
        NOTIFYICONDATA nid = {
            sizeof(NOTIFYICONDATA), // cbSize
            _hparent,               // hWnd
            _id,                    // uID
        };
 
        Shell_NotifyIcon(NIM_DELETE, &nid);
    }
 
protected:
    HWND    _hparent;
    UINT    _id;
 
    void    Set(DWORD dwMessage, UINT id, HICON hIcon, LPCTSTR tooltip=NULL)
    {
        NOTIFYICONDATA nid = {
            sizeof(NOTIFYICONDATA), // cbSize
            _hparent,               // hWnd
            id,                     // uID
            NIF_MESSAGE|NIF_ICON,   // uFlags
            PM_TRAYICON,            // uCallbackMessage
            hIcon                   // hIcon
        };
 
        if (tooltip)
            lstrcpyn(nid.szTip, tooltip, COUNTOF(nid.szTip));
 
        if (nid.szTip[0])
            nid.uFlags |= NIF_TIP;
 
        Shell_NotifyIcon(dwMessage, &nid);
    }
};
 
 
template<typename BASE> struct TrayIconControllerTemplate : public BASE
{
    typedef BASE super;
 
    TrayIconControllerTemplate(HWND hwnd) : BASE(hwnd),
        WM_TASKBARCREATED(RegisterWindowMessage(WINMSG_TASKBARCREATED))
    {
    }
 
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
    {
        if (nmsg == PM_TRAYICON) {
            switch(lparam) {
              case WM_MOUSEMOVE:
                TrayMouseOver(wparam);
                break;
 
              case WM_LBUTTONDOWN:
                TrayClick(wparam, TRAYBUTTON_LEFT);
                break;
 
              case WM_LBUTTONDBLCLK:
                TrayDblClick(wparam, TRAYBUTTON_LEFT);
                break;
 
              case WM_RBUTTONDOWN:
                TrayClick(wparam, TRAYBUTTON_RIGHT);
                break;
 
              case WM_RBUTTONDBLCLK:
                TrayDblClick(wparam, TRAYBUTTON_RIGHT);
                break;
 
              case WM_MBUTTONDOWN:
                TrayClick(wparam, TRAYBUTTON_MIDDLE);
                break;
 
              case WM_MBUTTONDBLCLK:
                TrayDblClick(wparam, TRAYBUTTON_MIDDLE);
                break;
            }
 
            return 0;
        } else if (nmsg == WM_TASKBARCREATED) {
            AddTrayIcons();
            return 0;
        } else
            return super::WndProc(nmsg, wparam, lparam);
    }
 
    virtual void AddTrayIcons() = 0;
    virtual void TrayMouseOver(UINT id) {}
    virtual void TrayClick(UINT id, int btn) {}
    virtual void TrayDblClick(UINT id, int btn) {}
 
protected:
    const UINT WM_TASKBARCREATED;
};
 
 
struct EditController : public SubclassedWindow
{
    typedef SubclassedWindow super;
 
    EditController(HWND hwnd)
     :  super(hwnd)
    {
    }
 
protected:
    LRESULT WndProc(UINT nmsg, WPARAM wparam, LPARAM lparam)
    {
        if (nmsg==WM_KEYDOWN && wparam==VK_RETURN) {
            SendParent(WM_COMMAND, MAKEWPARAM(GetDlgCtrlID(_hwnd),1), (LPARAM)_hwnd);
            return 0;
        } else
            return super::WndProc(nmsg, wparam, lparam);
    }
};