play with some tint2conf code

[chaz/tint2] / src / tint2conf / thumbview.cpp

/*

This file is from Nitrogen, an X11 background setter.
Copyright (C) 2006  Dave Foster & Javeed Shaikh

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

//#include "md5.h"
#include <glib/gstdio.h>
#include <png.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <iostream>
#include "thumbview.h"
//#include "Config.h"
//#include "Util.h"
//#include "gcs-i18n.h"

/**
 * Returns the last modified time of a file.
 * @param file The name of the file to get the modified time for.
 */
static time_t get_file_mtime(std::string file) {
        struct stat buf;
        if (stat(file.c_str(), &buf) == -1) return 0; // error
        return buf.st_mtime;
}

/**
 * Returns the value of the "tEXt::Thumb::MTime" key for fd.o style thumbs.
 * @param pixbuf The pixbuf of the fd.o thumbnail.
 */
static time_t get_fdo_thumbnail_mtime(Glib::RefPtr<Gdk::Pixbuf> pixbuf) {
        std::string mtime_str = pixbuf->get_option("tEXt::Thumb::MTime");
        std::stringstream stream(mtime_str);
        time_t mtime = 0;
        stream >> mtime;
        return mtime;
}

void DelayLoadingStore::get_value_vfunc (const iterator& iter, int column, Glib::ValueBase& value) const
{
        g_async_queue_ref(aqueue_loadthumbs);
        Gtk::ListStore::get_value_vfunc(iter, column, value);

        Gtk::TreeModel::Row row = *iter;
        if (column == 0)
        {
                Glib::Value< Glib::RefPtr<Gdk::Pixbuf> > base;
                Gtk::ListStore::get_value_vfunc(iter, column, base);

                Glib::RefPtr<Gdk::Pixbuf> thumb = base.get();

                if (thumb == thumbview->loading_image && !row[thumbview->record.LoadingThumb])
                {
                        TreePair* tp = new TreePair();
                        tp->file = row[thumbview->record.Filename];
                        tp->iter = iter;

                        row[thumbview->record.LoadingThumb] = true;

                        //Util::program_log("Custom model: planning on loading %s\n", tp->file.c_str());

                        g_async_queue_push(aqueue_loadthumbs, (gpointer)tp);
                }
        }
        g_async_queue_unref(aqueue_loadthumbs);
}

/**
 * Constructor, sets up gtk stuff, inits data and queues
 */
Thumbview::Thumbview() : dir("") {
        set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
        set_shadow_type (Gtk::SHADOW_IN);

    // load map of setbgs (need this for add_file)
    load_map_setbgs();

        // make our async queues
        this->aqueue_loadthumbs = g_async_queue_new();
        this->aqueue_createthumbs = g_async_queue_new();
        this->aqueue_donethumbs = g_async_queue_new();

        // create store
        store = DelayLoadingStore::create (record);
        store->set_queue(aqueue_loadthumbs);
        store->set_thumbview(this);

        // setup view
        view.set_model (store);
        view.set_headers_visible (FALSE);
        view.set_fixed_height_mode (TRUE);
        view.set_rules_hint (TRUE);

        // set cell renderer proprties
        rend.property_ellipsize () = Pango::ELLIPSIZE_END;
        rend.set_property ("ellipsize", Pango::ELLIPSIZE_END);
        rend.property_weight () = Pango::WEIGHT_BOLD;

        rend_img.set_fixed_size(105, 82);

        // make treeviewcolumns
        this->col_thumb = new Gtk::TreeViewColumn("thumbnail", this->rend_img);
        this->col_desc = new Gtk::TreeViewColumn("description", this->rend);

        col_thumb->add_attribute (rend_img, "pixbuf", record.Thumbnail);
        col_thumb->set_sizing(Gtk::TREE_VIEW_COLUMN_FIXED);
        col_thumb->set_fixed_width(105);
        col_desc->add_attribute (rend, "markup", record.Description);
        col_desc->set_sort_column (record.Filename);
        col_desc->set_sort_indicator (true);
        col_desc->set_sort_order (Gtk::SORT_ASCENDING);
        col_desc->set_sizing(Gtk::TREE_VIEW_COLUMN_FIXED);

        view.append_column (*col_thumb);
        view.append_column (*col_desc);

        // enable search
        view.set_search_column (record.Description);
        view.set_search_equal_func (sigc::mem_fun (this, &Thumbview::search_compare));

        // load loading image, which not all themes seem to provide
        try {
                this->loading_image = Gtk::IconTheme::get_default()->load_icon("image-loading", 64, Gtk::ICON_LOOKUP_FORCE_SVG);
        } catch (Gtk::IconThemeError e) {}

        // init dispatcher
        this->dispatch_thumb.connect(sigc::mem_fun(this, &Thumbview::handle_dispatch_thumb));

        col_desc->set_expand ();

        add (view);

        view.show ();
        show ();
}

/**
 * Destructor
 */
Thumbview::~Thumbview() {
        g_async_queue_unref(this->aqueue_loadthumbs);
        g_async_queue_unref(this->aqueue_createthumbs);
        g_async_queue_unref(this->aqueue_donethumbs);
}

/**
 * Adds the given file to the tree view and pushes it onto the thumbnail
 * creation queue.
 *
 * @param filename The name of the file to add.
 *
 */
void Thumbview::add_file(std::string filename) {
    Gtk::Window *window = dynamic_cast<Gtk::Window*>(get_toplevel());
        Gtk::TreeModel::iterator iter = this->store->append ();
        Gtk::TreeModel::Row row = *iter;
        Glib::RefPtr<Gdk::Pixbuf> thumb = this->loading_image;
        row[record.Thumbnail] = thumb;
        row[record.Filename] = filename;
        row[record.Description] = Glib::ustring(filename, filename.rfind ("/")+1);

    for (std::map<Glib::ustring, Glib::ustring>::iterator i = map_setbgs.begin(); i!=map_setbgs.end(); i++)
    {
        if (filename == (*i).second)
        {
            row[record.CurBGOnDisp] = (*i).first;
//            row[record.Description] = Util::make_current_set_string(window, filename, (*i).first);
        }
    }

        // for modified time
        row[record.Time] = get_file_mtime(filename);

//      Util::program_log("add_file(): Adding file %s\n", filename.c_str());

        // push it on the thumb queue
//      TreePair *tp = new TreePair();
//      tp->file = filename;
//      tp->iter = iter;

//      queue_thumbs.push(tp);
}


/**
 * Opens the internal directory and starts reading files into the async queue.
 */
void Thumbview::load_dir(std::string dir) {
        if (!dir.length()) dir = this->dir;

        std::queue<Glib::ustring> subdirs;
        Glib::Dir *dirhandle;

        // push the initial dir back onto subdirs
        subdirs.push(dir);

        // loop it
        while ( ! subdirs.empty() ) {

                // pop first
                Glib::ustring curdir = subdirs.front();
                subdirs.pop();

                try {
                        dirhandle = new Glib::Dir(curdir);
//                      Util::program_log("load_dir(): Opening dir %s\n", curdir.c_str());

                } catch (Glib::FileError e) {
                        std::cerr << "Could not open dir" << " " << this->dir << ": " << e.what() << "\n";
                        continue;
                }

#ifdef USE_INOTIFY

                // check if we're already monitoring this dir.
                if (watches.find(curdir) == watches.end()) {
                        // this dir was successfully opened. monitor it for changes with inotify.
                        // the Watch will be cleaned up automatically if the dir is deleted.
                        Inotify::Watch * watch = Inotify::Watch::create(curdir);
                        if (watch) {
                                // no error occurred.

                                // emitted when a file is deleted in this dir.
                                watch->signal_deleted.connect(sigc::mem_fun(this,
                                        &Thumbview::file_deleted_callback));
                                // emitted when a file is modified or created in this dir.
                                watch->signal_write_closed.connect(sigc::mem_fun(this,
                                        &Thumbview::file_changed_callback));
                                // two signals that are emitted when a file is renamed in this dir.
                                // the best way to handle this IMO is to remove the file upon receiving
                                // 'moved_from', and then to add the file upon receiving 'moved_to'.
                                watch->signal_moved_from.connect(sigc::mem_fun(this,
                                        &Thumbview::file_deleted_callback));
                                watch->signal_moved_to.connect(sigc::mem_fun(this,
                                        &Thumbview::file_changed_callback));
                                watch->signal_created.connect(sigc::mem_fun(this,
                                        &Thumbview::file_created_callback));

                                watches[curdir] = watch;
                        }
                }

#endif

                for (Glib::Dir::iterator i = dirhandle->begin(); i != dirhandle->end(); i++) {
                        Glib::ustring fullstr = curdir + Glib::ustring("/");
                        try {
                                fullstr += /*Glib::filename_to_utf8(*/*i;//);
                        } catch (Glib::ConvertError& error) {
                                std::cerr << "Invalid UTF-8 encountered. Skipping file" << " " << *i << std::endl;
                                continue;
                        }

                        if ( Glib::file_test(fullstr, Glib::FILE_TEST_IS_DIR) )
                        {
//                              if ( Config::get_instance()->get_recurse() )
//                                      subdirs.push(fullstr);
                        }
                        else {
                                if ( this->is_image(fullstr) ) {
                                        add_file(fullstr);
                                }
                        }
                }

                delete dirhandle;
        }
}

/**
 * Tests the file to see if it is an image
 * TODO: come up with less sux way of doing it than extension
 *
 * @param       file    The filename to test
 * @return                      If its an image or not
 */
bool Thumbview::is_image(std::string file) {
        if (file.find (".jpg")  != std::string::npos ||
                file.find (".JPG")  != std::string::npos ||
                file.find (".jpeg") != std::string::npos ||
                file.find (".JPEG") != std::string::npos )
                return true;

        return false;
}

/**
 * Determines the full path to a cache file.  Does all creation of dirs.
 * TODO: should throw exception if we cannot create the dirs!
 *
 * @param       file    The file to convert, calls cache_name on it
 * @return                      The full path to
 */
Glib::ustring Thumbview::cache_file(Glib::ustring file) {

        Glib::ustring urifile = Glib::filename_to_uri(file);
/*
        // compute md5 of file's uri
        md5_state_t state;
        md5_byte_t digest[16];
        md5_init(&state);
        md5_append(&state, (const md5_byte_t *)urifile.c_str(), strlen(urifile.c_str()));
        md5_finish(&state, digest);

        char *buf = new char[3];
        char *full = new char[33];
        full[0] = '\0';

        for (int di = 0; di < 16; ++di) {
                sprintf(buf, "%02x", digest[di]);
                strcat(full, buf);
        }

        Glib::ustring md5file = Glib::ustring(full) + Glib::ustring(".png");
        delete [] buf;
        delete [] full;

        // build dir paths
        Glib::ustring halfref = Glib::build_filename(Glib::get_home_dir(),".thumbnails/");
        halfref = Glib::build_filename(halfref, "normal/");

        if ( !Glib::file_test(halfref, Glib::FILE_TEST_EXISTS) )
                if ( g_mkdir_with_parents(halfref.c_str(), 0700) == -1)
                        // TODO: exception
                        return "FAIL";

        // add and return
        return Glib::build_filename(halfref, md5file);
*/
        return urifile;
}

/**
 * Creates cache images that show up in its queue.
 */
void Thumbview::load_cache_images()
{
        g_async_queue_ref(this->aqueue_loadthumbs);
        g_async_queue_ref(this->aqueue_donethumbs);

        while(1)
        {
                // remove first item (blocks until an item occurs)
                TreePair *p = (TreePair*)g_async_queue_pop(this->aqueue_loadthumbs);

                Glib::ustring file = p->file;
                Glib::ustring cachefile = this->cache_file(file);

                // branch to see if we need to load or create cache file
                if ( !Glib::file_test(cachefile, Glib::FILE_TEST_EXISTS) ) {
                        g_async_queue_push(this->aqueue_createthumbs,(gpointer)p);
                } else {
                        // load thumb
                        Glib::RefPtr<Gdk::Pixbuf> pb = Gdk::Pixbuf::create_from_file(this->cache_file(file));

                        // resize if we need to
                        if (pb->get_width() > 100 || pb->get_height() > 80)
                        {
                                int pbwidth = pb->get_width();
                                int pbheight = pb->get_height();
                                float ratio = (float)pbwidth / (float)pbheight;

                                int newwidth, newheight;

                                if (abs(100 - pbwidth) > abs(80 - pbheight))
                                {
                                        // cap to vertical
                                        newheight = 80;
                                        newwidth = newheight * ratio;
                                }
                                else
                                {
                                        // cap to horiz
                                        newwidth = 100;
                                        newheight = newwidth / ratio;
                                }

                                pb = pb->scale_simple(newwidth, newheight, Gdk::INTERP_NEAREST);
                        }

                        if (get_fdo_thumbnail_mtime(pb) < get_file_mtime(file)) {
                                // the thumbnail is old. we need to make a new one.
                                pb.clear();
                                g_async_queue_push(this->aqueue_createthumbs,(gpointer)p);
                        } else {
                                // display it
                                TreePair *sendp = new TreePair();
                                sendp->file = file;
                                sendp->iter = p->iter;
                                sendp->thumb = pb;

                                g_async_queue_push(this->aqueue_donethumbs, (gpointer)sendp);

                                this->dispatch_thumb.emit();

                                delete p;
                        }
                }
        }

        g_async_queue_unref(this->aqueue_loadthumbs);
        g_async_queue_unref(this->aqueue_donethumbs);
        throw Glib::Thread::Exit();
}

/**
 * Thread function to create thumbnail cache images for those that do not exist.
 */
void Thumbview::create_cache_images()
{
        Glib::RefPtr<Gdk::Pixbuf> thumb;

        g_async_queue_ref(this->aqueue_createthumbs);
        g_async_queue_ref(this->aqueue_donethumbs);

        // always work!
        while (1) {

                // remove first item (blocks when no items occur)
                TreePair *p = (TreePair*)g_async_queue_pop(this->aqueue_createthumbs);

                // get filenames
                Glib::ustring file = p->file;
                Glib::ustring cachefile = this->cache_file(file);

//              Util::program_log("create_cache_images(): Caching file %s\n", file.c_str());

                // open image
                try {
                        thumb = Gdk::Pixbuf::create_from_file(file);
                } catch (...) {
                        // forget it, move on
                        delete p;
                        continue;
                }

                // eliminate zero heights (due to really tiny images :/)
                int height = (int)(100*((float)thumb->get_height()/(float)thumb->get_width()));
                if (!height) height = 1;

                // create thumb
                thumb = thumb->scale_simple(100, height, Gdk::INTERP_TILES);

                // create required fd.o png tags
                std::list<Glib::ustring> opts, vals;
                opts.push_back(Glib::ustring("tEXt::Thumb::URI"));
                vals.push_back(Glib::filename_to_uri(file));

                time_t mtime = get_file_mtime(file);

                char *bufout = new char[20];
                sprintf(bufout, "%d", mtime);

                opts.push_back(Glib::ustring("tEXt::Thumb::MTime"));
                vals.push_back(Glib::ustring(bufout));

                delete [] bufout;

                thumb->save(cachefile, "png", opts, vals);

                // send it to the display
                TreePair *sendp = new TreePair();
                sendp->file = file;
                sendp->iter = p->iter;
                sendp->thumb = thumb;
                g_async_queue_push(this->aqueue_donethumbs, (gpointer)sendp);

                // emit dispatcher
                this->dispatch_thumb.emit();

                delete p;
        }

        g_async_queue_unref(this->aqueue_createthumbs);
        g_async_queue_unref(this->aqueue_donethumbs);
        throw Glib::Thread::Exit();
}

void Thumbview::handle_dispatch_thumb() {
        g_async_queue_ref(this->aqueue_donethumbs);

        TreePair *donep = (TreePair*)g_async_queue_pop(this->aqueue_donethumbs);
        this->update_thumbnail(donep->file, donep->iter, donep->thumb);
        delete donep;

        g_async_queue_unref(this->aqueue_donethumbs);
}

/**
 * Updates the treeview to show the passed in thumbnail.
 *
 */
void Thumbview::update_thumbnail(Glib::ustring file, Gtk::TreeModel::iterator iter, Glib::RefPtr<Gdk::Pixbuf> pb)
{
        Gtk::TreeModel::Row row = *iter;
        row[record.Thumbnail] = pb;
        // desc
        //row[record.Description] = Glib::ustring(file, file.rfind("/")+1);

        // emit a changed signal
        store->row_changed(store->get_path(iter), iter);
}

/**
 * Used by GTK to see whether or not an iterator matches a search string.
 */
bool Thumbview::search_compare (const Glib::RefPtr<Gtk::TreeModel>& model, int column, const Glib::ustring& key, const Gtk::TreeModel::iterator& iter) {
        Glib::ustring target = (*iter)[record.Description];
        if (target.find (key) != Glib::ustring::npos) {
                return false;
        }
        return true;
}

/**
 * Sets the sort mode. This tells the view how it should sort backgrounds.
 */
void Thumbview::set_sort_mode (Thumbview::SortMode mode) {
        switch (mode) {
                case SORT_ALPHA:
                        store->set_sort_column (record.Description, Gtk::SORT_ASCENDING);
                        break;
                case SORT_RALPHA:
                        store->set_sort_column (record.Description, Gtk::SORT_DESCENDING);
                        break;
                case SORT_TIME:
                        store->set_sort_column (record.Time, Gtk::SORT_ASCENDING);
                        break;
                case SORT_RTIME:
                        store->set_sort_column (record.Time, Gtk::SORT_DESCENDING);
                        break;
        }
}

/**
 * Loads the map of displays and their set bgs. Used to indicate which
 * files are currently set as a background.
 */
void Thumbview::load_map_setbgs()
{
    map_setbgs.clear();

    std::vector<Glib::ustring> vecgroups;
    bool ret = false;
//    bool ret = Config::get_instance()->get_bg_groups(vecgroups);
    if (!ret)
        return;

    for (std::vector<Glib::ustring>::iterator i = vecgroups.begin(); i!=vecgroups.end(); i++)
    {
        Glib::ustring file;
//        SetBG::SetMode mode;
        Gdk::Color bgcolor;

//        ret = Config::get_instance()->get_bg(*i, file, mode, bgcolor);
        if (!ret)
        {
            std::cerr << "(load_map_setbgs) Could not get background stored info for " << *i << "\n";
            return;
        }

        map_setbgs[*i] = file;
    }
}

#ifdef USE_INOTIFY

/**
 * Called when a file in a directory being monitored by inotify is deleted.
 * Removes the file from the tree view.
 *
 * @param filename The name of the file to remove.
 */
void Thumbview::file_deleted_callback(std::string filename) {
        if (watches.find(filename) != watches.end()) {
                watches.erase(filename);
                return;
        }
        Gtk::TreeIter iter;
        Gtk::TreeModel::Children children = store->children();
        for (iter = children.begin(); iter != children.end(); iter++) {
                Glib::ustring this_filename = (*iter)[record.Filename];
                if (this_filename == filename) {
                        // remove this iter.
                        store->erase(iter);
                        break;
                }
        }
}

/**
 * Called when a file in a directory being monitored by inotify is modified
 * or a new file is created. Adds the file to the tree view.
 *
 * @param filename The name of the file modified or created.
 */
void Thumbview::file_changed_callback(std::string filename) {
        // first remove the old instance of this file.
        file_deleted_callback(filename);
        if ( Glib::file_test(filename, Glib::FILE_TEST_IS_DIR) ) {
                // this is a directory; use load_dir() to set us up the bomb.
                load_dir(filename);
        } else if (is_image(filename)) {
                // this is a file.
                add_file(filename);
        }
        // restart the idle function
        //Glib::signal_idle().connect(sigc::mem_fun(this, &Thumbview::load_cache_images));
}

/**
 * Called when a new file or directory is created in a directory being
 * monitored. Discards the event for non-directories, because
 * file_changed_callback will be called for those.
 *
 * @param filename The name of the file modified or created.
 */
void Thumbview::file_created_callback(std::string filename) {
        if ( Glib::file_test(filename, Glib::FILE_TEST_IS_DIR) ) {
                file_changed_callback(filename);
        }
}

#endif