def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
### palette ###
self.paletteCanvas = PaletteCanvas(self)
self.paletteV = Viewer()
self.paletteV.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.paletteV.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.paletteV.setWidget(self.paletteCanvas)
### buttons ###
self.project.updatePaletteSign.connect(self.paletteCanvas.update)
addColorB = Button("add color", "icons/color_add.png", self.addColor)
delColorB = Button("delete color", "icons/color_del.png",
self.delColor)
moveLeftColorB = Button("move color left", "icons/color_move_left.png",
self.moveColorLeft)
moveRightColorB = Button("move color right",
"icons/color_move_right.png",
self.moveColorRight)
### layout ###
colorButtons = QtGui.QHBoxLayout()
colorButtons.setSpacing(0)
colorButtons.addWidget(addColorB)
colorButtons.addWidget(delColorB)
colorButtons.addWidget(moveLeftColorB)
colorButtons.addWidget(moveRightColorB)
self.layout = QtGui.QVBoxLayout()
self.layout.setSpacing(0)
self.layout.addWidget(self.paletteV)
self.layout.addLayout(colorButtons)
self.layout.setContentsMargins(6, 0, 6, 0)
self.setLayout(self.layout)
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
### coordinates ###
self.coords = Label("Cursor coordinates")
self.coords.setText("x\ny");
### tools buttons ###
self.penB = Button("pen (1)", "icons/tool_pen.png", self.penClicked, True)
self.penB.setChecked(True)
self.project.toolSetPenSign.connect(self.penClicked)
self.pipetteB = Button("pipette (2)", "icons/tool_pipette.png", self.pipetteClicked, True)
self.fillB = Button("fill (3)", "icons/tool_fill.png", self.fillClicked, True)
self.moveB = Button("move (4)", "icons/tool_move.png", self.moveClicked, True)
self.selectB = Button("select (5)", "icons/tool_select.png", self.selectClicked, True)
### Layout ###
layout = QtGui.QVBoxLayout()
layout.setSpacing(0)
layout.addWidget(self.coords)
layout.addWidget(self.penB)
layout.addWidget(self.pipetteB)
layout.addWidget(self.fillB)
layout.addWidget(self.moveB)
layout.addWidget(self.selectB)
layout.addStretch()
layout.setContentsMargins(6, 0, 6, 0)
self.setLayout(layout)
def __init__(self, window_type=gtk.WINDOW_TOPLEVEL):
gtk.Window.__init__(self, window_type)
# Init value.
self.form_x = 20
self.form_y = 20
self.form_w = 200
self.form_h = 200
self.titlebar_h = 30
# Init set window.
self.set_icon_from_file("image/titlebar/logo.ico")
self.set_title(" visible python ")
self.set_size_request(700, 500)
self.main_fixed = gtk.Fixed()
self.scroll_form_fixed = gtk.ScrolledWindow()
self.event_form_fixed = gtk.EventBox()
self.event_form_fixed.add_events(gtk.gdk.ALL_EVENTS_MASK)
self.form_fixed = gtk.Fixed()
self.event_form_fixed.add(self.form_fixed)
self.scroll_form_fixed.add_with_viewport(self.event_form_fixed)
self.form_fixed_x = 0
self.form_fixed_y = 0
self.form_press_bool = False
# Init form_fixed events.
self.form_fixed.connect("expose-event", self.draw_widgets)
self.event_form_fixed.connect("motion-notify-event",
self.motion_modify_mouse_style)
self.event_form_fixed.connect("button-press-event",
self.drag_press_form_window)
self.event_form_fixed.connect("button-release-event",
self.drag_release_form_window)
# Init titlbar window.
self.title_bar = TitleBar()
self.title_bar.set_size_request(self.form_w + 2, self.titlebar_h)
# Init form window.
self.form = Form()
self.button = Button()
self.button1 = Button()
self.form.put(self.button, 30, 120)
self.form.put(self.button1, 80, 120)
self.form.size(self.form_w, self.form_h)
self.scroll_form_fixed.set_size_request(700, 500)
self.event_form_fixed.set_size_request(self.form_w, self.form_h)
self.form_fixed.put(self.title_bar, self.form_x - 1, self.form_y)
self.form_fixed.put(self.form, self.form_x,
self.form_y + self.titlebar_h)
self.main_fixed.put(self.scroll_form_fixed, 100, 100)
self.add(self.main_fixed)
def __init__(self):
WidgetState.__init__(self)
Button("Game paused by host.", (None, None), None)
if game.server:
Button(
"Continue",
(None, common.screen.get_height() / 2 + 50),
lambda: game.server_call("unpause"),
)
Button(
"Quit",
(None, common.screen.get_height() / 2 + 85),
lambda: self.leave_game(),
)
game.unpause_signal.connect(self.resume)
def add_widget(self, name, type_, size, pos,
caption_data, skin, visible):
if type_ == 'button':
w = Button(self, name, size, pos, caption_data, skin, visible)
else:
w = Widget(self, name, size, pos, caption_data, skin, visible)
self.widgets[name] = w
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
### tools buttons ###
self.penB = Button("pen (1)", "icons/tool_pen.png", self.penClicked, True)
self.penB.setChecked(True)
self.pipetteB = Button("pipette (2)", "icons/tool_pipette.png", self.pipetteClicked, True)
self.fillB = Button("fill (3)", "icons/tool_fill.png", self.fillClicked, True)
self.moveB = Button("move (4)", "icons/tool_move.png", self.moveClicked, True)
self.selectB = Button("select (5)", "icons/tool_select.png", self.selectClicked, True)
### Layout ###
layout = QtGui.QVBoxLayout()
layout.setSpacing(0)
layout.addWidget(self.penB)
layout.addWidget(self.pipetteB)
layout.addWidget(self.fillB)
layout.addWidget(self.moveB)
layout.addWidget(self.selectB)
layout.addStretch()
layout.setContentsMargins(6, 0, 6, 0)
self.setLayout(layout)
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
self.penWidget = PenWidget(self, self.project)
self.brushWidget = BrushWidget(self, self.project)
self.alphaWidget = ColorWidget(False, self)
self.colorWidget = ColorWidget(True, self)
self.onionSkinB = Button("onion skin", "icons/onionskin_prev.png",
self.onionskinClicked, True)
self.optionFill = OptionFill(self, self.project)
self.optionMove = OptionMove(self, self.project)
self.optionSelect = OptionSelect(self, self.project)
self.project.toolChangedSign.connect(self.toolChanged)
### Layout ###
context = QtGui.QHBoxLayout()
context.setSpacing(8)
context.addWidget(self.alphaWidget)
context.addWidget(self.colorWidget)
context.addStretch()
context.addWidget(self.onionSkinB)
context.addStretch()
context.addWidget(self.penWidget)
context.addWidget(self.brushWidget)
context.setContentsMargins(0, 0, 0, 0)
layout = QtGui.QVBoxLayout()
layout.setSpacing(4)
layout.addLayout(context)
layout.addWidget(self.optionFill)
self.optionFill.hide()
layout.addWidget(self.optionMove)
self.optionMove.hide()
layout.addWidget(self.optionSelect)
self.optionSelect.hide()
layout.addStretch()
self.setLayout(layout)
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
self.penWidget = PenWidget(self, self.project)
self.brushWidget = BrushWidget(self, self.project)
self.alphaWidget = ColorWidget(False, self)
self.colorWidget = ColorWidget(True, self)
self.onionSkinB = Button("onion skin",
"icons/onionskin_prev.png", self.onionskinClicked, True)
self.optionFill = OptionFill(self, self.project)
self.optionMove = OptionMove(self, self.project)
self.optionSelect = OptionSelect(self, self.project)
self.project.toolChangedSign.connect(self.toolChanged)
### Layout ###
context = QtGui.QHBoxLayout()
context.setSpacing(8)
context.addWidget(self.alphaWidget)
context.addWidget(self.colorWidget)
context.addStretch()
context.addWidget(self.onionSkinB)
context.addStretch()
context.addWidget(self.penWidget)
context.addWidget(self.brushWidget)
context.setContentsMargins(0, 0, 0, 0)
layout = QtGui.QVBoxLayout()
layout.setSpacing(4)
layout.addLayout(context)
layout.addWidget(self.optionFill)
self.optionFill.hide()
layout.addWidget(self.optionMove)
self.optionMove.hide()
layout.addWidget(self.optionSelect)
self.optionSelect.hide()
layout.addStretch()
self.setLayout(layout)
class OptionsWidget(QtGui.QWidget):
""" widget cantaining options """
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
self.penWidget = PenWidget(self, self.project)
self.brushWidget = BrushWidget(self, self.project)
self.alphaWidget = ColorWidget(False, self)
self.colorWidget = ColorWidget(True, self)
self.onionSkinB = Button("onion skin",
"icons/onionskin_prev.png", self.onionskinClicked, True)
self.optionFill = OptionFill(self, self.project)
self.optionMove = OptionMove(self, self.project)
self.optionSelect = OptionSelect(self, self.project)
self.project.toolChangedSign.connect(self.toolChanged)
### Layout ###
context = QtGui.QHBoxLayout()
context.setSpacing(8)
context.addWidget(self.alphaWidget)
context.addWidget(self.colorWidget)
context.addStretch()
context.addWidget(self.onionSkinB)
context.addStretch()
context.addWidget(self.penWidget)
context.addWidget(self.brushWidget)
context.setContentsMargins(0, 0, 0, 0)
layout = QtGui.QVBoxLayout()
layout.setSpacing(4)
layout.addLayout(context)
layout.addWidget(self.optionFill)
self.optionFill.hide()
layout.addWidget(self.optionMove)
self.optionMove.hide()
layout.addWidget(self.optionSelect)
self.optionSelect.hide()
layout.addStretch()
self.setLayout(layout)
def toolChanged(self):
if self.project.tool == "fill":
self.optionSelect.hide()
self.optionMove.hide()
self.optionFill.show()
elif self.project.tool == "move":
self.optionFill.hide()
self.optionSelect.hide()
self.optionMove.show()
elif self.project.tool == "select":
self.optionFill.hide()
self.optionMove.hide()
self.optionSelect.show()
else:
self.optionFill.hide()
self.optionMove.hide()
self.optionSelect.hide()
def onionskinClicked(self):
self.project.onionSkin["check"] = self.onionSkinB.isChecked()
self.project.updateViewSign.emit()
class OptionsWidget(QtGui.QWidget):
""" widget cantaining options """
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
self.penWidget = PenWidget(self, self.project)
self.brushWidget = BrushWidget(self, self.project)
self.alphaWidget = ColorWidget(False, self)
self.colorWidget = ColorWidget(True, self)
self.onionSkinB = Button("onion skin", "icons/onionskin_prev.png",
self.onionskinClicked, True)
self.optionFill = OptionFill(self, self.project)
self.optionMove = OptionMove(self, self.project)
self.optionSelect = OptionSelect(self, self.project)
self.project.toolChangedSign.connect(self.toolChanged)
### Layout ###
context = QtGui.QHBoxLayout()
context.setSpacing(8)
context.addWidget(self.alphaWidget)
context.addWidget(self.colorWidget)
context.addStretch()
context.addWidget(self.onionSkinB)
context.addStretch()
context.addWidget(self.penWidget)
context.addWidget(self.brushWidget)
context.setContentsMargins(0, 0, 0, 0)
layout = QtGui.QVBoxLayout()
layout.setSpacing(4)
layout.addLayout(context)
layout.addWidget(self.optionFill)
self.optionFill.hide()
layout.addWidget(self.optionMove)
self.optionMove.hide()
layout.addWidget(self.optionSelect)
self.optionSelect.hide()
layout.addStretch()
self.setLayout(layout)
def toolChanged(self):
if self.project.tool == "fill":
self.optionSelect.hide()
self.optionMove.hide()
self.optionFill.show()
elif self.project.tool == "move":
self.optionFill.hide()
self.optionSelect.hide()
self.optionMove.show()
elif self.project.tool == "select":
self.optionFill.hide()
self.optionMove.hide()
self.optionSelect.show()
else:
self.optionFill.hide()
self.optionMove.hide()
self.optionSelect.hide()
def onionskinClicked(self):
self.project.onionSkin["check"] = self.onionSkinB.isChecked()
self.project.updateViewSign.emit()
def __init__(self):
WidgetState.__init__(self)
Button("Castle successfully defended!", (None, None), None)
Button("OK", (None, common.screen.get_height() / 2 + 50),
self.quit)
def __init__(self, project):
QWidget.__init__(self)
self.project = project
self.selection = False
self.toPaste = False
### viewer ###
self.layersCanvas = LayersCanvas(self)
self.layersV = Viewer()
self.layersV.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.layersV.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.layersV.setWidget(self.layersCanvas)
self.timelineCanvas = TimelineCanvas(self)
self.timelineV = Viewer()
self.timelineV.setWidget(self.timelineCanvas)
self.timelineV.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.timelineV.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.timeVSize = (0, 0)
self.timelineV.resyzing.connect(self.adjustSize)
self.layersV.verticalScrollBar().valueChanged.connect(
lambda v: self.timelineV.verticalScrollBar().setValue(v))
self.timelineV.verticalScrollBar().valueChanged.connect(
lambda v: self.layersV.verticalScrollBar().setValue(v))
self.project.updateTimelineSign.connect(self.timelineCanvas.update)
self.project.updateTimelineSign.connect(self.layersCanvas.update)
self.project.updateTimelineSizeSign.connect(self.adjustSize)
### adding and deleting layers ###
self.addLayerB = Button("add layer", "icons/layer_add.png", self.addLayerClicked)
self.dupLayerB = Button("duplicate layer", "icons/layer_dup.png", self.duplicateLayerClicked)
self.delLayerB = Button("delete layer", "icons/layer_del.png", self.deleteLayerClicked)
self.mergeLayerB = Button("merge layer", "icons/layer_merge.png", self.mergeLayerClicked)
self.upLayerB = Button("move up layer", "icons/layer_up.png", self.upLayerClicked)
self.downLayerB = Button("move down layer", "icons/layer_down.png", self.downLayerClicked)
### adding and deleting images ###
self.addFrameB = Button("add frame", "icons/frame_add.png", self.addFrameClicked)
self.dupFrameB = Button("duplicate frame", "icons/frame_dup.png", self.duplicateFrameClicked)
self.delFrameB = Button("delete frame", "icons/frame_del.png", self.deleteFrameClicked)
self.clearFrameB = Button("clear frame", "icons/frame_clear.png", self.clearFrameClicked)
### ponionskin ###
self.onionSkinPrevB = Button("onion skin - previous frame",
"icons/onionskin_prev.png", self.onionskinPrevClicked, True)
self.onionSkinNextB = Button("onion skin - next frame",
"icons/onionskin_next.png", self.onionskinNextClicked, True)
### play the animation ###
self.fpsW = QSpinBox(self)
self.fpsW.setValue(self.project.fps)
self.fpsW.setRange(1, 60)
self.fpsW.setSuffix(" fps")
self.project.updateFpsSign.connect(lambda: self.fpsW.setValue(self.project.fps))
self.fpsW.valueChanged.connect(self.fpsChanged)
self.repeatB = Button("no repeat / repeat", "icons/play_no_repeat.png", self.repeatClicked)
self.playFrameB = Button("play / pause", "icons/play_play.png", self.playPauseClicked)
self.playFrameB.state = "play"
### layout ###
layerTools = QVBoxLayout()
layerTools.setSpacing(0)
layerTools.addWidget(self.addLayerB)
layerTools.addWidget(self.dupLayerB)
layerTools.addWidget(self.delLayerB)
layerTools.addWidget(self.mergeLayerB)
layerTools.addStretch()
layerTools2 = QHBoxLayout()
layerTools2.setSpacing(0)
layerTools2.addWidget(self.upLayerB)
layerTools2.addWidget(self.downLayerB)
canvasTools = QHBoxLayout()
canvasTools.setSpacing(0)
canvasTools.addWidget(self.addFrameB)
canvasTools.addWidget(self.dupFrameB)
canvasTools.addWidget(self.delFrameB)
canvasTools.addWidget(self.clearFrameB)
canvasTools.addStretch()
canvasTools.addWidget(self.onionSkinPrevB)
canvasTools.addWidget(self.onionSkinNextB)
canvasTools.addWidget(self.fpsW)
canvasTools.addWidget(self.repeatB)
canvasTools.addWidget(self.playFrameB)
layout = QGridLayout()
layout.setSpacing(4)
layout.addLayout(layerTools, 0, 0)
layout.addWidget(self.layersV, 0, 1)
layout.addWidget(self.timelineV, 0, 2)
layout.addLayout(layerTools2, 1, 1)
layout.addLayout(canvasTools, 1, 2)
self.setLayout(layout)
class TimelineWidget(QWidget):
""" widget containing timeline, layers and all their buttons """
def __init__(self, project):
QWidget.__init__(self)
self.project = project
self.selection = False
self.toPaste = False
### viewer ###
self.layersCanvas = LayersCanvas(self)
self.layersV = Viewer()
self.layersV.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.layersV.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.layersV.setWidget(self.layersCanvas)
self.timelineCanvas = TimelineCanvas(self)
self.timelineV = Viewer()
self.timelineV.setWidget(self.timelineCanvas)
self.timelineV.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.timelineV.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.timeVSize = (0, 0)
self.timelineV.resyzing.connect(self.adjustSize)
self.layersV.verticalScrollBar().valueChanged.connect(
lambda v: self.timelineV.verticalScrollBar().setValue(v))
self.timelineV.verticalScrollBar().valueChanged.connect(
lambda v: self.layersV.verticalScrollBar().setValue(v))
self.project.updateTimelineSign.connect(self.timelineCanvas.update)
self.project.updateTimelineSign.connect(self.layersCanvas.update)
self.project.updateTimelineSizeSign.connect(self.adjustSize)
### adding and deleting layers ###
self.addLayerB = Button("add layer", "icons/layer_add.png", self.addLayerClicked)
self.dupLayerB = Button("duplicate layer", "icons/layer_dup.png", self.duplicateLayerClicked)
self.delLayerB = Button("delete layer", "icons/layer_del.png", self.deleteLayerClicked)
self.mergeLayerB = Button("merge layer", "icons/layer_merge.png", self.mergeLayerClicked)
self.upLayerB = Button("move up layer", "icons/layer_up.png", self.upLayerClicked)
self.downLayerB = Button("move down layer", "icons/layer_down.png", self.downLayerClicked)
### adding and deleting images ###
self.addFrameB = Button("add frame", "icons/frame_add.png", self.addFrameClicked)
self.dupFrameB = Button("duplicate frame", "icons/frame_dup.png", self.duplicateFrameClicked)
self.delFrameB = Button("delete frame", "icons/frame_del.png", self.deleteFrameClicked)
self.clearFrameB = Button("clear frame", "icons/frame_clear.png", self.clearFrameClicked)
### ponionskin ###
self.onionSkinPrevB = Button("onion skin - previous frame",
"icons/onionskin_prev.png", self.onionskinPrevClicked, True)
self.onionSkinNextB = Button("onion skin - next frame",
"icons/onionskin_next.png", self.onionskinNextClicked, True)
### play the animation ###
self.fpsW = QSpinBox(self)
self.fpsW.setValue(self.project.fps)
self.fpsW.setRange(1, 60)
self.fpsW.setSuffix(" fps")
self.project.updateFpsSign.connect(lambda: self.fpsW.setValue(self.project.fps))
self.fpsW.valueChanged.connect(self.fpsChanged)
self.repeatB = Button("no repeat / repeat", "icons/play_no_repeat.png", self.repeatClicked)
self.playFrameB = Button("play / pause", "icons/play_play.png", self.playPauseClicked)
self.playFrameB.state = "play"
### layout ###
layerTools = QVBoxLayout()
layerTools.setSpacing(0)
layerTools.addWidget(self.addLayerB)
layerTools.addWidget(self.dupLayerB)
layerTools.addWidget(self.delLayerB)
layerTools.addWidget(self.mergeLayerB)
layerTools.addStretch()
layerTools2 = QHBoxLayout()
layerTools2.setSpacing(0)
layerTools2.addWidget(self.upLayerB)
layerTools2.addWidget(self.downLayerB)
canvasTools = QHBoxLayout()
canvasTools.setSpacing(0)
canvasTools.addWidget(self.addFrameB)
canvasTools.addWidget(self.dupFrameB)
canvasTools.addWidget(self.delFrameB)
canvasTools.addWidget(self.clearFrameB)
canvasTools.addStretch()
canvasTools.addWidget(self.onionSkinPrevB)
canvasTools.addWidget(self.onionSkinNextB)
canvasTools.addWidget(self.fpsW)
canvasTools.addWidget(self.repeatB)
canvasTools.addWidget(self.playFrameB)
layout = QGridLayout()
layout.setSpacing(4)
layout.addLayout(layerTools, 0, 0)
layout.addWidget(self.layersV, 0, 1)
layout.addWidget(self.timelineV, 0, 2)
layout.addLayout(layerTools2, 1, 1)
layout.addLayout(canvasTools, 1, 2)
self.setLayout(layout)
######## Size adjust ###############################################
def showEvent(self, event):
self.timelineCanvas.setMinimumHeight(len(self.project.timeline) * 20 + 25)
self.timelineCanvas.update()
self.layersCanvas.setMinimumHeight(self.timelineCanvas.height())
self.layersCanvas.update()
self.layersV.setViewportMargins(0, 0, 0,
self.timelineV.horizontalScrollBar().height())
self.layersV.setMinimumWidth(self.layersCanvas.width() +
self.layersV.verticalScrollBar().width() + 2)
self.layersV.setMaximumWidth(self.layersCanvas.width() +
self.layersV.verticalScrollBar().width() + 2)
def adjustSize(self, timeVSize=False):
if timeVSize:
self.timeVSize = timeVSize
else:
timeVSize = self.timeVSize
wW = timeVSize[0]
wH = timeVSize[1] - self.timelineV.horizontalScrollBar().height()
timeMin = self.timelineCanvas.getMiniSize()
self.timelineCanvas.setFixedWidth(timeMin[0] + wW - self.timelineCanvas.frameWidth)
if timeMin[1] > wH - 2:
self.timelineCanvas.setFixedHeight(timeMin[1])
self.layersCanvas.setFixedHeight(timeMin[1])
else:
self.timelineCanvas.setFixedHeight(wH - 2)
self.layersCanvas.setFixedHeight(wH - 2)
self.timelineCanvas.update()
self.layersCanvas.update()
######## Copy ######################################################
def cut(self):
if self.selection:
self.project.saveToUndo("frames")
layer = self.project.timeline[self.selection[0]]
f1, f2 = self.selection[1], self.selection[2]
if f2 < f1:
f1, f2, = f2, f1
# copy frames
self.toPaste = layer[f1:f2 + 1]
# check if first frame is a real canvas
if not self.toPaste[0]:
self.toPaste[0] = layer.getCanvas(f1).copy_()
# check if frame next to selection is a real canvas
nex = layer.getCanvas(f2 + 1)
if nex and nex != layer.getCanvas(f1):
layer[f2 + 1] = nex.copy_()
# delete cutted frames
del layer[f1:f2 + 1]
self.timelineCanvas.update()
def copy(self):
if self.selection:
layer = self.project.timeline[self.selection[0]]
f1, f2 = self.selection[1], self.selection[2]
if f2 < f1:
f1, f2, = f2, f1
# copy frames
self.toPaste = layer[f1:f2 + 1]
# check if first frame is a real canvas
if not self.toPaste[0]:
self.toPaste[0] = layer.getCanvas(f1).copy_()
# make a real copy of all canvas
for n, canvas in enumerate(self.toPaste):
if canvas:
self.toPaste[n] = canvas.copy_()
def paste(self):
if self.toPaste:
self.project.saveToUndo("frames")
f = self.project.curFrame
l = self.project.curLayer
while f > len(self.project.timeline[l]):
self.project.timeline[l].append(0)
for n, canvas in enumerate(self.toPaste):
self.project.timeline[l].insert(f + n, canvas)
self.timelineCanvas.update()
self.project.updateViewSign.emit()
######## Buttons ###################################################
def addFrameClicked(self):
self.project.saveToUndo("frames")
self.project.timeline[self.project.curLayer].insertCanvas(
self.project.curFrame, self.project.makeCanvas())
self.adjustSize()
self.project.updateViewSign.emit()
def duplicateFrameClicked(self):
self.project.saveToUndo("frames")
layer = self.project.timeline[self.project.curLayer]
layer.insertCanvas(self.project.curFrame,
layer.getCanvas(self.project.curFrame).copy_())
self.adjustSize()
self.project.updateViewSign.emit()
def deleteFrameClicked(self):
self.project.saveToUndo("frames")
layer = self.project.timeline[self.project.curLayer]
frame = self.project.curFrame
if frame >= len(layer):
return
if len(layer) == 1 and frame == 0:
layer[frame].clear()
elif layer[frame] and not frame + 1 >= len(layer) and not layer[frame + 1]:
layer.pop(frame + 1)
else:
layer.pop(frame)
self.adjustSize()
self.project.updateViewSign.emit()
def clearFrameClicked(self):
f = self.project.timeline.getCanvas()
if f:
f.clear()
self.project.updateViewSign.emit()
def addLayerClicked(self):
self.project.saveToUndo("frames")
self.project.timeline.insert(self.project.curLayer,
self.project.makeLayer())
self.adjustSize()
self.project.updateViewSign.emit()
def duplicateLayerClicked(self):
self.project.saveToUndo("frames")
layer = self.project.timeline[self.project.curLayer].deepCopy()
layer.name = "%s copy" % (layer.name)
self.project.timeline.insert(self.project.curLayer, layer)
self.adjustSize()
self.project.updateViewSign.emit()
def deleteLayerClicked(self):
self.project.saveToUndo("frames")
del self.project.timeline[self.project.curLayer]
self.project.curLayer = 0
if not self.project.timeline:
self.project.timeline.append(self.project.makeLayer())
self.adjustSize()
self.project.updateViewSign.emit()
def mergeLayerClicked(self):
if not self.project.curLayer < len(self.project.timeline) - 1:
return
self.project.saveToUndo("frames")
layer1 = self.project.timeline[self.project.curLayer + 1]
layer2 = self.project.timeline[self.project.curLayer]
layer3 = self.project.makeLayer(False, True)
layer3.name = layer1.name
for i in range(max(len(layer1), len(layer2))):
if i == len(layer1):
layer3.append(layer2.getCanvas(i).copy_())
elif i == len(layer2):
layer3.append(layer1.getCanvas(i).copy_())
elif i > len(layer1):
if layer2[i]:
layer3.append(layer2[i].copy_())
else:
layer3.append(0)
elif i > len(layer2):
if layer1[i]:
layer3.append(layer1[i].copy_())
else:
layer3.append(0)
elif layer1[i] or layer2[i]:
c = layer1.getCanvas(i).copy_()
c.mergeCanvas(layer2.getCanvas(i))
layer3.append(c)
else:
layer3.append(0)
del self.project.timeline[self.project.curLayer]
self.project.timeline[self.project.curLayer] = layer3
self.adjustSize()
self.project.updateViewSign.emit()
def upLayerClicked(self):
self.project.saveToUndo("frames")
l = self.project.curLayer
f = self.project.timeline
if l > 0:
f[l], f[l - 1] = f[l - 1], f[l]
self.project.curLayer = l - 1
self.project.updateViewSign.emit()
self.project.updateTimelineSign.emit()
def downLayerClicked(self):
self.project.saveToUndo("frames")
l = self.project.curLayer
f = self.project.timeline
if l < len(f) - 1:
f[l], f[l + 1] = f[l + 1], f[l]
self.project.curLayer = l + 1
self.project.updateViewSign.emit()
self.project.updateTimelineSign.emit()
def renameLayer(self, l):
name = self.project.timeline[l].name
nName = RenameLayerDialog(name).getReturn()
if nName:
self.project.saveToUndo("frames")
self.project.timeline[l].name = str(nName)
self.project.updateTimelineSign.emit()
######## Onionskin #################################################
def onionskinPrevClicked(self):
self.project.onionSkinPrev = self.onionSkinPrevB.isChecked()
self.project.updateViewSign.emit()
def onionskinNextClicked(self):
self.project.onionSkinNext = self.onionSkinNextB.isChecked()
self.project.updateViewSign.emit()
######## Play ######################################################
def fpsChanged(self):
if 0 < self.fpsW.value() < 161:
self.project.fps = self.fpsW.value()
self.timelineCanvas.update()
def repeatClicked(self):
if self.project.loop:
self.repeatB.setIcon(QIcon(QPixmap("icons/play_no_repeat.png")))
self.project.loop = False
else:
self.repeatB.setIcon(QIcon(QPixmap("icons/play_repeat.png")))
self.project.loop = True
self.project.updateViewSign.emit()
def playPauseClicked(self):
"""play the animation"""
if self.playFrameB.state == 'play':
self.playFrameB.setIcon(QIcon(QPixmap("icons/play_pause.png")))
self.playFrameB.state = "stop"
self.timer = QTimer()
self.timer.timeout.connect(self.animate)
self.f = self.project.curFrame
self.fps = self.project.fps
self.project.playing = True
maxF = max([len(l) for l in self.project.timeline])
if self.project.curFrame + 1 >= maxF:
self.project.curFrame = 0
self.timelineCanvas.update()
self.project.updateViewSign.emit()
self.timer.start(1000 // self.fps)
elif self.playFrameB.state == 'stop':
self.playEnd()
def playEnd(self):
self.timer.stop()
self.playFrameB.state = "play"
self.playFrameB.setIcon(QIcon(QPixmap("icons/play_play.png")))
self.project.playing = False
self.project.updateViewSign.emit()
def animate(self):
if self.fps != self.project.fps:
self.fps = self.project.fps
self.timer.setInterval(1000 // self.fps)
maxF = max([len(l) for l in self.project.timeline])
self.f = self.project.curFrame + 1
if self.f < maxF:
self.project.curFrame = self.f
self.timelineCanvas.update()
self.project.updateViewSign.emit()
else:
if self.project.loop:
self.project.curFrame = 0
self.timelineCanvas.update()
self.project.updateViewSign.emit()
else:
self.playEnd()
def __init__(self):
WidgetState.__init__(self)
Button("Your last castle has fallen!", (None, None), None)
Button("OK", (None, common.screen.get_height() / 2 + 50),
self.quit)
def __init__(self):
WidgetState.__init__(self)
Button(string, (None, None), None)
Button("OK", (None, common.screen.get_height() / 2 + 50),
self.quit)
class ToolsWidget(QtGui.QWidget):
""" widget cantaining tools buttons """
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
### tools buttons ###
self.penB = Button("pen (1)", "icons/tool_pen.png", self.penClicked, True)
self.penB.setChecked(True)
self.project.toolSetPenSign.connect(self.penClicked)
self.pipetteB = Button("pipette (2)", "icons/tool_pipette.png", self.pipetteClicked, True)
self.fillB = Button("fill (3)", "icons/tool_fill.png", self.fillClicked, True)
self.moveB = Button("move (4)", "icons/tool_move.png", self.moveClicked, True)
self.selectB = Button("select (5)", "icons/tool_select.png", self.selectClicked, True)
### Layout ###
layout = QtGui.QVBoxLayout()
layout.setSpacing(0)
layout.addWidget(self.penB)
layout.addWidget(self.pipetteB)
layout.addWidget(self.fillB)
layout.addWidget(self.moveB)
layout.addWidget(self.selectB)
layout.addStretch()
layout.setContentsMargins(6, 0, 6, 0)
self.setLayout(layout)
def penClicked(self):
self.project.tool = "pen"
self.penB.setChecked(True)
self.pipetteB.setChecked(False)
self.fillB.setChecked(False)
self.moveB.setChecked(False)
self.selectB.setChecked(False)
self.project.toolChangedSign.emit()
def pipetteClicked(self):
self.project.tool = "pipette"
self.penB.setChecked(False)
self.fillB.setChecked(False)
self.pipetteB.setChecked(True)
self.moveB.setChecked(False)
self.selectB.setChecked(False)
self.project.toolChangedSign.emit()
def fillClicked(self):
self.project.tool = "fill"
self.fillB.setChecked(True)
self.pipetteB.setChecked(False)
self.penB.setChecked(False)
self.moveB.setChecked(False)
self.selectB.setChecked(False)
self.project.toolChangedSign.emit()
def moveClicked(self):
self.project.tool = "move"
self.fillB.setChecked(False)
self.pipetteB.setChecked(False)
self.penB.setChecked(False)
self.moveB.setChecked(True)
self.selectB.setChecked(False)
self.project.toolChangedSign.emit()
def selectClicked(self):
self.project.tool = "select"
self.fillB.setChecked(False)
self.pipetteB.setChecked(False)
self.penB.setChecked(False)
self.moveB.setChecked(False)
self.selectB.setChecked(True)
self.project.toolChangedSign.emit()
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
# color
self.prevcolorIcon = QtGui.QPixmap(32, 16)
self.prevcolorIcon.fill(self.project.onionSkin["prev_color"])
self.colorPrevB = Button("previous frames color",
QtGui.QIcon(self.prevcolorIcon), self.prevColorChanged)
self.colorPrevB.setIconSize(QtCore.QSize(36, 20))
self.colorCheck = QtGui.QCheckBox(self)
self.colorCheck.setToolTip("colored onion skin")
self.colorCheck.setChecked(self.project.onionSkin["color"])
self.colorCheck.stateChanged.connect(self.checkColor)
self.nextcolorIcon = QtGui.QPixmap(32, 16)
self.nextcolorIcon.fill(self.project.onionSkin["next_color"])
self.colorNextB = Button("next frames color",
QtGui.QIcon(self.nextcolorIcon), self.nextColorChanged)
self.colorNextB.setIconSize(QtCore.QSize(36, 20))
# onionskin
prev = self.project.onionSkin["prev"]
self.prev1Slider = QtGui.QSlider(QtCore.Qt.Vertical, self)
self.prev1Slider.setRange(0, 100)
self.prev1Slider.setValue(prev[0][1] * 100)
self.prev1Slider.valueChanged.connect(self.valueChanged)
self.prev1Check = QtGui.QCheckBox(self)
self.prev1Check.setChecked(prev[0][0])
self.prev1Check.stateChanged.connect(self.valueChanged)
self.prev2Slider = QtGui.QSlider(QtCore.Qt.Vertical, self)
self.prev2Slider.setRange(0, 100)
self.prev2Slider.setValue(prev[1][1] * 100)
self.prev2Slider.valueChanged.connect(self.valueChanged)
self.prev2Check = QtGui.QCheckBox(self)
self.prev2Check.setChecked(prev[1][0])
self.prev2Check.stateChanged.connect(self.valueChanged)
self.prev3Slider = QtGui.QSlider(QtCore.Qt.Vertical, self)
self.prev3Slider.setRange(0, 100)
self.prev3Slider.setValue(prev[2][1] * 100)
self.prev3Slider.valueChanged.connect(self.valueChanged)
self.prev3Check = QtGui.QCheckBox(self)
self.prev3Check.setChecked(prev[2][0])
self.prev3Check.stateChanged.connect(self.valueChanged)
self.currentSlider = QtGui.QSlider(QtCore.Qt.Vertical, self)
self.currentSlider.setRange(0, 100)
self.currentSlider.setValue(100)
#self.currentSlider.setDisabled(True)
self.currentSlider.setMinimumHeight(100)
self.currentSlider.valueChanged.connect(self.valueChanged)
nex = self.project.onionSkin["next"]
self.next1Slider = QtGui.QSlider(QtCore.Qt.Vertical, self)
self.next1Slider.setRange(0, 100)
self.next1Slider.setValue(nex[0][1] * 100)
self.next1Slider.valueChanged.connect(self.valueChanged)
self.next1Check = QtGui.QCheckBox(self)
self.next1Check.setChecked(nex[0][0])
self.next1Check.stateChanged.connect(self.valueChanged)
self.next2Slider = QtGui.QSlider(QtCore.Qt.Vertical, self)
self.next2Slider.setRange(0, 100)
self.next2Slider.setValue(nex[1][1] * 100)
self.next2Slider.valueChanged.connect(self.valueChanged)
self.next2Check = QtGui.QCheckBox(self)
self.next2Check.setChecked(nex[1][0])
self.next2Check.stateChanged.connect(self.valueChanged)
self.next3Slider = QtGui.QSlider(QtCore.Qt.Vertical, self)
self.next3Slider.setRange(0, 100)
self.next3Slider.setValue(nex[2][1] * 100)
self.next3Slider.valueChanged.connect(self.valueChanged)
self.next3Check = QtGui.QCheckBox(self)
self.next3Check.setChecked(nex[2][0])
self.next3Check.stateChanged.connect(self.valueChanged)
# layout
colorLayout = QtGui.QHBoxLayout()
colorLayout.setSpacing(0)
colorLayout.addWidget(self.colorPrevB)
colorLayout.addStretch()
colorLayout.addWidget(self.colorCheck)
colorLayout.addStretch()
colorLayout.addWidget(self.colorNextB)
sliderLayout = QtGui.QGridLayout()
sliderLayout.setSpacing(0)
sliderLayout.addWidget(self.prev3Slider, 0, 0)
sliderLayout.addWidget(self.prev3Check, 1, 0)
sliderLayout.addWidget(self.prev2Slider, 0, 1)
sliderLayout.addWidget(self.prev2Check, 1, 1)
sliderLayout.addWidget(self.prev1Slider, 0, 2)
sliderLayout.addWidget(self.prev1Check, 1, 2)
sliderLayout.addWidget(self.currentSlider, 0, 3)
sliderLayout.addWidget(self.next1Slider, 0, 4)
sliderLayout.addWidget(self.next1Check, 1, 4)
sliderLayout.addWidget(self.next2Slider, 0, 5)
sliderLayout.addWidget(self.next2Check, 1, 5)
sliderLayout.addWidget(self.next3Slider, 0, 6)
sliderLayout.addWidget(self.next3Check, 1, 6)
layout = QtGui.QVBoxLayout()
layout.addLayout(colorLayout)
layout.addLayout(sliderLayout)
self.setLayout(layout)
class TimelineWidget(QtGui.QWidget):
""" widget containing timeline, layers and all their buttons """
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
self.selection = False
self.toPaste = False
### viewer ###
self.layersCanvas = LayersCanvas(self)
self.layersV = Viewer()
self.layersV.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.layersV.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.layersV.setWidget(self.layersCanvas)
self.timelineCanvas = TimelineCanvas(self)
self.timelineV = Viewer()
self.timelineV.setWidget(self.timelineCanvas)
self.timelineV.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOn)
self.timelineV.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.timeVSize = (0, 0)
self.timelineV.resyzing.connect(self.adjustSize)
self.layersV.verticalScrollBar().valueChanged.connect(
lambda v: self.timelineV.verticalScrollBar().setValue(v))
self.timelineV.verticalScrollBar().valueChanged.connect(
lambda v: self.layersV.verticalScrollBar().setValue(v))
self.project.updateTimelineSign.connect(self.timelineCanvas.update)
self.project.updateTimelineSign.connect(self.layersCanvas.update)
self.project.updateTimelineSizeSign.connect(self.adjustSize)
### adding and deleting layers ###
self.addLayerB = Button("add layer", "icons/layer_add.png",
self.addLayerClicked)
self.dupLayerB = Button("duplicate layer", "icons/layer_dup.png",
self.duplicateLayerClicked)
self.delLayerB = Button("delete layer", "icons/layer_del.png",
self.deleteLayerClicked)
self.mergeLayerB = Button("merge layer", "icons/layer_merge.png",
self.mergeLayerClicked)
self.upLayerB = Button("move up layer", "icons/layer_up.png",
self.upLayerClicked)
self.downLayerB = Button("move down layer", "icons/layer_down.png",
self.downLayerClicked)
### adding and deleting images ###
self.addFrameB = Button("add frame", "icons/frame_add.png",
self.addFrameClicked)
self.dupFrameB = Button("duplicate frame", "icons/frame_dup.png",
self.duplicateFrameClicked)
self.delFrameB = Button("delete frame", "icons/frame_del.png",
self.deleteFrameClicked)
self.clearFrameB = Button("clear frame", "icons/frame_clear.png",
self.clearFrameClicked)
### play the animation ###
self.fpsW = QtGui.QSpinBox(self)
self.fpsW.setValue(self.project.fps)
self.fpsW.setRange(1, 60)
self.fpsW.setSuffix(" fps")
self.project.updateFpsSign.connect(
lambda: self.fpsW.setValue(self.project.fps))
self.fpsW.valueChanged.connect(self.fpsChanged)
self.repeatB = Button("no repeat / repeat", "icons/play_no_repeat.png",
self.repeatClicked)
self.playFrameB = Button("play / pause", "icons/play_play.png",
self.playPauseClicked)
self.playFrameB.state = "play"
### layout ###
layerTools = QtGui.QVBoxLayout()
layerTools.setSpacing(0)
layerTools.addWidget(self.addLayerB)
layerTools.addWidget(self.dupLayerB)
layerTools.addWidget(self.delLayerB)
layerTools.addWidget(self.mergeLayerB)
layerTools.addStretch()
layerTools2 = QtGui.QHBoxLayout()
layerTools2.setSpacing(0)
layerTools2.addWidget(self.upLayerB)
layerTools2.addWidget(self.downLayerB)
canvasTools = QtGui.QHBoxLayout()
canvasTools.setSpacing(0)
canvasTools.addWidget(self.addFrameB)
canvasTools.addWidget(self.dupFrameB)
canvasTools.addWidget(self.delFrameB)
canvasTools.addWidget(self.clearFrameB)
canvasTools.addStretch()
canvasTools.addWidget(self.fpsW)
canvasTools.addWidget(self.repeatB)
canvasTools.addWidget(self.playFrameB)
layout = QtGui.QGridLayout()
layout.setSpacing(4)
layout.addLayout(layerTools, 0, 0)
layout.addWidget(self.layersV, 0, 1)
layout.addWidget(self.timelineV, 0, 2)
layout.addLayout(layerTools2, 1, 1)
layout.addLayout(canvasTools, 1, 2)
self.setLayout(layout)
######## Size adjust ###############################################
def showEvent(self, event):
self.timelineCanvas.setMinimumHeight(
len(self.project.timeline) * 20 + 25)
self.timelineCanvas.update()
self.layersCanvas.setMinimumHeight(self.timelineCanvas.height())
self.layersCanvas.update()
self.layersV.setViewportMargins(
0, 0, 0,
self.timelineV.horizontalScrollBar().height())
self.layersV.setMinimumWidth(self.layersCanvas.width() +
self.layersV.verticalScrollBar().width() +
2)
self.layersV.setMaximumWidth(self.layersCanvas.width() +
self.layersV.verticalScrollBar().width() +
2)
def adjustSize(self, timeVSize=False):
if timeVSize:
self.timeVSize = timeVSize
else:
timeVSize = self.timeVSize
wW = timeVSize[0]
wH = timeVSize[1] - self.timelineV.horizontalScrollBar().height()
timeMin = self.timelineCanvas.getMiniSize()
self.timelineCanvas.setFixedWidth(timeMin[0] + wW -
self.timelineCanvas.frameWidth)
if timeMin[1] > wH - 2:
self.timelineCanvas.setFixedHeight(timeMin[1])
self.layersCanvas.setFixedHeight(timeMin[1])
else:
self.timelineCanvas.setFixedHeight(wH - 2)
self.layersCanvas.setFixedHeight(wH - 2)
self.timelineCanvas.update()
self.layersCanvas.update()
######## Copy ######################################################
def cut(self):
if self.selection:
self.project.saveToUndo("frames")
layer = self.project.timeline[self.selection[0]]
f1, f2 = self.selection[1], self.selection[2]
if f2 < f1:
f1, f2, = f2, f1
# copy frames
self.toPaste = layer[f1:f2 + 1]
# check if first frame is a real canvas
if not self.toPaste[0]:
self.toPaste[0] = layer.getCanvas(f1).copy_()
# check if frame next to selection is a real canvas
nex = layer.getCanvas(f2 + 1)
if nex and nex != layer.getCanvas(f1):
layer[f2 + 1] = nex.copy_()
# delete cutted frames
del layer[f1:f2 + 1]
self.timelineCanvas.update()
def copy(self):
if self.selection:
layer = self.project.timeline[self.selection[0]]
f1, f2 = self.selection[1], self.selection[2]
if f2 < f1:
f1, f2, = f2, f1
# copy frames
self.toPaste = layer[f1:f2 + 1]
# check if first frame is a real canvas
if not self.toPaste[0]:
self.toPaste[0] = layer.getCanvas(f1).copy_()
# make a real copy of all canvas
for n, canvas in enumerate(self.toPaste):
if canvas:
self.toPaste[n] = canvas.copy_()
def paste(self):
if self.toPaste:
self.project.saveToUndo("frames")
f = self.project.curFrame
l = self.project.curLayer
while f > len(self.project.timeline[l]):
self.project.timeline[l].append(0)
for n, canvas in enumerate(self.toPaste):
self.project.timeline[l].insert(f + n, canvas)
self.timelineCanvas.update()
self.project.updateViewSign.emit()
######## Buttons ###################################################
def addFrameClicked(self):
self.project.saveToUndo("frames")
self.project.timeline[self.project.curLayer].insertCanvas(
self.project.curFrame, self.project.makeCanvas())
self.adjustSize()
self.project.updateViewSign.emit()
def duplicateFrameClicked(self):
self.project.saveToUndo("frames")
layer = self.project.timeline[self.project.curLayer]
layer.insertCanvas(self.project.curFrame,
layer.getCanvas(self.project.curFrame).copy_())
self.adjustSize()
self.project.updateViewSign.emit()
def deleteFrameClicked(self):
self.project.saveToUndo("frames")
layer = self.project.timeline[self.project.curLayer]
frame = self.project.curFrame
if frame >= len(layer):
return
if len(layer) == 1 and frame == 0:
layer[frame].clear()
elif layer[frame] and not frame + 1 >= len(layer) and not layer[frame +
1]:
layer.pop(frame + 1)
else:
layer.pop(frame)
self.adjustSize()
self.project.updateViewSign.emit()
def clearFrameClicked(self):
f = self.project.timeline.getCanvas()
if f:
f.clear()
self.project.updateViewSign.emit()
def addLayerClicked(self):
self.project.saveToUndo("frames")
self.project.timeline.insert(self.project.curLayer,
self.project.makeLayer())
self.adjustSize()
self.project.updateViewSign.emit()
def duplicateLayerClicked(self):
self.project.saveToUndo("frames")
layer = self.project.timeline[self.project.curLayer].deepCopy()
layer.name = "%s copy" % (layer.name)
self.project.timeline.insert(self.project.curLayer, layer)
self.adjustSize()
self.project.updateViewSign.emit()
def deleteLayerClicked(self):
self.project.saveToUndo("frames")
del self.project.timeline[self.project.curLayer]
self.project.curLayer = 0
if not self.project.timeline:
self.project.timeline.append(self.project.makeLayer())
self.adjustSize()
self.project.updateViewSign.emit()
def mergeLayerClicked(self):
if not self.project.curLayer < len(self.project.timeline) - 1:
return
self.project.saveToUndo("frames")
layer1 = self.project.timeline[self.project.curLayer + 1]
layer2 = self.project.timeline[self.project.curLayer]
layer3 = self.project.makeLayer(False, True)
layer3.name = layer1.name
for i in range(max(len(layer1), len(layer2))):
if i == len(layer1):
layer3.append(layer2.getCanvas(i).copy_())
elif i == len(layer2):
layer3.append(layer1.getCanvas(i).copy_())
elif i > len(layer1):
if layer2[i]:
layer3.append(layer2[i].copy_())
else:
layer3.append(0)
elif i > len(layer2):
if layer1[i]:
layer3.append(layer1[i].copy_())
else:
layer3.append(0)
elif layer1[i] or layer2[i]:
c = layer1.getCanvas(i).copy_()
c.mergeCanvas(layer2.getCanvas(i))
layer3.append(c)
else:
layer3.append(0)
del self.project.timeline[self.project.curLayer]
self.project.timeline[self.project.curLayer] = layer3
self.adjustSize()
self.project.updateViewSign.emit()
def upLayerClicked(self):
self.project.saveToUndo("frames")
l = self.project.curLayer
f = self.project.timeline
if l > 0:
f[l], f[l - 1] = f[l - 1], f[l]
self.project.curLayer = l - 1
self.project.updateViewSign.emit()
self.project.updateTimelineSign.emit()
def downLayerClicked(self):
self.project.saveToUndo("frames")
l = self.project.curLayer
f = self.project.timeline
if l < len(f) - 1:
f[l], f[l + 1] = f[l + 1], f[l]
self.project.curLayer = l + 1
self.project.updateViewSign.emit()
self.project.updateTimelineSign.emit()
def renameLayer(self, l):
name = self.project.timeline[l].name
nName = RenameLayerDialog(name).getReturn()
if nName:
self.project.saveToUndo("frames")
self.project.timeline[l].name = str(nName)
self.project.updateTimelineSign.emit()
######## Play ######################################################
def fpsChanged(self):
if 0 < self.fpsW.value() < 161:
self.project.fps = self.fpsW.value()
self.timelineCanvas.update()
def repeatClicked(self):
if self.project.loop:
self.repeatB.setIcon(
QtGui.QIcon(QtGui.QPixmap("icons/play_no_repeat.png")))
self.project.loop = False
else:
self.repeatB.setIcon(
QtGui.QIcon(QtGui.QPixmap("icons/play_repeat.png")))
self.project.loop = True
self.project.updateViewSign.emit()
def playPauseClicked(self):
"""play the animation"""
if self.playFrameB.state == 'play':
self.playFrameB.setIcon(
QtGui.QIcon(QtGui.QPixmap("icons/play_pause.png")))
self.playFrameB.state = "stop"
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.animate)
self.f = self.project.curFrame
self.fps = self.project.fps
self.project.playing = True
if self.project.curFrame + 1 >= self.project.timeline.frameVisibleCount(
):
self.project.curFrame = 0
self.timelineCanvas.update()
self.project.updateViewSign.emit()
self.timer.start(1000 // self.fps)
elif self.playFrameB.state == 'stop':
self.playEnd()
def playEnd(self):
self.timer.stop()
self.playFrameB.state = "play"
self.playFrameB.setIcon(
QtGui.QIcon(QtGui.QPixmap("icons/play_play.png")))
self.project.playing = False
self.project.updateViewSign.emit()
def animate(self):
if self.fps != self.project.fps:
self.fps = self.project.fps
self.timer.setInterval(1000 // self.fps)
self.f = self.project.curFrame + 1
if self.f < self.project.timeline.frameVisibleCount():
self.project.curFrame = self.f
self.timelineCanvas.update()
self.project.updateViewSign.emit()
else:
if self.project.loop:
self.project.curFrame = 0
self.timelineCanvas.update()
self.project.updateViewSign.emit()
else:
self.playEnd()
def main(self):
# Buttons for cards in home screen
blue = Button(black, 145, 295, 110, 160)
gray = Button(black, 295, 295, 110, 160)
green = Button(black, 445, 295, 110, 160)
# Custom Bet Input
slider = Slider(self.win, 250, 250, 200, 40, min=1, max=500, step=1, handleRadius=25)
outputText = TextBox(self.win, 315, 325, 70, 50, fontSize=30)
# Buttons for Bet Selection
minButton = Button(white, 190, 400, 100, 50, 'MIN')
maxButton = Button(white, 410, 400, 100, 50, 'MAX')
customButton = Button(white, 300, 400, 100, 50, "CUSTOM")
# Buttons for Game Selection
hitButton = Button(white, 600, 150, 90, 50, 'HIT')
standButton = Button(white, 600, 250, 90, 50, 'STAND')
splitButton = Button(white, 600, 350, 90, 50, 'SPLIT')
doubleButton = Button(white, 600, 450, 90, 50, 'DOUBLE')
back = ''
state = 0
# Game Class
blackjack = Blackjack()
user = blackjack.user
dealer = blackjack.dealer
run = True
while run:
events = pygame.event.get()
for event in events:
pos = pygame.mouse.get_pos()
if event.type == pygame.QUIT:
run = False
self.checkHover(blue, gray, green, minButton, maxButton, customButton, hitButton, standButton, splitButton, doubleButton, pos)
if event.type == pygame.MOUSEBUTTONDOWN:
if state == 0:
if blue.isOver(pos):
back = pygame.transform.scale(blueCard, (80, 110))
elif gray.isOver(pos):
back = pygame.transform.scale(grayCard, (80, 110))
elif green.isOver(pos):
back = pygame.transform.scale(greenCard, (80, 110))
else:
break
state = 1
self.fade()
blackjack.deckOfCards.shuffle()
elif state == 1:
bet = 0
if minButton.isOver(pos):
bet = 1
elif maxButton.isOver(pos):
bet = 500
elif customButton.isOver(pos):
bet = slider.getValue()
else:
break
state = 2
blackjack.place_bet(bet)
blackjack.deal_start_cards()
self.display_first_cards(user, dealer, back, blackjack)
elif state == 2:
if hitButton.isOver(pos):
blackjack.hit()
elif standButton.isOver(pos):
blackjack.stand()
elif doubleButton.isOver(pos):
blackjack.double()
elif splitButton.isOver(pos):
pass
else:
break
if state == 0:
self.display_homescreen(blue, gray, green)
elif state == 1:
slider.listen(events)
blackjack.set_status('user')
self.display_betting(user.balance, slider, outputText, minButton, maxButton, customButton, back)
elif state == 2:
self.display_game(blackjack, user, dealer, back, hitButton, standButton, splitButton, doubleButton)
self.display_status(blackjack)
stat = blackjack.get_status()
if stat == 'user':
blackjack.check_blackjack()
elif stat == 'dealer':
self.display_status(blackjack)
self.dealer_turn(blackjack)
elif stat == 'reset' or stat == 'over' or stat == 'dealerbust' or stat == 'won' or stat == 'lost':
state = 1
self.display_status(blackjack)
pygame.display.update()
blackjack.reset_game()
pygame.time.delay(2500)
pygame.display.update()
def __init__(self, project):
QtGui.QWidget.__init__(self)
self.project = project
self.selection = False
self.toPaste = False
### viewer ###
self.layersCanvas = LayersCanvas(self)
self.layersV = Viewer()
self.layersV.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.layersV.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.layersV.setWidget(self.layersCanvas)
self.timelineCanvas = TimelineCanvas(self)
self.timelineV = Viewer()
self.timelineV.setWidget(self.timelineCanvas)
self.timelineV.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOn)
self.timelineV.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.timeVSize = (0, 0)
self.timelineV.resyzing.connect(self.adjustSize)
self.layersV.verticalScrollBar().valueChanged.connect(
lambda v: self.timelineV.verticalScrollBar().setValue(v))
self.timelineV.verticalScrollBar().valueChanged.connect(
lambda v: self.layersV.verticalScrollBar().setValue(v))
self.project.updateTimelineSign.connect(self.timelineCanvas.update)
self.project.updateTimelineSign.connect(self.layersCanvas.update)
self.project.updateTimelineSizeSign.connect(self.adjustSize)
### adding and deleting layers ###
self.addLayerB = Button("add layer", "icons/layer_add.png",
self.addLayerClicked)
self.dupLayerB = Button("duplicate layer", "icons/layer_dup.png",
self.duplicateLayerClicked)
self.delLayerB = Button("delete layer", "icons/layer_del.png",
self.deleteLayerClicked)
self.mergeLayerB = Button("merge layer", "icons/layer_merge.png",
self.mergeLayerClicked)
self.upLayerB = Button("move up layer", "icons/layer_up.png",
self.upLayerClicked)
self.downLayerB = Button("move down layer", "icons/layer_down.png",
self.downLayerClicked)
### adding and deleting images ###
self.addFrameB = Button("add frame", "icons/frame_add.png",
self.addFrameClicked)
self.dupFrameB = Button("duplicate frame", "icons/frame_dup.png",
self.duplicateFrameClicked)
self.delFrameB = Button("delete frame", "icons/frame_del.png",
self.deleteFrameClicked)
self.clearFrameB = Button("clear frame", "icons/frame_clear.png",
self.clearFrameClicked)
### play the animation ###
self.fpsW = QtGui.QSpinBox(self)
self.fpsW.setValue(self.project.fps)
self.fpsW.setRange(1, 60)
self.fpsW.setSuffix(" fps")
self.project.updateFpsSign.connect(
lambda: self.fpsW.setValue(self.project.fps))
self.fpsW.valueChanged.connect(self.fpsChanged)
self.repeatB = Button("no repeat / repeat", "icons/play_no_repeat.png",
self.repeatClicked)
self.playFrameB = Button("play / pause", "icons/play_play.png",
self.playPauseClicked)
self.playFrameB.state = "play"
### layout ###
layerTools = QtGui.QVBoxLayout()
layerTools.setSpacing(0)
layerTools.addWidget(self.addLayerB)
layerTools.addWidget(self.dupLayerB)
layerTools.addWidget(self.delLayerB)
layerTools.addWidget(self.mergeLayerB)
layerTools.addStretch()
layerTools2 = QtGui.QHBoxLayout()
layerTools2.setSpacing(0)
layerTools2.addWidget(self.upLayerB)
layerTools2.addWidget(self.downLayerB)
canvasTools = QtGui.QHBoxLayout()
canvasTools.setSpacing(0)
canvasTools.addWidget(self.addFrameB)
canvasTools.addWidget(self.dupFrameB)
canvasTools.addWidget(self.delFrameB)
canvasTools.addWidget(self.clearFrameB)
canvasTools.addStretch()
canvasTools.addWidget(self.fpsW)
canvasTools.addWidget(self.repeatB)
canvasTools.addWidget(self.playFrameB)
layout = QtGui.QGridLayout()
layout.setSpacing(4)
layout.addLayout(layerTools, 0, 0)
layout.addWidget(self.layersV, 0, 1)
layout.addWidget(self.timelineV, 0, 2)
layout.addLayout(layerTools2, 1, 1)
layout.addLayout(canvasTools, 1, 2)
self.setLayout(layout)
def __init__(self,
app,
obj=None,
title=None,
browse=False,
on_import=None,
geometry=None):
tk.Toplevel.__init__(self, app, background=Color.BLACK)
if geometry:
self.geometry(geometry)
self.protocol("WM_DELETE_WINDOW", self._on_close)
if obj:
self.title(title or classname(obj))
self.doc = Doc(self, obj, run_code=app.console.prompt.push)
self.doc.pack(fill="both", expand=True)
return
self.app = app
self.on_import = on_import
self.menu = Menu(self)
self.paned_window = ttk.PanedWindow(self, orient="horizontal")
self.notebook = Notebook(self, has_labels=True)
self.installed_pkgs = Treeview(self, self)
self.builtin_pkgs = Treeview(self, self)
self.notebook.add("Built In", self.builtin_pkgs)
self.notebook.add("Installed", self.installed_pkgs)
self.doc = Doc(self,
has_sidebar=True,
run_code=app.console.prompt.push)
frame = tk.Frame(self)
input_area = tk.Frame(frame, background=Color.BLACK)
name_label = tk.Label(input_area,
text="import ",
font="Menlo 14",
background=Color.BLACK,
foreground=Color.WHITE)
self.name_entry = tk.Entry(input_area,
font="Monospace 14",
highlightbackground=Color.BLACK)
input_area_2 = tk.Frame(frame, background=Color.BLACK)
as_label = tk.Label(input_area_2,
text=" as ",
font="Menlo 14",
background=Color.BLACK,
foreground=Color.WHITE)
self.as_entry = tk.Entry(input_area_2,
font="Monospace 14",
highlightbackground=Color.BLACK)
btn_area = tk.Frame(frame, background=Color.BLACK)
cancel_btn = Button(btn_area, text="Cancel", command=self.destroy)
self.ok_btn = Button(btn_area, text="Ok", command=self._on_ok)
for i in INSTALLED_PKGS:
self.installed_pkgs.insert("", "end", i, text=str(i).split(" ")[0])
for j in BUILTIN_PKGS:
self.builtin_pkgs.insert("", "end", j, text=j)
if on_import:
self.notebook.frame.pack(fill="both", expand=True)
frame.pack(side="left", fill="both", expand=True)
self.name_entry.focus()
else:
self.paned_window.add(self.notebook.frame)
self.paned_window.add(self.doc)
self.paned_window.pack(side="left", fill="both", expand=True)
if on_import:
cancel_btn.pack(side="left",
fill="x",
expand=True,
anchor="center",
padx=4,
pady=4)
self.ok_btn.pack(side="left",
fill="x",
expand=True,
anchor="center",
padx=4,
pady=4)
btn_area.pack(side="bottom", fill="both")
input_area_2.pack(side="bottom", fill="both")
as_label.pack(side="left")
self.as_entry.pack(side="left", expand=True)
input_area.pack(side="bottom", fill="both")
name_label.pack(side="left")
self.name_entry.pack(side="left", expand=True)
self.bind("<Return>", self._on_ok)
self.bind("<Escape>", lambda event: self.destroy())
else:
self.doc.paned_window.bind("<Configure>", self._on_configure_doc)
for i in ("installed_pkgs", "builtin_pkgs"):
getattr(self, i).bind(
"<<TreeviewSelect>>",
lambda event, key=i: self._on_selection(event, key))
getattr(self, i).bind(
BUTTON_RIGHT,
lambda event, key=i: self._on_button_right(event, key))
class Browser(tk.Toplevel):
def __init__(self,
app,
obj=None,
title=None,
browse=False,
on_import=None,
geometry=None):
tk.Toplevel.__init__(self, app, background=Color.BLACK)
if geometry:
self.geometry(geometry)
self.protocol("WM_DELETE_WINDOW", self._on_close)
if obj:
self.title(title or classname(obj))
self.doc = Doc(self, obj, run_code=app.console.prompt.push)
self.doc.pack(fill="both", expand=True)
return
self.app = app
self.on_import = on_import
self.menu = Menu(self)
self.paned_window = ttk.PanedWindow(self, orient="horizontal")
self.notebook = Notebook(self, has_labels=True)
self.installed_pkgs = Treeview(self, self)
self.builtin_pkgs = Treeview(self, self)
self.notebook.add("Built In", self.builtin_pkgs)
self.notebook.add("Installed", self.installed_pkgs)
self.doc = Doc(self,
has_sidebar=True,
run_code=app.console.prompt.push)
frame = tk.Frame(self)
input_area = tk.Frame(frame, background=Color.BLACK)
name_label = tk.Label(input_area,
text="import ",
font="Menlo 14",
background=Color.BLACK,
foreground=Color.WHITE)
self.name_entry = tk.Entry(input_area,
font="Monospace 14",
highlightbackground=Color.BLACK)
input_area_2 = tk.Frame(frame, background=Color.BLACK)
as_label = tk.Label(input_area_2,
text=" as ",
font="Menlo 14",
background=Color.BLACK,
foreground=Color.WHITE)
self.as_entry = tk.Entry(input_area_2,
font="Monospace 14",
highlightbackground=Color.BLACK)
btn_area = tk.Frame(frame, background=Color.BLACK)
cancel_btn = Button(btn_area, text="Cancel", command=self.destroy)
self.ok_btn = Button(btn_area, text="Ok", command=self._on_ok)
for i in INSTALLED_PKGS:
self.installed_pkgs.insert("", "end", i, text=str(i).split(" ")[0])
for j in BUILTIN_PKGS:
self.builtin_pkgs.insert("", "end", j, text=j)
if on_import:
self.notebook.frame.pack(fill="both", expand=True)
frame.pack(side="left", fill="both", expand=True)
self.name_entry.focus()
else:
self.paned_window.add(self.notebook.frame)
self.paned_window.add(self.doc)
self.paned_window.pack(side="left", fill="both", expand=True)
if on_import:
cancel_btn.pack(side="left",
fill="x",
expand=True,
anchor="center",
padx=4,
pady=4)
self.ok_btn.pack(side="left",
fill="x",
expand=True,
anchor="center",
padx=4,
pady=4)
btn_area.pack(side="bottom", fill="both")
input_area_2.pack(side="bottom", fill="both")
as_label.pack(side="left")
self.as_entry.pack(side="left", expand=True)
input_area.pack(side="bottom", fill="both")
name_label.pack(side="left")
self.name_entry.pack(side="left", expand=True)
self.bind("<Return>", self._on_ok)
self.bind("<Escape>", lambda event: self.destroy())
else:
self.doc.paned_window.bind("<Configure>", self._on_configure_doc)
for i in ("installed_pkgs", "builtin_pkgs"):
getattr(self, i).bind(
"<<TreeviewSelect>>",
lambda event, key=i: self._on_selection(event, key))
getattr(self, i).bind(
BUTTON_RIGHT,
lambda event, key=i: self._on_button_right(event, key))
def _on_configure_doc(self, event):
self.doc.paned_window.sashpos(0, 0)
self.doc.paned_window.unbind("<Configure>")
def _on_selection(self, event, name):
key = getattr(self, name).selection()[0]
self.doc.clear()
if self.on_import:
self.name_entry.delete(0, "end")
self.name_entry.insert("end", key)
return
try:
module = __import__(key)
except:
return
self.doc.show(module)
def _on_close(self):
help.geometry = self.geometry()
self.destroy()
def _on_ok(self, event=None):
name = self.name_entry.get()
if not name:
builtin_print("\a")
return
if self.on_import:
self.on_import(self.name_entry.get(), self.as_entry.get())
self.destroy()
def _on_button_right(self, event, name):
attr = getattr(self, name)
key = attr.identify_row(event.y)
attr.selection_set(key)
if self.on_import:
try:
module = __import__(key)
except:
return
items = [{"label": "View Doc", "command": lambda: help(module)}]
else:
items = [{
"label":
"Import Module",
"command":
lambda: self.app.menu.import_module(key, open_folders=True)
}]
self.menu.set_menu(items)
self.menu.show(event)
