falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Browse Source

Update CanvasMiniPreview code

tags/v0.9.0
falkTX 12 years ago
parent
a6cfdf1eba
commit
2aa7a8f3f6
2 changed files with 96 additions and 86 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +94
    -84
      src/canvaspreviewframe.py
  2. +2
    -2
      src/claudia.py

+ 94
- 84
src/canvaspreviewframe.py View File

@@ -1,171 +1,181 @@
#!/usr/bin/env python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Custom Mini Canvas Preview, a custom Qt4 widget
# Copyright (C) 2011-2012 Filipe Coelho <falktx@falktx.com>
# Copyright (C) 2011-2013 Filipe Coelho <falktx@falktx.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# any later version.
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of
# the License, or any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# For a full copy of the GNU General Public License see the COPYING file

# ------------------------------------------------------------------------------------------------------------
# Imports (Global)

from PyQt4.QtCore import Qt, QRectF, QTimer, SIGNAL, SLOT
from PyQt4.QtGui import QBrush, QColor, QCursor, QFrame, QPainter, QPen

# ------------------------------------------------------------------------------------------------------------
# Static Variables

iX = 0
iY = 1
iWidth = 2
iHeight = 3

# ------------------------------------------------------------------------------------------------------------
# Widget Class

class CanvasPreviewFrame(QFrame):
def __init__(self, parent):
QFrame.__init__(self, parent)

self.m_mouseDown = False
self.fMouseDown = False

self.m_viewbrush = QBrush(QColor(75, 75, 255, 30))
self.m_viewpen = QPen(Qt.blue, 1)
self.fViewBg = QColor(0, 0, 0)
self.fViewBrush = QBrush(QColor(75, 75, 255, 30))
self.fViewPen = QPen(Qt.blue, 1)

self.scale = 1.0
self.scene = None
self.real_parent = None
self.fake_width = 0
self.fake_height = 0
self.fScale = 1.0
self.fScene = None
self.fRealParent = None
self.fFakeWidth = 0.0
self.fFakeHeight = 0.0

self.render_source = self.getRenderSource()
self.render_target = QRectF(0, 0, 0, 0)
self.fRenderSource = self.getRenderSource()
self.fRenderTarget = QRectF(0, 0, 0, 0)

self.view_pad_x = 0.0
self.view_pad_y = 0.0
self.view_rect = [0.0, 0.0, 10.0, 10.0]
self.fViewPadX = 0.0
self.fViewPadY = 0.0
self.fViewRect = [0.0, 0.0, 10.0, 10.0]

def init(self, scene, real_width, real_height):
self.scene = scene
self.fake_width = float(real_width) / 15
self.fake_height = float(real_height) / 15
def init(self, scene, realWidth, realHeight):
padding = 6

self.setMinimumSize(self.fake_width, self.fake_height)
self.setMaximumSize(self.fake_width * 4, self.fake_height)
self.fScene = scene
self.fFakeWidth = float(realWidth) / 15
self.fFakeHeight = float(realHeight) / 15

self.render_target.setWidth(real_width)
self.render_target.setHeight(real_height)
self.setMinimumSize(self.fFakeWidth+padding, self.fFakeHeight+padding)
self.setMaximumSize(self.fFakeWidth*4+padding, self.fFakeHeight+padding)

self.fRenderTarget.setWidth(realWidth)
self.fRenderTarget.setHeight(realHeight)

def setRealParent(self, parent):
self.real_parent = parent
self.fRealParent = parent

def getRenderSource(self):
x_pad = (self.width() - self.fake_width) / 2
y_pad = (self.height() - self.fake_height) / 2
return QRectF(x_pad, y_pad, self.fake_width, self.fake_height)
xPadding = (float(self.width()) - self.fFakeWidth) / 2.0
yPadding = (float(self.height()) - self.fFakeHeight) / 2.0
return QRectF(xPadding, yPadding, self.fFakeWidth, self.fFakeHeight)

def setViewPosX(self, xp):
x = xp * self.fake_width
x_ratio = (x / self.fake_width) * self.view_rect[iWidth] / self.scale
self.view_rect[iX] = x - x_ratio + self.render_source.x()
x = self.fFakeWidth*xp
xRatio = (x / self.fFakeWidth) * self.fViewRect[iWidth] / self.fScale
self.fViewRect[iX] = x - xRatio + self.fRenderSource.x()
self.update()

def setViewPosY(self, yp):
y = yp * self.fake_height
y_ratio = (y / self.fake_height) * self.view_rect[iHeight] / self.scale
self.view_rect[iY] = y - y_ratio + self.render_source.y()
y = self.fFakeHeight*yp
yRatio = (y / self.fFakeHeight) * self.fViewRect[iHeight] / self.fScale
self.fViewRect[iY] = y - yRatio + self.fRenderSource.y()
self.update()

def setViewScale(self, scale):
self.scale = scale
QTimer.singleShot(0, self.real_parent, SLOT("slot_miniCanvasCheckAll()"))

def setViewSize(self, width_p, height_p):
width = width_p * self.fake_width
height = height_p * self.fake_height
self.view_rect[iWidth] = width
self.view_rect[iHeight] = height
self.fScale = scale
QTimer.singleShot(0, self.fRealParent, SLOT("slot_miniCanvasCheckAll()"))

def setViewSize(self, width, height):
self.fViewRect[iWidth] = width * self.fFakeWidth
self.fViewRect[iHeight] = height * self.fFakeHeight
self.update()

def setViewTheme(self, brushColor, penColor):
def setViewTheme(self, bgColor, brushColor, penColor):
brushColor.setAlpha(40)
penColor.setAlpha(100)
self.m_viewbrush = QBrush(brushColor)
self.m_viewpen = QPen(penColor, 1)
self.fViewBg = bgColor
self.fViewBrush = QBrush(brushColor)
self.fViewPen = QPen(penColor, 1)

def handleMouseEvent(self, event_x, event_y):
x = float(event_x) - self.render_source.x() - (self.view_rect[iWidth] / self.scale / 2)
y = float(event_y) - self.render_source.y() - (self.view_rect[iHeight] / self.scale / 2)
def handleMouseEvent(self, eventX, eventY):
x = float(eventX) - self.fRenderSource.x() - (self.fViewRect[iWidth] / self.fScale / 2)
y = float(eventY) - self.fRenderSource.y() - (self.fViewRect[iHeight] / self.fScale / 2)

max_width = self.view_rect[iWidth] / self.scale
max_height = self.view_rect[iHeight] / self.scale
maxWidth = self.fViewRect[iWidth] / self.fScale
maxHeight = self.fViewRect[iHeight] / self.fScale

if max_width > self.fake_width:
max_width = self.fake_width
if max_height > self.fake_height:
max_height = self.fake_height
if maxWidth > self.fFakeWidth:
maxWidth = self.fFakeWidth
if maxHeight > self.fFakeHeight:
maxHeight = self.fFakeHeight

if x < 0.0:
x = 0.0
elif x > self.fake_width - max_width:
x = self.fake_width - max_width
elif x > self.fFakeWidth - maxWidth:
x = self.fFakeWidth - maxWidth

if y < 0.0:
y = 0.0
elif y > self.fake_height - max_height:
y = self.fake_height - max_height
elif y > self.fFakeHeight - maxHeight:
y = self.fFakeHeight - maxHeight

self.view_rect[iX] = x + self.render_source.x()
self.view_rect[iY] = y + self.render_source.y()
self.fViewRect[iX] = x + self.fRenderSource.x()
self.fViewRect[iY] = y + self.fRenderSource.y()
self.update()

self.emit(SIGNAL("miniCanvasMoved(double, double)"), x * self.scale / self.fake_width, y * self.scale / self.fake_height)
self.emit(SIGNAL("miniCanvasMoved(double, double)"), x * self.fScale / self.fFakeWidth, y * self.fScale / self.fFakeHeight)

def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_mouseDown = True
self.fMouseDown = True
self.setCursor(QCursor(Qt.SizeAllCursor))
self.handleMouseEvent(event.x(), event.y())
event.accept()

def mouseMoveEvent(self, event):
if self.m_mouseDown:
if self.fMouseDown:
self.handleMouseEvent(event.x(), event.y())
event.accept()

def mouseReleaseEvent(self, event):
if self.m_mouseDown:
if self.fMouseDown:
self.setCursor(QCursor(Qt.ArrowCursor))
self.m_mouseDown = False
self.fMouseDown = False
QFrame.mouseReleaseEvent(self, event)

def paintEvent(self, event):
painter = QPainter(self)

painter.setBrush(QBrush(Qt.darkBlue, Qt.DiagCrossPattern))
painter.drawRect(0, 0, self.width(), self.height())
painter.setBrush(self.fViewBg)
painter.setPen(self.fViewBg)
painter.drawRoundRect(2, 2, self.width()-6, self.height()-6, 3, 3)

self.scene.render(painter, self.render_source, self.render_target, Qt.KeepAspectRatio)
self.fScene.render(painter, self.fRenderSource, self.fRenderTarget, Qt.KeepAspectRatio)

max_width = self.view_rect[iWidth] / self.scale
max_height = self.view_rect[iHeight] / self.scale
maxWidth = self.fViewRect[iWidth] / self.fScale
maxHeight = self.fViewRect[iHeight] / self.fScale

if max_width > self.fake_width:
max_width = self.fake_width
if max_height > self.fake_height:
max_height = self.fake_height
if maxWidth > self.fFakeWidth:
maxWidth = self.fFakeWidth
if maxHeight > self.fFakeHeight:
maxHeight = self.fFakeHeight

painter.setBrush(self.m_viewbrush)
painter.setPen(self.m_viewpen)
painter.drawRect(self.view_rect[iX], self.view_rect[iY], max_width, max_height)
painter.setBrush(self.fViewBrush)
painter.setPen(self.fViewPen)
painter.drawRect(self.fViewRect[iX], self.fViewRect[iY], maxWidth, maxHeight)

QFrame.paintEvent(self, event)

def resizeEvent(self, event):
self.render_source = self.getRenderSource()
if self.real_parent:
QTimer.singleShot(0, self.real_parent, SLOT("slot_miniCanvasCheckAll()"))
self.fRenderSource = self.getRenderSource()
if self.fRealParent:
QTimer.singleShot(0, self.fRealParent, SLOT("slot_miniCanvasCheckAll()"))
QFrame.resizeEvent(self, event)

+ 2
- 2
src/claudia.py View File

@@ -729,7 +729,7 @@ class ClaudiaMainW(AbstractCanvasJackClass, ui_claudia.Ui_ClaudiaMainW):
# Set-up Canvas Preview

self.miniCanvasPreview.setRealParent(self)
self.miniCanvasPreview.setViewTheme(patchcanvas.canvas.theme.rubberband_brush, patchcanvas.canvas.theme.rubberband_pen.color())
self.miniCanvasPreview.setViewTheme(patchcanvas.canvas.theme.canvas_bg, patchcanvas.canvas.theme.rubberband_brush, patchcanvas.canvas.theme.rubberband_pen.color())
self.miniCanvasPreview.init(self.scene, DEFAULT_CANVAS_WIDTH, DEFAULT_CANVAS_HEIGHT)
QTimer.singleShot(100, self, SLOT("slot_miniCanvasInit()"))

@@ -2561,7 +2561,7 @@ class ClaudiaMainW(AbstractCanvasJackClass, ui_claudia.Ui_ClaudiaMainW):
patchcanvas.setFeatures(pFeatures)
patchcanvas.init("Claudia", self.scene, self.canvasCallback, DEBUG)

self.miniCanvasPreview.setViewTheme(patchcanvas.canvas.theme.rubberband_brush, patchcanvas.canvas.theme.rubberband_pen.color())
self.miniCanvasPreview.setViewTheme(patchcanvas.canvas.theme.canvas_bg, patchcanvas.canvas.theme.rubberband_brush, patchcanvas.canvas.theme.rubberband_pen.color())

if DBus.ladish_control.IsStudioLoaded() and DBus.ladish_studio and DBus.ladish_studio.IsStarted():
self.init_ports()


Write Preview
Loading…
Cancel
Save