globals.h

Go to the documentation of this file.

/*
 * Copyright 2003, 2004 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
 //
 // globals.h
 //
 // Martin Fuchs, 23.07.2003
 //


#include "utility/xmlstorage.h"

using namespace XMLStorage;

#include "taskbar/favorites.h"


struct FileTypeInfo {
    String  _classname;
    String  _displayname;
    bool    _neverShowExt;
};

struct FileTypeManager : public map<String, FileTypeInfo>
{
    typedef map<String, FileTypeInfo> super;

    const FileTypeInfo& operator[](String ext);

    static bool is_exe_file(LPCTSTR ext);

    LPCTSTR set_type(struct Entry* entry, bool dont_hide_ext=false);
};


enum ICON_TYPE {
    IT_STATIC,
    IT_CACHED,
    IT_DYNAMIC,
    IT_SYSCACHE
};

enum ICON_ID {
    ICID_UNKNOWN,
    ICID_NONE,

    ICID_FOLDER,
    //ICID_DOCUMENT,
    ICID_APP,
    ICID_EXPLORER,

    ICID_CONFIG,
    ICID_DOCUMENTS,
    ICID_FAVORITES,
    ICID_INFO,
    ICID_APPS,
    ICID_SEARCH,
    ICID_ACTION,
    ICID_SEARCH_DOC,
    ICID_PRINTER,
    ICID_NETWORK,
    ICID_COMPUTER,
    ICID_LOGOFF,
    ICID_SHUTDOWN,
    ICID_RESTART,
    ICID_BOOKMARK,
    ICID_MINIMIZE,
    ICID_CONTROLPAN,
    ICID_DESKSETTING,
    ICID_NETCONNS,
    ICID_ADMIN,
    ICID_RECENT,

    ICID_DYNAMIC
};

struct Icon {
    Icon();
    Icon(ICON_ID id, UINT nid);
    Icon(ICON_ID id, UINT nid, int icon_size);
    Icon(ICON_TYPE itype, int id, HICON hIcon);
    Icon(ICON_TYPE itype, int id, int sys_idx);

    operator ICON_ID() const {return _id;}

    void    draw(HDC hdc, int x, int y, int cx, int cy, COLORREF bk_color, HBRUSH bk_brush) const;
    HBITMAP create_bitmap(COLORREF bk_color, HBRUSH hbrBkgnd, HDC hdc_wnd) const;
    int     add_to_imagelist(HIMAGELIST himl, HDC hdc_wnd, COLORREF bk_color=GetSysColor(COLOR_WINDOW), HBRUSH bk_brush=GetSysColorBrush(COLOR_WINDOW)) const;

    int     get_sysiml_idx() const {return _itype==IT_SYSCACHE? _sys_idx: -1;}
    HICON   get_hicon() const {return _itype!=IT_SYSCACHE? _hicon: 0;}
    ICON_TYPE get_icontype() const { return _itype; }

    bool    destroy() {if (_itype == IT_DYNAMIC) {DestroyIcon(_hicon); return true;} else return false;}

protected:
    ICON_ID _id;
    ICON_TYPE _itype;
    HICON   _hicon;
    int     _sys_idx;
};

struct SysCacheIcon : public Icon {
    SysCacheIcon(int id, int sys_idx)
     :  Icon(IT_SYSCACHE, id, sys_idx) {}
};

struct IconCache {
    IconCache() : _himlSys_small(0) {}

    virtual ~IconCache();
    void    init();

    const Icon& extract(LPCTSTR path, ICONCACHE_FLAGS flags=ICF_NORMAL);
    const Icon& extract(LPCTSTR path, int icon_idx, ICONCACHE_FLAGS flags=ICF_HICON);
    const Icon& extract(IExtractIcon* pExtract, LPCTSTR path, int icon_idx, ICONCACHE_FLAGS flags=ICF_HICON);
    const Icon& extract(LPCITEMIDLIST pidl, ICONCACHE_FLAGS flags=ICF_NORMAL);

    const Icon& add(HICON hIcon, ICON_TYPE type=IT_DYNAMIC);
    const Icon& add(int sys_idx/*, ICON_TYPE type=IT_SYSCACHE*/);

    const Icon& get_icon(int icon_id);

    HIMAGELIST get_sys_imagelist() const {return _himlSys_small;}

    void    free_icon(int icon_id);

protected:
    static int s_next_id;

    typedef map<int, Icon> IconMap;
    IconMap _icons;

    typedef pair<String,int/*ICONCACHE_FLAGS*/> CacheKey;
    typedef map<CacheKey, ICON_ID> PathCacheMap;
    PathCacheMap _pathCache;

    typedef pair<String,pair<int,int/*ICONCACHE_FLAGS*/> > IdxCacheKey;
    typedef map<IdxCacheKey, ICON_ID> IdxCacheMap;
    IdxCacheMap _idxCache;

    typedef pair<ShellPath,int/*ICONCACHE_FLAGS*/> PidlCacheKey;
    typedef map<PidlCacheKey, ICON_ID> PidlCacheMap;
    PidlCacheMap _pidlcache;

    HIMAGELIST _himlSys_small;
};


#define ICON_SIZE_SMALL     16  // GetSystemMetrics(SM_CXSMICON)
#define ICON_SIZE_MIDDLE    24  // special size for start menu root icons
#define ICON_SIZE_LARGE     32  // GetSystemMetrics(SM_CXICON)

#define STARTMENUROOT_ICON_SIZE     ICON_SIZE_MIDDLE    // ICON_SIZE_LARGE

#define ICON_SIZE_FROM_ICF(flags)   (flags&ICF_LARGE? ICON_SIZE_LARGE: flags&ICF_MIDDLE? ICON_SIZE_MIDDLE: ICON_SIZE_SMALL)
#define ICF_FROM_ICON_SIZE(size)    (size>=ICON_SIZE_LARGE? ICF_LARGE: size>=ICON_SIZE_MIDDLE? ICF_MIDDLE: (ICONCACHE_FLAGS)0)


extern HBITMAP create_bitmap_from_icon(HICON hIcon, HBRUSH hbrush_bkgnd, HDC hdc_wnd/*, int icon_size*/);

extern int ImageList_AddAlphaIcon(HIMAGELIST himl, HICON hIcon, HBRUSH hbrush_bkgnd, HDC hdc_wnd);

extern HICON get_window_icon_small(HWND hwnd);
extern HICON get_window_icon_big(HWND hwnd, bool allow_from_class=true);


#ifdef _USE_HDESK

typedef auto_ptr<struct DesktopThread> DesktopThreadPtr;

struct Desktop
{
    HDESK   _hdesktop;
//  HWINSTA _hwinsta;
    DesktopThreadPtr _pThread;
    WindowHandle _hwndDesktop;

    Desktop(HDESK hdesktop=0/*, HWINSTA hwinsta=0*/);
    ~Desktop();
};

typedef auto_ptr<Desktop> DesktopPtr;
typedef DesktopPtr DesktopRef;

struct DesktopThread : public Thread
{
    DesktopThread(Desktop& desktop)
     :  _desktop(desktop)
    {
    }

    int Run();

protected:
    Desktop&    _desktop;
};

#else

typedef pair<HWND, DWORD> MinimizeStruct;

struct Desktop
{
    set<HWND> _windows;
    WindowHandle _hwndForeground;
    list<MinimizeStruct> _minimized;
};
typedef Desktop DesktopRef;

#endif


#define DESKTOP_COUNT   4

struct Desktops : public vector<DesktopRef>
{
    Desktops();
    ~Desktops();

    void    init();
    void    SwitchToDesktop(int idx);
    void    ToggleMinimize();

#ifdef _USE_HDESK
    DesktopRef& get_current_Desktop() {return (*this)[_current_desktop];}
#endif

    int     _current_desktop;
};


extern struct ExplorerGlobals
{
    ExplorerGlobals();

    void    init(HINSTANCE hInstance);

    void    read_persistent();
    void    write_persistent();

    XMLPos  get_cfg();
    XMLPos  get_cfg(const char* path);

    HINSTANCE   _hInstance;
    UINT        _cfStrFName;

#ifndef ROSSHELL
    ATOM        _hframeClass;
    HWND        _hMainWnd;
    bool        _desktop_mode;
    bool        _prescan_nodes;
#endif

    FILE*       _log;

    DWORD(STDAPICALLTYPE* _SHRestricted)(RESTRICTIONS);

    FileTypeManager _ftype_mgr;
    IconCache   _icon_cache;

    HWND        _hwndDesktopBar;
    HWND        _hwndShellView;
    HWND        _hwndDesktop;

    Desktops    _desktops;

    XMLDoc      _cfg;
    String      _cfg_dir;
    String      _cfg_path;

    Favorites   _favorites;
    String      _favorites_path;
} g_Globals;


struct ResString : public String
{
    ResString(UINT nid);
};

struct ResIcon
{
    ResIcon(UINT nid);

    operator HICON() const {return _hicon;}

protected:
    HICON   _hicon;
};

struct SmallIcon
{
    SmallIcon(UINT nid);

    operator HICON() const {return _hicon;}

protected:
    HICON   _hicon;
};

struct ResIconEx
{
    ResIconEx(UINT nid, int w, int h);

    operator HICON() const {return _hicon;}

protected:
    HICON   _hicon;
};

extern void SetWindowIcon(HWND hwnd, UINT nid);

struct ResBitmap
{
    ResBitmap(UINT nid);
    ~ResBitmap() {DeleteObject(_hBmp);}

    operator HBITMAP() const {return _hBmp;}

protected:
    HBITMAP _hBmp;
};