funcobjs.h

Go to the documentation of this file.

// -*- C++ -*-
//
// gvectors is a frontend to libgvectors using gtkmm.
// Copyright (C) 2007  Rafael Ostertag
//
// 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.
//
// $Id: funcobjs_8h-source.html,v 1.1 2007-09-10 23:31:15 rafi Exp $
//
// File:   funcobjs.h
// Author: Rafael Ostertag
//
// Created on August 11, 2007, 6:52 PM
//



#include <list>
#include <gtkmm.h>
#include <gvectors.h>

#include "vectorlist.h"

#ifndef _FUNCOBJS_H
#define _FUNCOBJS_H


//
// ConvertTreePath2RowRef
//
class ConvertTreePath2RowRef {
private:
    std::list<Gtk::TreeRowReference>& row_ref;
    Glib::RefPtr<Gtk::TreeStore> liststore;
    inline const ConvertTreePath2RowRef& operator=(const ConvertTreePath2RowRef) { return *this; }
    
public:
    inline explicit ConvertTreePath2RowRef(std::list<Gtk::TreeRowReference>& rf, Glib::RefPtr<Gtk::TreeStore> ls) : row_ref(rf), liststore(ls) {}
    inline ConvertTreePath2RowRef(const ConvertTreePath2RowRef& conv) : row_ref(conv.row_ref), liststore(conv.liststore) {}
    void operator()(Gtk::TreePath& tp);
};


//
// DeleteTreeRows
//
class DeleteTreeRows {
private:
    Glib::RefPtr<Gtk::TreeStore> liststore;
    inline const DeleteTreeRows& operator=(const DeleteTreeRows&) { return *this; }
    
public:
    inline explicit DeleteTreeRows(Glib::RefPtr<Gtk::TreeStore> ls) : liststore(ls) {}
    inline DeleteTreeRows(const DeleteTreeRows& dtr) : liststore(dtr.liststore) {}
    void operator()(Gtk::TreeRowReference& tp);
};

//
// Class ImportVectors
//
class ImportVectors {
private:
    VectorList& vectorlist;
    Glib::RefPtr<Gtk::TreeStore> liststore;
    std::map<GVectors::vslevel_t, Gtk::TreeModel::Row> levelmap;
    inline const ImportVectors& operator=(const ImportVectors&) { return *this; }
    
public:
    inline explicit ImportVectors(VectorList& vl, Glib::RefPtr<Gtk::TreeStore> ts) : vectorlist(vl), liststore(ts) { ; }
    inline ImportVectors(const ImportVectors& iv) : vectorlist(iv.vectorlist), liststore(iv.liststore) { ; }
    inline ~ImportVectors() { ; }
    void operator()(GVectors::vslevel_t level,
            GVectors::gvid_t id,
            const GVectors::VisualVector* vv);
};

//
// Class SumupVectors
//
class SumUpVectors {
private:
    GVectors::VectorStore& vstore;
    GVectors::GVector sum;
    VectorList& vectorlist;
    
    inline const SumUpVectors& operator=(const SumUpVectors& wdc) { return *this; }
    
public:
    inline explicit SumUpVectors(GVectors::VectorStore& vs, VectorList& vl) : vstore(vs),
            vectorlist(vl) { ; }
    inline SumUpVectors(const SumUpVectors& suv) : vstore(suv.vstore),
            vectorlist(suv.vectorlist), sum(suv.sum) { ; }
    inline ~SumUpVectors() { ; }
    void operator()(const Gtk::TreeModel::iterator& iter);
    inline GVectors::GVector get() const { return sum; }
};

//
// Class GetTreeSelected
//
class GetTreeSelected {
private:
    Gtk::TreeModel::iterator iterator;
    
public:
    inline explicit GetTreeSelected() { ; }
    inline GetTreeSelected(const GetTreeSelected& gts) : iterator(gts.iterator) { ;  }
    inline ~GetTreeSelected() { ; }
    const GetTreeSelected& operator=(const GetTreeSelected& gts);
    inline Gtk::TreeModel::iterator get() const { return iterator; }
    void operator()(const Gtk::TreeModel::iterator& it);
};

class TreeLastTwoSelected {
private:
    Gtk::TreeModel::Path path_a;
    Gtk::TreeModel::Path path_b;
    Gtk::TreeModel::iterator it_a;
    Gtk::TreeModel::iterator it_b;
    Gtk::TreeModel::Row row_a;
    Gtk::TreeModel::Row row_b;
    GVectors::gvid_t id_a;
    GVectors::gvid_t id_b;
    GVectors::VisualVector* vec_a;
    GVectors::VisualVector* vec_b;
    
    GVectors::VectorStore& vstore;
    VectorList& vlist;
    bool set_a;
    
public:
    explicit TreeLastTwoSelected(GVectors::VectorStore& vs, VectorList& vl);
    TreeLastTwoSelected(const TreeLastTwoSelected& tlts);
    inline ~TreeLastTwoSelected() { ; }
    
    inline Gtk::TreeModel::Path get_path_A() const { return path_a; }
    inline Gtk::TreeModel::Path get_path_B() const { return path_b; }
    inline Gtk::TreeModel::iterator get_it_A() const { return it_a; }
    inline Gtk::TreeModel::iterator get_it_B() const { return it_b; }
    inline Gtk::TreeModel::Row get_row_A() const { return row_a; }
    inline Gtk::TreeModel::Row get_row_B() const { return row_b; }
    inline GVectors::gvid_t get_id_A() const { return id_a; }
    inline GVectors::gvid_t get_id_B() const { return id_b; }
    inline GVectors::VisualVector* get_vec_A() const { return vec_a; }
    inline GVectors::VisualVector* get_vec_B() const { return vec_b; }
    inline void reset() { set_a = true; }
    bool operator()(const Glib::RefPtr<Gtk::TreeModel>& model,
            const Gtk::TreeModel::Path& path,
            bool path_currently_selected);
    TreeLastTwoSelected operator=(const TreeLastTwoSelected& tlts);
};

#endif  /* _FUNCOBJS_H */

---