GtkCRNImage.h

Go to the documentation of this file.

/* Copyright 2010-2016 CoReNum, INSA-Lyon, ZHAO Xiaojuan, 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: GtkCRNImage.h
 * \author Yann LEYDIER, ZHAO Xiaojuan
 */

#ifndef GtkCRNImage_HEADER
#define GtkCRNImage_HEADER

#include <libgtkcrnmm_config.h>
#include <gtkmm.h>
#include <CRNGeometry/CRNPoint2DInt.h>
#include <CRNGeometry/CRNPoint2DDouble.h>
#include <CRNGeometry/CRNRect.h>
#include <CRNStringUTF8.h>
#include <vector>
#include <iostream>

namespace GtkCRN
{
    class Image:
#ifdef CRN_USING_GTKMM3
        public Gtk::Grid
#else
        public Gtk::Table
#endif
    {
        public:
            Image();
            virtual ~Image() override;

#ifndef CRN_USING_GTKMM3
            void set_rulers_visible(bool is_visible);
#endif /* !CRN_USING_GTKMM3 */

            const crn::Point2DInt& get_offset() { return pos; }
            void set_pixbuf(Glib::RefPtr<Gdk::Pixbuf> pb);
            double get_zoom() const { return zoom; }
            void set_zoom(double z);
            void zoom_in();
            void zoom_out();
            void zoom_100();
            void zoom_fit();

            void focus_on(int x, int y);

            void force_redraw() { need_recompute = true; }

#ifdef CRN_USING_GTKMM3
            void set_user_cursor(const Gdk::CursorType &cur);
#else /* CRN_USING_GTKMM3 */
            void set_user_cursor(const Gdk::Cursor &cur);
#endif /* CRN_USING_GTKMM3 */

#ifdef CRN_USING_GTKMM3

            Glib::RefPtr<Gio::SimpleActionGroup> get_actions() { return image_actions; }
#else

            Glib::RefPtr<Gtk::ActionGroup> get_actions() { return image_actions; }
#endif

            enum class MouseMode { NONE, SCROLL, DRAW, MOVE, STRETCH_LEFT, STRETCH_BOTTOM_LEFT, STRETCH_BOTTOM, STRETCH_BOTTOM_RIGHT, STRETCH_RIGHT, STRETCH_TOP_RIGHT, STRETCH_TOP, STRETCH_TOP_LEFT, MOVEPOINT, USER };
            sigc::signal<void, crn::String, crn::String, MouseMode> signal_overlay_changed() { return overlay_changed; }
            sigc::signal<void, guint, guint32, std::vector<std::pair<crn::String, crn::String> >, int, int > signal_rmb_clicked() { return rmb_clicked; }
            sigc::signal<void, int, int> signal_user_mouse() { return user_mouse; }
            sigc::signal<void, Glib::RefPtr<Gdk::Pixbuf> > signal_drawing() { return drawing; }
            sigc::signal<void> signal_zoom_changed() { return zoom_changed; }
            sigc::signal<void, int, int> signal_scrolled_event() { return scrolled_event; }

#ifdef CRN_USING_GTKMM3
            Glib::RefPtr<Gtk::Adjustment> get_hadjustment() { return hscrollbar.get_adjustment(); }
#else /* CRN_USING_GTKMM3 */
            Gtk::Adjustment& get_hadjustment() { return *hscrollbar.get_adjustment(); }
#endif /* CRN_USING_GTKMM3 */

#ifdef CRN_USING_GTKMM3
            Glib::RefPtr<Gtk::Adjustment> get_vadjustment() { return vscrollbar.get_adjustment(); }
#else /* CRN_USING_GTKMM3 */
            Gtk::Adjustment& get_vadjustment() { return *vscrollbar.get_adjustment(); }
#endif /* CRN_USING_GTKMM3 */

            enum class Overlay { None = 0, Rectangle, Point, Line, Text, User, Polygon };
            struct OverlayItem
            {
                OverlayItem(const crn::StringUTF8& lab = ""):label(lab) {}
                OverlayItem(const OverlayItem&) = delete;
                OverlayItem(OverlayItem&&) = default;
                OverlayItem& operator=(const OverlayItem&) = delete;
                OverlayItem& operator=(OverlayItem&&) = default;
                virtual ~OverlayItem() {}
                crn::StringUTF8 label; 
            };
            struct Line: public OverlayItem
            {
                Line(const crn::Point2DInt &p1_, const crn::Point2DInt &p2_, const crn::StringUTF8& lab = ""): OverlayItem(lab), p1(p1_), p2(p2_) { }
                Line(const Line&) = delete;
                Line(Line&&) = default;
                Line& operator=(const Line&) = delete;
                Line& operator=(Line&&) = default;
                crn::Point2DInt p1, p2;
            };
            struct Rectangle: public OverlayItem
            {
                Rectangle(const crn::Rect & r, const crn::StringUTF8& lab = ""): OverlayItem(lab), rect(r) { }
                Rectangle(const Rectangle&) = delete;
                Rectangle(Rectangle&&) = default;
                Rectangle& operator=(const Rectangle&) = delete;
                Rectangle& operator=(Rectangle&&) = default;
                crn::Rect rect;
            };
            struct Point: public OverlayItem
            {
                Point(const crn::Point2DInt &p, const crn::StringUTF8& lab = ""): OverlayItem(lab), point(p) { }
                Point(const Point&) = delete;
                Point(Point&&) = default;
                Point& operator=(const Point&) = delete;
                Point& operator=(Point&&) = default;
                crn::Point2DInt point;
            };
            struct Polygon: public OverlayItem
            {
                Polygon(const std::vector<crn::Point2DInt>& po, const crn::StringUTF8& lab = ""):OverlayItem(lab),points(po) { }
                Polygon(std::vector<crn::Point2DInt> &&po, const crn::StringUTF8& lab = ""):OverlayItem(lab),points(std::move(po)) { }
                Polygon(const Polygon&) = delete;
                Polygon(Polygon&&) = delete;
                Polygon& operator=(const Polygon&) = delete;
                Polygon& operator=(Polygon&&) = delete;
                std::vector<crn::Point2DInt> points;
            };
            struct Text: public OverlayItem
            {
                Text(const crn::Point2DInt &p, const crn::StringUTF8& lab = ""): OverlayItem(lab), pos(p) { }
                Text(const Text&) = delete;
                Text(Text&&) = delete;
                Text& operator=(const Text&) = delete;
                Text& operator=(Text&&) = delete;
                crn::Point2DInt pos;
            };
            struct OverlayConfig
            {
                OverlayConfig();
#ifdef CRN_USING_GTKMM3
                Gdk::RGBA color1; 
                Gdk::RGBA color2; 
                Gdk::RGBA text_color; 
#else
                Gdk::Color color1; 
                Gdk::Color color2; 
                Gdk::Color text_color; 
#endif
                bool show_labels; 
                unsigned int text_size; 
                bool editable; 
                bool moveable; 
                bool can_jut_out; 
                bool fill; 
                double fill_alpha; 
                unsigned int cross_size; 
                bool draw_arrows; 
                unsigned int arrow_size; 
                bool absolute_text_size; 
                Glib::ustring font_family; 
                bool closed_polygons; 
                bool show; 
            };
            OverlayConfig& get_overlay_config(const crn::String &id) { return overlays[id].config; }
            void show_overlay(const crn::String &id) { set_overlay_visible(id, true); }
            void hide_overlay(const crn::String &id) { set_overlay_visible(id, false); }
            void set_overlay_visible(const crn::String &id, bool visible);
            void clear_overlays();
            void clear_overlay(const crn::String &id);
            void add_overlay_item(const crn::String &overlay_id, const crn::String &item_id, const crn::Rect &r, const crn::StringUTF8 &label = "");
            void add_overlay_item(const crn::String &overlay_id, const crn::String &item_id, const crn::Point2DInt &point, const crn::StringUTF8 &label = "");
            void add_overlay_item(const crn::String &overlay_id, const crn::String &item_id, const crn::Point2DInt &p1, const crn::Point2DInt &p2, const crn::StringUTF8 &label = "");
            void add_overlay_item(const crn::String &overlay_id, const crn::String &item_id, const std::vector<crn::Point2DInt>& p, const crn::StringUTF8 &label="");
            void add_overlay_item(const crn::String &overlay_id, const crn::String &item_id, std::vector<crn::Point2DInt> &&p, const crn::StringUTF8 &label="");
            void add_overlay_item(const crn::String &overlay_id, const crn::String &item_id, const crn::StringUTF8 &label, const crn::Point2DInt &position);
            OverlayItem& get_overlay_item(const crn::String &overlay_id, const crn::String &item_id);
            const OverlayItem& get_overlay_item(const crn::String &overlay_id, const crn::String &item_id) const;
            void remove_overlay_item(const crn::String &overlay_id, const crn::String &item_id);

            void set_selection_type(Overlay typ);
            Overlay get_selection_type() const { return selection_type; }
            OverlayConfig& get_selection_config() { return get_overlay_config(selection_overlay()); }
            bool has_selection() const;
            void clear_selection();
            static const crn::String& selection_overlay();
            const crn::Rect& get_selection_as_rect() const;
            const crn::Point2DInt& get_selection_as_point() const;
            std::pair<crn::Point2DInt, crn::Point2DInt> get_selection_as_line() const;
            void set_selection(const crn::Rect &r);
            void set_selection(const crn::Point2DInt &p);
            void set_selection(const crn::Point2DInt &p1, const crn::Point2DInt &p2);

        private:
#ifdef CRN_USING_GTKMM3
            bool expose(const Cairo::RefPtr<Cairo::Context> &cc);
#else /* CRN_USING_GTKMM3 */
            bool expose(GdkEventExpose *ev);
#endif /* CRN_USING_GTKMM3 */

            bool configure(GdkEventConfigure *ev);
            bool mouse_motion(GdkEventMotion *ev);
            bool button_clicked(GdkEventButton *ev);
            bool mouse_wheel(GdkEventScroll *ev);
            MouseMode mouse_mode; 
            crn::Point2DDouble click_ref; 
            void scrolled();
            bool refresh();
            sigc::connection refresher; 
            bool need_redraw; 
            bool need_recompute; 
            Glib::RefPtr<Gdk::Pixbuf> image; 
            crn::Rect image_bounds; 
            crn::Point2DInt pos; 
            int dispw, disph; 
            double zoom; 
            Glib::RefPtr<Gdk::Pixbuf> buffer; 
            static int selection_margin; 
#ifdef CRN_USING_GTKMM3
            Glib::RefPtr<Gio::SimpleActionGroup> image_actions; 
#else
            Glib::RefPtr<Gtk::ActionGroup> image_actions; 
#endif
            crn::Point2DInt *movePoint;

            struct Overlay_internal
            {
                OverlayConfig config;
                std::map<crn::String, std::unique_ptr<OverlayItem> > items;
            };

            std::map<crn::String, Overlay_internal> overlays; 
            Overlay selection_type; 
            MouseMode find_selection_at(double mouse_x, double mouse_y, crn::String &overlay_id, crn::String &overlay_item_id);
            void set_cursor_from_mode(MouseMode m);
            crn::String selected_overlay; 
            crn::String selected_overlay_item; 
#ifndef CRN_USING_GTKMM3
            Gtk::HRuler hruler;
            Gtk::VRuler vruler;
#endif /* !CRN_USING_GTKMM3 */
            Gtk::DrawingArea da;
#ifndef CRN_USING_GTKMM3
            Glib::RefPtr<Gdk::GC> da_gc;
#endif /* !CRN_USING_GTKMM3 */
#ifdef CRN_USING_GTKMM3
            Gtk::Scrollbar hscrollbar;
            Gtk::Scrollbar vscrollbar;
#else
            Gtk::HScrollbar hscrollbar;
            Gtk::VScrollbar vscrollbar;
#endif
#ifdef CRN_USING_GTKMM3
            Gdk::CursorType scroll_cursor;
            Gdk::CursorType select_cursor;
            Gdk::CursorType move_cursor;
            Gdk::CursorType move_1_cursor;
            Gdk::CursorType drag_left_cursor;
            Gdk::CursorType drag_bottom_left_cursor;
            Gdk::CursorType drag_bottom_cursor;
            Gdk::CursorType drag_bottom_right_cursor;
            Gdk::CursorType drag_right_cursor;
            Gdk::CursorType drag_top_right_cursor;
            Gdk::CursorType drag_top_cursor;
            Gdk::CursorType drag_top_left_cursor;
            Gdk::CursorType user_cursor;
#else
            Gdk::Cursor scroll_cursor;
            Gdk::Cursor select_cursor;
            Gdk::Cursor move_cursor;
            Gdk::Cursor move_1_cursor;
            Gdk::Cursor drag_left_cursor;
            Gdk::Cursor drag_bottom_left_cursor;
            Gdk::Cursor drag_bottom_cursor;
            Gdk::Cursor drag_bottom_right_cursor;
            Gdk::Cursor drag_right_cursor;
            Gdk::Cursor drag_top_right_cursor;
            Gdk::Cursor drag_top_cursor;
            Gdk::Cursor drag_top_left_cursor;
            Gdk::Cursor user_cursor;
#endif /* CRN_USING_GTKMM3 */
            sigc::signal<void, crn::String, crn::String, MouseMode> overlay_changed; 
            sigc::signal<void, guint, guint32, std::vector<std::pair<crn::String, crn::String> >, int, int > rmb_clicked; 
            sigc::signal<void, int, int> user_mouse; 
            sigc::signal<void, Glib::RefPtr<Gdk::Pixbuf> > drawing; 
            sigc::signal<void> zoom_changed; 
            sigc::signal<void, int, int> scrolled_event; 
    };
}

#endif