X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;ds=sidebyside;f=synfig-studio%2Ftags%2Fsynfigstudio_0_61_07_rc3%2Fsrc%2Fgtkmm%2Fworkarea.h;fp=synfig-studio%2Ftags%2Fsynfigstudio_0_61_07_rc3%2Fsrc%2Fgtkmm%2Fworkarea.h;h=3b6ecaee08676708c9827b43ffe11474609cd35f;hb=1f5a0e6a86f9cf4798b6e1fb8dfcb4b6e84beb5d;hp=0000000000000000000000000000000000000000;hpb=0e729dddd753ed872265ba82c0089bc55e64bf55;p=synfig.git diff --git a/synfig-studio/tags/synfigstudio_0_61_07_rc3/src/gtkmm/workarea.h b/synfig-studio/tags/synfigstudio_0_61_07_rc3/src/gtkmm/workarea.h new file mode 100644 index 0000000..3b6ecae --- /dev/null +++ b/synfig-studio/tags/synfigstudio_0_61_07_rc3/src/gtkmm/workarea.h @@ -0,0 +1,505 @@ +/* === S Y N F I G ========================================================= */ +/*! \file workarea.h +** \brief Template Header +** +** $Id$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2007 Chris Moore +** +** This package 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 package 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. +** \endlegal +*/ +/* ========================================================================= */ + +/* === S T A R T =========================================================== */ + +#ifndef __SYNFIG_GTKMM_WORKAREA_H +#define __SYNFIG_GTKMM_WORKAREA_H + +/* === H E A D E R S ======================================================= */ + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "zoomdial.h" +#include "duckmatic.h" +#include "instance.h" + +/* === M A C R O S ========================================================= */ + +/* === T Y P E D E F S ===================================================== */ + +/* === C L A S S E S & S T R U C T S ======================================= */ + +/* +namespace etl { + +template > +class dereferenced_compare +{ +public: + typedef etl::loose_handle first_argument_type; + typedef etl::loose_handle second_argument_type; + typedef bool result_type; + +} +}; +*/ + +namespace synfigapp { class CanvasInterface; }; + +namespace synfig { class Layer; }; +namespace Gtk { class Frame; }; + +namespace studio +{ +class WorkAreaTarget; +class WorkAreaTarget_Full; + +class Instance; +class CanvasView; +class WorkArea; +class WorkAreaRenderer; +class AsyncRenderer; +class DirtyTrap +{ + friend class WorkArea; + WorkArea *work_area; +public: + DirtyTrap(WorkArea *work_area); + ~DirtyTrap(); +}; + + +class WorkArea : public Gtk::Table, public Duckmatic +{ + friend class WorkAreaTarget; + friend class WorkAreaTarget_Full; + friend class DirtyTrap; + friend class WorkAreaRenderer; + friend class WorkAreaProgress; + + /* + -- ** -- P U B L I C T Y P E S --------------------------------------------- + */ + +public: + + void insert_renderer(const etl::handle &x); + void insert_renderer(const etl::handle &x,int priority); + void erase_renderer(const etl::handle &x); + void resort_render_set(); + + enum DragMode + { + DRAG_NONE=0, + DRAG_WINDOW, + DRAG_DUCK, + DRAG_GUIDE, + DRAG_BOX + }; + + /* + -- ** -- P R I V A T E D A T A --------------------------------------------- + */ + +private: + + std::set > renderer_set_; + + etl::handle async_renderer; + + + etl::loose_handle canvas_interface; + etl::handle canvas; + etl::loose_handle instance; + etl::loose_handle canvas_view; + + // Widgets + Gtk::DrawingArea *drawing_area; + Gtk::Adjustment scrollx_adjustment; + Gtk::Adjustment scrolly_adjustment; + Gtk::VRuler *vruler; + Gtk::HRuler *hruler; + Gtk::Button *menubutton; + Gtk::Frame *drawing_frame; + + GdkDevice* curr_input_device; + + // Bleh! + int w; //!< Width of the image (in pixels) + int h; //!< Height of the image (in pixels) + synfig::Real canvaswidth; //!< Width of the canvas + synfig::Real canvasheight; //!< Height of the canvas + synfig::Real pw; //!< The width of a pixel + synfig::Real ph; //!< The height of a pixel + float zoom; //!< Zoom factor + float prev_zoom; //!< Previous Zoom factor + synfig::Point window_tl; //!< The (theoretical) top-left corner of the view window + synfig::Point window_br; //!< The (theoretical) bottom-right corner of the view window + + guint32 last_event_time; + + int bpp; + //unsigned char *buffer; + + //! ??? + synfig::ProgressCallback *progresscallback; + + //! ??? + synfig::RendDesc desc; + + //! This flag is set if the user is dragging the video window + /*! \see drag_point */ + DragMode dragging; + + etl::handle clicked_duck; + etl::handle hover_duck; + + //! When dragging the viewport, this is set to the origin of the drag + synfig::Point drag_point; + + synfig::Point curr_point; + + //! ??? + synfig::Point previous_focus; + + //! This flag is set if the grid should be drawn + bool show_grid; + + //! This flag is set if the guides should be drawn + bool show_guides; + + bool low_resolution; + + bool meta_data_lock; + + //! This flag is set if the entire frame is rendered rather than using tiles + bool full_frame; + + //Glib::RefPtr pix_buf; + + //! This vector holds all of the tiles for this image + std::vector< std::pair,int> > tile_book; + + //! This integer describes the total times that the work are has been refreshed + int refreshes; + + //! This list holds the queue of tiles that need to be rendered + //std::list tile_queue; + + int tile_w, tile_h; + + gint render_idle_func_id; + + //! The coordinates of the focus the last time a part of the screen was refreshed + synfig::Point last_focus_point; + + bool canceled_; + + int quality; + + bool dirty_trap_enabled; + + int dirty_trap_queued; + + + bool onion_skin; + + etl::loose_handle selected_value_node_; + + bool allow_duck_clicks; + bool allow_layer_clicks; + bool cancel; + bool curr_guide_is_x; + bool dirty; + bool queued; + bool rendering; + + /* + -- ** -- P U B L I C D A T A ----------------------------------------------- + */ + +public: + + const etl::loose_handle& get_selected_value_node() { return selected_value_node_; } + const synfig::Point& get_drag_point()const { return drag_point; } + std::vector< std::pair,int> >& get_tile_book(){ return tile_book; } + int get_refreshes()const { return refreshes; } + bool get_canceled()const { return canceled_; } + bool get_queued()const { return queued; } + bool get_rendering()const { return rendering; } + bool get_full_frame()const { return full_frame; } + //int get_w()const { return w; } + //int get_h()const { return h; } + + int get_tile_w()const { return tile_w; } + int get_tile_h()const { return tile_h; } + + bool get_allow_layer_clicks() { return allow_layer_clicks; } + void set_allow_layer_clicks(bool value) { allow_layer_clicks=value; } + + bool get_allow_duck_clicks() { return allow_duck_clicks; } + void set_allow_duck_clicks(bool value) { allow_duck_clicks=value; } + + // used in renderer_ducks.cpp + bool solid_lines; + + // used in renderer_guides.cpp + GuideList::iterator curr_guide; + + // used in renderer_timecode.cpp + int timecode_width, timecode_height; + + /* + -- ** -- P R I V A T E M E T H O D S --------------------------------------- + */ + +private: + + //unsigned char *get_buffer() { return buffer; } + bool set_wh(int w, int h,int chan=3); + + int next_unrendered_tile(int refreshes)const; + int next_unrendered_tile()const { return next_unrendered_tile(refreshes); } + + /* + -- ** -- S I G N A L S ------------------------------------------------------- + */ + +private: + + sigc::signal signal_input_device_changed_; + + //! One signal per button + sigc::signal signal_user_click_[5]; + + sigc::signal signal_popup_menu_; + + sigc::signal signal_cursor_moved_; + sigc::signal signal_rendering_; + + sigc::signal signal_onion_skin_changed_; + + //! Signal for when the user clicks on a layer + sigc::signal > signal_layer_selected_; + + sigc::signal signal_view_window_changed_; + +public: + + sigc::signal& signal_onion_skin_changed() { return signal_onion_skin_changed_; } + + sigc::signal& signal_rendering() { return signal_rendering_; } + + sigc::signal& signal_cursor_moved() { return signal_cursor_moved_; } + + sigc::signal& signal_view_window_changed() { return signal_view_window_changed_; } + void view_window_changed() { signal_view_window_changed()(); } + + sigc::signal& signal_input_device_changed() { return signal_input_device_changed_; } + + sigc::signal &signal_popup_menu() { return signal_popup_menu_; } + + //! One signal per button (5 buttons) + sigc::signal &signal_user_click(int button=0){ return signal_user_click_[button]; } + + sigc::signal >& signal_layer_selected() { return signal_layer_selected_; } + + /* + -- ** -- P U B L I C M E T H O D S ----------------------------------------- + */ + +public: + void set_onion_skin(bool x); + bool get_onion_skin()const; + void toggle_onion_skin() { set_onion_skin(!get_onion_skin()); } + + void set_selected_value_node(etl::loose_handle x); + + bool is_dragging() { return dragging!=DRAG_NONE; } + + DragMode get_dragging_mode() { return dragging; } + + WorkArea(etl::loose_handle canvas_interface); + virtual ~WorkArea(); + + void set_cursor(const Gdk::Cursor& x); + void set_cursor(Gdk::CursorType x); + + const synfig::Point& get_cursor_pos()const { return curr_point; } + + Gtk::Adjustment *get_scrollx_adjustment() { return &scrollx_adjustment; } + Gtk::Adjustment *get_scrolly_adjustment() { return &scrolly_adjustment; } + const Gtk::Adjustment *get_scrollx_adjustment()const { return &scrollx_adjustment; } + const Gtk::Adjustment *get_scrolly_adjustment()const { return &scrolly_adjustment; } + + void set_instance(etl::loose_handle x) { instance=x; } + void set_canvas(etl::handle x) { canvas=x; } + void set_canvas_view(etl::loose_handle x) { canvas_view=x; } + etl::handle get_canvas()const { return canvas; } + etl::handle get_instance()const { return instance; } + etl::loose_handle get_canvas_view()const { return canvas_view; } + + void refresh_dimension_info(); + + //! Enables showing of the grid + void enable_grid(); + + //! Disables showing of the grid + void disable_grid(); + + //! Toggles the showing of the grid + void toggle_grid(); + + //! Returns the state of the show_grid flag + bool grid_status()const { return show_grid; } + + void toggle_grid_snap() { Duckmatic::toggle_grid_snap(); } + + bool get_show_guides()const { return show_guides; } + void set_show_guides(bool x); + void toggle_show_guides() { set_show_guides(!get_show_guides()); } + + bool get_low_resolution_flag()const { return low_resolution; } + void set_low_resolution_flag(bool x); + void toggle_low_resolution_flag(); + + //! ??? + void queue_scroll(); + + //! Sets the size of the grid + void set_grid_size(const synfig::Vector &s); + + //! ?? + void popup_menu(); + + int get_quality()const { return quality; } + + void set_quality(int x); + + + int get_w()const { return w; } + int get_h()const { return h; } + int get_bpp()const { return bpp; } + + //! ?? + const synfig::RendDesc &get_rend_desc()const { return desc; } + + //! ?? + void set_rend_desc(const synfig::RendDesc &x) { desc=x; } + + //! Converts screen coords (ie: pixels) to composition coordinates + synfig::Point screen_to_comp_coords(synfig::Point pos)const; + + //! Converts composition coordinates to screen coords (ie: pixels) + synfig::Point comp_to_screen_coords(synfig::Point pos)const; + + float get_pw()const { return pw; } + float get_ph()const { return ph; } + + const synfig::Point &get_window_tl()const { return window_tl; } + const synfig::Point &get_window_br()const { return window_br; } + + + bool async_update_preview(); + void async_update_finished(); + void async_render_preview(synfig::Time time); + void async_render_preview(); + + bool sync_update_preview(); + bool sync_render_preview(synfig::Time time); + bool sync_render_preview(); + void sync_render_preview_hook(); + + void queue_render_preview(); + + + void queue_draw_preview(); + + void zoom_in(); + void zoom_out(); + void zoom_fit(); + void zoom_norm(); + float get_zoom()const { return zoom; } + + void set_zoom(float z); + + + void set_progress_callback(synfig::ProgressCallback *x) { progresscallback=x; } + synfig::ProgressCallback *get_progress_callback() { return progresscallback; } + + void set_focus_point(const synfig::Point &x); + + synfig::Point get_focus_point()const; + + void done_rendering(); + + bool refresh(GdkEventExpose*bleh=NULL); + + void reset_cursor(); + void refresh_cursor(); + + void save_meta_data(); + void load_meta_data(); + + /* + -- ** -- S I G N A L T E R M I N A L S ------------------------------------- + */ + +private: + bool on_key_press_event(GdkEventKey* event); + bool on_drawing_area_event(GdkEvent* event); + bool on_hruler_event(GdkEvent* event); + bool on_vruler_event(GdkEvent* event); + + /* + -- ** -- S T A T I C P U B L I C M E T H O D S --------------------------- + */ + +public: + + /* + -- ** -- S T A T I C P R I V A T E M E T H O D S ------------------------- + */ + +private: + + static gboolean __render_preview(gpointer data); + +}; // END of class WorkArea + +}; // END of namespace studio + +/* === E N D =============================================================== */ + +#endif