diff options
Diffstat (limited to 'lib/icon_buffer.cpp')
| -rw-r--r-- | lib/icon_buffer.cpp | 560 |
1 files changed, 323 insertions, 237 deletions
diff --git a/lib/icon_buffer.cpp b/lib/icon_buffer.cpp index 44440be8..dd80f6dd 100644 --- a/lib/icon_buffer.cpp +++ b/lib/icon_buffer.cpp @@ -12,54 +12,52 @@ #ifdef FFS_WIN #include <zen/dll.h> -#include "Thumbnail/thumbnail.h" #include <zen/win_ver.h> +#include <wx/image.h> +#include "Thumbnail/thumbnail.h" #elif defined FFS_LINUX #include <gtk/gtk.h> + +#elif defined FFS_MAC +#include "osx_file_icon.h" #endif using namespace zen; -warn_static("mac") - -#if defined FFS_MAC -struct IconBuffer::Pimpl {}; -IconBuffer::IconBuffer(IconSize sz): pimpl(), icoSize(sz), genDirIcon(), genFileIcon() {} -IconBuffer::~IconBuffer() {} -int IconBuffer::getSize(IconSize icoSize) {return 16; } -bool IconBuffer::requestFileIcon(const Zstring& filename, wxIcon* icon) { return false; } -void IconBuffer::setWorkload(const std::vector<Zstring>& load) {} -#else - namespace { -const size_t BUFFER_SIZE_MAX = 800; //maximum number of icons to buffer +const size_t BUFFER_SIZE_MAX = 600; //maximum number of icons to hold in buffer + +#ifndef NDEBUG +boost::thread::id mainThreadId = boost::this_thread::get_id(); +#endif + +#ifdef FFS_WIN +#define DEF_DLL_FUN(name) DllFun<thumb::FunType_##name> name(thumb::getDllName(), thumb::funName_##name); -class IconHolder //handle HICON/GdkPixbuf ownership WITHOUT ref-counting to allow thread-safe usage (in contrast to wxIcon) +DEF_DLL_FUN(getIconByIndex); // +DEF_DLL_FUN(getThumbnail); //let's spare the boost::call_once hustle and allocate statically +DEF_DLL_FUN(releaseImageData); // +#endif + +class IconHolder //handle HICON/GdkPixbuf ownership supporting thread-safe usage (in contrast to wxIcon/wxBitmap) { public: #ifdef FFS_WIN - typedef HICON HandleType; + typedef const thumb::ImageData* HandleType; #elif defined FFS_LINUX typedef GdkPixbuf* HandleType; +#elif defined FFS_MAC + typedef osx::ImageData* HandleType; #endif explicit IconHolder(HandleType handle = nullptr) : handle_(handle) {} //take ownership! - //icon holder has value semantics! - IconHolder(const IconHolder& other) : handle_(other.handle_ == nullptr ? nullptr : -#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(IconHolder&& other) : handle_(other.handle_) { other.handle_ = nullptr; } + IconHolder(IconHolder&& other) : handle_(other.release()) {} - IconHolder& operator=(IconHolder other) //unifying assignment: no need for r-value reference optimization! + IconHolder& operator=(IconHolder other) //unifying assignment { other.swap(*this); return *this; @@ -69,72 +67,69 @@ public: { if (handle_ != nullptr) #ifdef FFS_WIN - ::DestroyIcon(handle_); + releaseImageData(handle_); #elif defined FFS_LINUX ::g_object_unref(handle_); //superseedes "::gdk_pixbuf_unref"! +#elif defined FFS_MAC + delete handle_; #endif } + HandleType release() + { + ZEN_ON_SCOPE_EXIT(handle_ = nullptr); + return handle_; + } + void swap(IconHolder& other) { std::swap(handle_, other.handle_); } //throw() - wxIcon toWxIcon(int expectedSize) const //copy HandleType, caller needs to take ownership! + //destroys raw icon! Call from GUI thread only! + wxBitmap extractWxBitmap() { - if (handle_ == nullptr) - return wxNullIcon; + ZEN_ON_SCOPE_EXIT(assert(!*this)); + assert(boost::this_thread::get_id() == mainThreadId ); - IconHolder clone(*this); + if (!handle_) + return wxNullBitmap; - wxIcon newIcon; //attention: wxIcon uses reference counting! #ifdef FFS_WIN - newIcon.SetHICON(clone.handle_); - { - //this block costs ~0.04 ms - ICONINFO icoInfo = {}; - if (::GetIconInfo(clone.handle_, &icoInfo)) - { - if (icoInfo.hbmMask) //VC11 static analyzer warns this could be null - ::DeleteObject(icoInfo.hbmMask); //nice potential for a GDI leak! - - if (icoInfo.hbmColor) //optional (for black and white bitmap) - { - ZEN_ON_SCOPE_EXIT(::DeleteObject(icoInfo.hbmColor)); // - - BITMAP bmpInfo = {}; - if (::GetObject(icoInfo.hbmColor, //__in HGDIOBJ hgdiobj, - sizeof(BITMAP), //__in int cbBuffer, - &bmpInfo) != 0) // __out LPVOID lpvObject - { - const int maxExtent = std::max(bmpInfo.bmWidth, bmpInfo.bmHeight); - if (0 < expectedSize && expectedSize < maxExtent) - { - bmpInfo.bmWidth = bmpInfo.bmWidth * expectedSize / maxExtent; //scale those Vista jumbo 256x256 icons down! - bmpInfo.bmHeight = bmpInfo.bmHeight * expectedSize / maxExtent; // - } - newIcon.SetSize(bmpInfo.bmWidth, bmpInfo.bmHeight); //wxIcon is stretched to this size - } - } - } - } - //no stretching for now - //newIcon.SetSize(expectedSize, expectedSize); //icon is stretched to this size if referenced HICON differs + ZEN_ON_SCOPE_EXIT(IconHolder().swap(*this)); //destroy after extraction + + //let wxImage reference data without taking ownership: + wxImage fileIcon(handle_->width, handle_->height, handle_->rgb, true); + fileIcon.SetAlpha(handle_->alpha, true); + return wxBitmap(fileIcon); #elif defined FFS_LINUX - // transfer ownership!! #if wxCHECK_VERSION(2, 9, 4) - newIcon.CopyFromBitmap(wxBitmap(clone.handle_)); + return wxBitmap(release()); //ownership passed! #else - newIcon.SetPixbuf(clone.handle_); + wxBitmap newIcon; + newIcon.SetPixbuf(release()); //ownership passed! + return newIcon; #endif -#endif // - clone.handle_ = nullptr; // - return newIcon; +#elif defined FFS_MAC + ZEN_ON_SCOPE_EXIT(IconHolder().swap(*this)); //destroy after extraction + + //let wxImage reference data without taking ownership: + if (!handle_->rgb.empty()) + { + wxImage fileIcon(handle_->width, handle_->height, &handle_->rgb[0], true); + if (!handle_->alpha.empty()) + fileIcon.SetAlpha(&handle_->alpha[0], true); + return wxBitmap(fileIcon); + } + assert(false); //rgb and alpha should never be empty + return wxBitmap(); +#endif } private: HandleType handle_; - struct ConversionToBool { int dummy; }; + IconHolder(const IconHolder& other); //move semantics! + struct ConversionToBool { int dummy; }; public: //use member pointer as implicit conversion to bool (C++ Templates - Vandevoorde/Josuttis; chapter 20) operator int ConversionToBool::* () const { return handle_ != nullptr ? &ConversionToBool::dummy : nullptr; } @@ -151,51 +146,51 @@ Zstring getFileExtension(const Zstring& filename) Zstring(); } + std::set<Zstring, LessFilename> priceyExtensions; //thread-safe! boost::once_flag initExtensionsOnce = BOOST_ONCE_INIT; // - //test for extension for non-thumbnail icons that physically have to be retrieved from disc bool isCheapExtension(const Zstring& extension) { boost::call_once(initExtensionsOnce, []() { priceyExtensions.insert(L"exe"); - priceyExtensions.insert(L"lnk"); priceyExtensions.insert(L"ico"); priceyExtensions.insert(L"ani"); priceyExtensions.insert(L"cur"); - priceyExtensions.insert(L"url"); priceyExtensions.insert(L"msc"); priceyExtensions.insert(L"scr"); + + priceyExtensions.insert(L"lnk"); // + priceyExtensions.insert(L"url"); //make sure shortcuts are pricey to get them to be detected by SHGetFileInfo + priceyExtensions.insert(L"pif"); // + priceyExtensions.insert(L"website"); // + }); return priceyExtensions.find(extension) == priceyExtensions.end(); } - const bool wereVistaOrLater = vistaOrLater(); //thread-safety: init at startup -int getShilIconType(IconBuffer::IconSize sz) +thumb::IconSizeType getThumbSizeType(IconBuffer::IconSize sz) { + using namespace thumb; switch (sz) { case IconBuffer::SIZE_SMALL: - return SHIL_SMALL; //16x16, but the size can be customized by the user. + return ICON_SIZE_16; case IconBuffer::SIZE_MEDIUM: - return SHIL_EXTRALARGE; //typically 48x48, but the size can be customized by the user. + if (!wereVistaOrLater) return ICON_SIZE_32; //48x48 doesn't look sharp on XP + return ICON_SIZE_48; case IconBuffer::SIZE_LARGE: - return wereVistaOrLater ? SHIL_JUMBO //normally 256x256 pixels -> will be scaled down by IconHolder - : SHIL_EXTRALARGE; //XP doesn't have jumbo icons + return ICON_SIZE_128; } - return SHIL_SMALL; + return ICON_SIZE_16; } -DllFun<thumb::FunType_getIconByIndex> getIconByIndex; -boost::once_flag initGetIconByIndexOnce = BOOST_ONCE_INIT; - - IconHolder getIconByAttribute(LPCWSTR pszPath, DWORD dwFileAttributes, IconBuffer::IconSize sz) { //NOTE: CoInitializeEx()/CoUninitialize() needs to be called for THIS thread! @@ -205,16 +200,13 @@ IconHolder getIconByAttribute(LPCWSTR pszPath, DWORD dwFileAttributes, IconBuffe &fileInfo, sizeof(fileInfo), SHGFI_SYSICONINDEX | SHGFI_USEFILEATTRIBUTES); - //no need to IUnknown::Release() imgList! - if (!imgList) + if (!imgList) //no need to IUnknown::Release() imgList! return IconHolder(); - boost::call_once(initGetIconByIndexOnce, [] //thread-safe init - { - using namespace thumb; - getIconByIndex = DllFun<FunType_getIconByIndex>(getDllName(), funName_getIconByIndex); - }); - return IconHolder(getIconByIndex ? static_cast<HICON>(getIconByIndex(fileInfo.iIcon, getShilIconType(sz))) : nullptr); + if (!getIconByIndex) + return IconHolder(); + + return IconHolder(getIconByIndex(fileInfo.iIcon, getThumbSizeType(sz))); } @@ -224,33 +216,66 @@ IconHolder getAssociatedIconByExt(const Zstring& extension, IconBuffer::IconSize return getIconByAttribute((L"dummy." + extension).c_str(), FILE_ATTRIBUTE_NORMAL, sz); } - -DllFun<thumb::FunType_getThumbnail> getThumbnailIcon; -boost::once_flag initThumbnailOnce = BOOST_ONCE_INIT; +#elif defined FFS_LINUX +IconHolder iconHolderFromGicon(GIcon* gicon, IconBuffer::IconSize sz) +{ + if (gicon) + if (GtkIconTheme* defaultTheme = ::gtk_icon_theme_get_default()) //not owned! + if (GtkIconInfo* iconInfo = ::gtk_icon_theme_lookup_by_gicon(defaultTheme, gicon, IconBuffer::getSize(sz), GTK_ICON_LOOKUP_USE_BUILTIN)) //this may fail if icon is not installed on system + { + ZEN_ON_SCOPE_EXIT(::gtk_icon_info_free(iconInfo);) + if (GdkPixbuf* pixBuf = ::gtk_icon_info_load_icon(iconInfo, nullptr)) + return IconHolder(pixBuf); //pass ownership + } + return IconHolder(); +} #endif } -//################################################################################################################################################ +//################################################################################################################################################ -IconHolder getThumbnail(const Zstring& filename, int requestedSize) //return 0 on failure +IconHolder getThumbnailIcon(const Zstring& filename, int requestedSize) //return 0 on failure { #ifdef FFS_WIN - boost::call_once(initThumbnailOnce, [] //note: "getThumbnail" function itself is already thread-safe - { - using namespace thumb; - getThumbnailIcon = DllFun<FunType_getThumbnail>(getDllName(), funName_getThumbnail); - }); - return IconHolder(getThumbnailIcon ? static_cast< ::HICON>(getThumbnailIcon(filename.c_str(), requestedSize)) : nullptr); + if (getThumbnail) + return IconHolder(getThumbnail(filename.c_str(), requestedSize)); #elif defined FFS_LINUX - GdkPixbuf* pixBuf = gdk_pixbuf_new_from_file_at_size(filename.c_str(), requestedSize, requestedSize, nullptr); - return IconHolder(pixBuf); //pass ownership (may be 0) + gint width = 0; + gint height = 0; + if (GdkPixbufFormat* fmt = ::gdk_pixbuf_get_file_info(filename.c_str(), &width, &height)) + { + (void)fmt; + if (width > 0 && height > 0 && requestedSize > 0) + { + int trgWidth = width; + int trgHeight = height; + + const int maxExtent = std::max(width, height); //don't stretch small images, but shrink large ones instead! + if (requestedSize < maxExtent) + { + trgWidth = width * requestedSize / maxExtent; + trgHeight = height * requestedSize / maxExtent; + } + if (GdkPixbuf* pixBuf = ::gdk_pixbuf_new_from_file_at_size(filename.c_str(), trgWidth, trgHeight, nullptr)) + return IconHolder(pixBuf); //pass ownership + } + } + +#elif defined FFS_MAC + try + { + return IconHolder(new osx::ImageData(osx::getThumbnail(filename.c_str(), requestedSize))); //throw OsxError + } + catch (osx::OsxError&) {} #endif + return IconHolder(); } IconHolder getGenericFileIcon(IconBuffer::IconSize sz) { + //we're called by getAssociatedIcon()! -> avoid endless recursion! #ifdef FFS_WIN return getIconByAttribute(L"dummy", FILE_ATTRIBUTE_NORMAL, sz); @@ -259,18 +284,44 @@ IconHolder getGenericFileIcon(IconBuffer::IconSize sz) { "application-x-zerosize", //Kubuntu: /usr/share/icons/oxygen/48x48/mimetypes "text-x-generic", //http://live.gnome.org/GnomeArt/Tutorials/IconThemes - "empty", // - "gtk-file", //Ubuntu: /usr/share/icons/Humanity/mimes/48 + "empty", //Ubuntu: /usr/share/icons/Humanity/mimes/48 + GTK_STOCK_FILE, //"gtk-file", "gnome-fs-regular", // }; - const int requestedSize = IconBuffer::getSize(sz); - if (GtkIconTheme* defaultTheme = gtk_icon_theme_get_default()) //not owned! for (auto it = std::begin(mimeFileIcons); it != std::end(mimeFileIcons); ++it) - if (GdkPixbuf* pixBuf = gtk_icon_theme_load_icon(defaultTheme, *it, requestedSize, GTK_ICON_LOOKUP_USE_BUILTIN, nullptr)) - return IconHolder(pixBuf); //pass ownership (may be nullptr) + if (GdkPixbuf* pixBuf = gtk_icon_theme_load_icon(defaultTheme, *it, IconBuffer::getSize(sz), GTK_ICON_LOOKUP_USE_BUILTIN, nullptr)) + return IconHolder(pixBuf); //pass ownership + return IconHolder(); + +#elif defined FFS_MAC + try + { + return IconHolder(new osx::ImageData(osx::getDefaultFileIcon(IconBuffer::getSize(sz)))); //throw OsxError + } + catch (osx::OsxError&) {} + return IconHolder(); +#endif +} + + +IconHolder getGenericDirectoryIcon(IconBuffer::IconSize sz) +{ +#ifdef FFS_WIN + return getIconByAttribute(L"dummy", //Windows 7 doesn't like this parameter to be an empty string! + FILE_ATTRIBUTE_DIRECTORY, sz); +#elif defined FFS_LINUX + if (GIcon* dirIcon = ::g_content_type_get_icon("inode/directory")) //should contain fallback to GTK_STOCK_DIRECTORY ("gtk-directory") + return iconHolderFromGicon(dirIcon, sz); return IconHolder(); + +#elif defined FFS_MAC + try + { + return IconHolder(new osx::ImageData(osx::getDefaultFolderIcon(IconBuffer::getSize(sz)))); //throw OsxError + } + catch (osx::OsxError&) { return IconHolder(); } #endif } @@ -284,15 +335,14 @@ IconHolder getAssociatedIcon(const Zstring& filename, IconBuffer::IconSize sz) break; case IconBuffer::SIZE_MEDIUM: case IconBuffer::SIZE_LARGE: - { - IconHolder ico = getThumbnail(filename, IconBuffer::getSize(sz)); - if (ico) + if (IconHolder ico = getThumbnailIcon(filename, IconBuffer::getSize(sz))) return ico; //else: fallback to non-thumbnail icon - } - break; + break; } + warn_static("problem: für folder links ist getThumbnail erfolgreich => SFGAO_LINK nicht gecheckt!") + //2. retrieve file icons #ifdef FFS_WIN //perf: optimize fallback case for SIZE_MEDIUM and SIZE_LARGE: @@ -303,70 +353,52 @@ IconHolder getAssociatedIcon(const Zstring& filename, IconBuffer::IconSize sz) //which means the access to get thumbnail failed: thumbnail failure is not dependent from extension in general! SHFILEINFO fileInfo = {}; - DWORD_PTR imgList = ::SHGetFileInfo(filename.c_str(), //_In_ LPCTSTR pszPath, -> note: ::SHGetFileInfo() can't handle \\?\-prefix! - 0, //DWORD dwFileAttributes, - &fileInfo, //_Inout_ SHFILEINFO *psfi, - sizeof(fileInfo), //UINT cbFileInfo, - SHGFI_SYSICONINDEX); //UINT uFlags - - //Quote: "The IImageList pointer type, such as that returned in the ppv parameter, can be cast as an HIMAGELIST as - // needed; for example, for use in a list view. Conversely, an HIMAGELIST can be cast as a pointer to an IImageList." - //http://msdn.microsoft.com/en-us/library/windows/desktop/bb762185(v=vs.85).aspx + if (DWORD_PTR imgList = ::SHGetFileInfo(filename.c_str(), //_In_ LPCTSTR pszPath, -> note: ::SHGetFileInfo() can't handle \\?\-prefix! + 0, //DWORD dwFileAttributes, + &fileInfo, //_Inout_ SHFILEINFO *psfi, + sizeof(fileInfo), //UINT cbFileInfo, + SHGFI_SYSICONINDEX | SHGFI_ATTRIBUTES)) //UINT uFlags + { + //imgList->Release(); //empiric study: crash on XP if we release this! Seems we do not own it... -> also no GDI leak on Win7 -> okay + //another comment on http://msdn.microsoft.com/en-us/library/bb762179(v=VS.85).aspx describes exact same behavior on Win7/XP - if (!imgList) - return IconHolder(); - //imgList->Release(); //empiric study: crash on XP if we release this! Seems we do not own it... -> also no GDI leak on Win7 -> okay - //another comment on http://msdn.microsoft.com/en-us/library/bb762179(v=VS.85).aspx describes exact same behavior on Win7/XP + //Quote: "The IImageList pointer type, such as that returned in the ppv parameter, can be cast as an HIMAGELIST as + // needed; for example, for use in a list view. Conversely, an HIMAGELIST can be cast as a pointer to an IImageList." + //http://msdn.microsoft.com/en-us/library/windows/desktop/bb762185(v=vs.85).aspx - boost::call_once(initGetIconByIndexOnce, [] //thread-safe init - { - getIconByIndex = DllFun<thumb::FunType_getIconByIndex>(thumb::getDllName(), thumb::funName_getIconByIndex); - }); - return IconHolder(getIconByIndex ? static_cast<HICON>(getIconByIndex(fileInfo.iIcon, getShilIconType(sz))) : nullptr); +#ifndef SFGAO_LINK //Shobjidl.h +#define SFGAO_LINK 0x00010000L // Shortcut (link) or symlinks +#endif -#elif defined FFS_LINUX - const int requestedSize = IconBuffer::getSize(sz); + warn_static("support SFGAO_GHOSTED or hidden?") - GFile* file = g_file_new_for_path(filename.c_str()); //never fails - ZEN_ON_SCOPE_EXIT(g_object_unref(file);) + const bool isLink = (fileInfo.dwAttributes & SFGAO_LINK) != 0; - if (GFileInfo* fileInfo = g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_ICON, G_FILE_QUERY_INFO_NONE, nullptr, nullptr)) - { - ZEN_ON_SCOPE_EXIT(g_object_unref(fileInfo);) - - if (GIcon* gicon = g_file_info_get_icon(fileInfo)) //not owned! - if (GtkIconTheme* defaultTheme = gtk_icon_theme_get_default()) //not owned! - if (GtkIconInfo* iconInfo = gtk_icon_theme_lookup_by_gicon(defaultTheme, gicon, requestedSize, GTK_ICON_LOOKUP_USE_BUILTIN)) //this may fail if icon is not installed on system - { - ZEN_ON_SCOPE_EXIT(gtk_icon_info_free(iconInfo);) - if (GdkPixbuf* pixBuf = gtk_icon_info_load_icon(iconInfo, nullptr)) - return IconHolder(pixBuf); //pass ownership (may be nullptr) - } + if (getIconByIndex) + if (const thumb::ImageData* imgData = getIconByIndex(fileInfo.iIcon, getThumbSizeType(sz))) + return IconHolder(imgData); } - //fallback: icon lookup may fail because some icons are currently not present on system - return ::getGenericFileIcon(sz); -#endif -} -/* Dependency Diagram: +#elif defined FFS_LINUX + GFile* file = ::g_file_new_for_path(filename.c_str()); //never fails + ZEN_ON_SCOPE_EXIT(::g_object_unref(file);) -getGenericFileIcon() - /|\ - | -getAssociatedIcon() - /|\ - | -getGenericDirectoryIcon() -*/ + if (GFileInfo* fileInfo = ::g_file_query_info(file, G_FILE_ATTRIBUTE_STANDARD_ICON, G_FILE_QUERY_INFO_NONE, nullptr, nullptr)) + { + ZEN_ON_SCOPE_EXIT(::g_object_unref(fileInfo);) + if (GIcon* gicon = ::g_file_info_get_icon(fileInfo)) //not owned! + return iconHolderFromGicon(gicon, sz); + } + //need fallback: icon lookup may fail because some icons are currently not present on system -IconHolder getGenericDirectoryIcon(IconBuffer::IconSize sz) -{ -#ifdef FFS_WIN - return getIconByAttribute(L"dummy", //Windows 7 doesn't like this parameter to be an empty string! - FILE_ATTRIBUTE_DIRECTORY, sz); -#elif defined FFS_LINUX - return ::getAssociatedIcon(Zstr("/usr/"), sz); //all directories will look like "/usr/" +#elif defined FFS_MAC + try + { + return IconHolder(new osx::ImageData(osx::getFileIcon(filename.c_str(), IconBuffer::getSize(sz)))); //throw OsxError + } + catch (osx::OsxError&) {} #endif + return ::getGenericFileIcon(sz); //make sure this does not internally call getAssociatedIcon("someDefaultFile.txt")!!! => endless recursion! } //################################################################################################################################################ @@ -377,6 +409,7 @@ class WorkLoad public: Zstring extractNextFile() //context of worker thread, blocking { + assert(boost::this_thread::get_id() != mainThreadId ); boost::unique_lock<boost::mutex> dummy(lockFiles); while (filesToLoad.empty()) @@ -387,8 +420,9 @@ public: return fileName; } - void setWorkload(const std::vector<Zstring>& newLoad) //context of main thread + void setWorkload(const std::list<Zstring>& newLoad) //context of main thread { + assert(boost::this_thread::get_id() == mainThreadId ); { boost::unique_lock<boost::mutex> dummy(lockFiles); filesToLoad = newLoad; @@ -397,57 +431,95 @@ public: //condition handling, see: http://www.boost.org/doc/libs/1_43_0/doc/html/thread/synchronization.html#thread.synchronization.condvar_ref } + void addToWorkload(const Zstring& newEntry) //context of main thread + { + assert(boost::this_thread::get_id() == mainThreadId ); + { + boost::unique_lock<boost::mutex> dummy(lockFiles); + filesToLoad.push_back(newEntry); //set as next item to retrieve + } + conditionNewFiles.notify_all(); + } + private: - std::vector<Zstring> filesToLoad; //processes last elements of vector first! + std::list<Zstring> filesToLoad; //processes last elements of vector first! boost::mutex lockFiles; boost::condition_variable conditionNewFiles; //signal event: data for processing available }; -typedef std::map<Zstring, IconHolder, LessFilename> NameIconMap; //entryName/icon -> note: Zstring is "thread-safe like an int" -typedef std::queue<Zstring> IconDbSequence; //entryName - class Buffer { public: - bool requestFileIcon(const Zstring& fileName, IconHolder* icon = nullptr) + //called by main and worker thread: + bool hasFileIcon(const Zstring& fileName) { - boost::lock_guard<boost::mutex> dummy(lockBuffer); + boost::lock_guard<boost::mutex> dummy(lockIconList); + return iconList.find(fileName) != iconList.end(); + } - auto it = iconMappping.find(fileName); - if (it != iconMappping.end()) + //must be called by main thread only! => wxBitmap is NOT thread-safe like an int (non-atomic ref-count!!!) + Opt<wxBitmap> retrieveFileIcon(const Zstring& fileName) + { + assert(boost::this_thread::get_id() == mainThreadId ); + boost::lock_guard<boost::mutex> dummy(lockIconList); + auto it = iconList.find(fileName); + if (it == iconList.end()) + return NoValue(); + + IconData& idata = it->second; + if (idata.iconRaw) //if not yet converted... { - if (icon) - *icon = it->second; - return true; + idata.iconFmt = make_unique<wxBitmap>(idata.iconRaw.extractWxBitmap()); //convert in main thread! + assert(!idata.iconRaw); } - return false; + return idata.iconFmt ? *idata.iconFmt : wxNullBitmap; //idata.iconRaw may be inserted as empty from worker thread! } - void insertIntoBuffer(const Zstring& entryName, const IconHolder& icon) //called by worker thread + //must be called by main thread only! => ~wxBitmap() is NOT thread-safe! + //call at an appropriate time, e.g. after Workload::setWorkload() + void limitBufferSize() //critical because GDI resources are limited (e.g. 10000 on XP per process) { - boost::lock_guard<boost::mutex> dummy(lockBuffer); + assert(boost::this_thread::get_id() == mainThreadId ); + boost::lock_guard<boost::mutex> dummy(lockIconList); + while (iconList.size() > BUFFER_SIZE_MAX) + { + iconList.erase(iconSequence.front()); //remove oldest element + iconSequence.pop(); + } + } + + //called by main and worker thread: + void moveIntoBuffer(const Zstring& entryName, IconHolder&& icon) + { + boost::lock_guard<boost::mutex> dummy(lockIconList); - //thread saftey: icon uses ref-counting! But is NOT shared with main thread! - auto rc = iconMappping.insert(std::make_pair(entryName, icon)); + //thread safety: moving IconHolder is free from side effects, but ~wxBitmap() is NOT! => do NOT delete items from iconList here! + auto rc = iconList.insert(std::make_pair(entryName, IconData(std::move(icon)))); if (rc.second) //if insertion took place iconSequence.push(entryName); //note: sharing Zstring with IconDB!!! - assert(iconMappping.size() == iconSequence.size()); - - //remove elements if buffer becomes too big: - if (iconMappping.size() > BUFFER_SIZE_MAX) //limit buffer size: critical because GDI resources are limited (e.g. 10000 on XP per process) - { - //remove oldest element - iconMappping.erase(iconSequence.front()); - iconSequence.pop(); - } + assert(iconList.size() == iconSequence.size()); } private: - boost::mutex lockBuffer; - NameIconMap iconMappping; //use synchronisation when accessing this! - IconDbSequence iconSequence; //save sequence of buffer entry to delete oldest elements + struct IconData + { + IconData(IconHolder&& tmp) : iconRaw(std::move(tmp)) {} + IconData(IconData&& tmp) : iconRaw(std::move(tmp.iconRaw)), iconFmt(std::move(tmp.iconFmt)) {} + + IconHolder iconRaw; //native icon representation: may be used by any thread + + std::unique_ptr<wxBitmap> iconFmt; //use ONLY from main thread! + //wxBitmap is NOT thread-safe: non-atomic ref-count just to begin with... + //- prohibit implicit calls to wxBitmap(const wxBitmap&) + //- prohibit calls to ~wxBitmap() and transitively ~IconData() + //- prohibit even wxBitmap() default constructor - better be safe than sorry! + }; + + boost::mutex lockIconList; + std::map<Zstring, IconData, LessFilename> iconList; //shared resource; Zstring is thread-safe like an int + std::queue<Zstring> iconSequence; //save sequence of buffer entry to delete oldest elements }; //################################################################################################################################################ @@ -457,17 +529,17 @@ class WorkerThread //lifetime is part of icon buffer public: WorkerThread(const std::shared_ptr<WorkLoad>& workload, const std::shared_ptr<Buffer>& buffer, - IconBuffer::IconSize sz) : + IconBuffer::IconSize st) : workload_(workload), buffer_(buffer), - icoSize(sz) {} + iconSizeType(st) {} void operator()(); //thread entry private: std::shared_ptr<WorkLoad> workload_; //main/worker thread may access different shared_ptr instances safely (even though they have the same target!) std::shared_ptr<Buffer> buffer_; //http://www.boost.org/doc/libs/1_43_0/libs/smart_ptr/shared_ptr.htm?sess=8153b05b34d890e02d48730db1ff7ddc#ThreadSafety - const IconBuffer::IconSize icoSize; + const IconBuffer::IconSize iconSizeType; }; @@ -493,20 +565,20 @@ void WorkerThread::operator()() //thread entry { boost::this_thread::interruption_point(); - const Zstring fileName = workload_->extractNextFile(); //start work: get next icon to load + const Zstring fileName = workload_->extractNextFile(); //start work: blocks until next icon to load is retrieved - if (buffer_->requestFileIcon(fileName)) - continue; //icon already in buffer: skip - - buffer_->insertIntoBuffer(fileName, getAssociatedIcon(fileName, icoSize)); + if (!buffer_->hasFileIcon(fileName)) //perf: workload may contain duplicate entries? + buffer_->moveIntoBuffer(fileName, getAssociatedIcon(fileName, iconSizeType)); } } + //######################### redirect to impl ##################################################### struct IconBuffer::Pimpl { - Pimpl() : workload(std::make_shared<WorkLoad>()), - buffer(std::make_shared<Buffer>()) {} + Pimpl() : + workload(std::make_shared<WorkLoad>()), + buffer (std::make_shared<Buffer>()) {} std::shared_ptr<WorkLoad> workload; std::shared_ptr<Buffer> buffer; @@ -516,9 +588,9 @@ struct IconBuffer::Pimpl IconBuffer::IconBuffer(IconSize sz) : pimpl(make_unique<Pimpl>()), - icoSize(sz), - genDirIcon(::getGenericDirectoryIcon(sz).toWxIcon(IconBuffer::getSize(icoSize))), - genFileIcon(::getGenericFileIcon(sz).toWxIcon(IconBuffer::getSize(icoSize))) + iconSizeType(sz), + genDirIcon (::getGenericDirectoryIcon(sz).extractWxBitmap()), + genFileIcon(::getGenericFileIcon (sz).extractWxBitmap()) { pimpl->worker = boost::thread(WorkerThread(pimpl->workload, pimpl->buffer, sz)); } @@ -526,7 +598,7 @@ IconBuffer::IconBuffer(IconSize sz) : pimpl(make_unique<Pimpl>()), IconBuffer::~IconBuffer() { - setWorkload(std::vector<Zstring>()); //make sure interruption point is always reached! + setWorkload(std::list<Zstring>()); //make sure interruption point is always reached! pimpl->worker.interrupt(); pimpl->worker.join(); //we assume precondition "worker.joinable()"!!! } @@ -543,7 +615,11 @@ int IconBuffer::getSize(IconSize icoSize) return 24; #endif case IconBuffer::SIZE_MEDIUM: +#ifdef FFS_WIN + if (!wereVistaOrLater) return 32; //48x48 doesn't look sharp on XP +#endif return 48; + case IconBuffer::SIZE_LARGE: return 128; } @@ -552,41 +628,51 @@ int IconBuffer::getSize(IconSize icoSize) } -bool IconBuffer::requestFileIcon(const Zstring& filename, wxIcon* icon) +bool IconBuffer::readyForRetrieval(const Zstring& filename) { - auto getIcon = [&](const Zstring& entryName) -> bool - { - if (!icon) - return pimpl->buffer->requestFileIcon(entryName); - - IconHolder heldIcon; - if (!pimpl->buffer->requestFileIcon(entryName, &heldIcon)) - return false; - *icon = heldIcon.toWxIcon(IconBuffer::getSize(icoSize)); - return true; - }; +#ifdef FFS_WIN + if (iconSizeType == IconBuffer::SIZE_SMALL) + if (isCheapExtension(getFileExtension(filename))) + return true; +#endif + return pimpl->buffer->hasFileIcon(filename); +} + +Opt<wxBitmap> IconBuffer::retrieveFileIcon(const Zstring& filename) +{ #ifdef FFS_WIN //perf: let's read icons which don't need file access right away! No async delay justified! - if (icoSize == IconBuffer::SIZE_SMALL) //non-thumbnail view, we need file type icons only! + if (iconSizeType == IconBuffer::SIZE_SMALL) //non-thumbnail view, we need file type icons only! { const Zstring& extension = getFileExtension(filename); if (isCheapExtension(extension)) //"pricey" extensions are stored with fullnames and are read from disk, while cheap ones require just the extension { - if (!getIcon(extension)) - { - IconHolder heldIcon = getAssociatedIconByExt(extension, icoSize); //fast! - pimpl->buffer->insertIntoBuffer(extension, heldIcon); - if (icon) - *icon = heldIcon.toWxIcon(IconBuffer::getSize(icoSize)); - } - return true; + if (Opt<wxBitmap> ico = pimpl->buffer->retrieveFileIcon(extension)) + return ico; + + //make sure icon is in buffer, even if icon needs not be retrieved! + pimpl->buffer->moveIntoBuffer(extension, getAssociatedIconByExt(extension, iconSizeType)); + + Opt<wxBitmap> ico = pimpl->buffer->retrieveFileIcon(extension); + assert(ico); + return ico; } } #endif - return getIcon(filename); + if (Opt<wxBitmap> ico = pimpl->buffer->retrieveFileIcon(filename)) + return ico; + + //since this icon seems important right now, we don't want to wait until next setWorkload() to start retrieving + pimpl->workload->addToWorkload(filename); + pimpl->buffer->limitBufferSize(); + return NoValue(); } -void IconBuffer::setWorkload(const std::vector<Zstring>& load) { pimpl->workload->setWorkload(load); } -#endif + +void IconBuffer::setWorkload(const std::list<Zstring>& load) +{ + pimpl->workload->setWorkload(load); //since buffer can only increase due to new workload, + pimpl->buffer->limitBufferSize(); //this is the place to impose the limit from main thread! +} |