GtkCRNSelectionBox.h

Go to the documentation of this file.

/* Copyright 2010-2016 CoReNum, INSA-Lyon, ENS-Lyon
 * 
 * This file is part of libgtkcrnmm.
 * 
 * libgtkcrnmm is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libgtkcrnmm 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 Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libgtkcrnmm.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: GtkCRNSelectionBox.h
 * \author Yann LEYDIER
 */

#ifndef GtkCRNSelectionBox_HEADER
#define GtkCRNSelectionBox_HEADER

#include <libgtkcrnmm_config.h>
#include <gtkmm.h>
#include <vector>
#include <CRNMath/CRNMath.h>
#include <memory>
#include <CRNStringUTF8.h>
#include <CRNString.h>
#include <set>

namespace GtkCRN
{
    class SelectionBox: public Gtk::EventBox
    {
        public:
            SelectionBox(crn::Orientation ori);
            virtual ~SelectionBox() override;
            
            // Gtk::Box methods

            bool get_homogeneous() const { return box->get_homogeneous(); }
            void set_homogeneous(bool homogeneous = true) { box->set_homogeneous(homogeneous); }
            int get_spacing() const { return box->get_spacing(); }
            void set_spacing(int spacing) { box->set_spacing(spacing); }

            void pack_start(Gtk::Widget& child, Gtk::PackOptions options = Gtk::PACK_EXPAND_WIDGET, guint padding = 0);
            void pack_start(Gtk::Widget& child, bool expand, bool fill, guint padding = 0);
            void pack_end(Gtk::Widget& child, Gtk::PackOptions options = Gtk::PACK_EXPAND_WIDGET, guint padding = 0);
            void pack_end(Gtk::Widget& child, bool expand, bool fill, guint padding = 0);

            void clear();

            // Gtk::ScrolledWindow methods

            void set_policy(Gtk::PolicyType hscrollbar_policy, Gtk::PolicyType vscrollbar_policy) { sw.set_policy(hscrollbar_policy, vscrollbar_policy); }

            // Specific methods

            crn::Orientation get_orientation() const { return orientation; }

            void set_can_reorder(bool reorder = true) { can_reorder = reorder; }
            bool get_can_reorder() const { return can_reorder; }

            std::vector<Gtk::Widget*> get_selection() const;
            Gtk::Widget* get_last_selected() const;

            std::vector<Gtk::Widget*> get_content() const;
            size_t get_nb_children() const { return content.size(); }

            void set_selection(size_t index);
            void set_selected(size_t index, bool selected = true, bool silent = false);
            bool is_selected(size_t index);

            void select_all();
            void deselect_all();
            void select_odd();
            void select_even();
            void invert_selection();

            void select_first();
            void select_previous();
            void select_next();
            void select_last();

            sigc::signal<void, std::vector<size_t>, std::vector<size_t>> signal_moved() { return moved; }

            sigc::signal<void, int, crn::StringUTF8> signal_droppedin() { return droppedin; }
            sigc::signal<void, Gtk::Widget*, const std::vector<Gtk::Widget*>> signal_selection_changed() { return selection_changed; } 

        private:
            crn::Orientation orientation; 
            bool can_reorder; 
            Gtk::Box *box; 
            Gtk::ScrolledWindow sw; 
            class Element;
            class DropZone: public Gtk::DrawingArea
            {
                public:
                    DropZone(const sigc::slot7<void, Element*, const Glib::RefPtr<Gdk::DragContext>&, int, int, const Gtk::SelectionData&, guint, guint> &dropfun, SelectionBox *sb, Element *el);
                private:
                    bool drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
                    void drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time);
#ifdef CRN_USING_GTKMM3
                    bool expose(const Cairo::RefPtr<Cairo::Context>&);
#else /* CRN_USING_GTKMM3 */
                    bool expose(GdkEventExpose *ev);
#endif /* CRN_USING_GTKMM3 */
                    bool in;
#ifdef CRN_USING_GTKMM3
                    Gdk::RGBA bg;
#endif /* CRN_USING_GTKMM3 */
            };
            DropZone first_drop_zone; 
            DropZone last_drop_zone; 
            static const crn::String reorderKey; 
            static const int reorderId; 
            static const int dropId; 
            class Element: public Gtk::Frame
            {
                public:
                    Element(Gtk::Widget &w, SelectionBox *sb);

                    void Select() { tb.set_active(true); }
                    void Deselect() { tb.set_active(false); }

                    Gtk::Widget& GetWidget() { return widget; }
                    const Gtk::Widget& GetWidget() const { return widget; }

                private:
                    void toggled(SelectionBox *const sb);
                    void drag_begin(const Glib::RefPtr<Gdk::DragContext>&) { Select(); }
                    void drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context, Gtk::SelectionData& seldata, guint info, guint time) { seldata.set_text(reorderKey.CStr()); }

                    std::shared_ptr<Gtk::Box> box;
                    Gtk::Widget& widget;
                    Gtk::ToggleButton tb;
                    DropZone dz;

            };
            friend class Element;

            std::vector<std::shared_ptr<Element>> content; 
            std::set<std::shared_ptr<Element>> selection; 
            std::weak_ptr<Element> last_selected; 
            bool keyevents(GdkEventKey *ev);
            bool cursor_cross(GdkEventCrossing *ev);
            bool shift_key; 
            bool control_key; 
            bool selecting; 
            void drop(Element *dropon, const Glib::RefPtr<Gdk::DragContext>& context, int, int, const Gtk::SelectionData& selection_data, guint, guint time);
#ifdef CRN_USING_GTKMM3
            void dodrop(Element *dropon, const Gtk::SelectionData *selection_data, int info);
#else /* CRN_USING_GTKMM3 */
            void dodrop(Element *dropon, const GtkSelectionData *selection_data, int info);
#endif /* CRN_USING_GTKMM3 */

            bool drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
            bool autoscroll();

            Gtk::Widget *drag_item; 
            int vscrolldiv, hscrolldiv; 
            sigc::signal<void, std::vector<size_t>, std::vector<size_t>> moved; 
            sigc::signal<void, int, crn::StringUTF8> droppedin; 
            sigc::signal<void, Gtk::Widget*, const std::vector<Gtk::Widget*>> selection_changed; 
    };
}

#endif