diff options
Diffstat (limited to 'library/icon_buffer.cpp')
| -rw-r--r-- | library/icon_buffer.cpp | 451 |
1 files changed, 451 insertions, 0 deletions
diff --git a/library/icon_buffer.cpp b/library/icon_buffer.cpp new file mode 100644 index 00000000..81d14146 --- /dev/null +++ b/library/icon_buffer.cpp @@ -0,0 +1,451 @@ +// ************************************************************************** +// * This file is part of the FreeFileSync project. It is distributed under * +// * GNU General Public License: http://www.gnu.org/licenses/gpl.html * +// * Copyright (C) 2008-2010 ZenJu (zhnmju123 AT gmx.de) * +// ************************************************************************** +// +#include "icon_buffer.h" +#include <wx/msgdlg.h> +#include <map> +#include <queue> +#include <set> +#include <boost/thread.hpp> + +#ifdef FFS_WIN +#include <wx/msw/wrapwin.h> //includes "windows.h" + +#elif defined FFS_LINUX +#include <giomm/file.h> +#include <gtkmm/icontheme.h> +#include <gtkmm/main.h> +#endif + + +using ffs3::IconBuffer; + + +namespace +{ +#ifdef FFS_WIN +Zstring getFileExtension(const Zstring& filename) +{ + const Zstring shortName = filename.AfterLast(DefaultChar('\\')); //warning: using windows file name separator! + const size_t pos = shortName.Find(DefaultChar('.'), true); + return pos == Zstring::npos ? + Zstring() : + Zstring(shortName.c_str() + pos + 1); +} + + +//test for extension for icons that physically have to be retrieved from disc +bool isPriceyExtension(const Zstring& extension) +{ + static std::set<Zstring, LessFilename> exceptions; + static bool isInitalized = false; + if (!isInitalized) + { + isInitalized = true; + exceptions.insert(DefaultStr("exe")); + exceptions.insert(DefaultStr("lnk")); + exceptions.insert(DefaultStr("ico")); + exceptions.insert(DefaultStr("ani")); + exceptions.insert(DefaultStr("cur")); + exceptions.insert(DefaultStr("url")); + exceptions.insert(DefaultStr("msc")); + exceptions.insert(DefaultStr("scr")); + } + return exceptions.find(extension) != exceptions.end(); +} +#endif +} +//################################################################################################################################################ + + +class IconBuffer::IconHolder //handle HICON/GdkPixbuf ownership WITHOUT ref-counting to allow thread-safe usage (in contrast to wxIcon) +{ +public: +#ifdef FFS_WIN + typedef HICON HandleType; +#elif defined FFS_LINUX + typedef GdkPixbuf* HandleType; +#endif + + IconHolder(HandleType handle = 0) : handle_(handle) {} //take ownership! + + //icon holder has value semantics! + IconHolder(const IconHolder& other) : handle_(other.handle_ == 0 ? 0 : +#ifdef FFS_WIN + ::CopyIcon(other.handle_) +#elif defined FFS_LINUX + gdk_pixbuf_copy(other.handle_) //create new Pix buf with reference count 1 or return 0 on error +#endif + ) {} + + IconHolder& operator=(const IconHolder& other) + { + IconHolder(other).swap(*this); + return *this; + } + + ~IconHolder() + { + if (handle_ != 0) +#ifdef FFS_WIN + ::DestroyIcon(handle_); +#elif defined FFS_LINUX + g_object_unref(handle_); +#endif + } + + void swap(IconHolder& other) //throw() + { + std::swap(handle_, other.handle_); + } + + wxIcon toWxIcon() const //copy HandleType, caller needs to take ownership! + { + IconHolder clone(*this); + if (clone.handle_ != 0) + { + wxIcon newIcon; //attention: wxIcon uses reference counting! +#ifdef FFS_WIN + newIcon.SetHICON(clone.handle_); // + newIcon.SetSize(IconBuffer::ICON_SIZE, IconBuffer::ICON_SIZE); //icon is actually scaled to this size (just in case referenced HICON differs) +#elif defined FFS_LINUX // + newIcon.SetPixbuf(clone.handle_); // transfer ownership!! +#endif // + clone.handle_ = 0; // + return newIcon; + } + return wxNullIcon; + } + +private: + HandleType handle_; +}; + + +const wxIcon& IconBuffer::getDirectoryIcon() //one folder icon should be sufficient... +{ + static wxIcon folderIcon; + + static bool isInitalized = false; + if (!isInitalized) + { + isInitalized = true; + +#ifdef FFS_WIN + SHFILEINFO fileInfo; + fileInfo.hIcon = 0; //initialize hIcon + + //NOTE: CoInitializeEx()/CoUninitialize() implicitly called by wxWidgets on program startup! + if (::SHGetFileInfo(DefaultStr("dummy"), //Windows Seven doesn't like this parameter to be an empty string + FILE_ATTRIBUTE_DIRECTORY, + &fileInfo, + sizeof(fileInfo), + SHGFI_ICON | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES) && + + fileInfo.hIcon != 0) //fix for weird error: SHGetFileInfo() might return successfully WITHOUT filling fileInfo.hIcon!! + { + folderIcon.SetHICON(fileInfo.hIcon); //transfer ownership! + folderIcon.SetSize(IconBuffer::ICON_SIZE, IconBuffer::ICON_SIZE); + } + +#elif defined FFS_LINUX + folderIcon = getAssociatedIcon(DefaultStr("/usr/")).toWxIcon(); //all directories will look like "/usr/" +#endif + } + return folderIcon; +} + + +IconBuffer::IconHolder IconBuffer::getAssociatedIcon(const Zstring& filename) +{ +#ifdef FFS_WIN + //despite what docu says about SHGetFileInfo() it can't handle all relative filenames, e.g. "\DirName" + //but no problem, directory formatting takes care that filenames are always absolute! + + SHFILEINFO fileInfo; + fileInfo.hIcon = 0; //initialize hIcon -> fix for weird error: SHGetFileInfo() might return successfully WITHOUT filling fileInfo.hIcon!! + //bug report: https://sourceforge.net/tracker/?func=detail&aid=2768004&group_id=234430&atid=1093080 + + //NOTE: CoInitializeEx()/CoUninitialize() implicitly called by wxWidgets on program startup! + ::SHGetFileInfo(filename.c_str(), //ffs3::removeLongPathPrefix(fileName), //::SHGetFileInfo() can't handle \\?\-prefix! + 0, + &fileInfo, + sizeof(fileInfo), + SHGFI_ICON | SHGFI_SMALLICON); + + return IconHolder(fileInfo.hIcon); //pass icon ownership (may be 0) + +#elif defined FFS_LINUX + static struct RunOnce + { + RunOnce() + { + Gtk::Main::init_gtkmm_internals(); + } + } dummy; + + try + { + Glib::RefPtr<Gio::File> fileObj = Gio::File::create_for_path(filename.c_str()); //never fails + Glib::RefPtr<Gio::FileInfo> fileInfo = fileObj->query_info(G_FILE_ATTRIBUTE_STANDARD_ICON); + if (fileInfo) + { + Glib::RefPtr<Gio::Icon> gicon = fileInfo->get_icon(); + if (gicon) + { + Glib::RefPtr<Gtk::IconTheme> iconTheme = Gtk::IconTheme::get_default(); + if (iconTheme) + { + Gtk::IconInfo iconInfo = iconTheme->lookup_icon(gicon, ICON_SIZE, Gtk::ICON_LOOKUP_USE_BUILTIN); //this may fail if icon is not installed on system + if (iconInfo) + { + Glib::RefPtr<Gdk::Pixbuf> iconPixbuf = iconInfo.load_icon(); //render icon into Pixbuf + if (iconPixbuf) + return IconHolder(iconPixbuf->gobj_copy()); //copy and pass icon ownership (may be 0) + } + } + } + } + } + catch (const Glib::Error&) {} + + try //fallback: icon lookup may fail because some icons are currently not present on system + { + Glib::RefPtr<Gtk::IconTheme> iconTheme = Gtk::IconTheme::get_default(); + if (iconTheme) + { + Glib::RefPtr<Gdk::Pixbuf> iconPixbuf = iconTheme->load_icon("misc", ICON_SIZE, Gtk::ICON_LOOKUP_USE_BUILTIN); + if (!iconPixbuf) + iconPixbuf = iconTheme->load_icon("text-x-generic", ICON_SIZE, Gtk::ICON_LOOKUP_USE_BUILTIN); + if (iconPixbuf) + return IconHolder(iconPixbuf->gobj_copy()); //copy and pass icon ownership (may be 0) + } + } + catch (const Glib::Error&) {} + + //fallback fallback + return IconHolder(); +#endif +} + + +#ifdef FFS_WIN +IconBuffer::IconHolder IconBuffer::getAssociatedIconByExt(const Zstring& extension) +{ + SHFILEINFO fileInfo; + fileInfo.hIcon = 0; //initialize hIcon -> fix for weird error: SHGetFileInfo() might return successfully WITHOUT filling fileInfo.hIcon!! + + //no read-access to disk! determine icon by extension + ::SHGetFileInfo((Zstring(DefaultStr("dummy.")) + extension).c_str(), //Windows Seven doesn't like this parameter to be without short name + FILE_ATTRIBUTE_NORMAL, + &fileInfo, + sizeof(fileInfo), + SHGFI_ICON | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES); + + return IconHolder(fileInfo.hIcon); //pass icon ownership (may be 0) +} +#endif + + +//--------------------------------------------------------------------------------------------------- +typedef std::vector<DefaultChar> BasicString; //simple thread safe string class: std::vector is guaranteed to not use reference counting, Effective STL, item 13 +//avoid reference-counted objects as shared data: NOT THREADSAFE!!! (implicitly shared variables: ref-count + c-string) +//--------------------------------------------------------------------------------------------------- + + +class IconBuffer::WorkerThread +{ +public: + WorkerThread(IconBuffer& iconBuff); + ~WorkerThread(); + + void setWorkload(const std::vector<Zstring>& load); //(re-)set new workload of icons to be retrieved + + void operator()(); //thread entry + +private: + void doWork(); + +//---------------------- Shared Data ------------------------- + typedef BasicString FileName; + + struct SharedData + { + std::vector<FileName> workload; //processes last elements of vector first! + boost::mutex mutex; + boost::condition_variable condition; //signal event: data for processing available + } shared; +//------------------------------------------------------------ + + IconBuffer& iconBuffer; + + boost::thread threadObj; +}; + + +IconBuffer::WorkerThread::WorkerThread(IconBuffer& iconBuff) : + iconBuffer(iconBuff) +{ + threadObj = boost::thread(boost::ref(*this)); //localize all thread logic to this class! +} + + +IconBuffer::WorkerThread::~WorkerThread() +{ + setWorkload(std::vector<Zstring>()); //make sure interruption point is always reached! + threadObj.interrupt(); + threadObj.join(); +} + + +void IconBuffer::WorkerThread::setWorkload(const std::vector<Zstring>& load) //(re-)set new workload of icons to be retrieved +{ + { + boost::lock_guard<boost::mutex> dummy(shared.mutex); + + shared.workload.clear(); + for (std::vector<Zstring>::const_iterator i = load.begin(); i != load.end(); ++i) + shared.workload.push_back(FileName(i->c_str(), i->c_str() + i->length() + 1)); //make DEEP COPY from Zstring (include null-termination)! + } + + shared.condition.notify_one(); + //condition handling, see: http://www.boost.org/doc/libs/1_43_0/doc/html/thread/synchronization.html#thread.synchronization.condvar_ref +} + + +void IconBuffer::WorkerThread::operator()() //thread entry +{ + try + { + while (true) + { + { + boost::unique_lock<boost::mutex> dummy(shared.mutex); + while(shared.workload.empty()) + shared.condition.wait(dummy); //interruption point! + //shared.condition.timed_wait(dummy, boost::get_system_time() + boost::posix_time::milliseconds(100)); + } + + doWork(); //no need to lock the complete method! + } + } + catch (const std::exception& e) //exceptions must be catched per thread + { + wxMessageBox(wxString::FromAscii(e.what()), wxString(_("An exception occurred!")) + wxT("(Icon buffer)"), wxOK | wxICON_ERROR); + } +} + + +void IconBuffer::WorkerThread::doWork() +{ + //do work: get the file icon. + while (true) + { + Zstring fileName; + { + boost::lock_guard<boost::mutex> dummy(shared.mutex); + if (shared.workload.empty()) + break; //enter waiting state + fileName = &shared.workload.back()[0]; //deep copy (includes NULL-termination) + shared.workload.pop_back(); + } + + if (iconBuffer.requestFileIcon(fileName)) //thread safety: Zstring okay, won't be reference-counted in requestIcon() + continue; //icon already in buffer: skip + +#ifdef FFS_WIN + const Zstring extension = getFileExtension(fileName); //thread-safe: no sharing! + if (isPriceyExtension(extension)) //"pricey" extensions are stored with fullnames and are read from disk, while cheap ones require just the extension + { + const IconHolder newIcon = IconBuffer::getAssociatedIcon(fileName); + iconBuffer.insertIntoBuffer(fileName, newIcon); + } + else //no read-access to disk! determine icon by extension + { + const IconHolder newIcon = IconBuffer::getAssociatedIconByExt(extension); + iconBuffer.insertIntoBuffer(extension, newIcon); + } +#elif defined FFS_LINUX + const IconHolder newIcon = IconBuffer::getAssociatedIcon(fileName); + iconBuffer.insertIntoBuffer(fileName, newIcon); +#endif + } +} + + +//--------------------------------------------------------------------------------------------------- +class IconBuffer::IconDB : public std::map<Zstring, IconBuffer::IconHolder> {}; //entryName/icon -> ATTENTION: avoid ref-counting for this shared data structure!!! (== don't copy instances between threads) +class IconBuffer::IconDbSequence : public std::queue<Zstring> {}; //entryName +//--------------------------------------------------------------------------------------------------- + + +IconBuffer& IconBuffer::getInstance() +{ + static IconBuffer instance; + return instance; +} + + +IconBuffer::IconBuffer() : + buffer( new IconDB), + bufSequence(new IconDbSequence), + worker( new WorkerThread(*this)) //might throw exceptions! +{} + + +IconBuffer::~IconBuffer() {} //auto_ptr<>: keep destructor non-inline + + +bool IconBuffer::requestFileIcon(const Zstring& fileName, wxIcon* icon) +{ + boost::lock_guard<boost::mutex> dummy(lockIconDB); + +#ifdef FFS_WIN + //"pricey" extensions are stored with fullnames and are read from disk, while cheap ones require just the extension + const Zstring extension = getFileExtension(fileName); + IconDB::const_iterator i = buffer->find(isPriceyExtension(extension) ? fileName : extension); +#elif defined FFS_LINUX + IconDB::const_iterator i = buffer->find(fileName); +#endif + + if (i == buffer->end()) + return false; + + if (icon != NULL) + *icon = i->second.toWxIcon(); + + return true; +} + + +void IconBuffer::setWorkload(const std::vector<Zstring>& load) +{ + worker->setWorkload(load); +} + + +void IconBuffer::insertIntoBuffer(const DefaultChar* entryName, const IconHolder& icon) //called by worker thread +{ + boost::lock_guard<boost::mutex> dummy(lockIconDB); + + //thread safety, ref-counting: (implicitly) make deep copy! + const Zstring fileNameZ = entryName; + + const std::pair<IconDB::iterator, bool> rc = buffer->insert(std::make_pair(fileNameZ, icon)); //thread saftey: icon uses ref-counting! But is NOT shared with main thread! + + if (rc.second) //if insertion took place + bufSequence->push(fileNameZ); //note: sharing Zstring with IconDB!!! + + assert(buffer->size() == bufSequence->size()); + + //remove elements if buffer becomes too big: + if (buffer->size() > BUFFER_SIZE) //limit buffer size: critical because GDI resources are limited (e.g. 10000 on XP per process) + { + //remove oldest element + buffer->erase(bufSequence->front()); + bufSequence->pop(); + } +} |