Changeset 890

Timestamp:

07/11/07 11:16:47 (1 year ago)

Author:

ok_computer

Message:

Adding multiple sub-range support to timeline.

Location:

trunk

Files:

• jahplayer/control.py (modified) (1 diff)
• jahwidgets/src/qt3/python/py.cpp (modified) (2 diffs)
• jahwidgets/src/qt3/python/python.pro (modified) (1 diff)
• jahwidgets/src/qt3/python/python_vc80.vcproj (modified) (1 diff)
• jahwidgets/src/qt3/python/timeline.cpp (added)
• jahwidgets/src/qt3/widgets/timelineSlider.cpp (modified) (34 diffs)
• jahwidgets/src/qt3/widgets/timelineSlider.h (modified) (10 diffs)
• jahwidgets/test/timelineSlider-test.ui (modified) (1 diff)

trunk/jahplayer/control.py

@@ -139 +139 @@
                 # In/out point handling
                 self.ignore_points = False
-                self.in_point = utilities.create_property_and_attach( self.handle, "timeline:inValue", utilities.call_method_observer( self.in_changed ) )
-                self.out_point = utilities.create_property_and_attach( self.handle, "timeline:outValue", utilities.call_method_observer( self.out_changed ) )
+                self.in_point = utilities.create_property_and_attach( self.handle, "timeline:activeInValue", utilities.call_method_observer( self.in_changed ) )
+                self.out_point = utilities.create_property_and_attach( self.handle, "timeline:activeOutValue", utilities.call_method_observer( self.out_changed ) )
                 self.in_prop = utilities.create_property_and_attach( self.handle, "pb_in:clicked", utilities.call_method_observer( self.set_in ) )
                 self.out_prop = utilities.create_property_and_attach( self.handle, "pb_out:clicked", utilities.call_method_observer( self.set_out ) )

trunk/jahwidgets/src/qt3/python/py.cpp

@@ -40 +40 @@
 extern void register_scrollview();
 extern void register_settings();
+extern void register_timeline();
 
 #ifdef MAC_OSX
@@ -79 +80 @@
         register_scrollview();
         register_settings();
+        register_timeline();
         
 #ifdef MAC_OSX

trunk/jahwidgets/src/qt3/python/python.pro

@@ -65 +65 @@
                    messagebox.cpp \
                    scrollview.cpp \
-                   settings.cpp
+                   settings.cpp \
+                   timeline.cpp
 
 mac: SOURCES += macutils.cpp

trunk/jahwidgets/src/qt3/python/python_vc80.vcproj

@@ -287 +287 @@
                         </File>
                         <File
+                                RelativePath=".\timeline.cpp"
+                                >
+                        </File>
+                        <File
                                 RelativePath=".\splitter.cpp"
                                 >

trunk/jahwidgets/src/qt3/widgets/timelineSlider.cpp

@@ -5 +5 @@
 // Released under the GPL.
 // For more information, see http://www.jahshaka.org.
-
-// Custom geometry classes, with minimal interfaces.
 
 #include "timelineSlider.h"
@@ -26 +24 @@
 // std
 #include <algorithm>
+#include <set>
+#include <memory>
+
+// boost
+#include <boost/shared_ptr.hpp>
 
 namespace jahwidgets { namespace qt3 {
@@ -33 +36 @@
 public:
         IconSet() :
-                _isActive(false)
+                _isActive(false),
+                _isSelected(false)
                 {}
 
         QPixmap pixmap() const {
-                return (_isActive && !active.isNull()) ? active : normal;
+                if ( _isActive && !active.isNull() ) {
+                        return active;
+                }
+                else if ( _isSelected && !selected.isNull() ) {
+                        return selected;
+                }
+                else {
+                        return normal;
+                }
         }
 
@@ -55 +67 @@
         }
 
+        void setSelected( bool s ) {
+                _isSelected = s;
+        }
+
+        bool isSelected() const {
+                return _isSelected;
+        }
+
         QPixmap normal;
         QPixmap active;
+        QPixmap selected;
 
 private:
         bool _isActive;
+        bool _isSelected;
 };
 
-struct TimelineSlider::PrivateTimelineSlider
+int TimelineSlider::Range::id_count = 0;
+
+typedef boost::shared_ptr<TimelineSlider::Range> RangePtr;
+
+struct RangeCompare
+{
+        bool operator()( RangePtr lhs, RangePtr rhs ) const
+                {
+                        // Ordered by in-point - or out point if in points are equal
+                        return lhs->in < rhs->in || (lhs->in == rhs->in && lhs->out < rhs->out);
+                }
+};
+
+// We use a multiset because it is legal to contain sets with duplicate in points
+typedef std::multiset<RangePtr, RangeCompare> RangeSet;
+
+struct RangeIdentity
+{
+public:
+        RangeIdentity( int an_id ) : id(an_id) {}
+
+        bool operator()( RangePtr range ) const {
+                return range->id() == id;
+        }
+
+        int id;
+};
+
+struct RangeContains
+{
+public:
+        RangeContains( int an_pt ) : pt(an_pt) {}
+
+        bool operator()( RangePtr range ) const {
+                return range->contains( pt );
+        }
+
+        int pt;
+};
+
+struct TimelineSlider::PrivateTimeline
 {
         enum Tracking { NONE, VALUE, IN, OUT };
 
-        PrivateTimelineSlider( TimelineSlider* p )
+        PrivateTimeline( TimelineSlider* p )
                 : parent( p ),
                   min( 0 ),
                   max( 1000 ),
                   v( 0 ),
-                  inValue( min ),
-                  outValue( max ),
+                  thumbnailFrame( -1 ),
                   showInOut( true ),
                   fps( 30 ),
@@ -81 +142 @@
                   showTimecodes( false ),
                   showTicks( false )
-                {}
-
-        int clamp( int i )
+                {
+                        rangeContainer.insert( RangePtr( Range::create( min, max ) ) );
+                        activeRange = *rangeContainer.begin();
+                }
+
+        int clamp( int i ) const
         {
                 return std::max( std::min( i, max ), min );
         }
 
-        int inClamp( int i )
-        {
-                return std::max( std::min( i, outValue ), min );
-        }
-
-        int outClamp( int i )
-        {
-                return std::max( std::min( i, max ), inValue );
-        }
-
-        void updateValue()
-        {
-                // ensure min and max are the right way around...
-                if ( min > max )
-                {
-                        std::swap( min, max );
-                }
-
-                // clamp value to range. Perfer in-point over out-point
-                int nv = inClamp( outClamp( clamp( v ) ) );
-                if ( nv != v )
-                {
-                        v = nv;
-                        emit parent->valueChanged( v );
-                        emit parent->value_changed();
-                }
+        int inClamp( int i ) const
+        {
+                i = std::max( std::min( i, activeRange->out ), min );
+
+                // And clamp above neighbouring out point
+                for ( RangeSet::const_iterator I = rangeContainer.begin();
+                          I != rangeContainer.end();
+                          ++I ) 
+                {
+                        if ( *I == activeRange ) continue;
+
+                        if ( (*I)->out > activeRange->out ) break;
+
+                        if ( i <= (*I)->out ) {
+                                i = (*I)->out + 1;
+                                break;
+                        }
+                }
+
+                return i;
+        }
+
+        int outClamp( int i ) const
+        {
+                i = std::max( std::min( i, max ), activeRange->in );
+
+                // And clamp below neighbouring in point
+                for ( RangeSet::const_reverse_iterator I = rangeContainer.rbegin();
+                          I != rangeContainer.rend();
+                          ++I ) 
+                {
+                        if ( *I == activeRange ) continue;
+
+                        if ( (*I)->out < activeRange->in ) break;
+
+                        if ( i >= (*I)->in ) {
+                                i = (*I)->in - 1;
+                                break;
+                        }
+                }
+
+                return i;
         }
 
         int convertToValue( int pt ) const
         {
-                return min + (int)( length() * ((double)(pt - xoffset())/trackLength()) );
+                return clamp( min + (int)( length() * ((double)(pt - xoffset())/trackLength()) ) );
         }
 
@@ -137 +217 @@
         {
                 // Should include the yoffset(), but this interacts badly with the outRect() offset...
-                int width = parent->width() - xoffset(); // - yoffset();
+                int width = parent->width() - xoffset() - (outThumb.normal.isNull() ? 0 : outThumb.normal.width() / 2);
                 // Ensure it's a multiple of the thumb width
-                return width - width % thumbWidth();
+                return width; // - width % thumbWidth();
         }
 
         int xoffset() const 
         {
-                return inThumb.normal.isNull() ? 0 : inThumb.normal.width();
-        }
-
-        int yoffset() const 
-        {
-                return outThumb.normal.isNull() ? 0 : outThumb.normal.width();
+                return inThumb.normal.isNull() ? 0 : inThumb.normal.width() / 2;
         }
 
@@ -159 +234 @@
         QRect inRect() const
         {
-                int v = convertToPixel( inValue );
+                // center in and out rects horizontally to allow for various marker positions
+                int v = convertToPixel( activeRange->in );
                 QSize size = inThumb.normal.isNull() ? inOutSize( parent->height() ) : inThumb.normal.size();
-                return QRect( QPoint( v - size.width(), (parent->height() - size.height())/2 ), size );
+                return QRect( QPoint( v - size.width() / 2, (parent->height() - size.height())/2 ), size );
         }
 
         QRect outRect() const
         {
+                // center in and out rects horizontally to allow for various marker positions
                 QSize size = outThumb.normal.isNull() ? inOutSize( parent->height() ) : outThumb.normal.size();
                 int x;
-                if ( outValue != inValue )
-                        x = convertToPixel( outValue );
+                if ( activeRange->out != activeRange->in )
+                        x = convertToPixel( activeRange->out ) - size.width() / 2;
                 else
-                        x = parent->width() - size.width();
+                        x = parent->width() - size.width() / 2;
 
                 // x should be v + size.width(), but this interacts badly when trackLength() is calculated correctly...
@@ -177 +254 @@
         }
 
+        QRect thumbnailMarkerRect() const 
+        {
+                if ( thumbnailFrame == -1 || thumbnailMarker.normal.isNull() ) return QRect();
+
+                QSize size = thumbnailMarker.normal.size();
+                int markerPos = convertToPixel( thumbnailFrame );
+                return QRect( markerPos - size.width() / 2, (parent->height() - size.height()) / 2, 
+                                          size.width(), size.height() );
+        }
+
         QRect currentMarkerRect() const
         {
@@ -186 +273 @@
                 return QRect( convertToPixel( v ) - width/2, (parent->height()-thumb.normal.height())/2,
                                           width, thumb.normal.height() );
+        }
+
+        bool hitInRect( QPoint pos ) const
+        {
+                // We've got to be in the thumb rect and outside the currentMarkerRect region
+                if ( inRect().contains( pos ) == false ) return false;
+
+                // else check the marker rect
+                QRect markerRect = currentMarkerRect();
+                return (pos.y() > markerRect.bottom() || pos.y() < markerRect.top());
+        }
+
+        bool hitOutRect( QPoint pos ) const
+        {
+                // We've got to be in the thumb rect and outside the currentMarkerRect region
+                if ( outRect().contains( pos ) == false ) return false;
+
+                // else check the marker rect
+                QRect markerRect = currentMarkerRect();
+                return (pos.y() > markerRect.bottom() || pos.y() < markerRect.top());
         }
 
@@ -232 +339 @@
         }
 
+        void paintTray() 
+        {
+                buffer = QPixmap();
+                tray_full.resize( parent->size() );
+
+                if ( !tray.isNull() )
+                {
+                        // assume we can split in the middle and stretch
+                        // pixmap should always be horizontal; we will rotate 
+                        // for vertical sliders
+                        const int half_width = tray.width()/2;
+                        const int height = tray.height();
+                
+                        QPixmap filler( 1, height );
+                
+                        // get filler
+                        copyBlt( &filler, 0, 0, &tray, half_width, 0, 1, height );
+                
+                        // work out how much filler we need
+                        const int fillerDistance = parent->width() - 2*half_width;
+                
+                        // get left
+                        copyBlt( &tray_full, 0, 0, &tray, 0, 0, half_width, height );
+                
+                        // filler
+                        int i = 0;
+                        while ( i < fillerDistance )
+                        {
+                                copyBlt( &tray_full, half_width + i++, 0, &filler, 0, 0, 1, height );
+                        }
+                
+                        // right
+                        copyBlt( &tray_full, half_width + fillerDistance, 0, 
+                                         &tray, half_width, 0, half_width, height );
+                }
+                else
+                {
+                        tray_full.fill( parent, 0, 0 );
+                }
+
+                // And the full duration/elapsed pixmaps
+                if ( !duration.isNull() )
+                {
+                        const int h = duration.height();
+                        const int w = parent->width();
+                        duration_full.resize( w, h );
+                        copyBlt( &duration_full, 0, 0,
+                                         &tray_full, 0, (parent->height()-h)/2, w, h );
+
+                        QPainter p( &duration_full );
+                        p.drawTiledPixmap( 0, 0, w, h, duration );
+                }
+
+                if ( !elapsed.isNull() )
+                {
+                        const int h = elapsed.height();
+                        const int w = parent->width();
+                        elapsed_full.resize( w, h );
+                        copyBlt( &elapsed_full, 0, 0,
+                                         &tray_full, 0, (parent->height()-h)/2, w, h );
+
+                        QPainter p( &elapsed_full );
+                        p.drawTiledPixmap( 0, 0, w, h, elapsed );
+                }
+        }
+
         TimelineSlider* parent;
 
@@ -239 +412 @@
         int v;
 
+        int thumbnailFrame;
+
         // in, out are in frames also
-        int inValue;
-        int outValue;
+        RangeSet rangeContainer;
+        RangePtr activeRange;
+
         bool showInOut;
 
@@ -267 +443 @@
         IconSet inThumb;
         IconSet outThumb;
+        IconSet thumbnailMarker;
         QPixmap duration;
         QPixmap elapsed;
@@ -278 +455 @@
         // for drawing
         QPixmap buffer;
+
+        std::auto_ptr<Delegate> delegate;
 };
 
 TimelineSlider::TimelineSlider( QWidget* parent, const char* name )
         : QWidget( parent, name ),
-          m_impl( new PrivateTimelineSlider( this ) )
+          m_impl( new PrivateTimeline( this ) )
 {
         setBackgroundMode( Qt::NoBackground );
@@ -295 +474 @@
 }
 
-void TimelineSlider::setRange( int minval, int maxval )
-{
-        setMinValue( minval );
-        setMaxValue( maxval );
+void TimelineSlider::setMaxRange( int minval, int maxval )
+{
+        if ( minval > maxval ) {
+                int tmp = minval;
+                minval = maxval;
+                maxval = tmp;
+        }
+
+        m_impl->min = minval;
+        m_impl->max = maxval;
+
+        // Reset ranges
+        m_impl->rangeContainer.clear();
+        m_impl->rangeContainer.insert( RangePtr(Range::create(minval, maxval)) );
+
+        // Update value
+        m_impl->v = m_impl->clamp( m_impl->v );
+
+        emit valueChanged( m_impl->v );
+        emit value_changed();
+
+        emit minValueChanged( minval );
+        emit minimum_changed();
+
+        emit maxValueChanged( maxval );
+        emit maximum_changed();
+
+        // Update active range
+        setActiveRangeId( (*(m_impl->rangeContainer.begin()))->id() );
 }
 
@@ -308 +512 @@
 void TimelineSlider::setLength( int l )
 {
-        setMinValue( 0 );
-        setMaxValue( l - 1 );
+        setMaxRange( 0, l - 1 );
 }
 
@@ -319 +522 @@
         }
 
-        m_impl->min = val;
-        m_impl->inValue = val;
-        m_impl->updateValue();
+        setMaxRange( val, m_impl->max );
 
         emit minValueChanged( m_impl->min );
-        emit inValueChanged( m_impl->inValue );
-        emit valueChanged( m_impl->v );
-        
         emit minimum_changed();
-        emit value_changed();
-        emit inValue_changed();
-
-        update();
 }
 
@@ -341 +535 @@
         }
 
-        m_impl->max = val;
-        m_impl->outValue = val;
-        m_impl->updateValue();
+        setMaxRange( m_impl->min, val );
 
         emit maxValueChanged( m_impl->max );
-        emit outValueChanged( m_impl->outValue );
-        emit valueChanged( m_impl->v );
-
         emit maximum_changed();
-        emit value_changed();
-        emit outValue_changed();
-
-        update();
 }
 
@@ -371 +556 @@
 }
 
-int TimelineSlider::inValue() const
-{
-        return m_impl->inValue;
-}
-
-void TimelineSlider::setInValue( int v )
-{
-        m_impl->inValue = m_impl->inClamp( v );
-        emit inValueChanged( m_impl->inValue );
-        emit inValue_changed();
-        
-        update();
-}
-
-int TimelineSlider::outValue() const
-{
-        return m_impl->outValue;
-}
-
-void TimelineSlider::setOutValue( int v )
-{
-        m_impl->outValue = m_impl->outClamp( v );
-        emit outValueChanged( m_impl->outValue );
-        emit outValue_changed();
+int TimelineSlider::activeInValue() const
+{
+        return m_impl->activeRange->in;
+}
+
+void TimelineSlider::setActiveInValue( int v )
+{
+        m_impl->activeRange->in = m_impl->inClamp( v );
+        emit activeInValueChanged( m_impl->activeRange->in );
+        emit activeInValue_changed();
+
+        if ( m_impl->inThumb.isSelected() ) {
+                emit selectedPointChanged( m_impl->activeRange->in );
+                emit selectedPoint_changed();
+        }
+
+        update();
+}
+
+int TimelineSlider::insertRange( int in, int out )
+{
+        qDebug( "insertRange: %d %d", in, out );
+
+        // Clamp to min/max, but otherwise leave as-is
+        RangePtr range( Range::create( m_impl->clamp(in), m_impl->clamp(out) ) );
+        m_impl->rangeContainer.insert( range );
+
+        update();
+
+        return range->id();
+}
+
+void TimelineSlider::removeRangeWithId( int id ) 
+{
+        qDebug( "removeRangeWithId: %d", id );
+
+        RangeSet::iterator I = std::find_if( m_impl->rangeContainer.begin(),
+                                                                                 m_impl->rangeContainer.end(),
+                                                                                 RangeIdentity( id ) );
+
+        if ( I == m_impl->rangeContainer.end() ) {
+                qWarning( "Remove: unable to find range with id: %d", id );
+                return;
+        }
+
+        m_impl->rangeContainer.erase( I );
+
+        if ( m_impl->activeRange->id() == id ) {
+                if ( m_impl->rangeContainer.empty() ) {
+                        m_impl->rangeContainer.insert( RangePtr( Range::create( m_impl->min, m_impl->max ) ) );
+                }
+
+                setActiveRangeId( (*m_impl->rangeContainer.begin())->id() );
+        }
+
+        update();
+}
+
+TimelineSlider::RangeArray TimelineSlider::allRanges() const
+{
+        RangeArray allRanges;
+
+        for ( RangeSet::const_iterator I = m_impl->rangeContainer.begin();
+                  I != m_impl->rangeContainer.end();
+                  ++I )
+        {
+                allRanges.push_back( *(I->get()) );
+        }
+
+        return allRanges;
+}