2008-04-19 21:31:27 +02:00
/*
2008-05-31 14:22:15 +02:00
timeline - widget . cpp - Implementation of the timeline widget
2010-12-17 23:28:49 +01:00
2008-04-19 21:31:27 +02:00
Copyright ( C ) Lumiera . org
2008 , Joel Holdsworth < joel @ airwebreathe . org . uk >
2010-12-17 23:28:49 +01:00
2008-04-19 21:31:27 +02:00
This program is free software ; you can redistribute it and / or
modify it under the terms of the GNU General Public License as
2010-12-17 23:28:49 +01:00
published by the Free Software Foundation ; either version 2 of
the License , or ( at your option ) any later version .
2008-04-19 21:31:27 +02:00
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 .
2010-12-17 23:28:49 +01:00
2008-04-19 21:31:27 +02:00
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 .
2010-12-17 23:28:49 +01:00
2008-04-19 21:31:27 +02:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# include "timeline-widget.hpp"
2008-06-07 14:53:17 +02:00
# include <boost/foreach.hpp>
2008-11-29 17:13:58 +01:00
# include <typeinfo>
2008-06-07 14:53:17 +02:00
2008-05-22 20:19:04 +02:00
using namespace Gtk ;
2008-05-31 14:22:15 +02:00
using namespace std ;
2011-10-21 09:56:10 +02:00
using namespace std : : tr1 ;
2008-12-06 15:52:59 +01:00
using namespace util ;
2008-10-18 01:13:27 +02:00
using namespace gui : : widgets : : timeline ;
2011-05-16 08:38:01 +02:00
using lib : : time : : Time ;
using lib : : time : : TimeValue ;
2008-05-22 20:19:04 +02:00
2008-04-19 21:31:27 +02:00
namespace gui {
namespace widgets {
2008-05-31 19:21:05 +02:00
const int TimelineWidget : : TrackPadding = 1 ;
2008-11-15 16:17:26 +01:00
const int TimelineWidget : : HeaderWidth = 150 ;
2009-01-02 16:26:12 +01:00
const int TimelineWidget : : HeaderIndentWidth = 10 ;
2011-11-27 01:28:48 +01:00
2008-05-31 19:21:05 +02:00
2011-10-22 02:49:30 +02:00
TimelineWidget : : TimelineWidget ( shared_ptr < timeline : : TimelineState > source_state )
: Table ( 2 , 2 )
, layoutHelper ( * this )
, headerContainer ( NULL )
, body ( NULL )
, ruler ( NULL )
, horizontalAdjustment ( 0 , 0 , 0 )
, verticalAdjustment ( 0 , 0 , 0 )
, horizontalScroll ( horizontalAdjustment )
, verticalScroll ( verticalAdjustment )
, update_tracks_frozen ( false )
2008-06-19 22:57:53 +02:00
{
2009-04-14 22:40:58 +02:00
body = manage ( new TimelineBody ( * this ) ) ;
2008-06-23 11:54:37 +02:00
ENSURE ( body ! = NULL ) ;
2009-04-14 22:40:58 +02:00
headerContainer = manage ( new TimelineHeaderContainer ( * this ) ) ;
2008-06-23 11:54:37 +02:00
ENSURE ( headerContainer ! = NULL ) ;
2009-04-14 22:40:58 +02:00
ruler = manage ( new TimelineRuler ( * this ) ) ;
2008-08-07 21:27:41 +02:00
ENSURE ( ruler ! = NULL ) ;
2011-10-22 11:29:55 +02:00
2008-07-17 20:07:38 +02:00
horizontalAdjustment . signal_value_changed ( ) . connect ( sigc : : mem_fun (
this , & TimelineWidget : : on_scroll ) ) ;
verticalAdjustment . signal_value_changed ( ) . connect ( sigc : : mem_fun (
this , & TimelineWidget : : on_scroll ) ) ;
body - > signal_motion_notify_event ( ) . connect ( sigc : : mem_fun (
this , & TimelineWidget : : on_motion_in_body_notify_event ) ) ;
2009-03-23 23:22:14 +01:00
2008-10-18 00:36:37 +02:00
update_tracks ( ) ;
2011-10-22 11:29:55 +02:00
2008-06-19 22:57:53 +02:00
attach ( * body , 1 , 2 , 1 , 2 , FILL | EXPAND , FILL | EXPAND ) ;
2008-08-07 21:27:41 +02:00
attach ( * ruler , 1 , 2 , 0 , 1 , FILL | EXPAND , SHRINK ) ;
2008-06-19 22:57:53 +02:00
attach ( * headerContainer , 0 , 1 , 1 , 2 , SHRINK , FILL | EXPAND ) ;
attach ( horizontalScroll , 1 , 2 , 2 , 3 , FILL | EXPAND , SHRINK ) ;
attach ( verticalScroll , 2 , 3 , 1 , 2 , SHRINK , FILL | EXPAND ) ;
2008-07-30 01:12:37 +02:00
2009-03-27 17:56:37 +01:00
set_state ( source_state ) ;
2008-07-30 01:12:37 +02:00
set_tool ( timeline : : Arrow ) ;
2008-06-19 22:57:53 +02:00
}
2008-05-31 14:22:15 +02:00
TimelineWidget : : ~ TimelineWidget ( )
2008-06-19 22:57:53 +02:00
{
2009-04-14 22:40:58 +02:00
REQUIRE ( headerContainer ) ;
headerContainer - > clear_headers ( ) ;
2009-04-13 17:42:58 +02:00
2009-04-14 22:40:58 +02:00
trackMap . clear ( ) ;
2008-06-19 22:57:53 +02:00
}
2008-05-31 14:22:15 +02:00
2008-11-15 16:17:26 +01:00
/* ===== Data Access ===== */
2011-10-21 09:56:10 +02:00
shared_ptr < timeline : : TimelineState >
2009-03-23 23:22:14 +01:00
TimelineWidget : : get_state ( )
2008-07-30 01:12:37 +02:00
{
2009-03-23 23:22:14 +01:00
return state ;
2008-08-07 21:27:41 +02:00
}
2008-07-30 01:12:37 +02:00
void
2009-03-23 23:22:14 +01:00
TimelineWidget : : set_state ( shared_ptr < timeline : : TimelineState > new_state )
2009-03-27 17:56:37 +01:00
{
2011-10-11 21:39:20 +02:00
2009-03-23 23:22:14 +01:00
state = new_state ;
2009-03-27 15:26:08 +01:00
// Clear the track tree
trackMap . clear ( ) ;
2008-08-30 23:34:26 +02:00
2010-12-27 10:35:57 +01:00
if ( state )
2009-03-27 17:56:37 +01:00
{
// Hook up event handlers
state - > get_view_window ( ) . changed_signal ( ) . connect ( sigc : : mem_fun (
this , & TimelineWidget : : on_view_window_changed ) ) ;
state - > get_sequence ( ) - > get_child_track_list ( ) . signal_changed ( ) .
connect ( sigc : : mem_fun (
this , & TimelineWidget : : on_track_list_changed ) ) ;
state - > selection_changed_signal ( ) . connect ( mem_fun ( * this ,
& TimelineWidget : : on_body_changed ) ) ;
state - > playback_changed_signal ( ) . connect ( mem_fun ( * this ,
& TimelineWidget : : on_body_changed ) ) ;
}
2009-03-23 23:22:14 +01:00
update_tracks ( ) ;
2009-03-27 15:26:08 +01:00
// Send the state changed signal
2011-10-10 00:08:50 +02:00
stateChangedSignal . emit ( state ) ;
2008-08-07 21:27:41 +02:00
}
2008-10-07 22:17:29 +02:00
void
2011-10-11 21:39:20 +02:00
TimelineWidget : : zoom_view ( double timescale_ratio )
2008-10-07 22:17:29 +02:00
{
2009-03-27 17:56:37 +01:00
if ( state )
2011-10-06 19:38:10 +02:00
{
const int view_width = body - > get_allocation ( ) . get_width ( ) ;
2011-10-11 21:39:20 +02:00
state - > get_view_window ( ) . zoom_view ( view_width / 2 , timescale_ratio ) ;
2011-10-06 19:38:10 +02:00
}
2008-10-07 22:17:29 +02:00
}
2008-08-07 21:27:41 +02:00
ToolType
TimelineWidget : : get_tool ( ) const
{
REQUIRE ( body ! = NULL ) ;
return body - > get_tool ( ) ;
}
void
TimelineWidget : : set_tool ( ToolType tool_type )
{
REQUIRE ( body ! = NULL ) ;
body - > set_tool ( tool_type ) ;
2008-07-30 01:12:37 +02:00
}
2008-12-08 23:30:54 +01:00
shared_ptr < timeline : : Track >
2008-11-15 16:17:26 +01:00
TimelineWidget : : get_hovering_track ( ) const
{
return hoveringTrack ;
}
/* ===== Signals ===== */
2011-05-16 08:38:01 +02:00
sigc : : signal < void , Time >
2008-08-16 23:06:46 +02:00
TimelineWidget : : mouse_hover_signal ( ) const
{
return mouseHoverSignal ;
}
2008-10-07 22:17:29 +02:00
sigc : : signal < void >
TimelineWidget : : playback_period_drag_released_signal ( ) const
{
return playbackPeriodDragReleasedSignal ;
}
2008-12-08 23:30:54 +01:00
sigc : : signal < void , shared_ptr < timeline : : Track > >
2008-11-15 16:17:26 +01:00
TimelineWidget : : hovering_track_changed_signal ( ) const
{
return hoveringTrackChangedSignal ;
}
2011-01-02 06:03:28 +01:00
2011-10-10 00:08:50 +02:00
TimelineWidget : : TimelineStateChangeSignal
2009-03-27 15:26:08 +01:00
TimelineWidget : : state_changed_signal ( ) const
{
return stateChangedSignal ;
}
2008-11-15 16:17:26 +01:00
/* ===== Events ===== */
2008-05-31 14:22:15 +02:00
void
TimelineWidget : : on_scroll ( )
2008-06-19 22:57:53 +02:00
{
2009-03-27 17:56:37 +01:00
if ( state )
2011-05-16 08:38:01 +02:00
{
TimeValue newStartOffset ( ( gavl_time_t ) horizontalAdjustment . get_value ( ) ) ;
state - > get_view_window ( ) . set_time_offset ( Time ( newStartOffset ) ) ;
}
2008-06-19 22:57:53 +02:00
}
2008-06-05 21:27:53 +02:00
void
TimelineWidget : : on_size_allocate ( Allocation & allocation )
2008-06-19 22:57:53 +02:00
{
Widget : : on_size_allocate ( allocation ) ;
2008-06-05 21:27:53 +02:00
2008-06-19 22:57:53 +02:00
update_scroll ( ) ;
}
2008-11-19 23:42:38 +01:00
void
TimelineWidget : : on_view_window_changed ( )
2008-08-07 21:27:41 +02:00
{
2008-11-19 23:42:38 +01:00
REQUIRE ( ruler ! = NULL ) ;
2009-03-23 23:22:14 +01:00
2009-03-27 17:56:37 +01:00
if ( state )
{
timeline : : TimelineViewWindow & window = state - > get_view_window ( ) ;
2011-10-11 21:39:20 +02:00
2009-03-27 17:56:37 +01:00
const int view_width = body - > get_allocation ( ) . get_width ( ) ;
2011-10-11 21:39:20 +02:00
2009-03-27 17:56:37 +01:00
horizontalAdjustment . set_page_size (
window . get_time_scale ( ) * view_width ) ;
2011-10-11 21:39:20 +02:00
2011-05-16 08:38:01 +02:00
horizontalAdjustment . set_value ( _raw ( window . get_time_offset ( ) ) ) ;
2009-03-27 17:56:37 +01:00
}
2008-08-07 21:27:41 +02:00
}
2008-12-17 01:03:30 +01:00
void
2009-03-23 23:22:14 +01:00
TimelineWidget : : on_body_changed ( )
2008-12-17 01:03:30 +01:00
{
2009-03-23 23:22:14 +01:00
REQUIRE ( ruler ! = NULL ) ;
REQUIRE ( body ! = NULL ) ;
ruler - > queue_draw ( ) ;
body - > queue_draw ( ) ;
}
void
TimelineWidget : : on_add_track_command ( )
{
2008-12-17 01:03:30 +01:00
// # TEST CODE
2009-03-27 17:56:37 +01:00
if ( sequence ( ) )
sequence ( ) - > get_child_track_list ( ) . push_back (
shared_ptr < model : : Track > ( new model : : ClipTrack ( ) ) ) ;
2008-12-17 01:03:30 +01:00
}
2008-11-15 16:17:26 +01:00
/* ===== Internals ===== */
2008-05-31 14:22:15 +02:00
void
2008-06-05 21:27:53 +02:00
TimelineWidget : : update_tracks ( )
2008-11-29 17:13:58 +01:00
{
2009-01-22 00:48:56 +01:00
if ( update_tracks_frozen )
return ;
2009-03-27 17:56:37 +01:00
if ( state )
{
// Remove any tracks which are no longer present in the model
remove_orphaned_tracks ( ) ;
// Create timeline tracks from all the model tracks
create_timeline_tracks ( ) ;
// Update the layout helper
layoutHelper . clone_tree_from_sequence ( ) ;
layoutHelper . update_layout ( ) ;
}
else
trackMap . clear ( ) ;
2008-06-19 22:57:53 +02:00
}
2008-11-29 17:13:58 +01:00
2009-01-22 00:48:56 +01:00
void
TimelineWidget : : freeze_update_tracks ( )
{
update_tracks_frozen = true ;
}
void
TimelineWidget : : thaw_update_tracks ( )
{
update_tracks_frozen = false ;
}
2008-11-29 17:13:58 +01:00
void
TimelineWidget : : create_timeline_tracks ( )
{
2009-03-27 17:56:37 +01:00
REQUIRE ( state ) ;
2008-12-10 19:09:01 +01:00
BOOST_FOREACH ( shared_ptr < model : : Track > child ,
2009-03-23 23:22:14 +01:00
sequence ( ) - > get_child_tracks ( ) )
2008-12-13 14:57:19 +01:00
create_timeline_tracks_from_branch ( child ) ;
2009-01-10 11:50:44 +01:00
// Update the header container
REQUIRE ( headerContainer ! = NULL ) ;
headerContainer - > update_headers ( ) ;
2008-11-29 17:13:58 +01:00
}
void
TimelineWidget : : create_timeline_tracks_from_branch (
2011-01-02 10:47:04 +01:00
shared_ptr < model : : Track > modelTrack )
2008-11-29 17:13:58 +01:00
{
2011-01-02 10:47:04 +01:00
REQUIRE ( modelTrack ) ;
2008-11-29 18:02:27 +01:00
// Is a timeline UI track present in the map already?
2011-01-02 10:47:04 +01:00
if ( ! contains ( trackMap , modelTrack ) )
2008-11-29 17:13:58 +01:00
{
2008-11-29 18:02:27 +01:00
// The timeline UI track is not present
// We will need to create one
2011-01-02 10:47:04 +01:00
trackMap [ modelTrack ] =
create_timeline_track_from_modelTrack ( modelTrack ) ;
2008-11-29 17:13:58 +01:00
}
2008-11-29 18:02:27 +01:00
// Recurse to child tracks
2008-12-08 23:30:54 +01:00
BOOST_FOREACH ( shared_ptr < model : : Track > child ,
2011-01-02 10:47:04 +01:00
modelTrack - > get_child_tracks ( ) )
2008-11-29 18:02:27 +01:00
create_timeline_tracks_from_branch ( child ) ;
2008-11-29 17:13:58 +01:00
}
2008-12-08 23:30:54 +01:00
shared_ptr < timeline : : Track >
2011-01-02 10:47:04 +01:00
TimelineWidget : : create_timeline_track_from_modelTrack (
shared_ptr < model : : Track > modelTrack )
2008-11-29 17:13:58 +01:00
{
2011-01-02 10:47:04 +01:00
REQUIRE ( modelTrack ) ;
2008-11-29 17:13:58 +01:00
2008-11-29 17:40:50 +01:00
// Choose a corresponding timeline track class from the model track's
// class
2011-01-02 10:47:04 +01:00
if ( typeid ( * modelTrack ) = = typeid ( model : : ClipTrack ) )
2008-12-27 23:02:18 +01:00
return shared_ptr < timeline : : Track > ( new timeline : : ClipTrack (
2011-01-02 10:47:04 +01:00
* this , dynamic_pointer_cast < model : : ClipTrack > ( modelTrack ) ) ) ;
else if ( typeid ( * modelTrack ) = = typeid ( model : : GroupTrack ) )
2008-12-27 23:02:18 +01:00
return shared_ptr < timeline : : Track > ( new timeline : : GroupTrack (
2011-01-02 10:47:04 +01:00
* this , dynamic_pointer_cast < model : : GroupTrack > ( modelTrack ) ) ) ;
2008-11-29 17:30:45 +01:00
ASSERT ( NULL ) ; // Unknown track type;
2008-12-08 23:30:54 +01:00
return shared_ptr < timeline : : Track > ( ) ;
2008-11-29 17:13:58 +01:00
}
2008-12-20 15:31:11 +01:00
void
TimelineWidget : : remove_orphaned_tracks ( )
2011-01-02 16:57:14 +01:00
{
2011-10-21 09:56:10 +02:00
std : : map < shared_ptr < model : : Track > ,
shared_ptr < timeline : : Track > >
2008-12-20 15:31:11 +01:00
orphan_track_map ( trackMap ) ;
// Remove all tracks which are still present in the sequence
BOOST_FOREACH ( shared_ptr < model : : Track > child ,
2009-03-23 23:22:14 +01:00
sequence ( ) - > get_child_tracks ( ) )
2008-12-20 15:31:11 +01:00
search_orphaned_tracks_in_branch ( child , orphan_track_map ) ;
// orphan_track_map now contains all the orphaned tracks
// Remove them
std : : pair < shared_ptr < model : : Track > , shared_ptr < timeline : : Track > >
pair ;
BOOST_FOREACH ( pair , orphan_track_map )
{
2009-01-05 08:33:15 +01:00
ENSURE ( pair . first ) ;
2008-12-20 15:31:11 +01:00
trackMap . erase ( pair . first ) ;
}
}
void
TimelineWidget : : search_orphaned_tracks_in_branch (
2011-10-21 09:56:10 +02:00
shared_ptr < model : : Track > modelTrack ,
std : : map < shared_ptr < model : : Track > ,
shared_ptr < timeline : : Track > > & orphan_track_map )
2008-12-20 15:31:11 +01:00
{
2011-01-02 10:47:04 +01:00
REQUIRE ( modelTrack ) ;
2008-12-20 15:31:11 +01:00
// Is the timeline UI still present?
2011-01-02 10:47:04 +01:00
if ( contains ( orphan_track_map , modelTrack ) )
orphan_track_map . erase ( modelTrack ) ;
2008-12-20 15:31:11 +01:00
// Recurse to child tracks
BOOST_FOREACH ( shared_ptr < model : : Track > child ,
2011-01-02 10:47:04 +01:00
modelTrack - > get_child_tracks ( ) )
2008-12-20 15:31:11 +01:00
search_orphaned_tracks_in_branch ( child , orphan_track_map ) ;
}
2008-12-08 23:30:54 +01:00
shared_ptr < timeline : : Track >
2008-12-06 15:08:03 +01:00
TimelineWidget : : lookup_timeline_track (
2011-01-02 10:47:04 +01:00
shared_ptr < model : : Track > modelTrack ) const
2008-11-29 17:13:58 +01:00
{
2011-01-02 10:47:04 +01:00
REQUIRE ( modelTrack ) ;
REQUIRE ( modelTrack ! = sequence ( ) ) ; // The sequence isn't
2009-03-23 23:22:14 +01:00
// really a track
2009-01-01 19:43:46 +01:00
2008-12-20 12:45:23 +01:00
std : : map < shared_ptr < model : : Track > , shared_ptr < timeline : : Track > > : :
2011-01-02 10:47:04 +01:00
const_iterator iterator = trackMap . find ( modelTrack ) ;
2008-11-29 17:13:58 +01:00
if ( iterator = = trackMap . end ( ) )
{
// The track is not present in the map
// We are in an error condition if the timeline track is not found
// - the timeline tracks must always be synchronous with the model
// tracks.
2008-12-06 15:48:52 +01:00
ENSURE ( 0 ) ;
2008-12-08 23:30:54 +01:00
return shared_ptr < timeline : : Track > ( ) ;
2008-11-29 17:13:58 +01:00
}
ENSURE ( iterator - > second ! = NULL ) ;
return iterator - > second ;
}
2008-12-20 15:31:11 +01:00
2008-05-31 14:22:15 +02:00
void
2009-01-02 14:03:00 +01:00
TimelineWidget : : on_layout_changed ( )
{
REQUIRE ( headerContainer ! = NULL ) ;
REQUIRE ( body ! = NULL ) ;
2009-01-09 21:02:09 +01:00
headerContainer - > on_layout_changed ( ) ;
2009-01-02 14:03:00 +01:00
body - > queue_draw ( ) ;
2009-01-24 15:41:32 +01:00
update_scroll ( ) ;
2009-01-02 14:03:00 +01:00
}
void
2008-06-05 21:27:53 +02:00
TimelineWidget : : update_scroll ( )
2008-06-19 22:57:53 +02:00
{
2008-12-26 19:58:29 +01:00
REQUIRE ( body ! = NULL ) ;
2008-06-19 22:57:53 +02:00
const Allocation body_allocation = body - > get_allocation ( ) ;
2009-03-27 17:56:37 +01:00
if ( state )
{
2011-11-27 00:52:10 +01:00
///////////////////////////////////////////////TICKET #861 shoudln't that be performed by TimelineViewWindow, instead of manipulating values from the outside?
2009-03-27 17:56:37 +01:00
timeline : : TimelineViewWindow & window = state - > get_view_window ( ) ;
//----- Horizontal Scroll ------//
// TEST CODE
2011-11-27 00:52:10 +01:00
horizontalAdjustment . set_upper ( 1000 * GAVL_TIME_SCALE / 200 ) ;
2009-03-27 17:56:37 +01:00
horizontalAdjustment . set_lower ( - 1000 * GAVL_TIME_SCALE / 200 ) ;
// Set the page size
horizontalAdjustment . set_page_size (
window . get_time_scale ( ) * body_allocation . get_width ( ) ) ;
//----- Vertical Scroll -----//
// Calculate the vertical length that can be scrolled:
// the total height of all the tracks minus one screenful
int y_scroll_length = layoutHelper . get_total_height ( ) -
body_allocation . get_height ( ) ;
if ( y_scroll_length < 0 ) y_scroll_length = 0 ;
// If by resizing we're now over-scrolled, scroll back to
// maximum distance
if ( ( int ) verticalAdjustment . get_value ( ) > y_scroll_length )
verticalAdjustment . set_value ( y_scroll_length ) ;
verticalAdjustment . set_upper ( y_scroll_length ) ;
// Hide the scrollbar if no scrolling is possible
2008-07-24 00:23:48 +02:00
#if 0
2009-03-27 17:56:37 +01:00
// Having this code included seems to cause a layout loop as the
// window is shrunk
if ( y_scroll_length < = 0 & & verticalScroll . is_visible ( ) )
verticalScroll . hide ( ) ;
else if ( y_scroll_length > 0 & & ! verticalScroll . is_visible ( ) )
verticalScroll . show ( ) ;
2008-07-24 00:23:48 +02:00
# endif
2009-03-27 17:56:37 +01:00
}
2008-06-19 22:57:53 +02:00
}
2008-05-31 14:22:15 +02:00
2008-06-05 21:27:53 +02:00
int
TimelineWidget : : get_y_scroll_offset ( ) const
2008-06-19 22:57:53 +02:00
{
return ( int ) verticalAdjustment . get_value ( ) ;
}
2008-04-19 21:31:27 +02:00
2009-01-17 12:09:44 +01:00
void
TimelineWidget : : set_y_scroll_offset ( const int offset )
{
verticalAdjustment . set_value ( offset ) ;
}
2008-07-17 20:07:38 +02:00
bool
TimelineWidget : : on_motion_in_body_notify_event ( GdkEventMotion * event )
2008-06-25 21:23:53 +02:00
{
2008-07-17 20:07:38 +02:00
REQUIRE ( event ! = NULL ) ;
2008-08-07 21:27:41 +02:00
ruler - > set_mouse_chevron_offset ( event - > x ) ;
2009-03-23 23:22:14 +01:00
2009-03-27 17:56:37 +01:00
if ( state )
{
timeline : : TimelineViewWindow & window = state - > get_view_window ( ) ;
mouseHoverSignal . emit ( window . x_to_time ( event - > x ) ) ;
}
2008-10-18 00:36:37 +02:00
2008-07-17 20:07:38 +02:00
return true ;
2008-06-25 21:23:53 +02:00
}
2011-10-21 09:56:10 +02:00
shared_ptr < model : : Sequence >
2009-03-23 23:22:14 +01:00
TimelineWidget : : sequence ( ) const
{
2009-03-27 17:56:37 +01:00
if ( ! state )
return shared_ptr < model : : Sequence > ( ) ;
shared_ptr < model : : Sequence > sequence = state - > get_sequence ( ) ;
2009-03-23 23:22:14 +01:00
ENSURE ( sequence ) ;
return sequence ;
}
2008-12-17 01:03:30 +01:00
void
TimelineWidget : : on_track_list_changed ( )
{
update_tracks ( ) ;
}
2008-10-07 22:17:29 +02:00
void
TimelineWidget : : on_playback_period_drag_released ( )
{
playbackPeriodDragReleasedSignal . emit ( ) ;
}
2008-11-15 16:17:26 +01:00
void
2008-12-08 23:30:54 +01:00
TimelineWidget : : set_hovering_track (
shared_ptr < timeline : : Track > hovering_track )
2008-11-15 16:17:26 +01:00
{
hoveringTrack = hovering_track ;
hoveringTrackChangedSignal . emit ( hovering_track ) ;
}
2008-04-19 21:31:27 +02:00
} // namespace widgets
} // namespace gui