2013-04-04 00:32:52 -04:00
/*
Copyright ( C ) 2011 Paul Davis
Author : Carl Hetherington < cth @ carlh . net >
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 . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
/** @file canvas/canvas.cc
* @ brief Implementation of the main canvas classes .
*/
2013-12-12 10:03:33 -05:00
# include <list>
2013-04-04 00:32:52 -04:00
# include <cassert>
# include <gtkmm/adjustment.h>
2013-04-11 20:19:22 -04:00
# include <gtkmm/label.h>
2013-04-05 11:27:26 -04:00
2013-04-04 00:32:52 -04:00
# include "pbd/compose.h"
2013-04-05 11:27:26 -04:00
# include "pbd/stacktrace.h"
2013-04-04 00:32:52 -04:00
# include "canvas/canvas.h"
# include "canvas/debug.h"
2014-01-10 14:35:36 -05:00
# include "canvas/line.h"
2013-04-04 00:32:52 -04:00
using namespace std ;
using namespace ArdourCanvas ;
/** Construct a new Canvas */
Canvas : : Canvas ( )
: _root ( this )
2013-04-11 20:19:22 -04:00
, _scroll_offset_x ( 0 )
, _scroll_offset_y ( 0 )
2013-04-04 00:32:52 -04:00
{
set_epoch ( ) ;
}
2013-04-11 20:19:22 -04:00
void
Canvas : : scroll_to ( Coord x , Coord y )
{
_scroll_offset_x = x ;
_scroll_offset_y = y ;
2013-10-31 03:10:18 -04:00
2013-12-12 20:44:04 -05:00
pick_current_item ( 0 ) ; // no current mouse position
2013-10-31 03:10:18 -04:00
}
void
Canvas : : zoomed ( )
{
2013-12-12 20:44:04 -05:00
pick_current_item ( 0 ) ; // no current mouse position
2013-04-11 20:19:22 -04:00
}
2013-04-04 00:32:52 -04:00
/** Render an area of the canvas.
* @ param area Area in canvas coordinates .
* @ param context Cairo context to render to .
*/
void
Canvas : : render ( Rect const & area , Cairo : : RefPtr < Cairo : : Context > const & context ) const
{
2013-04-09 14:22:58 -04:00
# ifdef CANVAS_DEBUG
if ( DEBUG_ENABLED ( PBD : : DEBUG : : CanvasRender ) ) {
2014-01-10 14:35:36 -05:00
cerr < < this < < " RENDER: " < < area < < endl ;
2013-04-24 15:42:14 -04:00
//cerr << "CANVAS @ " << this << endl;
//dump (cerr);
//cerr << "-------------------------\n";
2013-04-09 14:22:58 -04:00
}
# endif
2013-04-05 11:27:26 -04:00
2013-04-04 00:32:52 -04:00
render_count = 0 ;
boost : : optional < Rect > root_bbox = _root . bounding_box ( ) ;
if ( ! root_bbox ) {
/* the root has no bounding box, so there's nothing to render */
return ;
}
2013-06-18 08:23:06 -04:00
boost : : optional < Rect > draw = root_bbox - > intersection ( area ) ;
2013-04-04 00:32:52 -04:00
if ( draw ) {
2013-12-23 15:35:49 -05:00
2013-04-04 00:32:52 -04:00
/* there's a common area between the root and the requested
area , so render it .
*/
2013-06-24 16:28:53 -04:00
2013-04-04 00:32:52 -04:00
_root . render ( * draw , context ) ;
2013-12-23 15:35:49 -05:00
// This outlines the rect being rendered, after it has been drawn.
// context->rectangle (draw->x0, draw->y0, draw->x1 - draw->x0, draw->y1 - draw->y0);
// context->set_source_rgba (1.0, 0, 0, 1.0);
// context->stroke ();
2013-04-04 00:32:52 -04:00
}
2013-10-31 11:49:36 -04:00
2013-04-04 00:32:52 -04:00
}
2013-04-05 11:27:26 -04:00
ostream &
operator < < ( ostream & o , Canvas & c )
{
c . dump ( o ) ;
return o ;
}
std : : string
Canvas : : indent ( ) const
{
string s ;
for ( int n = 0 ; n < ArdourCanvas : : dump_depth ; + + n ) {
s + = ' \t ' ;
}
return s ;
}
2013-04-09 14:22:58 -04:00
std : : string
Canvas : : render_indent ( ) const
{
string s ;
for ( int n = 0 ; n < ArdourCanvas : : render_depth ; + + n ) {
s + = ' ' ;
}
return s ;
}
2013-04-05 11:27:26 -04:00
void
Canvas : : dump ( ostream & o ) const
{
dump_depth = 0 ;
_root . dump ( o ) ;
}
2013-04-04 00:32:52 -04:00
/** Called when an item has been shown or hidden.
* @ param item Item that has been shown or hidden .
*/
void
Canvas : : item_shown_or_hidden ( Item * item )
2013-04-16 10:07:52 -04:00
{
boost : : optional < Rect > bbox = item - > bounding_box ( ) ;
if ( bbox ) {
queue_draw_item_area ( item , bbox . get ( ) ) ;
}
}
/** Called when an item has a change to its visual properties
* that do NOT affect its bounding box .
* @ param item Item that has been modified .
*/
void
Canvas : : item_visual_property_changed ( Item * item )
2013-04-04 00:32:52 -04:00
{
boost : : optional < Rect > bbox = item - > bounding_box ( ) ;
if ( bbox ) {
queue_draw_item_area ( item , bbox . get ( ) ) ;
}
}
/** Called when an item has changed, but not moved.
* @ param item Item that has changed .
* @ param pre_change_bounding_box The bounding box of item before the change ,
* in the item ' s coordinates .
*/
void
Canvas : : item_changed ( Item * item , boost : : optional < Rect > pre_change_bounding_box )
{
if ( pre_change_bounding_box ) {
/* request a redraw of the item's old bounding box */
queue_draw_item_area ( item , pre_change_bounding_box . get ( ) ) ;
}
boost : : optional < Rect > post_change_bounding_box = item - > bounding_box ( ) ;
if ( post_change_bounding_box ) {
/* request a redraw of the item's new bounding box */
queue_draw_item_area ( item , post_change_bounding_box . get ( ) ) ;
}
}
2013-04-17 10:53:17 -04:00
Duple
Canvas : : window_to_canvas ( Duple const & d ) const
{
return d . translate ( Duple ( _scroll_offset_x , _scroll_offset_y ) ) ;
}
Duple
Canvas : : canvas_to_window ( Duple const & d ) const
{
2013-10-31 11:49:36 -04:00
Duple wd = d . translate ( Duple ( - _scroll_offset_x , - _scroll_offset_y ) ) ;
2014-01-08 10:31:14 -05:00
/* Note that this intentionally always returns integer coordinates */
2013-10-31 11:49:36 -04:00
wd . x = round ( wd . x ) ;
wd . y = round ( wd . y ) ;
2014-01-08 10:31:14 -05:00
2013-10-31 11:49:36 -04:00
return wd ;
2013-04-17 10:53:17 -04:00
}
Rect
Canvas : : window_to_canvas ( Rect const & r ) const
{
return r . translate ( Duple ( _scroll_offset_x , _scroll_offset_y ) ) ;
}
Rect
Canvas : : canvas_to_window ( Rect const & r ) const
{
2013-10-31 11:49:36 -04:00
Rect wr = r . translate ( Duple ( - _scroll_offset_x , - _scroll_offset_y ) ) ;
2014-01-08 10:31:14 -05:00
/* Note that this intentionally always returns integer coordinates */
wr . x0 = round ( wr . x0 ) ;
wr . x1 = round ( wr . x1 ) ;
wr . y0 = round ( wr . y0 ) ;
wr . y1 = round ( wr . y1 ) ;
2013-10-31 11:49:36 -04:00
return wr ;
2013-04-17 10:53:17 -04:00
}
2013-04-04 00:32:52 -04:00
/** Called when an item has moved.
* @ param item Item that has moved .
* @ param pre_change_parent_bounding_box The bounding box of the item before
* the move , in its parent ' s coordinates .
*/
void
Canvas : : item_moved ( Item * item , boost : : optional < Rect > pre_change_parent_bounding_box )
{
if ( pre_change_parent_bounding_box ) {
2013-04-15 10:38:12 -04:00
/* request a redraw of where the item used to be. The box has
* to be in parent coordinate space since the bounding box of
* an item does not change when moved . If we use
* item - > item_to_canvas ( ) on the old bounding box , we will be
2013-10-24 17:14:12 -04:00
2013-04-15 10:38:12 -04:00
* using the item ' s new position , and so will compute the wrong
* invalidation area . If we use the parent ( which has not
* moved , then this will work .
*/
2013-04-04 00:32:52 -04:00
queue_draw_item_area ( item - > parent ( ) , pre_change_parent_bounding_box . get ( ) ) ;
}
boost : : optional < Rect > post_change_bounding_box = item - > bounding_box ( ) ;
if ( post_change_bounding_box ) {
/* request a redraw of where the item now is */
queue_draw_item_area ( item , post_change_bounding_box . get ( ) ) ;
}
}
/** Request a redraw of a particular area in an item's coordinates.
* @ param item Item .
* @ param area Area to redraw in the item ' s coordinates .
*/
void
Canvas : : queue_draw_item_area ( Item * item , Rect area )
{
2013-04-15 10:38:12 -04:00
ArdourCanvas : : Rect canvas_area = item - > item_to_canvas ( area ) ;
2014-01-10 14:35:36 -05:00
// cerr << "CANVAS " << this << " for " << item->whatami() << ' ' << item->name << " invalidate " << area << " TRANSLATE AS " << canvas_area << " window = " << canvas_to_window (canvas_area) << std::endl;
2013-04-15 10:38:12 -04:00
request_redraw ( canvas_area ) ;
2013-04-04 00:32:52 -04:00
}
/** Construct a GtkCanvas */
GtkCanvas : : GtkCanvas ( )
2013-12-12 10:03:33 -05:00
: _current_item ( 0 )
, _new_current_item ( 0 )
, _grabbed_item ( 0 )
2013-10-30 23:36:30 -04:00
, _focused_item ( 0 )
2013-04-04 00:32:52 -04:00
{
/* these are the events we want to know about */
2013-10-31 16:43:35 -04:00
add_events ( Gdk : : BUTTON_PRESS_MASK | Gdk : : BUTTON_RELEASE_MASK | Gdk : : POINTER_MOTION_MASK |
Gdk : : ENTER_NOTIFY_MASK | Gdk : : LEAVE_NOTIFY_MASK ) ;
2013-04-04 00:32:52 -04:00
}
2013-04-20 16:09:43 -04:00
void
2013-12-12 20:44:04 -05:00
GtkCanvas : : pick_current_item ( int state )
2013-04-20 16:09:43 -04:00
{
int x ;
int y ;
2013-04-24 15:42:14 -04:00
2013-12-12 20:44:04 -05:00
/* this version of ::pick_current_item() is called after an item is
2013-04-24 15:42:14 -04:00
* added or removed , so we have no coordinates to work from as is the
* case with a motion event . Find out where the mouse is and use that .
*/
2013-04-20 16:09:43 -04:00
Glib : : RefPtr < const Gdk : : Window > pointer_window = Gdk : : Display : : get_default ( ) - > get_window_at_pointer ( x , y ) ;
if ( pointer_window ! = get_window ( ) ) {
return ;
}
2013-04-04 00:32:52 -04:00
2013-12-12 20:44:04 -05:00
pick_current_item ( window_to_canvas ( Duple ( x , y ) ) , state ) ;
2013-04-20 16:09:43 -04:00
}
void
2013-12-12 20:44:04 -05:00
GtkCanvas : : pick_current_item ( Duple const & point , int state )
2013-04-20 16:09:43 -04:00
{
2013-10-30 23:36:30 -04:00
/* we do not enter/leave items during a drag/grab */
2013-04-24 15:42:14 -04:00
2013-10-30 23:36:30 -04:00
if ( _grabbed_item ) {
return ;
}
2013-04-04 00:32:52 -04:00
2013-10-30 23:36:30 -04:00
/* find the items at the given position */
vector < Item const * > items ;
_root . add_items_at_point ( point , items ) ;
2013-12-12 10:03:33 -05:00
/* put all items at point that are event-sensitive and visible and NOT
groups into within_items . Note that items is sorted from bottom to
top , but we ' re going to reverse that for within_items so that its
first item is the upper - most item that can be chosen as _current_item .
2013-10-30 23:36:30 -04:00
*/
2013-10-28 16:36:11 -04:00
2013-10-30 23:36:30 -04:00
vector < Item const * > : : const_iterator i ;
2013-12-12 10:03:33 -05:00
list < Item const * > within_items ;
2013-08-08 14:04:29 -04:00
2013-10-30 23:36:30 -04:00
for ( i = items . begin ( ) ; i ! = items . end ( ) ; + + i ) {
2013-04-24 15:42:14 -04:00
2013-12-12 10:03:33 -05:00
Item const * new_item = * i ;
2013-11-03 10:07:00 -05:00
2013-12-30 14:02:43 -05:00
/* We ignore invisible items, groups and items that ignore events */
2013-12-12 20:44:04 -05:00
2013-12-30 14:02:43 -05:00
if ( ! new_item - > visible ( ) | | new_item - > ignore_events ( ) | | dynamic_cast < Group const * > ( new_item ) ! = 0 ) {
2013-04-24 15:42:14 -04:00
continue ;
}
2013-12-12 10:03:33 -05:00
within_items . push_front ( new_item ) ;
}
2013-04-24 18:31:00 -04:00
2013-12-12 10:03:33 -05:00
if ( within_items . empty ( ) ) {
2013-12-12 20:44:04 -05:00
/* no items at point, just send leave event below */
} else {
2014-01-10 11:02:05 -05:00
2013-12-12 20:44:04 -05:00
if ( within_items . front ( ) = = _current_item ) {
/* uppermost item at point is already _current_item */
return ;
2013-04-24 22:57:23 -04:00
}
2013-12-12 20:44:04 -05:00
_new_current_item = const_cast < Item * > ( within_items . front ( ) ) ;
2013-10-30 23:36:30 -04:00
}
2014-01-10 11:02:05 -05:00
if ( _new_current_item ! = _current_item ) {
deliver_enter_leave ( point , state ) ;
}
2013-12-12 20:44:04 -05:00
}
void
GtkCanvas : : deliver_enter_leave ( Duple const & point , int state )
{
/* setup enter & leave event structures */
GdkEventCrossing enter_event ;
enter_event . type = GDK_ENTER_NOTIFY ;
enter_event . window = get_window ( ) - > gobj ( ) ;
enter_event . send_event = 0 ;
enter_event . subwindow = 0 ;
enter_event . mode = GDK_CROSSING_NORMAL ;
enter_event . focus = FALSE ;
enter_event . state = state ;
enter_event . x = point . x ;
enter_event . y = point . y ;
GdkEventCrossing leave_event = enter_event ;
leave_event . type = GDK_LEAVE_NOTIFY ;
Item * i ;
GdkNotifyType enter_detail ;
GdkNotifyType leave_detail ;
vector < Item * > items_to_leave_virtual ;
vector < Item * > items_to_enter_virtual ;
if ( _new_current_item = = 0 ) {
leave_detail = GDK_NOTIFY_UNKNOWN ;
if ( _current_item ) {
/* no current item, so also send virtual leave events to the
* entire heirarchy for the current item
*/
for ( i = _current_item - > parent ( ) ; i ; i = i - > parent ( ) ) {
items_to_leave_virtual . push_back ( i ) ;
}
2013-12-12 10:03:33 -05:00
}
2013-10-30 23:36:30 -04:00
2013-12-12 20:44:04 -05:00
} else if ( _current_item = = 0 ) {
enter_detail = GDK_NOTIFY_UNKNOWN ;
/* no current item, so also send virtual enter events to the
* entire heirarchy for the new item
*/
for ( i = _new_current_item - > parent ( ) ; i ; i = i - > parent ( ) ) {
items_to_enter_virtual . push_back ( i ) ;
}
} else if ( _current_item - > is_descendant_of ( * _new_current_item ) ) {
/* move from descendant to ancestor (X: "_current_item is an
2014-01-10 11:02:05 -05:00
* inferior ( " child " ) of _new_current_item " )
2013-12-12 20:44:04 -05:00
*
* Deliver " virtual " leave notifications to all items in the
* heirarchy between current and new_current .
*/
for ( i = _current_item - > parent ( ) ; i & & i ! = _new_current_item ; i = i - > parent ( ) ) {
items_to_leave_virtual . push_back ( i ) ;
}
enter_detail = GDK_NOTIFY_INFERIOR ;
leave_detail = GDK_NOTIFY_ANCESTOR ;
} else if ( _new_current_item - > is_descendant_of ( * _current_item ) ) {
/* move from ancestor to descendant (X: "_new_current_item is
2014-01-10 11:02:05 -05:00
* an inferior ( " child " ) of _current_item " )
2013-12-12 20:44:04 -05:00
*
* Deliver " virtual " enter notifications to all items in the
* heirarchy between current and new_current .
*/
for ( i = _new_current_item - > parent ( ) ; i & & i ! = _current_item ; i = i - > parent ( ) ) {
items_to_enter_virtual . push_back ( i ) ;
}
enter_detail = GDK_NOTIFY_ANCESTOR ;
leave_detail = GDK_NOTIFY_INFERIOR ;
2013-10-30 23:36:30 -04:00
2013-12-12 10:03:33 -05:00
} else {
2013-10-30 23:36:30 -04:00
2013-12-12 20:44:04 -05:00
Item const * common_ancestor = _current_item - > closest_ancestor_with ( * _new_current_item ) ;
2013-04-24 15:42:14 -04:00
2013-12-12 20:44:04 -05:00
/* deliver virtual leave events to everything between _current
* and common_ancestor .
*/
for ( i = _current_item - > parent ( ) ; i & & i ! = common_ancestor ; i = i - > parent ( ) ) {
items_to_leave_virtual . push_back ( i ) ;
}
/* deliver virtual enter events to everything between
* _new_current and common_ancestor .
*/
for ( i = _new_current_item - > parent ( ) ; i & & i ! = common_ancestor ; i = i - > parent ( ) ) {
items_to_enter_virtual . push_back ( i ) ;
}
enter_detail = GDK_NOTIFY_NONLINEAR ;
leave_detail = GDK_NOTIFY_NONLINEAR ;
2013-10-30 23:36:30 -04:00
}
2013-12-12 20:44:04 -05:00
if ( _current_item & & ! _current_item - > ignore_events ( ) ) {
leave_event . detail = leave_detail ;
_current_item - > Event ( ( GdkEvent * ) & leave_event ) ;
2013-12-30 14:02:43 -05:00
// std::cerr << "LEAVE " << _current_item->whatami() << '/' << _current_item->name << std::endl;
2013-10-30 23:36:30 -04:00
}
2013-08-08 14:04:29 -04:00
2013-12-12 20:44:04 -05:00
leave_event . detail = GDK_NOTIFY_VIRTUAL ;
enter_event . detail = GDK_NOTIFY_VIRTUAL ;
for ( vector < Item * > : : iterator it = items_to_leave_virtual . begin ( ) ; it ! = items_to_leave_virtual . end ( ) ; + + it ) {
if ( ! ( * it ) - > ignore_events ( ) ) {
( * it ) - > Event ( ( GdkEvent * ) & leave_event ) ;
2013-12-30 14:02:43 -05:00
// std::cerr << "leave " << (*it)->whatami() << '/' << (*it)->name << std::endl;
2013-12-12 20:44:04 -05:00
}
}
for ( vector < Item * > : : iterator it = items_to_enter_virtual . begin ( ) ; it ! = items_to_enter_virtual . end ( ) ; + + it ) {
if ( ! ( * it ) - > ignore_events ( ) ) {
( * it ) - > Event ( ( GdkEvent * ) & enter_event ) ;
2013-12-30 14:02:43 -05:00
// std::cerr << "enter " << (*it)->whatami() << '/' << (*it)->name << std::endl;
2013-12-12 20:44:04 -05:00
}
}
if ( _new_current_item & & ! _new_current_item - > ignore_events ( ) ) {
enter_event . detail = enter_detail ;
_new_current_item - > Event ( ( GdkEvent * ) & enter_event ) ;
2013-12-30 14:02:43 -05:00
// std::cerr << "ENTER " << _new_current_item->whatami() << '/' << _new_current_item->name << std::endl;
2013-12-12 20:44:04 -05:00
}
2013-12-12 10:03:33 -05:00
2013-12-12 20:44:04 -05:00
_current_item = _new_current_item ;
2013-04-04 00:32:52 -04:00
}
2013-12-12 20:44:04 -05:00
2013-04-04 00:32:52 -04:00
/** Deliver an event to the appropriate item; either the grabbed item, or
* one of the items underneath the event .
* @ param point Position that the event has occurred at , in canvas coordinates .
* @ param event The event .
*/
bool
2013-12-12 10:03:33 -05:00
GtkCanvas : : deliver_event ( GdkEvent * event )
2013-04-04 00:32:52 -04:00
{
2013-10-28 12:25:41 -04:00
/* Point in in canvas coordinate space */
2013-04-04 00:32:52 -04:00
if ( _grabbed_item ) {
/* we have a grabbed item, so everything gets sent there */
2013-04-10 11:09:16 -04:00
DEBUG_TRACE ( PBD : : DEBUG : : CanvasEvents , string_compose ( " %1 %2 (%3) was grabbed, send event there \n " ,
_grabbed_item , _grabbed_item - > whatami ( ) , _grabbed_item - > name ) ) ;
2013-04-04 00:32:52 -04:00
return _grabbed_item - > Event ( event ) ;
}
2013-12-12 10:03:33 -05:00
if ( ! _current_item ) {
return false ;
}
2013-04-04 00:32:52 -04:00
2013-12-12 10:03:33 -05:00
/* run through the items from child to parent, until one claims the event */
2013-04-10 11:09:16 -04:00
2013-12-12 20:44:04 -05:00
Item * item = const_cast < Item * > ( _current_item ) ;
while ( item ) {
2013-04-04 00:32:52 -04:00
2013-12-12 20:44:04 -05:00
Item * parent = item - > parent ( ) ;
if ( ! item - > ignore_events ( ) & &
item - > Event ( event ) ) {
2013-04-04 00:32:52 -04:00
/* this item has just handled the event */
DEBUG_TRACE (
PBD : : DEBUG : : CanvasEvents ,
2013-12-12 10:03:33 -05:00
string_compose ( " canvas event handled by %1 %2 \n " , item - > whatami ( ) , item - > name . empty ( ) ? " [unknown] " : item - > name )
2013-04-04 00:32:52 -04:00
) ;
return true ;
}
2014-01-16 10:52:34 -05:00
DEBUG_TRACE ( PBD : : DEBUG : : CanvasEvents , string_compose ( " canvas event %3 left unhandled by %1 %2 \n " , item - > whatami ( ) , item - > name . empty ( ) ? " [unknown] " : item - > name , event_type_string ( event - > type ) ) ) ;
2013-12-12 20:44:04 -05:00
if ( ( item = parent ) = = 0 ) {
break ;
}
2013-04-04 00:32:52 -04:00
}
return false ;
}
/** Called when an item is being destroyed.
* @ param item Item being destroyed .
* @ param bounding_box Last known bounding box of the item .
*/
void
GtkCanvas : : item_going_away ( Item * item , boost : : optional < Rect > bounding_box )
{
if ( bounding_box ) {
queue_draw_item_area ( item , bounding_box . get ( ) ) ;
}
2013-10-30 23:36:30 -04:00
/* no need to send a leave event to this item, since it is going away
*/
2013-12-12 10:03:33 -05:00
if ( _new_current_item = = item ) {
_new_current_item = 0 ;
}
if ( _current_item = = item ) {
_current_item = 0 ;
}
2013-04-04 00:32:52 -04:00
if ( _grabbed_item = = item ) {
_grabbed_item = 0 ;
}
2013-04-20 16:09:43 -04:00
2013-10-30 23:36:30 -04:00
if ( _focused_item = = item ) {
_focused_item = 0 ;
}
2014-01-20 10:53:58 -05:00
/* an item which ignores events can never be the current item
so we do not need to repick the current item .
*/
if ( ! item - > ignore_events ( ) ) {
pick_current_item ( 0 ) ; // no mouse state
}
2013-04-20 16:09:43 -04:00
2013-04-04 00:32:52 -04:00
}
/** Handler for GDK expose events.
* @ param ev Event .
* @ return true if the event was handled .
*/
bool
GtkCanvas : : on_expose_event ( GdkEventExpose * ev )
{
2014-01-10 14:35:36 -05:00
Cairo : : RefPtr < Cairo : : Context > cairo_context = get_window ( ) - > create_cairo_context ( ) ;
Rect area ( ev - > area . x , ev - > area . y , ev - > area . x + ev - > area . width , ev - > area . y + ev - > area . height ) ;
2013-04-11 20:19:22 -04:00
2014-01-10 14:35:36 -05:00
render ( area , cairo_context ) ;
2013-04-11 20:19:22 -04:00
2013-04-04 00:32:52 -04:00
return true ;
}
/** @return Our Cairo context, or 0 if we don't have one */
Cairo : : RefPtr < Cairo : : Context >
GtkCanvas : : context ( )
{
Glib : : RefPtr < Gdk : : Window > w = get_window ( ) ;
if ( ! w ) {
return Cairo : : RefPtr < Cairo : : Context > ( ) ;
}
return w - > create_cairo_context ( ) ;
}
/** Handler for GDK button press events.
* @ param ev Event .
* @ return true if the event was handled .
*/
bool
GtkCanvas : : on_button_press_event ( GdkEventButton * ev )
{
2013-04-11 20:19:22 -04:00
/* translate event coordinates from window to canvas */
2013-10-31 16:43:35 -04:00
GdkEvent copy = * ( ( GdkEvent * ) ev ) ;
2013-04-11 20:19:22 -04:00
Duple where = window_to_canvas ( Duple ( ev - > x , ev - > y ) ) ;
2013-10-31 16:43:35 -04:00
copy . button . x = where . x ;
copy . button . y = where . y ;
2013-04-04 00:32:52 -04:00
/* Coordinates in the event will be canvas coordinates, correctly adjusted
for scroll if this GtkCanvas is in a GtkCanvasViewport .
*/
2013-10-28 12:25:41 -04:00
2013-12-12 20:44:04 -05:00
pick_current_item ( where , ev - > state ) ;
2013-10-28 12:25:41 -04:00
DEBUG_TRACE ( PBD : : DEBUG : : CanvasEvents , string_compose ( " canvas button press @ %1, %2 => %3 \n " , ev - > x , ev - > y , where ) ) ;
2013-12-12 10:03:33 -05:00
return deliver_event ( reinterpret_cast < GdkEvent * > ( & copy ) ) ;
2013-04-04 00:32:52 -04:00
}
/** Handler for GDK button release events.
* @ param ev Event .
* @ return true if the event was handled .
*/
bool
GtkCanvas : : on_button_release_event ( GdkEventButton * ev )
2013-04-11 20:19:22 -04:00
{
/* translate event coordinates from window to canvas */
2013-10-31 16:43:35 -04:00
GdkEvent copy = * ( ( GdkEvent * ) ev ) ;
2013-04-11 20:19:22 -04:00
Duple where = window_to_canvas ( Duple ( ev - > x , ev - > y ) ) ;
2013-11-04 11:56:10 -05:00
2013-12-12 20:44:04 -05:00
pick_current_item ( where , ev - > state ) ;
2013-04-11 20:19:22 -04:00
2013-10-31 16:43:35 -04:00
copy . button . x = where . x ;
copy . button . y = where . y ;
2013-04-04 00:32:52 -04:00
/* Coordinates in the event will be canvas coordinates, correctly adjusted
for scroll if this GtkCanvas is in a GtkCanvasViewport .
*/
2013-10-28 12:25:41 -04:00
2013-12-12 20:44:04 -05:00
pick_current_item ( where , ev - > state ) ;
2013-10-28 12:25:41 -04:00
DEBUG_TRACE ( PBD : : DEBUG : : CanvasEvents , string_compose ( " canvas button release @ %1, %2 => %3 \n " , ev - > x , ev - > y , where ) ) ;
2013-12-12 10:03:33 -05:00
return deliver_event ( reinterpret_cast < GdkEvent * > ( & copy ) ) ;
2013-04-04 00:32:52 -04:00
}
/** Handler for GDK motion events.
* @ param ev Event .
* @ return true if the event was handled .
*/
bool
GtkCanvas : : on_motion_notify_event ( GdkEventMotion * ev )
{
2013-04-11 20:19:22 -04:00
/* translate event coordinates from window to canvas */
GdkEvent copy = * ( ( GdkEvent * ) ev ) ;
2013-11-04 11:56:10 -05:00
Duple point ( ev - > x , ev - > y ) ;
Duple where = window_to_canvas ( point ) ;
2013-04-11 20:19:22 -04:00
copy . motion . x = where . x ;
copy . motion . y = where . y ;
2013-11-04 11:56:10 -05:00
/* Coordinates in "copy" will be canvas coordinates,
*/
2013-12-12 10:03:33 -05:00
// DEBUG_TRACE (PBD::DEBUG::CanvasEvents, string_compose ("canvas motion @ %1, %2\n", ev->x, ev->y));
2013-11-04 11:56:10 -05:00
if ( _grabbed_item ) {
/* if we have a grabbed item, it gets just the motion event,
since no enter / leave events can have happened .
*/
DEBUG_TRACE ( PBD : : DEBUG : : CanvasEvents , string_compose ( " %1 %2 (%3) was grabbed, send MOTION event there \n " ,
_grabbed_item , _grabbed_item - > whatami ( ) , _grabbed_item - > name ) ) ;
return _grabbed_item - > Event ( reinterpret_cast < GdkEvent * > ( & copy ) ) ;
}
2013-12-12 20:44:04 -05:00
pick_current_item ( where , ev - > state ) ;
2013-11-04 11:56:10 -05:00
/* Now deliver the motion event. It may seem a little inefficient
to recompute the items under the event , but the enter notify / leave
events may have deleted canvas items so it is important to
recompute the list in deliver_event .
2013-04-04 00:32:52 -04:00
*/
2013-11-04 11:56:10 -05:00
2013-12-12 10:03:33 -05:00
return deliver_event ( reinterpret_cast < GdkEvent * > ( & copy ) ) ;
2013-04-04 00:32:52 -04:00
}
2013-10-30 23:36:30 -04:00
bool
GtkCanvas : : on_enter_notify_event ( GdkEventCrossing * ev )
{
Duple where = window_to_canvas ( Duple ( ev - > x , ev - > y ) ) ;
2013-12-12 20:44:04 -05:00
pick_current_item ( where , ev - > state ) ;
2013-10-30 23:36:30 -04:00
return true ;
}
bool
2013-12-12 20:44:04 -05:00
GtkCanvas : : on_leave_notify_event ( GdkEventCrossing * ev )
2013-10-30 23:36:30 -04:00
{
2013-12-12 10:03:33 -05:00
_new_current_item = 0 ;
2013-12-12 20:44:04 -05:00
Duple where = window_to_canvas ( Duple ( ev - > x , ev - > y ) ) ;
deliver_enter_leave ( where , ev - > state ) ;
2013-10-30 23:36:30 -04:00
return true ;
}
2013-04-04 00:32:52 -04:00
/** Called to request a redraw of our canvas.
* @ param area Area to redraw , in canvas coordinates .
*/
void
2013-04-11 20:19:22 -04:00
GtkCanvas : : request_redraw ( Rect const & request )
2013-04-04 00:32:52 -04:00
{
2014-01-10 14:35:36 -05:00
boost : : optional < Rect > req = request . intersection ( visible_area ( ) ) ;
if ( req ) {
Rect r = req . get ( ) ;
Rect area = canvas_to_window ( r ) ;
queue_draw_area ( area . x0 , area . y0 , area . width ( ) , area . height ( ) ) ;
}
2013-04-04 00:32:52 -04:00
}
/** Called to request that we try to get a particular size for ourselves.
* @ param size Size to request , in pixels .
*/
void
GtkCanvas : : request_size ( Duple size )
{
Duple req = size ;
if ( req . x > INT_MAX ) {
req . x = INT_MAX ;
}
if ( req . y > INT_MAX ) {
req . y = INT_MAX ;
}
2013-04-05 11:27:26 -04:00
2013-04-04 00:32:52 -04:00
set_size_request ( req . x , req . y ) ;
}
/** `Grab' an item, so that all events are sent to that item until it is `ungrabbed'.
* This is typically used for dragging items around , so that they are grabbed during
* the drag .
* @ param item Item to grab .
*/
void
GtkCanvas : : grab ( Item * item )
{
/* XXX: should this be doing gdk_pointer_grab? */
_grabbed_item = item ;
}
2013-10-30 23:36:30 -04:00
2013-04-04 00:32:52 -04:00
/** `Ungrab' any item that was previously grabbed */
void
GtkCanvas : : ungrab ( )
{
/* XXX: should this be doing gdk_pointer_ungrab? */
_grabbed_item = 0 ;
}
2013-10-30 23:36:30 -04:00
/** Set keyboard focus on an item, so that all keyboard events are sent to that item until the focus
* moves elsewhere .
* @ param item Item to grab .
*/
void
GtkCanvas : : focus ( Item * item )
{
_focused_item = item ;
}
void
GtkCanvas : : unfocus ( Item * item )
{
if ( item = = _focused_item ) {
_focused_item = 0 ;
}
}
2013-04-17 10:53:17 -04:00
/** @return The visible area of the canvas, in canvas coordinates */
Rect
GtkCanvas : : visible_area ( ) const
{
Distance const xo = _scroll_offset_x ;
Distance const yo = _scroll_offset_y ;
return Rect ( xo , yo , xo + get_allocation ( ) . get_width ( ) , yo + get_allocation ( ) . get_height ( ) ) ;
}
2013-04-04 00:32:52 -04:00
/** Create a GtkCanvaSViewport.
* @ param hadj Adjustment to use for horizontal scrolling .
* @ param vadj Adjustment to use for vertica scrolling .
*/
GtkCanvasViewport : : GtkCanvasViewport ( Gtk : : Adjustment & hadj , Gtk : : Adjustment & vadj )
2013-04-11 20:19:22 -04:00
: Alignment ( 0 , 0 , 1.0 , 1.0 )
, hadjustment ( hadj )
, vadjustment ( vadj )
2013-04-04 00:32:52 -04:00
{
add ( _canvas ) ;
2013-04-11 20:19:22 -04:00
hadj . signal_value_changed ( ) . connect ( sigc : : mem_fun ( * this , & GtkCanvasViewport : : scrolled ) ) ;
vadj . signal_value_changed ( ) . connect ( sigc : : mem_fun ( * this , & GtkCanvasViewport : : scrolled ) ) ;
2013-04-04 00:32:52 -04:00
}
2013-04-11 20:19:22 -04:00
void
GtkCanvasViewport : : scrolled ( )
{
_canvas . scroll_to ( hadjustment . get_value ( ) , vadjustment . get_value ( ) ) ;
queue_draw ( ) ;
}
2013-04-04 00:32:52 -04:00
/** Handler for when GTK asks us what minimum size we want.
* @ param req Requsition to fill in .
*/
void
GtkCanvasViewport : : on_size_request ( Gtk : : Requisition * req )
{
2013-04-11 20:19:22 -04:00
/* force the canvas to size itself */
// _canvas.root()->bounding_box();
2013-04-04 00:32:52 -04:00
req - > width = 16 ;
req - > height = 16 ;
}