favorites.cpp

Go to the documentation of this file.

/*
 * Copyright 2004, 2006 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 and Desktop clone
 //
 // favorites.cpp
 //
 // Martin Fuchs, 04.04.2004
 //


#include <precomp.h>

#include "startmenu.h"


String DecodeURLString(const char* s)
{
    TCHAR buffer[BUFFER_LEN];
    LPTSTR o = buffer;

    for(const char* p=s; *p; ++p)
        if (*p == '%') {
            if (!strncmp(p+1, "20", 2)) {
                *o++ = ' ';
                p += 2;
            } else
                *o++ = *p;
        } else
            *o++ = *p;

    return String(buffer, o-buffer);
}


bool Bookmark::read_url(LPCTSTR path)
{
    char line[BUFFER_LEN];

    tifstream in(path);

    while(in.good()) {
        in.getline(line, BUFFER_LEN);

        const char* p = line;
        while(isspace(*p))
            ++p;

        const char* keyword = p;
        const char* eq = strchr(p, '=');

        if (eq) {
            const char* cont = eq + 1;
            while(isspace(*cont))
                ++cont;

            if (!_strnicmp(keyword, "URL", 3))
                _url = DecodeURLString(cont);
            else if (!_strnicmp(keyword, "IconFile", 8))
                _icon_path = DecodeURLString(cont);
        }
    }

    return true;
}

bool Bookmark::read(const_XMLPos& pos)
{
    _url = pos.get("href").c_str();

    if (pos.go_down("title")) {
        _name = pos->get_content();
        pos.back();
    }

    if (pos.go_down("desc")) {
        _description = pos->get_content();
        pos.back();
    }

    if (pos.go_down("info")) {
        const_XMLChildrenFilter metadata(pos, "metadata");

        for(const_XMLChildrenFilter::const_iterator it=metadata.begin(); it!=metadata.end(); ++it) {
            const XMLNode& node = **it;
            const_XMLPos sub_pos(&node);

            if (node.get("owner") == "ros-explorer") {
                if (sub_pos.go_down("icon")) {
                    _icon_path = sub_pos.get("path").c_str();
                    _icon_idx = XS_toi(sub_pos.get("index"));

                    sub_pos.back(); // </icon>
                }
            }
        }

        pos.back(); // </metadata>
        pos.back(); // </info>
    }

    return !_url.empty();   // _url is mandatory.
}

void Bookmark::write(XMLPos& pos) const
{
    pos.create("bookmark");

    pos["href"] = _url.c_str();

    if (!_name.empty()) {
        pos.create("title");
        pos->set_content(_name);
        pos.back();
    }

    if (!_description.empty()) {
        pos.create("desc");
        pos->set_content(_description);
        pos.back();
    }

    if (!_icon_path.empty()) {
        pos.create("info");
        pos.create("metadata");
        pos["owner"] = "ros-explorer";
        pos.create("icon");
        pos["path"] = _icon_path.c_str();
        pos["index"].printf(XS_TEXT("%d"), _icon_idx);
        pos.back(); // </icon>
        pos.back(); // </metadata>
        pos.back(); // </info>
    }

    pos.back();
}


void BookmarkFolder::read(const_XMLPos& pos)
{
    if (pos.go_down("title")) {
        _name = pos->get_content();
        pos.back();
    }

    if (pos.go_down("desc")) {
        _description = pos->get_content();
        pos.back();
    }

    _bookmarks.read(pos);
}

void BookmarkFolder::write(XMLPos& pos) const
{
    pos.create("folder");

    if (!_name.empty()) {
        pos.create("title");
        pos->set_content(_name);
        pos.back();
    }

    if (!_description.empty()) {
        pos.create("desc");
        pos->set_content(_description);
        pos.back();
    }

    _bookmarks.write(pos);
}


BookmarkNode::BookmarkNode()
 :  _type(BMNT_NONE)
{
    _pbookmark = NULL;
}

BookmarkNode::BookmarkNode(const Bookmark& bm)
 :  _type(BMNT_BOOKMARK)
{
    _pbookmark = new Bookmark(bm);
}

BookmarkNode::BookmarkNode(const BookmarkFolder& bmf)
 :  _type(BMNT_FOLDER)
{
    _pfolder = new BookmarkFolder(bmf);
}

BookmarkNode::BookmarkNode(const BookmarkNode& other)
 :  _type(other._type)
{
    if (other._type == BMNT_BOOKMARK)
        _pbookmark = new Bookmark(*other._pbookmark);
    else if (other._type == BMNT_FOLDER)
        _pfolder = new BookmarkFolder(*other._pfolder);
    else
        _pbookmark = NULL;
}

BookmarkNode::~BookmarkNode()
{
    if (_type == BMNT_BOOKMARK)
        delete _pbookmark;
    else if (_type == BMNT_FOLDER)
        delete _pfolder;
}

BookmarkNode& BookmarkNode::operator=(const Bookmark& bm)
{
    clear();

    _pbookmark = new Bookmark(bm);

    return *this;
}

BookmarkNode& BookmarkNode::operator=(const BookmarkFolder& bmf)
{
    clear();

    _pfolder = new BookmarkFolder(bmf);

    return *this;
}

BookmarkNode& BookmarkNode::operator=(const BookmarkNode& other)
{
    clear();

    _type = other._type;

    if (other._type == BMNT_BOOKMARK)
        _pbookmark = new Bookmark(*other._pbookmark);
    else if (other._type == BMNT_FOLDER)
        _pfolder = new BookmarkFolder(*other._pfolder);

    return *this;
}

void BookmarkNode::clear()
{
    if (_type == BMNT_BOOKMARK) {
        delete _pbookmark;
        _pbookmark = NULL;
    }
    else if (_type == BMNT_FOLDER) {
        delete _pfolder;
        _pfolder = NULL;
    }

    _type = BMNT_NONE;
}


void BookmarkList::read(const_XMLPos& pos)
{
    const XMLNode::Children& children = pos->get_children();

    for(XMLNode::Children::const_iterator it=children.begin(); it!=children.end(); ++it) {
        const XMLNode& node = **it;
        const_XMLPos sub_pos(&node);

        if (node == "folder") {
            BookmarkFolder folder;

            folder.read(sub_pos);

            push_back(folder);
        } else if (node == "bookmark") {
            Bookmark bookmark;

            if (bookmark.read(sub_pos))
                push_back(bookmark);
        }
    }
}

void BookmarkList::write(XMLPos& pos) const
{
    for(const_iterator it=begin(); it!=end(); ++it) {
        const BookmarkNode& node = *it;

        if (node._type == BookmarkNode::BMNT_FOLDER) {
            const BookmarkFolder& folder = *node._pfolder;

            folder.write(pos);

            pos.back();
        } else if (node._type == BookmarkNode::BMNT_BOOKMARK) {
            const Bookmark& bookmark = *node._pbookmark;

            if (!bookmark._url.empty())
                bookmark.write(pos);
        }
    }
}


void BookmarkList::fill_tree(HWND hwnd, HTREEITEM parent, HIMAGELIST himagelist, HDC hdc_wnd) const
{
    TV_INSERTSTRUCT tvi;

    tvi.hParent = parent;
    tvi.hInsertAfter = TVI_LAST;

    TV_ITEM& tv = tvi.item;
    tv.mask = TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_PARAM;

    for(const_iterator it=begin(); it!=end(); ++it) {
        const BookmarkNode& node = *it;

        tv.lParam = (LPARAM)&node;

        if (node._type == BookmarkNode::BMNT_FOLDER) {
            const BookmarkFolder& folder = *node._pfolder;

            tv.pszText = (LPTSTR)folder._name.c_str();
            tv.iImage = 3;          // folder
            tv.iSelectedImage = 4;  // open folder
            HTREEITEM hitem = TreeView_InsertItem(hwnd, &tvi);

            folder._bookmarks.fill_tree(hwnd, hitem, himagelist, hdc_wnd);
        } else if (node._type == BookmarkNode::BMNT_BOOKMARK) {
            const Bookmark& bookmark = *node._pbookmark;

            tv.pszText = (LPTSTR)bookmark._name.c_str();
            tv.iImage = 1;          // bookmark
            tv.iSelectedImage = 2;  // selected bookmark

            if (!bookmark._icon_path.empty()) {
                const Icon& icon = g_Globals._icon_cache.extract(bookmark._icon_path, bookmark._icon_idx);

                if ((ICON_ID)icon != ICID_NONE)
                    tv.iImage = tv.iSelectedImage = icon.add_to_imagelist(himagelist, hdc_wnd);
            }

            (void)TreeView_InsertItem(hwnd, &tvi);
        }
    }
}


void BookmarkList::import_IE_favorites(ShellDirectory& dir, HWND hwnd)
{
    TCHAR path[MAX_PATH], ext[_MAX_EXT];

    dir.smart_scan(SORT_NAME, SCAN_DONT_EXTRACT_ICONS);

    for(Entry*entry=dir._down; entry; entry=entry->_next) {
        if (entry->_shell_attribs & SFGAO_HIDDEN)   // ignore files like "desktop.ini"
            continue;

        String name;

        if (entry->_etype == ET_SHELL)
            name = dir._folder.get_name(static_cast<ShellEntry*>(entry)->_pidl);
        else
            name = entry->_display_name;

        if (entry->_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
            BookmarkFolder new_folder;

            new_folder._name = DecodeXMLString(name);

            if (entry->_etype == ET_SHELL) {
                ShellDirectory new_dir(dir._folder, static_cast<ShellEntry*>(entry)->_pidl, hwnd);
                new_folder._bookmarks.import_IE_favorites(new_dir, hwnd);
            } else {
                entry->get_path(path, COUNTOF(path));
                ShellDirectory new_dir(GetDesktopFolder(), path, hwnd);
                new_folder._bookmarks.import_IE_favorites(new_dir, hwnd);
            }

            push_back(new_folder);
        } else {
            Bookmark bookmark;

            bookmark._name = DecodeXMLString(name);

            entry->get_path(path, COUNTOF(path));
            _tsplitpath_s(path, NULL, 0, NULL, 0, NULL, 0, ext, COUNTOF(ext));

            if (!_tcsicmp(ext, TEXT(".url"))) {
                bookmark.read_url(path);
                push_back(bookmark);
            } else {
                //assert(0);
            }
        }
    }
}


bool Favorites::read(LPCTSTR path)
{
    XMLDoc xbel;

    if (!xbel.read_file(path)) {
        if (!xbel._errors.empty())
            MessageBox(g_Globals._hwndDesktop, xbel._errors.str(),
                        TEXT("ROS Explorer - reading bookmark file"), MB_OK);
    }

    const_XMLPos pos(&xbel);

    if (!pos.go_down("xbel"))
        return false;

    super::read(pos);

    pos.back();

    return true;
}

void Favorites::write(LPCTSTR path) const
{
    XMLDoc xbel;

    XMLPos pos(&xbel);
    pos.create("xbel");
    super::write(pos);
    pos.back();

    xbel._format._doctype._name = "xbel";
    xbel._format._doctype._public = "+//IDN python.org//DTD XML Bookmark Exchange Language 1.0//EN//XML";
    xbel._format._doctype._system = "http://www.python.org/topics/xml/dtds/xbel-1.0.dtd";

    xbel.write_file(path);
}

bool Favorites::import_IE_favorites(HWND hwnd)
{
    WaitCursor wait;

    StartMenuShellDirs dirs;

    try {
        dirs.push_back(ShellDirectory(GetDesktopFolder(), SpecialFolderPath(CSIDL_COMMON_FAVORITES, hwnd), hwnd));
        dirs.push_back(ShellDirectory(GetDesktopFolder(), SpecialFolderPath(CSIDL_FAVORITES, hwnd), hwnd));
    } catch(COMException&) {
    }

    for(StartMenuShellDirs::iterator it=dirs.begin(); it!=dirs.end(); ++it) {
        StartMenuDirectory& smd = *it;
        ShellDirectory& dir = smd._dir;

        try {
            super::import_IE_favorites(dir, hwnd);
        } catch(COMException&) {
        }
    }

    return true;
}