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;
};