class AnimatorWidget( QtGui.QWidget, AnimatorWidgetUI ):
"""docstring for AnimatorWidget"""
def __init__( self, *args, **kwargs ):
super(AnimatorWidget, self).__init__( *args, **kwargs )
self.setupUi( self )
self.treeTracks = AnimatorTrackTree( parent = self )
self.timeline = AnimatorTimelineWidget( parent = self )
self.treeClips = AnimatorClipListTree( parent = self )
self.propertyEditor = PropertyEditor( self )
self.propertyEditor.propertyChanged.connect( self.onPropertyChanged )
self.propertyEditor.objectChanged.connect( self.onPropertyTargetChanged )
# self.treeTracks.setRowHeight( _TRACK_SIZE )
self.treeTracks.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
self.treeTracks.verticalScrollBar().setStyleSheet('width:4px')
self.treeTracks.setHorizontalScrollBarPolicy( Qt.ScrollBarAlwaysOff )
self.toolbarTarget = QtGui.QToolBar()
self.toolbarClips = QtGui.QToolBar()
self.toolbarPlay = QtGui.QToolBar()
self.toolbarTrack = QtGui.QToolBar()
self.toolbarEdit = self.timeline.toolbarEdit
self.timeline.toolbuttonCurveModeLinear .setIcon( getIcon( 'curve_mode_linear' ) )
self.timeline.toolbuttonCurveModeConstant .setIcon( getIcon( 'curve_mode_constant' ) )
self.timeline.toolbuttonCurveModeBezier .setIcon( getIcon( 'curve_mode_bezier' ) )
self.timeline.toolbuttonCurveModeBezierS .setIcon( getIcon( 'curve_mode_bezier_s' ) )
self.timeline.toolbuttonAddMarker .setIcon( getIcon( 'marker' ) )
self.timeline.toolbuttonAddKey .setIcon( getIcon( 'add' ) )
self.timeline.toolbuttonRemoveKey .setIcon( getIcon( 'remove' ) )
self.timeline.toolbuttonCloneKey .setIcon( getIcon( 'clone' ) )
treeLayout = QtGui.QVBoxLayout(self.containerTree)
treeLayout.setSpacing( 0 )
treeLayout.setMargin( 0 )
treeLayout.addWidget( self.treeTracks )
rightLayout = QtGui.QVBoxLayout(self.containerRight)
rightLayout.setSpacing( 0 )
rightLayout.setMargin( 0 )
rightLayout.addWidget( self.timeline )
treeClipsLayout = QtGui.QVBoxLayout(self.containerClips)
treeClipsLayout.setSpacing( 0 )
treeClipsLayout.setMargin( 0 )
treeClipsLayout.addWidget( self.toolbarTarget )
treeClipsLayout.addWidget( self.treeClips )
treeClipsLayout.addWidget( self.toolbarClips )
self.treeClips.setHeaderHidden( True )
self.treeClips.verticalScrollBar().setStyleSheet('width:4px')
propLayout = QtGui.QVBoxLayout(self.containerProperty)
propLayout.setSpacing( 0 )
propLayout.setMargin( 0 )
propLayout.addWidget( self.propertyEditor )
# headerHeight = self.treeTracks.header().height()
playToolLayout = QtGui.QVBoxLayout(self.containerPlayTool)
playToolLayout.setSpacing( 0 )
playToolLayout.setMargin( 0 )
playToolLayout.addWidget( self.toolbarPlay )
playToolLayout.addStretch( )
trackToolLayout = QtGui.QVBoxLayout(self.containerTrackTool)
trackToolLayout.setSpacing( 0 )
trackToolLayout.setMargin( 0 )
trackToolLayout.addWidget( self.toolbarTrack )
bottomToolHeight = 20
self.containerTrackTool.setFixedHeight( bottomToolHeight )
self.toolbarClips.setFixedHeight( bottomToolHeight )
self.toolbarTrack.setFixedHeight( bottomToolHeight )
topToolHeight = self.timeline.getRulerHeight()
self.containerPlayTool.setFixedHeight( topToolHeight )
self.toolbarPlay.setFixedHeight( topToolHeight )
self.toolbarClips.setFixedHeight( topToolHeight )
self.treeTracks.header().hide()
self.treeTracks.setObjectName( 'AnimatorTrackTree' )
self.treeClips.setObjectName( 'AnimatorClipListTree' )
self.toolbarPlay.setObjectName( 'TimelineToolBarPlay')
self.toolbarTrack.setObjectName( 'TimelineToolBarTrack')
#signals
self.treeTracks.verticalScrollBar().valueChanged.connect( self.onTrackTreeScroll )
self.timeline.cursorPosChanged.connect( self.onCursorPosChanged )
self.timeline.trackView.scrollYChanged.connect( self.onTrackViewScrollDragged )
self.treeTracks.layoutChanged.connect( self.updateTrackLayout )
self.cursorMovable = True
self.updatingScroll = False
def setOwner( self, owner ):
self.owner = owner
self.treeTracks.parentView = self
self.treeClips.parentView = self
self.timeline.parentView = self
self.treeTracks.owner = owner
self.treeClips.owner = owner
self.timeline.owner = owner
#signals
self.timeline.markerChanged.connect( self.onMarkerChanged )
self.timeline.keyChanged.connect( self.onKeyChanged )
self.timeline.keyCurveValueChanged.connect( self.onKeyCurveValueChanged )
self.timeline.keyBezierPointChanged.connect( self.onKeyBezierPointChanged )
self.timeline.keyTweenModeChanged.connect( self.onKeyTweenModeChanged )
def rebuild( self ):
self.treeTracks.rebuild()
self.treeClips.rebuild()
self.timeline.rebuild()
self.setTrackViewScrollRange( 0 )
def rebuildTimeline( self ):
self.timeline.rebuild()
self.treeTracks.rebuild()
def rebuildClipList( self ):
self.treeClips.rebuild()
def updateTrackLayout( self ):
self.timeline.updateTrackLayout()
def createClip( self ):
pass
def addClip( self, clip, focus = False ):
self.treeClips.addNode( clip )
if focus:
self.treeClips.selectNode( clip )
self.treeClips.editNode( clip )
def addKey( self, key, focus = False ):
self.addTrack( key.parent )
self.timeline.addKey( key )
if focus:
#TODO: select key
pass
def addTrack( self, track, focus = False ):
self.treeTracks.addNode( track )
self.timeline.addTrack( track )
if focus:
self.treeTracks.editNode( track )
self.timeline.setTrackSelection( [track] )
def addMarker( self, marker, focus = False ):
self.timeline.addMarker( marker )
if focus:
#TODO: select marker
pass
def selectTrack( self, trackNode ):
self.treeTracks.selectNode( trackNode )
def removeClip( self, clip ):
self.treeClips.removeNode( clip )
def removeTrack( self, track ):
self.treeTracks.removeNode( track )
self.timeline.removeTrack( track )
def removeKey( self, key ):
self.timeline.removeKey( key )
def setPropertyTarget( self, target ):
self.propertyEditor.setTarget( target )
def isTrackVisible( self, trackNode ):
return self.treeTracks.isNodeVisible( trackNode )
def getTrackPos( self, trackNode ):
rect = self.treeTracks.getNodeVisualRect( trackNode )
scrollY = self.treeTracks.verticalScrollBar().value()
pos = rect.y() + 3 + scrollY
return pos
def onTrackViewScrollDragged( self, y ):
if self.updatingScroll: return
self.updatingScroll = True
self.treeTracks.verticalScrollBar().setValue( -y )
self.updatingScroll = False
def setTrackViewScrollRange( self, maxRange ):
self.timeline.setTrackViewScrollRange( maxRange )
def onTrackTreeScroll( self, v ):
self.timeline.setTrackViewScroll( -v )
def onTrackFolded( self, track, folded ):
track._folded = folded
self.timeline.updateTrackLayout()
self.timeline.clearSelection()
def onMarkerChanged( self, marker, pos ):
self.propertyEditor.refreshFor( marker )
self.owner.onTimelineMarkerChanged( marker, pos )
def onKeyChanged( self, key, pos, length ):
self.propertyEditor.refreshFor( key )
self.owner.onTimelineKeyChanged( key, pos, length )
def onKeyCurveValueChanged( self, key, value ):
self.owner.onTimelineKeyCurveValueChanged( key, value )
def onKeyBezierPointChanged( self, key, bpx0, bpy0, bpx1, bpy1 ):
self.owner.onTimelineKeyBezierPointChanged( key, bpx0, bpy0, bpx1, bpy1 )
def onKeyTweenModeChanged( self, key, mode ):
if mode == TWEEN_MODE_LINEAR:
mode = 0
elif mode == TWEEN_MODE_CONSTANT:
mode = 1
elif mode == TWEEN_MODE_BEZIER:
mode = 2
else:
mode = 0
self.owner.onTimelineKeyTweenModeChanged( key, mode )
def onKeyRemoving( self, key ):
return self.owner.onKeyRemoving( key )
def onPropertyChanged( self, obj, fid, value ):
pass
# if isMockInstance( obj, 'AnimatorKey' ):
# if fid == 'pos' or fid == 'length':
# self.timeline.refreshKey( obj )
# elif isMockInstance( obj, 'AnimatorClipMarker' ):
# if fid == 'name' or fid =='pos':
# self.timeline.refreshMarker( obj )
# self.owner.onObjectEdited( obj )
def onPropertyTargetChanged( self, obj ):
if isMockInstance( obj, 'AnimatorKey' ):
self.timeline.refreshKey( obj )
elif isMockInstance( obj, 'AnimatorClipMarker' ):
self.timeline.refreshMarker( obj )
self.owner.onObjectEdited( obj )
def setEnabled( self, enabled ):
super( AnimatorWidget, self ).setEnabled( enabled )
self.timeline.setEnabled( enabled )
def startPreview( self ):
# self.timeline.setCursorDraggable( False )
pass
def stopPreview( self ):
# self.timeline.setCursorDraggable( True )
pass
def setCursorMovable( self, movable ):
self.cursorMovable = movable
self.timeline.setCursorDraggable( movable )
def onCursorPosChanged( self, pos ):
if self.cursorMovable:
self.owner.applyTime( pos )
def setCursorPos( self, pos, focus = False ):
self.timeline.setCursorPos( pos, focus )
def getCursorPos( self ):
return self.timeline.getCursorPos()
def onTrackSelectioChanged( self ):
selection = self.treeTracks.getSelection()
self.timeline.setTrackSelection( selection )
if selection:
track = selection[0]
else:
track = None
self.owner.setCurrentTrack( track )
def onClipSelectioChanged( self ):
selection = self.treeClips.getSelection()
if selection:
clip = selection[0]
else:
clip = None
if isMockInstance( clip, 'AnimatorClip' ):
self.owner.setTargetClip( clip )
else:
#TODO
pass
def getTrackSelection( self ):
return self.timeline.getTrackSelection()
def getClipSelection( self ):
return self.treeClips.getSelection()
def getKeySelection( self ):
return self.timeline.getSelection()
def getCurrentClipGroup( self ):
selection = self.treeClips.getSelection()
if selection:
node = selection[ 0 ]
while node:
if isMockInstance( node, 'AnimatorClipGroup' ):
return node
node = node.parentGroup
return None
