Selection.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream 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.

   GTK+ IOStream 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 have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */

#ifndef SELECTION_H_
#define SELECTION_H_
#if GTK_MAJOR_VERSION>2
#error "Support not ready for GTK major version > 2"
#endif

#include <iomanip>
#include <utility>
#include <gtk/gtk.h>

#include <string.h>
#include <string>

#include "mffm/LinkList.H"

using namespace std;

class SelectionColumn : public LinkList<pair<string *, GType> *> {
    GtkTreeViewColumn *column;
    int number; 
public:
    SelectionColumn(const char*title, int number_) {
        number=number_;
        column=gtk_tree_view_column_new();
        gtk_tree_view_column_set_title (column, title);
        setTitleAlignment(0.5);
    }

    virtual ~SelectionColumn(void) {
        while (getCount()) { // free up the string pointers in the inherited LinkList<string*>
            pair<string *, GType> *deleteMe=remove();
            delete deleteMe->first;
            delete deleteMe;
        }
    }

    void setTitleAlignment(float align) {
        gtk_tree_view_column_set_alignment(column, align);
    }

    void setAlignment(float xAlign, float yAlign) {
        GList*renderers=gtk_tree_view_column_get_cell_renderers(column);
        for (unsigned int i=0;i<g_list_length(renderers);i++)
            //g_object_set(GTK_CELL_RENDERER(g_list_nth_data(renderers,i)), "align-set", 1, "xalign", xAlign, "yalign", yAlign, NULL);
            gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(g_list_nth_data(renderers,i)), xAlign, yAlign);
    }

//    /* \brief Set the justification of the text column contents
//    Justify the text renderer contents with respect to the edges of the column.
//    param justification The justification 0.0 for left and 1.0 for right, (0.5 center).
//    */
//    void setJustification(float justification){
//        GList*renderers=gtk_tree_view_column_get_cell_renderers(column);
//        cout<<"flatmax : setJustification : g_list_length(renderers) "<<g_list_length(renderers)<<endl;
//        for (uint i=0;i<g_list_length(renderers);i++){
//            cout<<"flatmax "<<i<<endl;
//            g_object_set(GTK_CELL_RENDERER(g_list_nth_data(renderers,i)), "align-set", 1, "alignment", justification, NULL);
//            //g_object_set(GTK_CELL_RENDERER(g_list_nth_data(renderers,i)), "xalign", justification, NULL);
//        }
//    }

//    /* \brief Set the justification of the text column contents
//    Justify the text renderer contents with respect to the edges of the column.
//    param justification The justification PangoAlignment = {PANGO_ALIGN_LEFT, PANGO_ALIGN_CENTER, PANGO_ALIGN_RIGHT};
//    */
//    void setJustification(PangoAlignment justification){
//        GList*renderers=gtk_tree_view_column_get_cell_renderers(column);
//        cout<<"flatmax : setJustification : g_list_length(renderers) "<<g_list_length(renderers)<<endl;
//        for (uint i=0;i<g_list_length(renderers);i++){
//            cout<<"flatmax "<<i<<endl;
//            g_object_set(GTK_CELL_RENDERER_TEXT(g_list_nth_data(renderers,i)), "align-set", 1, "alignment", justification, NULL);
//            ////g_object_set(GTK_CELL_RENDERER(g_list_nth_data(renderers,i)), "alignment", justification, NULL);
//        }
//    }
//
    SelectionColumn &add(string *name, GType whichType, GtkCellRenderer *renderer, int source, gboolean expand=true) {
        gtk_cell_renderer_set_alignment(renderer, 0.5,0.5); // place in the middle
        LinkList<pair<string*,GType> *>::add(new pair<string*,GType>(name, whichType));
        gtk_tree_view_column_pack_start (column, renderer, expand);
        gtk_tree_view_column_add_attribute (column, renderer, name->c_str(), source);
        return *this;
    }

//    /** Add a renderer to the column.
//    This operator uses this column as the source, and doesn't expand during render
//    \param detail get<0>(detail) is the name, get<1>(detail) is the renderer, get<2>(detail) is the source, get<3>(detail) is the expansion
//    */
//    SelectionColumn &operator<<(tuple<string*, GtkCellRenderer*, int, gboolean> detail){
//        return add(get<0>(detail),get<1>(detail),get<2>(detail),get<3>(detail));
//    }
//
//    /** Add a renderer to the column.
//    This operator uses this column as the source, and doesn't expand during render
//    \param detail get<0>(detail) is the name, get<1>(detail) is the renderer, get<2>(detail) is the source
//    */
//    SelectionColumn &operator<<(tuple<string*, GtkCellRenderer*, int> detail){
//        return add(get<0>(detail),get<1>(detail),get<2>(detail));
//    }

    SelectionColumn &operator<<(pair<string*, GtkCellRendererText*> detail) {
        return add(detail.first,G_TYPE_STRING,(GtkCellRenderer *)detail.second, number);
    }

    SelectionColumn &operator<<(pair<string*, GtkCellRendererPixbuf*> detail) {
        return add(detail.first,GDK_TYPE_PIXBUF,(GtkCellRenderer *)detail.second, number);
    }

    GtkTreeViewColumn *getColumn(void) {
        return column;
    }

    int getNumber(void) {
        return number;
    }

    void setSizing(GtkTreeViewColumnSizing sz){
        gtk_tree_view_column_set_sizing(column,sz);
    }

    GtkTreeViewColumnSizing getSizing(void){
        return gtk_tree_view_column_get_sizing(column);
    }

};


class Selection : public LinkList<SelectionColumn *> {

        gulong changedHandlerID; 

    void init(void) {
        tree = gtk_tree_view_new();
                changedHandlerID=0;
    }

//    GtkTreeIter* getLastIter(void){
//        GtkTreeIter *iter=new GtkTreeIter;
//        GtkTreeStore *store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)));
//
//        GtkTreeIter last;
//        if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), iter)){
//            cout<<"n children "<<gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), iter)<<endl;
//            while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &last))
//                   (*iter)=last;
//        } else{
//            delete iter;
//            return NULL;
//        }
//        return iter;
//    }

    GtkTreeIter* getLastIter(GtkTreeStore *store=NULL) {
        if (store==NULL) // get the local tree store
            store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)));
        GtkTreeIter* iter = new GtkTreeIter;
        if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(store), iter, NULL,gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), NULL)-1))
            return iter;
        else
            return NULL;
    }

    GtkTreeIter* appendRow(GtkTreeStore *store=NULL) {
        if (store==NULL) // get the local tree store
            store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)));
        GtkTreeIter* iter=NULL;
        if (store) {
            iter=new GtkTreeIter;
            if (iter)
                gtk_tree_store_append(store, iter, NULL);
        }
        return iter;
    }

    GtkTreeIter* appendNewIter(GtkTreeStore *store, gboolean sameRow, gboolean sameColumn) {
        GtkTreeIter* iter=NULL;
        if (!sameColumn)
            next();
        if (sameRow) { // find the correct column and add to the same row
            iter=getLastIter(store);
        }

        if (iter==NULL)
            iter=appendRow(store);
        return iter;
    }

protected:
    GtkWidget *tree; 
    GtkTreeSelection *selection; 

    int currentColumnNumber(void) {
        if (!getCount())
            return -1;
        int which=0;
        if (getCount()!=1){
            SelectionColumn *currentCol=current(); // remember the current column number
            grab(1);
            prev(); // get the last column
            while (next()!=currentCol) // keep getting the next unitl it is the same as the original state
                which++;
        }
        return which; // return the column number, starting from zero, the LinkList's state is as it was upon entry
    }
public:

    Selection(void) {
        init();
    }

    Selection(const char *listName, GCallback callback=NULL, void *data=NULL) {
        init(listName, callback, data);
    }

    virtual ~Selection(){
        //cout<<"Selection::~Selection"<<endl;
    }

    void init(const char *listName, GCallback callback=NULL, void *data=NULL) {
        init();
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));

        SelectionColumn *sc= new SelectionColumn(listName, getCount()); // create the new column
        //        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); // use this to hide the headers

        *sc<<pair<string*, GtkCellRendererText*>(new string("text"), GTK_CELL_RENDERER_TEXT(gtk_cell_renderer_text_new()));

        add(sc);

        if (callback && data)
            setSelectionCallback("changed", callback, data);
        else
            setSelectionCallback(callback);
    }

    void setSelectionCallback(GCallback callback) {
        setSelectionCallback("changed", callback, this);
    }

    void setSelectionCallback(const char *event, GCallback callback, gpointer data) {
        changedHandlerID=g_signal_connect(selection, event, callback, data);
    }

    void setTreeCallback(const char *event, GCallback callback, gpointer data) {
        g_signal_connect(tree, event, G_CALLBACK(callback), data);
    }

    void add(SelectionColumn *newCol) {
        LinkList<SelectionColumn *>::add(newCol); // add to the list of columns

        gtk_tree_view_append_column(GTK_TREE_VIEW(tree), current()->getColumn());

        // find the types and create a new store, then attach to the current treeview
        // find the total number of renderers.
//        int rendCnt=0; // in the future support one column with many renderers
//        for (int i=0;i<getCount();i++)
//            rendCnt+=next()->getCount();
//        GType types[rendCnt]; // create the type holder
//        grab(1); prev(); // get the last column and iterate from there
//        int index=0;
//        for (int i=0;i<getCount();i++){
//            for (int j=0; j<current()->getCount();j++){
//                types[index++]=current()->next()->second;
//            }
//            next();
//        }

        GType *types =new GType[getCount()]; // create the type holder
        grab(1);
        prev(); // get the last column and iterate from there
        for (int i=0; i<getCount(); i++) {
            types[i]=next()->current()->second;
        }

        while (next()!=newCol) ; // get the linklist back to its original location

        GtkTreeStore *store = gtk_tree_store_newv(getCount(), types); // get the column type
        gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(store));
        g_object_unref(store);
                delete [] types;
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
    }

    void setCallbackAfter(GCallback callback, void *data) {
        g_signal_connect_after(selection, "changed", G_CALLBACK(callback), data);
    }

    GtkWidget *getWidget(void) {
        return tree;
    }

    void show(void) {
        gtk_widget_show_all(tree);
    }

    void hide(void) {
        gtk_widget_hide(tree);
    }

    void getSelection(char *value) {
                string valueS;
        getSelection(valueS);
        strcpy(value,valueS.c_str());
    }

    void getSelection(string &value){
        GtkTreeIter iter;
        GtkTreeModel *model;
        char *val;

        int colNum=currentColumnNumber();
        if (colNum>=0){
            if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(selection), &model, &iter)) {
                gtk_tree_model_get(model, &iter, colNum, &val,  -1);
                if (val)
                    value=val;
                else
                    value.resize(0);
                g_free(val);
            }
        }
    }

    void add(const char *text, gboolean sameRow=false, gboolean sameColumn=true) {
        GtkTreeStore *store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)));
        GtkTreeIter* iter=appendNewIter(store, sameRow, sameColumn);

        int whichColumn=currentColumnNumber();
        if (iter) {
            gtk_tree_store_set(store, iter, whichColumn, text, -1);
            delete iter;
        }
    }

    void add(GdkPixbuf *pixbuf, gboolean sameRow=false, gboolean sameColumn=true) {
        GtkTreeStore *store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)));
        GtkTreeIter* iter=appendNewIter(store, sameRow, sameColumn);

        int whichColumn=currentColumnNumber();
        if (iter) {
            gtk_tree_store_set(store, iter, whichColumn, pixbuf, -1);
            delete iter;
        }
    }

    void clear(void) {
                if (changedHandlerID)
                        g_signal_handler_block(selection, changedHandlerID);
        //GtkTreeStore *store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (tree)));
        GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (tree));
        GtkTreeIter  iter;

        if (gtk_tree_model_get_iter_first(model, &iter) == FALSE)
            return;
        gtk_tree_store_clear(GTK_TREE_STORE(model));

                if (changedHandlerID)
                        g_signal_handler_unblock(selection, changedHandlerID);
    }
//    /* add a pixbuf item to the selection column
//    if you want to add to a different column, shift the inherited LinkList<SelectionColumn *> to the correct one.
//    For example use one of these to locate the desired column prior to adding : LinkList<SelectionColumn *>::grab, LinkList<SelectionColumn *>::next, LinkList<SelectionColumn *>::prev
//    \param firstColumn, which column to start with, 1 for the first column
//    \return This Selection object
//    */
//    void addRow(int firstColumn, ...) {
//        GtkTreeStore *store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)));
//        GtkTreeIter* iter=appendNewIter(store, false, false);
//        grab(firstColumn);
//        va_list var_args;
//        va_start (var_args, firstColumn);
//        gtk_tree_store_set_valist (store, iter, var_args);
//        va_end (var_args);
//    }

//    /* add a list of items to the same row in each column - starting from the first column
//    \param ll the LinkList of items to add to the list on the current row
//    \return This Selection object
//    */
//    void add(LinkList<GValue> &ll) {
//  //      int whichColumn=currentColumnNumber(); // restore current column at the end
//        GtkTreeIter iter;
//        GtkTreeStore *store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(tree)));
//        int cols[ll.getCount()];
//        GValue values[ll.getCount()];
//
//        ll.grab(1); ll.prev(); // get the last element on the linked list
//        for (int i=0;i<ll.getCount();i++){
//            cols[i]=i;
//            g_value_init (&values[i], next()->current->second); // setup the current type
//            =ll.next();
//        }
//
//        gtk_tree_store_append(store, &iter, NULL);
//        gtk_tree_store_set_valuesv(store, &iter, cols, values, ll.getCount());
//    }

    Selection & operator<<(const string text) {
        add(text.c_str());
        return *this;
    }

    Selection & operator<<(const char *text) {
        add(text);
        return *this;
    }

    Selection & operator<<(GdkPixbuf *pixbuf) {
        add(pixbuf);
        return *this;
    }

//    /* add a row with multiple items
//    starts from row 0
//    \param ll the LinkList of items to add
//    \return This Selection object
//    */
//    Selection & operator<<(LinkList<void*> &ll) {
//        add(ll);
//        return *this;
//    }

    Selection & operator<<(SelectionColumn *newCol) {
        add(newCol);
        return *this;
    }

    void selectRow(char *path){
        GtkTreePath *pathLocal = gtk_tree_path_new_from_string (path);
        //gtk_tree_view_row_activated(GTK_TREE_VIEW(tree), pathLocal, current()->getColumn());
        gtk_tree_selection_select_path(selection, pathLocal);
    }
};
#endif //SELECTION_H_