def paint(self, painter, option, index):
"""
Overloads the base paint method for a QItemDelegate
to force the overlay color options to be drawn.
:param painter:
:type <QPainter>:
:param option:
:type <QStyleOptionViewItem>:
:param index:
:type <QModelIndex>:
"""
self.drawBackground(painter, option, index)
# extract the option's frame range information
key = index.data(Qt.UserRole).toString()
if not key:
return
pixmap = QPixmap()
# restore the pixmap from cache
if not QPixmapCache.find(key, pixmap):
pixmap.load(settings.iconCachePath("%s.jpg" % key))
QPixmapCache.insert(key, pixmap)
# draw the overlay
painter.drawPixmap(option.rect, pixmap)
class LabelCompartilharImagemRemoto(QLabel):
def __init__(self, ip, parent=None):
super().__init__(parent)
self.setAcceptDrops(True)
self.setText("Arraste e solte uma imagem aqui")
self._pixmap = None
self._servicoCompartilhar = CompartilharImagemRemoto()
self._servicoCompartilhar.setPara(ip)
self._servicoCompartilhar.imagemRecebida.connect(self._mostrarImagem)
def _mostrarImagem(self, imagem):
self.setPixmap(imagem)
def dragEnterEvent(self, event):
if event.mimeData().hasUrls():
url = event.mimeData().urls()[0].toString().strip("file:///")
self._pixmap = QPixmap()
self._pixmap.load(url)
if not self._pixmap.isNull():
event.acceptProposedAction()
def dropEvent(self, event):
#self.setPixmap(self._pixmap)
self._servicoCompartilhar.enviarImagem(self._pixmap)
def png(nom):
u"""Charge l'image <nom>.png depuis le repertoire 'images/'.
L'image doit être au format png, et son nom doit indiqué sans l'extension '.png'."""
pixmap = QPixmap()
pixmap.load(png_pth(nom), 'PNG')
return pixmap
def paint(self, painter, option, index):
"""
Overloads the base paint method for a QItemDelegate
to force the overlay color options to be drawn.
:param painter:
:type <QPainter>:
:param option:
:type <QStyleOptionViewItem>:
:param index:
:type <QModelIndex>:
"""
self.drawBackground(painter, option, index)
# extract the option's frame range information
key = index.data(Qt.UserRole).toString()
if (not key):
return
pixmap = QPixmap()
# restore the pixmap from cache
if (not QPixmapCache.find(key, pixmap)):
pixmap.load(settings.iconCachePath('%s.jpg' % key))
QPixmapCache.insert(key, pixmap)
# draw the overlay
painter.drawPixmap(option.rect, pixmap)
def drawOverlay(self, painter, option, index):
"""
Paints the overlay color for this item if the current thumbnail
based on whether or not it is the latest thumbnail available
:param painter:
:type <QPainter>:
:param option:
:param <QStyleOptionItem>:
:param index:
:type <QModelIndex>:
"""
# extract the option's frame range information
key = index.data(Qt.UserRole).toString()
if (not key):
return
pixmap = QPixmap()
# restore the pixmap from cache
if (not QPixmapCache.find(key, pixmap)):
pixmap.load(settings.iconCachePath('%s.jpg' % key))
QPixmapCache.insert(key, pixmap)
# draw the overlay
painter.drawPixmap(option.rect, pixmap)
def __filesListReceived_(self):
"""Called when the files listing of the current folder has arrived"""
if config.DEBUG_GUI:
print "<-- Received files listing"
self.__scanned_files_ = self.__scanner_.files
# Add the files to the list and request their previews
if len(self.__scanned_files_) != 0:
# Sort by filename (wich is also by date)
filenames = self.__scanned_files_.keys()
filenames.sort()
# Create the Waiting for preview pixmap
pixmap = QPixmap()
pixmap.load(config.WAITING_PREVIEW_FILENAME)
self.__add_black_border_(pixmap)
# Add the files to the list
for filename in filenames:
self.__basewidget_.imageList.addItem(QListWidgetItem(QIcon(pixmap), filename))
# Request the previews
if config.DEBUG_GUI:
print "--> Requesting previews"
self.__scanner_.getPreviews(filenames)
else:
self.__unlock_()
def drawImage (self, uri):
uri = IMAGES_DIR + "/" + str(uri)
image = QPixmap()
image.load(uri)
self.ui_.img.setPixmap(image)
print uri
def showFeatureDetail(self, errMsg, theFeature):
strFeatureInfo = self.getFeatureInfoString(theFeature)
self.textEditFeatureInfo.setText(strFeatureInfo)
if self.mIsMyFeature(theFeature) == False:
return
errMsg = ['']
day_pic = theFeature.attribute('day_pic')
arrowimg = theFeature.attribute('arrowimg')
basePath = r"\\tangpinghui\20151010_nostra_junctionview\output_jpg_and_png"
day_pic_path = os.path.join(basePath, day_pic + ".psd\Main_Day.jpg")
arrowimg_path = ''
tempPath = os.path.join(basePath, day_pic + ".psd")
for curDir, subDirs, fileNames in os.walk(tempPath):
for oneFile in fileNames:
if oneFile.find(arrowimg) != -1 and oneFile.find('_en') != -1:
arrowimg_path = os.path.join(curDir, oneFile)
self.mPixmapList = []
patternPixmap = QPixmap()
patternPixmap.load(day_pic_path)
self.mPixmapList.append(patternPixmap)
arrowPixmap = QPixmap()
arrowPixmap.load(arrowimg_path)
self.mPixmapList.append(arrowPixmap)
self.showImageInGraphicsView()
return
def __previewReceived_(self, filename):
"""Received when a preview has been received
@param filename: The filename of the preview
@type filename: str
"""
if config.DEBUG_GUI:
print "<-- Preview received:", filename
filename = str(filename)
preview = self.__scanner_.previews[filename]
del self.__scanner_.previews[filename]
# Create the pixmap item
pixmap = QPixmap()
if preview == None:
pixmap.load(config.NO_PREVIEW_FILENAME)
else:
pixmap.loadFromData(preview)
# Add a black border
self.__add_black_border_(pixmap)
# Add the new icon to the list
items = self.__basewidget_.imageList.findItems(filename, Qt.MatchExactly)
items[0].setIcon(QIcon(pixmap))
def set_file(self, file_path):
self.clear()
self.file_path = file_path
if file_path and os.path.exists(file_path):
pix_map = QPixmap()
if file_path.endswith('.jpg'):
jpg_data = read(file_path)
str_io = StringIO.StringIO(jpg_data)
img = Image.open(str_io)
img.thumbnail((300,300), Image.ANTIALIAS)
png_data = StringIO.StringIO()
mode = img.mode
if mode not in ('L', 'RGB'):
if mode == 'RGBA':
alpha = img.split()[3]
bg_mask = alpha.point(lambda x: 255 - x)
img = img.convert('RGB')
img.paste((255, 255, 255), None, bg_mask)
else:
img = img.convert('RGB')
img.save(png_data, format='png')
pix_map.loadFromData(QtCore.QByteArray(png_data.getvalue()))
else:
pix_map.load(file_path)
self.addPixmap(pix_map)
def drawOverlay(self, painter, option, index):
"""
Paints the overlay color for this item if the current thumbnail
based on whether or not it is the latest thumbnail available
:param painter:
:type <QPainter>:
:param option:
:param <QStyleOptionItem>:
:param index:
:type <QModelIndex>:
"""
# extract the option's frame range information
key = index.data(Qt.UserRole).toString()
if not key:
return
pixmap = QPixmap()
# restore the pixmap from cache
if not QPixmapCache.find(key, pixmap):
pixmap.load(settings.iconCachePath("%s.jpg" % key))
QPixmapCache.insert(key, pixmap)
# draw the overlay
painter.drawPixmap(option.rect, pixmap)
def data(self, index, role):
#
if role == Qt.BackgroundColorRole and (
index.column() == self.ColumnID.Fix
or index.column() == self.ColumnID.FixIcon):
row = index.row()
value = self._elements[row]
if value.isFixed:
color = QColor(Qt.red)
color.setAlphaF(0.5)
return QVariant(color)
if role == Qt.DisplayRole and index.column() == self.ColumnID.Text:
row = index.row()
value = self._elements[row]
return value.density
if role == Qt.DisplayRole and index.column() == self.ColumnID.Fix:
row = index.row()
value = self._elements[row]
return value.fixvalue
if role == Qt.DecorationRole and index.column() == self.ColumnID.Color:
row = index.row()
value = self._elements[row]
pixmap = QPixmap(_NPIXELS, _NPIXELS)
pixmap.fill(value.color)
icon = QIcon(pixmap)
return icon
if role == Qt.DecorationRole and index.column(
) == self.ColumnID.FixIcon:
row = index.row()
value = self._elements[row]
pixmap = QPixmap(_NPIXELS, _NPIXELS)
if value.isFixed:
iconpath = os.path.join(
os.path.split(__file__)[0], 'icons/lock-edit-icon-32.png')
else:
iconpath = os.path.join(
os.path.split(__file__)[0], 'icons/lock_open-32.png')
pixmap.load(iconpath)
icon = QIcon(pixmap)
return icon
return super(BoxListModel, self).data(index, role)
def displayIcon(self, summoner_name):
iconName = self.summoner.getIcon(summoner_name)
iconPixmap = QPixmap()
self.icon_label.setStyleSheet(
"QLabel {border-style: outset; border-width: 3px; border-color: gold}"
)
try:
iconPixmap.loadFromData(
self.summoner.getImage('profileicon', iconName))
self.icon_label.setPixmap(iconPixmap)
except RiotError:
iconPixmap.load("./images/no_image.png")
self.icon_label.setPixmap(iconPixmap)
def _load_icon(filename, backgroundColor, width, height):
foreground = QPixmap()
foreground.load(filename)
pixmap = QPixmap(foreground.size())
pixmap.fill(backgroundColor)
painter = QPainter()
painter.begin(pixmap)
painter.drawPixmap(QPointF(0, 0), foreground)
painter.end()
pixmap = pixmap.scaled(QSize(width, height), Qt.KeepAspectRatio, Qt.SmoothTransformation)
return pixmap
def data(self, index, role):
#
if role == Qt.BackgroundColorRole and (index.column() == self.ColumnID.Fix or index.column() == self.ColumnID.FixIcon):
row = index.row()
value = self._elements[row]
if value.isFixed:
color=QColor(Qt.red)
color.setAlphaF(0.5)
return QVariant(color)
if role == Qt.DisplayRole and index.column() == self.ColumnID.Text:
row = index.row()
value = self._elements[row]
return value.density
if role == Qt.DisplayRole and index.column() == self.ColumnID.Fix:
row = index.row()
value = self._elements[row]
return value.fixvalue
if role == Qt.DecorationRole and index.column() == self.ColumnID.Color:
row = index.row()
value = self._elements[row]
pixmap = QPixmap(_NPIXELS, _NPIXELS)
pixmap.fill(value.color)
icon = QIcon(pixmap)
return icon
if role == Qt.DecorationRole and index.column() == self.ColumnID.FixIcon:
row = index.row()
value = self._elements[row]
pixmap = QPixmap(_NPIXELS,_NPIXELS)
if value.isFixed:
iconpath=os.path.join(os.path.split(__file__)[0],
'icons/lock-edit-icon-32.png')
else:
iconpath=os.path.join(os.path.split(__file__)[0],
'icons/lock_open-32.png')
pixmap.load(iconpath)
icon = QIcon(pixmap)
return icon
return super(BoxListModel,self).data(index, role)
def __load_image(self, image_name):
"""
Load a file and return corresponding surface object
:param image_name: file name
:type image_name: string
:returns: image
:rtype: QPixmap
"""
image = QPixmap()
image.load(image_name)
return image
def __load_image(self, image_name):
"""
Load a file and return corresponding surface object
:param image_name: file name
:type image_name: string
:returns: image
:rtype: QPixmap
"""
image = QPixmap()
image.load(image_name)
return image
def _load_icon(filename, backgroundColor, width, height):
foreground = QPixmap()
foreground.load(filename)
pixmap = QPixmap(foreground.size())
pixmap.fill(backgroundColor)
painter = QPainter()
painter.begin(pixmap)
painter.drawPixmap(QPointF(0, 0), foreground)
painter.end()
pixmap = pixmap.scaled(QSize(width, height), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
return pixmap
def openimage(url):
key = url.toString().lstrip('file://')
try:
data, imagetype = images[os.path.basename(key)]
except KeyError:
# It's not a image so lets just pass it of as a normal
# URL
QDesktopServices.openUrl(url)
return
pix = QPixmap()
if imagetype == 'base64':
pix.loadFromData(data)
else:
pix.load(data)
utils.openImageViewer(pix)
def store_file(self, id, file):
directory = ApplicationData.get('images')
filename = os.path.join(directory, id + '.png')
if filename == os.path.normpath(file):
return self.iconmap.get(id, None)
makedirs(directory)
pixmap = QPixmap()
if file is not None and pixmap.load(file):
if pixmap.size().width() > self.max_size or pixmap.size().height(
) > self.max_size:
pixmap = pixmap.scaled(self.max_size, self.max_size,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
buffer = QBuffer()
pixmap.save(buffer, 'png')
data = str(buffer.data())
with open(filename, 'wb') as f:
f.write(data)
icon = QIcon(pixmap)
icon.filename = filename
icon.content = data
else:
unlink(filename)
icon = None
self.iconmap[id] = icon
return icon
def getProjectsBanner(self): projectName = str(self.ui.ProjectsEDIT.text()) # Don't requery for the project banner if its there if self.currentProjectName == projectName: return self.currentProjectName = projectName self.ui.ProjectsEDIT.currentProject = Project.recordByName(projectName) sgProj = sg.find_one( "Project", [["name", "is", projectName]], ["billboard"] ) if sgProj: if sgProj["billboard"]: billboardPath = sgProj["billboard"]["url"] if billboardPath: urllib.urlretrieve(billboardPath, self.BANNERPATH) if os.path.exists(self.BANNERPATH): bannerPixmap = QPixmap( self.ui.ProjectBannerView.maximumWidth(), self.ui.ProjectBannerView.maximumHeight() ) didLoad = bannerPixmap.load(self.BANNERPATH) # We actually don't care about the height # since this will be clamped from the width self.ui.ProjectBannerView.setPixmap( bannerPixmap.scaled(244, 200, Qt.KeepAspectRatio) ) self.ui.ProjectBannerView.setAlignment(Qt.AlignCenter) self.ui.ProjectBannerView.setScaledContents(True) # For some reason, calling the window repaint # fixes the issue with the flickering self.ui.header.show() self.repaint() self.parent.repaint()
class Desk(QLabel):
def __init__(self, deskID):
QLabel.__init__(self)
self.ID = deskID
self.setupUI()
pass
def setupUI(self):
self.setFixedSize(QSize(120, 120))
self.desk = QPixmap()
self.desk.load("img\\desk.png")
self.setPixmap(self.desk)
def mousePressEvent(self, QMouseEvent):
pass
def _set_filename(self, filename):
self.__dict__['filename'] = filename
filename = ApplicationData.get(filename) if filename else Resources.get(self.default_icon)
pixmap = QPixmap()
if pixmap.load(filename):
self.setPixmap(pixmap.scaled(32, 32, Qt.KeepAspectRatio, Qt.SmoothTransformation))
else:
self.setPixmap(pixmap)
def __init__(self, parent=None, size=16):
QWidget.__init__(self, parent)
self.setFocusPolicy(Qt.NoFocus)
self.setVisible(True)
self.setMinimumSize(size+2, size+2)
pixmap = QPixmap()
if pixmap.load(Resources.get("icons/search.svg")):
self.icon = pixmap.scaled(size, size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
else:
self.icon = None
def _NH_SIPAccountManagerDidAddAccount(self, notification):
account = notification.data.account
icon = None
if account is BonjourAccount():
pixmap = QPixmap()
if pixmap.load(Resources.get("icons/bonjour.png")):
pixmap = pixmap.scaled(16, 16, Qt.KeepAspectRatio, Qt.SmoothTransformation)
icon = QIcon(pixmap)
self.beginInsertRows(QModelIndex(), len(self.accounts), len(self.accounts))
self.accounts.append(AccountInfo(account, icon))
self.endInsertRows()
def __init__(self, parent=None, size=16):
QWidget.__init__(self, parent)
self.setFocusPolicy(Qt.NoFocus)
self.setVisible(True)
self.setMinimumSize(size + 2, size + 2)
pixmap = QPixmap()
if pixmap.load(Resources.get("icons/search.svg")):
self.icon = pixmap.scaled(size, size, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
else:
self.icon = None
class Model(QAbstractListModel):
def __init__(self, parent = None):
QAbstractListModel.__init__(self, parent)
self.list = []
self.strategies = parent
self.play = QPixmap()
self.play.load("img/Play.png")
self.none = QPixmap(32, 32)
self.none.fill(QColor(0, 0, 0, 0))
def add(self, obj):
self.list.append(obj)
index = QModelIndex()
self.dataChanged.emit(index, index)
def remove(self, index):
del self.list[index.row()]
self.dataChanged.emit(index.child(0, 1), index.child(len(self.list), 1))
def rowCount(self, parent):
return len(self.list)
def data(self, index, role):
#print index
if index.row() < 0 or index.row() >= len(self.list):
return None
if role == Qt.DisplayRole:
return unicode(self.list[index.row()].name())
elif role == Qt.DecorationRole:
module = self.list[index.row()]
if module == self.strategies.activeStrategy:
return self.play
else:
return self.none
def get(self, index):
return self.list[index.row()]
def findIconHelper(self, size=int, themeName=str, iconName=str):
pixmap = QPixmap()
if iconName == '' or self.themeName == '':
return pixmap
if themeName == '':
themeName = self.themeName
if themeName == self.themeName:
index = self.themeIndex
else:
index = self.readThemeIndex(themeName)
subDirs = filter(lambda x: x[0] == size, index.dirList)
for iconDir in self.iconDirs:
if path.exists(path.join(iconDir, themeName)):
for theme in subDirs:
fileName = path.join(iconDir, themeName, theme[1],
'%s.png' % str(iconName))
logging.debug('Looking for : %s' % fileName)
if path.exists(fileName):
pixmap.load(fileName)
logging.debug('Icon: %s found in theme %s' % \
(iconName, themeName))
return pixmap
for iconDir in self.extraIcons:
fileName = path.join(iconDir, '%s.png' % str(iconName))
if path.exists(fileName):
pixmap.load(fileName)
logging.debug('Icon: %s found in %s' % (iconName, iconDir))
return pixmap
if len(self._themes) > 0:
self._themes.pop(0)
if not len(self._themes) == 0 and pixmap.isNull():
pixmap = self.findIconHelper(size, self._themes[0], iconName)
return pixmap
def findIconHelper(self, size = int, themeName = str, iconName = str):
pixmap = QPixmap()
if iconName == '' or self.themeName == '':
return pixmap
if themeName == '':
themeName = self.themeName
if themeName == self.themeName:
index = self.themeIndex
else:
index = self.readThemeIndex(themeName)
subDirs = filter(lambda x:x[0] == size, index.dirList)
for iconDir in self.iconDirs:
if path.exists(path.join(iconDir, themeName)):
for theme in subDirs:
fileName = path.join(iconDir, themeName, theme[1],
'%s.png' % str(iconName))
logging.debug('Looking for : %s' % fileName)
if path.exists(fileName):
pixmap.load(fileName)
logging.debug('Icon: %s found in theme %s' % \
(iconName, themeName))
return pixmap
for iconDir in self.extraIcons:
fileName = path.join(iconDir, '%s.png' % str(iconName))
if path.exists(fileName):
pixmap.load(fileName)
logging.debug('Icon: %s found in %s' % (iconName, iconDir))
return pixmap
if len(self._themes) > 0:
self._themes.pop(0)
if not len(self._themes) == 0 and pixmap.isNull():
pixmap = self.findIconHelper(size, self._themes[0], iconName)
return pixmap
def check_connection(self):
"""
checks if internet connection is up.
if internet connection is down, notifies the user with a message.
"""
try:
# try to open a web URL
f = urllib2.urlopen("http://www.google.com/")
except URLError:
# if an error occurs, notify the user with a message
msg_box = QMessageBox()
msg_box.setWindowTitle(QApplication.translate('GUI', "Internet connection down?"))
msg_box.setText(QApplication.translate('GUI', """
<p>It seems your internet connection is down (but maybe I'm wrong).</p>
<p>That program needs access to the internet, to get information about movies, so please check your connection.</p>
<p>If I'm wrong, sorry for the interruption...</p>
"""))
icon = QPixmap()
icon.load('icons/exclamation.png')
msg_box.setIconPixmap(icon)
msg_box.exec_()
def viewurl(self, url):
"""
Open a URL in Roam
:param url:
:return:
"""
key = url.toString().lstrip('file://')
try:
# Hack. Eww fix me.
data, imagetype = roam.htmlviewer.images[os.path.basename(key)]
pix = QPixmap()
if imagetype == 'base64':
pix.loadFromData(data)
else:
pix.load(data)
self.openimage(pix)
except KeyError:
pix = QPixmap()
pix.load(key)
if pix.isNull():
QDesktopServices.openUrl(url)
return
self.openimage(pix)
def viewurl(self, url):
"""
Open a URL in Roam
:param url:
:return:
"""
key = url.toString().lstrip('file://')
try:
# Hack. Eww fix me.
data, imagetype = roam.htmlviewer.images[os.path.basename(key)]
pix = QPixmap()
if imagetype == 'base64':
pix.loadFromData(data)
else:
pix.load(data)
self.openimage(pix)
except KeyError:
pix = QPixmap()
pix.load(key)
if pix.isNull():
QDesktopServices.openUrl(url)
return
self.openimage(pix)
def viewurl(self, url):
"""
Open a URL in Roam
:param url:
:return:
"""
key = url.toString().lstrip('file://')
try:
# Hack. Eww fix me.
data, imagetype = roam.htmlviewer.images[os.path.basename(key)]
except KeyError:
# It's not a image so lets just pass it of as a normal
# URL
QDesktopServices.openUrl(url)
return
pix = QPixmap()
if imagetype == 'base64':
pix.loadFromData(data)
else:
pix.load(data)
self.openimage(pix)
def set_user_icon(self, image_file_name):
pixmap = QPixmap(32, 32)
pixmap.fill(QColor(Qt.transparent))
painter = QPainter(pixmap)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setBrush(QBrush(Qt.white))
painter.setPen(QPen(painter.brush(), 0, Qt.NoPen))
#painter.drawRoundedRect(0, 0, 32, 32, 6, 6)
painter.drawRoundedRect(0, 0, 32, 32, 0, 0)
icon = QPixmap()
if icon.load(image_file_name):
icon = icon.scaled(32, 32, Qt.KeepAspectRatio, Qt.SmoothTransformation)
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.drawPixmap(0, 0, icon)
painter.end()
self.image.setPixmap(pixmap)
class PixmapButton(QPushButton):
def __init__(self, parent):
QPushButton.__init__(self, parent)
self.fPixmapNormal = QPixmap()
self.fPixmapDown = QPixmap()
self.fPixmapHover = QPixmap()
self.fPixmapRect = QRectF(0, 0, 0, 0)
self.fIsHovered = False
self.setText("")
def setPixmaps(self, normal, down, hover):
self.fPixmapNormal.load(normal)
self.fPixmapDown.load(down)
self.fPixmapHover.load(hover)
width = self.fPixmapNormal.width()
height = self.fPixmapNormal.height()
self.fPixmapRect = QRectF(0, 0, width, height)
self.setMinimumSize(width, height)
self.setMaximumSize(width, height)
def enterEvent(self, event):
self.fIsHovered = True
QPushButton.enterEvent(self, event)
def leaveEvent(self, event):
self.fIsHovered = False
QPushButton.leaveEvent(self, event)
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
if not self.isEnabled():
painter.save()
painter.setOpacity(0.2)
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect)
painter.restore()
elif self.isChecked() or self.isDown():
painter.drawPixmap(self.fPixmapRect, self.fPixmapDown, self.fPixmapRect)
elif self.fIsHovered:
painter.drawPixmap(self.fPixmapRect, self.fPixmapHover, self.fPixmapRect)
else:
painter.drawPixmap(self.fPixmapRect, self.fPixmapNormal, self.fPixmapRect)
class Board(QLabel):
def __init__(self, layoutWidget):
QLabel.__init__(self, layoutWidget)
self.resize(490,490)
#建立棋盘
self.board = QPixmap()
self.board.load("img\\board.png")
self.setPixmap(self.board)
self.whiteChess = QPixmap()
self.whiteChess.load("img\\white.png")
self.blackChess = QPixmap()
self.blackChess.load("img\\black.png")
self.boardArray = [[0 for col in range(15)] for row in range(15)]
def mousePressEvent(self, QMouseEvent):
self.setPixmap(self.board)
x = None
if ((QMouseEvent.x() - 20) % 32) < 16:
x = (QMouseEvent.x() - 20) / 32
else:
x = ((QMouseEvent.x() - 20) / 32 + 1)
y = None
if ((QMouseEvent.y() - 20) % 32) < 16:
y = (QMouseEvent.y() - 20) / 32
else:
y = ((QMouseEvent.y() - 20) / 32 + 1)
if (x >= 15) | (y >= 15):
return
if self.boardArray[x][y] == 1:
self.boardArray[x][y] = 0
else:
self.boardArray[x][y] = 1
self.update()
def paintEvent(self, QPaintEvent):
QLabel.paintEvent(self, QPaintEvent)
painter = QPainter(self)
for i in range(15):
for j in range(15):
if self.boardArray[i][j] == 1:
painter.drawPixmap(i * 32 + 5, j * 32 + 5, self.whiteChess)
def setBoardImg(self):
self.setPixmap(self.board)
def store(self, filename, pixmap=None):
if filename is None:
return None
if not os.path.isabs(filename):
return filename
if filename.startswith(ApplicationData.directory + os.path.sep):
return filename[len(ApplicationData.directory + os.path.sep):]
try:
file_mapping = self.filemap[filename]
except KeyError:
pass
else:
source_info = FileInfo(filename)
destination_info = FileInfo(file_mapping.destination.name)
if (source_info, destination_info) == (file_mapping.source, file_mapping.destination):
return destination_info.name
try:
destination_name = os.path.join('images', self.available_names.popleft())
except IndexError:
# No more available file names. Return original file for now
return filename
if pixmap is None:
pixmap = QPixmap()
if pixmap.load(filename):
pixmap = pixmap.scaled(32, 32, Qt.KeepAspectRatio, Qt.SmoothTransformation)
makedirs(ApplicationData.get('images'))
if pixmap.save(ApplicationData.get(destination_name)):
source_info = FileInfo(filename)
destination_info = FileInfo(destination_name)
file_mapping = FileMapping(source_info, destination_info)
self.filemap[filename] = file_mapping
map_filename = ApplicationData.get(os.path.join('images', '.cached_icons.map'))
map_tempname = map_filename + '.tmp'
try:
file = open(map_tempname, 'wb')
pickle.dump(self.filemap, file)
file.close()
if sys.platform == 'win32':
unlink(map_filename)
os.rename(map_tempname, map_filename)
except Exception, e:
log.error("could not save icon cache file mappings: %s" % e)
return destination_name
def __init__(self, parent=None, size=16):
QAbstractButton.__init__(self, parent)
self.setCursor(Qt.ArrowCursor)
self.setFocusPolicy(Qt.NoFocus)
self.setToolTip(u"Clear")
self.setVisible(False)
self.setMinimumSize(size+2, size+2)
pixmap = QPixmap()
if pixmap.load(Resources.get("icons/delete.svg")):
self.icon = pixmap.scaled(size, size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
# Use QImage because QPainter using a QPixmap does not support CompositionMode_Multiply -Dan
image = self.icon.toImage()
painter = QPainter(image)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setCompositionMode(QPainter.CompositionMode_Multiply)
painter.drawPixmap(0, 0, self.icon)
painter.end()
self.icon_pressed = QPixmap(image)
else:
self.icon = self.icon_pressed = None
def __init__(self, parent=None, size=16):
QAbstractButton.__init__(self, parent)
self.setCursor(Qt.ArrowCursor)
self.setFocusPolicy(Qt.NoFocus)
self.setToolTip(u"Clear")
self.setVisible(False)
self.setMinimumSize(size + 2, size + 2)
pixmap = QPixmap()
if pixmap.load(Resources.get("icons/delete.svg")):
self.icon = pixmap.scaled(size, size, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
# Use QImage because QPainter using a QPixmap does not support CompositionMode_Multiply -Dan
image = self.icon.toImage()
painter = QPainter(image)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setCompositionMode(QPainter.CompositionMode_Multiply)
painter.drawPixmap(0, 0, self.icon)
painter.end()
self.icon_pressed = QPixmap(image)
else:
self.icon = self.icon_pressed = None
def pixmap_cache ( name ):
""" Return the QPixmap corresponding to a filename. If the filename does
not contain a path component then the local 'images' directory is used.
"""
if name[:1] == '@':
image = image_for( name )
if image is not None:
return image.bitmap
path, _ = split( name )
if not path:
name = join( dirname( __file__ ), 'images', name )
pm = QPixmap()
if not QPixmapCache.find( name, pm ):
if not pm.load( name ) :
print "WARNING: could not load pixmap file", name
QPixmapCache.insert( name, pm )
return pm
def store_file(self, id, file):
directory = ApplicationData.get('images')
filename = os.path.join(directory, id + '.png')
if filename == os.path.normpath(file):
return self.iconmap.get(id, None)
makedirs(directory)
pixmap = QPixmap()
if file is not None and pixmap.load(file):
if pixmap.size().width() > self.max_size or pixmap.size().height() > self.max_size:
pixmap = pixmap.scaled(self.max_size, self.max_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
buffer = QBuffer()
pixmap.save(buffer, 'png')
data = str(buffer.data())
with open(filename, 'wb') as f:
f.write(data)
icon = QIcon(pixmap)
icon.filename = filename
icon.content = data
else:
unlink(filename)
icon = None
self.iconmap[id] = icon
return icon
class BackgroundFrame(QFrame):
backgroundColor = QtDynamicProperty('backgroundColor', unicode)
backgroundImage = QtDynamicProperty('backgroundImage', unicode)
imageGeometry = QtDynamicProperty('imageGeometry', QRect)
def __init__(self, parent=None):
super(BackgroundFrame, self).__init__(parent)
self.backgroundColor = None
self.backgroundImage = None
self.imageGeometry = None
self.pixmap = None
self.scaled_pixmap = None
@property
def image_position(self):
return QPoint(0, 0) if self.imageGeometry is None else self.imageGeometry.topLeft()
@property
def image_size(self):
if self.imageGeometry is not None:
size = self.imageGeometry.size().expandedTo(QSize(0, 0)) # requested size with negative values turned to 0
if size.isNull():
return size if self.pixmap is None else self.pixmap.size()
elif size.width() == 0:
return size.expandedTo(QSize(16777215, 0))
elif size.height() == 0:
return size.expandedTo(QSize(0, 16777215))
else:
return size
elif self.pixmap:
return self.pixmap.size()
else:
return QSize(0, 0)
def event(self, event):
if event.type() == QEvent.DynamicPropertyChange:
if event.propertyName() == 'backgroundImage':
self.pixmap = QPixmap()
if self.backgroundImage and self.pixmap.load(Resources.get(self.backgroundImage)):
self.scaled_pixmap = self.pixmap.scaled(self.image_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
else:
self.pixmap = self.scaled_pixmap = None
self.update()
elif event.propertyName() == 'imageGeometry' and self.pixmap:
self.scaled_pixmap = self.pixmap.scaled(self.image_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
self.update()
elif event.propertyName() == 'backgroundColor':
self.update()
return super(BackgroundFrame, self).event(event)
def resizeEvent(self, event):
self.scaled_pixmap = self.pixmap and self.pixmap.scaled(self.image_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
def paintEvent(self, event):
super(BackgroundFrame, self).paintEvent(event)
painter = QPainter(self)
if self.backgroundColor:
painter.fillRect(self.rect(), QColor(self.backgroundColor))
if self.scaled_pixmap is not None:
painter.drawPixmap(self.image_position, self.scaled_pixmap)
painter.end()
class PixmapKeyboard(QWidget):
COLOR_CLASSIC = 0
COLOR_ORANGE = 1
HORIZONTAL = 0
VERTICAL = 1
def __init__(self, parent):
QWidget.__init__(self, parent)
self.m_octaves = 6
self.m_lastMouseNote = -1
self.m_needsUpdate = False
self.m_enabledKeys = []
self.m_font = QFont("Monospace", 8, QFont.Normal)
self.m_pixmap = QPixmap("")
self.setMode(self.HORIZONTAL)
def sendNoteOn(self, note, sendSignal=True):
if 0 <= note <= 127 and note not in self.m_enabledKeys:
self.m_enabledKeys.append(note)
if sendSignal:
self.emit(SIGNAL("noteOn(int)"), note)
self.m_needsUpdate = True
QTimer.singleShot(0, self, SLOT("slot_updateOnce()"))
if len(self.m_enabledKeys) == 1:
self.emit(SIGNAL("notesOn()"))
def sendNoteOff(self, note, sendSignal=True):
if 0 <= note <= 127 and note in self.m_enabledKeys:
self.m_enabledKeys.remove(note)
if sendSignal:
self.emit(SIGNAL("noteOff(int)"), note)
self.m_needsUpdate = True
QTimer.singleShot(0, self, SLOT("slot_updateOnce()"))
if len(self.m_enabledKeys) == 0:
self.emit(SIGNAL("notesOff()"))
def setMode(self, mode, color=COLOR_ORANGE):
if color == self.COLOR_CLASSIC:
self.m_colorStr = "classic"
elif color == self.COLOR_ORANGE:
self.m_colorStr = "orange"
else:
qCritical("PixmapKeyboard::setMode(%i, %i) - Invalid keyboard color" % (mode, color))
return self.setMode(mode)
if mode == self.HORIZONTAL:
self.m_midi_map = midi_key2rect_map_horizontal
self.m_pixmap.load(":/bitmaps/kbd_h_%s.png" % self.m_colorStr)
self.m_pixmap_mode = self.HORIZONTAL
self.p_width = self.m_pixmap.width()
self.p_height = self.m_pixmap.height() / 2
elif mode == self.VERTICAL:
self.m_midi_map = midi_key2rect_map_vertical
self.m_pixmap.load(":/bitmaps/kbd_v_%s.png" % self.m_colorStr)
self.m_pixmap_mode = self.VERTICAL
self.p_width = self.m_pixmap.width() / 2
self.p_height = self.m_pixmap.height()
else:
qCritical("PixmapKeyboard::setMode(%i, %i) - Invalid keyboard mode" % (mode, color))
return self.setMode(self.HORIZONTAL)
self.setOctaves(self.m_octaves)
def setOctaves(self, octaves):
if octaves < 1:
octaves = 1
elif octaves > 6:
octaves = 6
self.m_octaves = octaves
if self.m_pixmap_mode == self.HORIZONTAL:
self.setMinimumSize(self.p_width * self.m_octaves, self.p_height)
self.setMaximumSize(self.p_width * self.m_octaves, self.p_height)
elif self.m_pixmap_mode == self.VERTICAL:
self.setMinimumSize(self.p_width, self.p_height * self.m_octaves)
self.setMaximumSize(self.p_width, self.p_height * self.m_octaves)
self.update()
def keyPressEvent(self, event):
qKey = str(event.key())
if qKey in midi_keyboard2key_map.keys():
self.sendNoteOn(midi_keyboard2key_map.get(qKey))
QWidget.keyPressEvent(self, event)
def keyReleaseEvent(self, event):
qKey = str(event.key())
if qKey in midi_keyboard2key_map.keys():
self.sendNoteOff(midi_keyboard2key_map.get(qKey))
QWidget.keyReleaseEvent(self, event)
def mousePressEvent(self, event):
self.m_lastMouseNote = -1
self.handleMousePos(event.pos())
self.setFocus()
QWidget.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
self.handleMousePos(event.pos())
QWidget.mousePressEvent(self, event)
def mouseReleaseEvent(self, event):
if self.m_lastMouseNote != -1:
self.sendNoteOff(self.m_lastMouseNote)
self.m_lastMouseNote = -1
QWidget.mouseReleaseEvent(self, event)
def handleMousePos(self, pos):
if self.m_pixmap_mode == self.HORIZONTAL:
if pos.x() < 0 or pos.x() > self.m_octaves * 144:
return
octave = int(pos.x() / self.p_width)
n_pos = QPointF(pos.x() % self.p_width, pos.y())
elif self.m_pixmap_mode == self.VERTICAL:
if pos.y() < 0 or pos.y() > self.m_octaves * 144:
return
octave = int(self.m_octaves - pos.y() / self.p_height)
n_pos = QPointF(pos.x(), pos.y() % self.p_height)
else:
return
octave += 3
if self.m_midi_map['1'].contains(n_pos): # C#
note = 1
elif self.m_midi_map['3'].contains(n_pos): # D#
note = 3
elif self.m_midi_map['6'].contains(n_pos): # F#
note = 6
elif self.m_midi_map['8'].contains(n_pos): # G#
note = 8
elif self.m_midi_map['10'].contains(n_pos):# A#
note = 10
elif self.m_midi_map['0'].contains(n_pos): # C
note = 0
elif self.m_midi_map['2'].contains(n_pos): # D
note = 2
elif self.m_midi_map['4'].contains(n_pos): # E
note = 4
elif self.m_midi_map['5'].contains(n_pos): # F
note = 5
elif self.m_midi_map['7'].contains(n_pos): # G
note = 7
elif self.m_midi_map['9'].contains(n_pos): # A
note = 9
elif self.m_midi_map['11'].contains(n_pos):# B
note = 11
else:
note = -1
if note != -1:
note += octave * 12
if self.m_lastMouseNote != note:
self.sendNoteOff(self.m_lastMouseNote)
self.sendNoteOn(note)
else:
self.sendNoteOff(self.m_lastMouseNote)
self.m_lastMouseNote = note
def paintEvent(self, event):
painter = QPainter(self)
# -------------------------------------------------------------
# Paint clean keys (as background)
for octave in range(self.m_octaves):
if self.m_pixmap_mode == self.HORIZONTAL:
target = QRectF(self.p_width * octave, 0, self.p_width, self.p_height)
elif self.m_pixmap_mode == self.VERTICAL:
target = QRectF(0, self.p_height * octave, self.p_width, self.p_height)
else:
return
source = QRectF(0, 0, self.p_width, self.p_height)
painter.drawPixmap(target, self.m_pixmap, source)
# -------------------------------------------------------------
# Paint (white) pressed keys
paintedWhite = False
for i in range(len(self.m_enabledKeys)):
note = self.m_enabledKeys[i]
pos = self._getRectFromMidiNote(note)
if self._isNoteBlack(note):
continue
if note < 35:
# cannot paint this note
continue
elif note < 48:
octave = 0
elif note < 60:
octave = 1
elif note < 72:
octave = 2
elif note < 84:
octave = 3
elif note < 96:
octave = 4
elif note < 108:
octave = 5
else:
# cannot paint this note either
continue
if self.m_pixmap_mode == self.VERTICAL:
octave = self.m_octaves - octave - 1
if self.m_pixmap_mode == self.HORIZONTAL:
target = QRectF(pos.x() + (self.p_width * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), self.p_height, pos.width(), pos.height())
elif self.m_pixmap_mode == self.VERTICAL:
target = QRectF(pos.x(), pos.y() + (self.p_height * octave), pos.width(), pos.height())
source = QRectF(self.p_width, pos.y(), pos.width(), pos.height())
else:
return
paintedWhite = True
painter.drawPixmap(target, self.m_pixmap, source)
# -------------------------------------------------------------
# Clear white keys border
if paintedWhite:
for octave in range(self.m_octaves):
for note in (1, 3, 6, 8, 10):
pos = self._getRectFromMidiNote(note)
if self.m_pixmap_mode == self.HORIZONTAL:
target = QRectF(pos.x() + (self.p_width * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), 0, pos.width(), pos.height())
elif self.m_pixmap_mode == self.VERTICAL:
target = QRectF(pos.x(), pos.y() + (self.p_height * octave), pos.width(), pos.height())
source = QRectF(0, pos.y(), pos.width(), pos.height())
else:
return
painter.drawPixmap(target, self.m_pixmap, source)
# -------------------------------------------------------------
# Paint (black) pressed keys
for i in range(len(self.m_enabledKeys)):
note = self.m_enabledKeys[i]
pos = self._getRectFromMidiNote(note)
if not self._isNoteBlack(note):
continue
if note < 35:
# cannot paint this note
continue
elif note < 48:
octave = 0
elif note < 60:
octave = 1
elif note < 72:
octave = 2
elif note < 84:
octave = 3
elif note < 96:
octave = 4
elif note < 108:
octave = 5
else:
# cannot paint this note either
continue
if self.m_pixmap_mode == self.VERTICAL:
octave = self.m_octaves - octave - 1
if self.m_pixmap_mode == self.HORIZONTAL:
target = QRectF(pos.x() + (self.p_width * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), self.p_height, pos.width(), pos.height())
elif self.m_pixmap_mode == self.VERTICAL:
target = QRectF(pos.x(), pos.y() + (self.p_height * octave), pos.width(), pos.height())
source = QRectF(self.p_width, pos.y(), pos.width(), pos.height())
else:
return
painter.drawPixmap(target, self.m_pixmap, source)
# Paint C-number note info
painter.setFont(self.m_font)
painter.setPen(Qt.black)
for i in range(self.m_octaves):
if self.m_pixmap_mode == self.HORIZONTAL:
painter.drawText(i * 144, 48, 18, 18, Qt.AlignCenter, "C%i" % (i + 2))
elif self.m_pixmap_mode == self.VERTICAL:
painter.drawText(45, (self.m_octaves * 144) - (i * 144) - 16, 18, 18, Qt.AlignCenter, "C%i" % (i + 2))
@pyqtSlot()
def slot_updateOnce(self):
if self.m_needsUpdate:
self.update()
self.m_needsUpdate = False
def _isNoteBlack(self, note):
baseNote = note % 12
return bool(baseNote in (1, 3, 6, 8, 10))
def _getRectFromMidiNote(self, note):
return self.m_midi_map.get(str(note % 12))
class PixmapDial(QDial):
# enum CustomPaint
CUSTOM_PAINT_NULL = 0
CUSTOM_PAINT_CARLA_WET = 1
CUSTOM_PAINT_CARLA_VOL = 2
CUSTOM_PAINT_CARLA_L = 3
CUSTOM_PAINT_CARLA_R = 4
# enum Orientation
HORIZONTAL = 0
VERTICAL = 1
HOVER_MIN = 0
HOVER_MAX = 9
def __init__(self, parent):
QDial.__init__(self, parent)
self.fPixmap = QPixmap("./bitmaps/dial_01d.png")
self.fPixmapNum = "01"
self.fCustomPaint = self.CUSTOM_PAINT_NULL
self.fHovered = False
self.fHoverStep = self.HOVER_MIN
if self.fPixmap.width() > self.fPixmap.height():
self.fOrientation = self.HORIZONTAL
else:
self.fOrientation = self.VERTICAL
self.fLabel = ""
self.fLabelPos = QPointF(0.0, 0.0)
self.fLabelFont = QFont()
self.fLabelFont.setPointSize(6)
self.fLabelWidth = 0
self.fLabelHeight = 0
self.fLabelGradient = QLinearGradient(0, 0, 0, 1)
if self.palette().window().color().lightness() > 100:
# Light background
c = self.palette().dark().color()
self.fColor1 = c
self.fColor2 = QColor(c.red(), c.green(), c.blue(), 0)
self.fColorT = [self.palette().buttonText().color(), self.palette().mid().color()]
else:
# Dark background
self.fColor1 = QColor(0, 0, 0, 255)
self.fColor2 = QColor(0, 0, 0, 0)
self.fColorT = [Qt.white, Qt.darkGray]
self.updateSizes()
def getSize(self):
return self.fSize
def setCustomPaint(self, paint):
self.fCustomPaint = paint
self.fLabelPos.setY(self.fSize + self.fLabelHeight/2)
self.update()
def setEnabled(self, enabled):
if self.isEnabled() != enabled:
self.fPixmap.load("./bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if enabled else "d"))
self.updateSizes()
self.update()
QDial.setEnabled(self, enabled)
def setLabel(self, label):
self.fLabel = label
self.fLabelWidth = QFontMetrics(self.fLabelFont).width(label)
self.fLabelHeight = QFontMetrics(self.fLabelFont).height()
self.fLabelPos.setX(float(self.fSize)/2.0 - float(self.fLabelWidth)/2.0)
self.fLabelPos.setY(self.fSize + self.fLabelHeight)
self.fLabelGradient.setColorAt(0.0, self.fColor1)
self.fLabelGradient.setColorAt(0.6, self.fColor1)
self.fLabelGradient.setColorAt(1.0, self.fColor2)
self.fLabelGradient.setStart(0, float(self.fSize)/2.0)
self.fLabelGradient.setFinalStop(0, self.fSize + self.fLabelHeight + 5)
self.fLabelGradientRect = QRectF(float(self.fSize)/8.0, float(self.fSize)/2.0, float(self.fSize*6)/8.0, self.fSize+self.fLabelHeight+5)
self.update()
def setPixmap(self, pixmapId):
self.fPixmapNum = "%02i" % pixmapId
self.fPixmap.load("./bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if self.isEnabled() else "d"))
if self.fPixmap.width() > self.fPixmap.height():
self.fOrientation = self.HORIZONTAL
else:
self.fOrientation = self.VERTICAL
self.updateSizes()
self.update()
def minimumSizeHint(self):
return QSize(self.fSize, self.fSize)
def sizeHint(self):
return QSize(self.fSize, self.fSize)
def updateSizes(self):
self.fWidth = self.fPixmap.width()
self.fHeight = self.fPixmap.height()
if self.fWidth < 1:
self.fWidth = 1
if self.fHeight < 1:
self.fHeight = 1
if self.fOrientation == self.HORIZONTAL:
self.fSize = self.fHeight
self.fCount = self.fWidth / self.fHeight
else:
self.fSize = self.fWidth
self.fCount = self.fHeight / self.fWidth
self.setMinimumSize(self.fSize, self.fSize + self.fLabelHeight + 5)
self.setMaximumSize(self.fSize, self.fSize + self.fLabelHeight + 5)
def enterEvent(self, event):
self.fHovered = True
if self.fHoverStep == self.HOVER_MIN:
self.fHoverStep = self.HOVER_MIN + 1
QDial.enterEvent(self, event)
def leaveEvent(self, event):
self.fHovered = False
if self.fHoverStep == self.HOVER_MAX:
self.fHoverStep = self.HOVER_MAX - 1
QDial.leaveEvent(self, event)
def paintEvent(self, event):
event.accept()
painter = QPainter(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
if self.fLabel:
if self.fCustomPaint == self.CUSTOM_PAINT_NULL:
painter.setPen(self.fColor2)
painter.setBrush(self.fLabelGradient)
painter.drawRect(self.fLabelGradientRect)
painter.setFont(self.fLabelFont)
painter.setPen(self.fColorT[0 if self.isEnabled() else 1])
painter.drawText(self.fLabelPos, self.fLabel)
if self.isEnabled():
current = float(self.value() - self.minimum())
divider = float(self.maximum() - self.minimum())
if divider == 0.0:
return
value = current / divider
target = QRectF(0.0, 0.0, self.fSize, self.fSize)
per = int((self.fCount - 1) * value)
if self.fOrientation == self.HORIZONTAL:
xpos = self.fSize * per
ypos = 0.0
else:
xpos = 0.0
ypos = self.fSize * per
source = QRectF(xpos, ypos, self.fSize, self.fSize)
painter.drawPixmap(target, self.fPixmap, source)
# Custom knobs (Dry/Wet and Volume)
if self.fCustomPaint in (self.CUSTOM_PAINT_CARLA_WET, self.CUSTOM_PAINT_CARLA_VOL):
# knob color
colorGreen = QColor(0x5D, 0xE7, 0x3D, 191 + self.fHoverStep*7)
colorBlue = QColor(0x3E, 0xB8, 0xBE, 191 + self.fHoverStep*7)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*value)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*value
if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_WET:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
gradient = QConicalGradient(15.5, 15.5, -45)
gradient.setColorAt(0.0, colorBlue)
gradient.setColorAt(0.125, colorBlue)
gradient.setColorAt(0.625, colorGreen)
gradient.setColorAt(0.75, colorGreen)
gradient.setColorAt(0.76, colorGreen)
gradient.setColorAt(1.0, colorGreen)
painter.setBrush(gradient)
painter.setPen(QPen(gradient, 3))
else:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (L and R)
elif self.fCustomPaint in (self.CUSTOM_PAINT_CARLA_L, self.CUSTOM_PAINT_CARLA_R):
# knob color
color = QColor(0xAD + self.fHoverStep*5, 0xD5 + self.fHoverStep*4, 0x4B + self.fHoverStep*5)
# draw small circle
ballRect = QRectF(7.0, 8.0, 11.0, 12.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*value)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))
# draw arc
if self.fCustomPaint == self.CUSTOM_PAINT_CARLA_L:
startAngle = 216*16
spanAngle = -252.0*16*value
elif self.fCustomPaint == self.CUSTOM_PAINT_CARLA_R:
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-value)
else:
return
painter.setPen(QPen(color, 2))
painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)
if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:
self.fHoverStep += 1 if self.fHovered else -1
QTimer.singleShot(20, self, SLOT("update()"))
else: # isEnabled()
target = QRectF(0.0, 0.0, self.fSize, self.fSize)
painter.drawPixmap(target, self.fPixmap, target)
painter.restore()
def resizeEvent(self, event):
self.updateSizes()
QDial.resizeEvent(self, event)
class BackgroundFrame(QFrame):
backgroundColor = QtDynamicProperty('backgroundColor', unicode)
backgroundImage = QtDynamicProperty('backgroundImage', unicode)
imageGeometry = QtDynamicProperty('imageGeometry', QRect)
def __init__(self, parent=None):
super(BackgroundFrame, self).__init__(parent)
self.backgroundColor = None
self.backgroundImage = None
self.imageGeometry = None
self.pixmap = None
self.scaled_pixmap = None
@property
def image_position(self):
return QPoint(
0,
0) if self.imageGeometry is None else self.imageGeometry.topLeft()
@property
def image_size(self):
if self.imageGeometry is not None:
size = self.imageGeometry.size().expandedTo(QSize(
0, 0)) # requested size with negative values turned to 0
if size.isNull():
return size if self.pixmap is None else self.pixmap.size()
elif size.width() == 0:
return size.expandedTo(QSize(16777215, 0))
elif size.height() == 0:
return size.expandedTo(QSize(0, 16777215))
else:
return size
elif self.pixmap:
return self.pixmap.size()
else:
return QSize(0, 0)
def event(self, event):
if event.type() == QEvent.DynamicPropertyChange:
if event.propertyName() == 'backgroundImage':
self.pixmap = QPixmap()
if self.backgroundImage and self.pixmap.load(
Resources.get(self.backgroundImage)):
self.scaled_pixmap = self.pixmap.scaled(
self.image_size, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
else:
self.pixmap = self.scaled_pixmap = None
self.update()
elif event.propertyName() == 'imageGeometry' and self.pixmap:
self.scaled_pixmap = self.pixmap.scaled(
self.image_size, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.update()
elif event.propertyName() == 'backgroundColor':
self.update()
return super(BackgroundFrame, self).event(event)
def resizeEvent(self, event):
self.scaled_pixmap = self.pixmap and self.pixmap.scaled(
self.image_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
def paintEvent(self, event):
super(BackgroundFrame, self).paintEvent(event)
painter = QPainter(self)
if self.backgroundColor:
painter.fillRect(self.rect(), QColor(self.backgroundColor))
if self.scaled_pixmap is not None:
painter.drawPixmap(self.image_position, self.scaled_pixmap)
painter.end()
class LEDButton(QPushButton):
BLUE = 1
GREEN = 2
RED = 3
YELLOW = 4
BIG_RED = 5
def __init__(self, parent):
QPushButton.__init__(self, parent)
self.m_pixmap = QPixmap()
self.m_pixmap_rect = QRectF(0, 0, 0, 0)
self.setCheckable(True)
self.setText("")
self.setColor(self.BLUE)
def setColor(self, color):
self.m_color = color
if color in (self.BLUE, self.GREEN, self.RED, self.YELLOW):
size = 14
elif color == self.BIG_RED:
size = 32
else:
return qCritical("LEDButton::setColor(%i) - Invalid color" % color)
self.setPixmapSize(size)
def setPixmapSize(self, size):
self.m_pixmap_rect = QRectF(0, 0, size, size)
self.setMinimumWidth(size)
self.setMaximumWidth(size)
self.setMinimumHeight(size)
self.setMaximumHeight(size)
def paintEvent(self, event):
painter = QPainter(self)
if self.isChecked():
if self.m_color == self.BLUE:
self.m_pixmap.load(":/bitmaps/led_blue.png")
elif self.m_color == self.GREEN:
self.m_pixmap.load(":/bitmaps/led_green.png")
elif self.m_color == self.RED:
self.m_pixmap.load(":/bitmaps/led_red.png")
elif self.m_color == self.YELLOW:
self.m_pixmap.load(":/bitmaps/led_yellow.png")
elif self.m_color == self.BIG_RED:
self.m_pixmap.load(":/bitmaps/led-big_on.png")
else:
return
else:
if self.m_color in (self.BLUE, self.GREEN, self.RED, self.YELLOW):
self.m_pixmap.load(":/bitmaps/led_off.png")
elif self.m_color == self.BIG_RED:
self.m_pixmap.load(":/bitmaps/led-big_off.png")
else:
return
painter.drawPixmap(self.m_pixmap_rect, self.m_pixmap, self.m_pixmap_rect)
class Panel(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.clean_up_queue = []
self.summoner = SummonerData()
self.summoner.getStaticData()
### Search Bar ###
##################
#label
self.search_label = QLabel(self)
self.search_label.move(20, 15)
self.search_label.resize(220, 25)
self.search_label.setText('Enter summoner name(s):')
self.search_label.setStyleSheet("QLabel {font:14pt}")
#text field
self.search_field = QLineEdit(self)
self.search_field.move(260, 15)
self.search_field.resize(250, 25)
self.search_field.setPlaceholderText("ex: mcnuggets, teltor, ...")
self.search_field.setFocusPolicy(Qt.ClickFocus)
#search button
self.search_button = QPushButton(self)
self.search_button.move(520, 15)
self.search_button.resize(150, 25)
self.search_button.setText('Search Summoner')
#region combobox
self.region_list = QComboBox(self)
self.region_list.move(680, 15)
self.region_list.resize(75, 25)
regions = ['NA', 'LAN', 'BR', 'LAS', 'EUW', 'EUNE', 'TR', 'RU', 'OCE']
self.region_list.addItems(regions)
#error label
self.error_label = QLabel(self)
self.error_label.move(775, 15)
self.error_label.resize(160, 25)
self.error_label.setStyleSheet("QLabel {font:14pt}")
### Summoner Information ###
############################
#summoner Icon label
self.icon_label = QLabel(self)
self.icon_label.setScaledContents(True)
self.icon_label.move(260, 50)
self.icon_label.resize(110, 110)
#name label
self.name_label = QLabel(self)
self.name_label.move(380, 50)
self.name_label.resize(620, 50)
self.name_label.setText('SUMMONER NAME')
self.name_label.setStyleSheet("QLabel {font:32pt}")
#rank label
self.rank_label = QLabel(self)
self.rank_label.move(380, 100)
self.rank_label.resize(200, 60)
self.rank_label.setText('summoner rank')
self.rank_label.setStyleSheet("QLabel {font:18pt}")
#miniseries labels
self.series_labels = {}
self.pixmap_win = QPixmap()
self.pixmap_loss = QPixmap()
self.pixmap_n = QPixmap()
self.pixmap_win.load("./images/win.png")
self.pixmap_loss.load("./images/loss.png")
self.pixmap_n.load("./images/n.png")
xPos = 600
for x in range(5):
match_label = QLabel(self)
match_label.move(xPos, 120)
match_label.resize(35, 35)
match_label.setScaledContents(True)
match_label.hide()
self.series_labels[x] = match_label
xPos += 40
#mastery image labels
print 'loading mastery images ...'
self.ferocity_tree_images = self.getMasteryImages(
self.summoner.ferocityMasteryTree())
self.cunning_tree_images = self.getMasteryImages(
self.summoner.cunningMasteryTree())
self.resolve_tree_images = self.getMasteryImages(
self.summoner.resolveMasteryTree())
print 'Done'
#champion icon image labels
print 'loading champion icon images ...'
self.championIcons = self.getChampionIconImages(
self.summoner.championList())
print 'Done'
#overview widget
self.overview_widget = QWidget()
self.overview_menu = QTabWidget(self.overview_widget)
self.overview_menu.resize(720, 270)
#runes widget
self.runes_widget = QWidget()
self.runes_menu = QTabWidget(self.runes_widget)
self.runes_menu.resize(720, 270)
#masteries widget
self.masteries_widget = QWidget()
self.masteries_menu = QTabWidget(self.masteries_widget)
self.masteries_menu.resize(720, 270)
#summoner menu
self.menu = QTabWidget(self)
self.menu.move(260, 180)
self.menu.resize(720, 300)
self.menu.addTab(self.overview_widget, "Overview")
self.menu.addTab(self.runes_widget, "Runes")
self.menu.addTab(self.masteries_widget, "Masteries")
self.menu.hide()
#summoners buttons
self.button_list = {}
yPos = 150
for x in range(10):
sum_button = QPushButton(self)
sum_button.move(50, yPos)
sum_button.resize(150, 25)
sum_button.hide()
self.button_list[x] = sum_button
yPos += 25
### Connecting Widgets ###
##########################
self.connect(self.search_button, QtCore.SIGNAL("clicked()"),
self.getData)
self.connect(self.search_button, QtCore.SIGNAL("clicked()"),
self.getRankedData)
self.connect(self.button_list[0], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[0].text())))
self.connect(self.button_list[1], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[1].text())))
self.connect(self.button_list[2], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[2].text())))
self.connect(self.button_list[3], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[3].text())))
self.connect(self.button_list[4], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[4].text())))
self.connect(self.button_list[5], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[5].text())))
self.connect(self.button_list[6], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[6].text())))
self.connect(self.button_list[7], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[7].text())))
self.connect(self.button_list[8], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[8].text())))
self.connect(self.button_list[9], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[9].text())))
### Window Configuration ###
############################
#window settings
self.setGeometry(200, 150, 1000, 500)
self.setMaximumSize(1000, 500)
self.setWindowTitle('summoner App')
self.show()
### GUI methods ###
###################
############### GUI get methods ###############
#get data related to given summoner names
def getData(self):
self.cleanUp()
name_list = str(self.search_field.text()).replace(
' ', '').lower().split(',')
region = str(self.region_list.currentText()).lower()
if name_list != ['']:
try:
self.summoner.getSummonerData(name_list, region)
for x in range(len(name_list)):
sum_name = self.summoner.getName(name_list[x])
if sum_name != None:
self.button_list[x].setText(sum_name)
self.clean_up_queue.append(self.button_list[x])
else:
self.button_list[x].setText(name_list[x])
self.clean_up_queue.append(self.button_list[x])
self.button_list[x].setEnabled(False)
self.button_list[x].show()
except RiotError as e:
response = e.message
print response
if response == 'ServiceUnavailable':
self.error_label.setText(response)
elif response == '429':
self.error_label.setText('Rate limit reached')
elif response == 'InternalServerError':
self.error_label.setText(response)
elif response == 'Unauthorized':
self.error_label.setText('Invalid Input')
elif response == 'ServerError':
self.error_label.setText(response)
else:
self.error_label.setText('Not Found')
except KeyError as k:
self.error_label.setText('Invalid Input')
#get summoner ranked data
def getRankedData(self):
if str(self.search_field.text()) != '':
region = str(self.region_list.currentText()).lower()
try:
self.summoner.getRankedData(region)
except RiotError:
print 'Rank info not found'
#get mastery images
def getMasteryImages(self, masteryList):
pixmap_list = collections.OrderedDict()
empty_spaces = 0
for row in masteryList:
if len(row['masteryTreeItems']) == 2:
#if len(row) == 3:
row['masteryTreeItems'].append(None)
#row.append(None)
for element in row['masteryTreeItems']:
#for element in row:
if element != None:
pixmap = QPixmap()
pixmap.loadFromData(
self.summoner.getImage(
'mastery',
str(element['masteryId']) + '.png'))
pixmap_list[element['masteryId']] = pixmap
else:
pixmap_list['null' + str(empty_spaces)] = None
empty_spaces += 1
return pixmap_list
#get champion icon images
def getChampionIconImages(self, clist):
pixmap_list = {}
for champ in clist.values():
pixmap = QPixmap()
pixmap.loadFromData(
self.summoner.getImage('champion', champ['key'] + '.png'))
pixmap_list[champ['name']] = pixmap
return pixmap_list
############### GUI update methods ###############
#removes previous data from GUI
def cleanUp(self):
self.error_label.setText("")
#clears summoner info
self.icon_label.setPixmap(QPixmap())
self.icon_label.setStyleSheet("QLabel {}")
self.name_label.setText("")
self.rank_label.setText("")
#hides elements in clean up queue
for x in self.clean_up_queue:
x.hide()
x.setEnabled(True)
#display data
def displayData(self, buttonName):
sum_ID = self.summoner.getID(buttonName)
self.displayIcon(buttonName.replace(' ', '').lower())
self.name_label.setText(buttonName)
self.displayRank(sum_ID)
self.displayMenu(sum_ID)
#display summoner icon
def displayIcon(self, summoner_name):
iconName = self.summoner.getIcon(summoner_name)
iconPixmap = QPixmap()
self.icon_label.setStyleSheet(
"QLabel {border-style: outset; border-width: 3px; border-color: gold}"
)
try:
iconPixmap.loadFromData(
self.summoner.getImage('profileicon', iconName))
self.icon_label.setPixmap(iconPixmap)
except RiotError:
iconPixmap.load("./images/no_image.png")
self.icon_label.setPixmap(iconPixmap)
#display summoner rank
def displayRank(self, sumID):
for x in range(len(self.series_labels)):
self.series_labels[x].setPixmap(QPixmap())
try:
tier = self.summoner.getTier(sumID)
division = self.summoner.getDivision(sumID)
points = self.summoner.getLeaguePoints(sumID)
self.rank_label.setText(tier + ': ' + division + '\n' +
str(points) + ' league points')
if points == 100:
self.displayMiniseries(sumID)
except KeyError:
self.rank_label.setText('UNRANKED')
#display promotion series
def displayMiniseries(self, sumID):
progress = self.summoner.getRankSeries(sumID)
i = 0
for x in progress:
if x == 'W':
self.series_labels[i].setPixmap(self.pixmap_win)
elif x == 'L':
self.series_labels[i].setPixmap(self.pixmap_loss)
else:
self.series_labels[i].setPixmap(self.pixmap_n)
self.clean_up_queue.append(self.series_labels[i])
self.series_labels[i].show()
i += 1
#display summoner menu
def displayMenu(self, sumID):
self.displayOverviewMenu(sumID)
self.displayRuneMenu(sumID)
self.displayMasteryMenu(sumID)
self.clean_up_queue.append(self.menu)
self.menu.show()
#display overview menu
def displayOverviewMenu(self, sumID):
self.overview_menu.clear()
overview_normal = OverviewWidget()
overview_ranked_solo = OverviewWidget()
overview_ranked_team = OverviewWidget()
overview_champions = ChampionsWidget()
overview_normal.showStats(self.summoner.getStats(sumID, 'Normal'))
overview_ranked_solo.showStats(
self.summoner.getStats(sumID, 'Ranked Solo'))
overview_ranked_team.showStats(
self.summoner.getStats(sumID, 'Ranked Team'))
overview_champions.showStats(self.summoner.getChampionStats(sumID),
self.championIcons)
self.overview_menu.addTab(overview_normal, 'Normal')
self.overview_menu.addTab(overview_ranked_solo, 'Ranked Solo')
self.overview_menu.addTab(overview_ranked_team, 'Ranked Team')
self.overview_menu.addTab(overview_champions, 'Champions')
#display rune menu
def displayRuneMenu(self, sumID):
self.runes_menu.clear()
for x in range(self.summoner.getNumOfRunePages(sumID)):
rune_page = RuneWidget()
rune_page.setSize(700, 225)
rune_page.setName(self.summoner.getRunePageName(sumID, x))
rune_data = self.summoner.getRunes(sumID, x)
if rune_data != None:
for y in rune_data:
rid = self.summoner.getRuneID(y)
desc = self.summoner.runeDescription(rid)
rname = self.summoner.runeName(rid)
rune_page.addRune(rid, desc, rname)
rune_page.showRunes()
self.runes_menu.addTab(rune_page, str(x + 1))
#display mastery menu
def displayMasteryMenu(self, sumID):
self.masteries_menu.clear()
for x in range(self.summoner.getNumOfMasteryPages(sumID)):
mastery_page = MasteryWidget()
mastery_page.setMasteryLabels(self.ferocity_tree_images,
self.cunning_tree_images,
self.resolve_tree_images)
mastery_page.setName(self.summoner.getMasteryPageName(sumID, x))
mastery_data = self.summoner.getMasteries(sumID, x)
if mastery_data != None:
for y in mastery_data:
mid = self.summoner.getMasteryID(y)
rank = self.summoner.getMasteryRank(y)
mastery_page.setMasteryRank(mid, rank)
mastery_page.setTotalPoints()
self.masteries_menu.addTab(mastery_page, str(x + 1))
class Empresas(QMainWindow, Ui_MainWindow):
"""
Class documentation goes here.
"""
def __init__(self, parent=None):
"""
Constructor
"""
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.botonera = Botonera(self.frmbotonera)
#self.botonera.connect(self, QtCore.SIGNAL('on_btnNuevo_released()'), self.on_action_Nuevo_triggered)
#self.botonera.setupUi(self.frmbotonera)
self.connect(self.botonera, QtCore.SIGNAL("btnNuevo_released"),
self.on_actionNuevo_triggered)
self.connect(self.botonera, QtCore.SIGNAL("btnModificar_released"),
self.on_actionModificar_triggered)
self.connect(self.botonera, QtCore.SIGNAL("btnGuardar_released"),
self.on_actionGuardar_triggered)
self.connect(self.botonera, QtCore.SIGNAL("btnSalir_released"),
self.on_actionSalir_triggered)
self.connect(self.botonera, QtCore.SIGNAL("btnSearch_released"),
self.show_search)
self.connect(self.botonera, QtCore.SIGNAL("btnEliminar_released"),
self.on_actionEliminar_triggered)
self.datos = Dbdata()
#self.havedata=False
self.fill_data()
#base de datos para controlesQT (tablesview, combos, etc)
self.db = QDbdata()
self.ok = self.db.open()
self.isediting = False
self.isadding = False
#self.emit(SIGNAL("btnNuevo_released"), ())
self.msgBox = QMessageBox(self)
self.search = Busqueda(self)
self.search.db = self.db
self.search.campos = ['id', 'nombre', 'rif']
self.search.tabla = 'cf_empresa'
self.search.headers = ['Id', 'Nombre', 'Rif']
self.search.sql = 'select ' + ','.join(
self.search.campos) + ' from ' + self.search.tabla
self.connect(self.search, QtCore.SIGNAL("tableView_clicked"),
self.fill_data)
def show_search(self):
self.search.fillgrid()
self.search.show()
def fill_data(self, id=None):
#id.model().record(id.row()).value('id').toInt()
#if id !=None:
# id = id.model().record(id.row()).value('id').toInt()
# id = id[0] #solo para enteros para string cambia
if self.datos.check_havedata('cf_empresa') == True:
self.botonera.btnModificar.setEnabled(True)
self.botonera.btnEliminar.setEnabled(True)
self.botonera.btnSearch.setEnabled(True)
self.botonera.btnPrint.setEnabled(True)
self.emp = self.datos.get_data('cf_empresa', id)
self.empid = self.emp[0]
self.lineEdit_2.setText(self.emp[1])
self.lineEdit_3.setText(self.emp[2])
self.lineEdit_4.setText(self.emp[3])
self.lineEdit_5.setText(self.emp[4])
self.lineEdit_6.setText(self.emp[5])
self.lineEdit_7.setText(self.emp[6])
self.lineEdit_8.setText(self.emp[7])
self.lineEdit.setText(self.emp[8])
else:
self.botonera.btnModificar.setEnabled(False)
self.botonera.btnEliminar.setEnabled(False)
self.clear_fields()
def clear_fields(self):
self.lineEdit_2.setText('')
self.lineEdit_3.setText('')
self.lineEdit_4.setText('')
self.lineEdit_5.setText('')
self.lineEdit_6.setText('')
self.lineEdit_7.setText('')
self.lineEdit_8.setText('')
self.lineEdit.setText('')
@pyqtSignature("")
def on_pushButton_released(self):
"""
Slot documentation goes here.
"""
self.filedialog = QFileDialog.getOpenFileName(self,
"Seleccione Archivo", "",
"*.jpg")
self.lineEdit.setText(self.filedialog)
self.logo = QPixmap()
self.logo.load(self.filedialog)
self.label.setPixmap(self.logo)
self.msgBox.setText("Imagen cargada con exito !!!")
self.msgBox.exec_()
#codigo para copiar a la carpeta seleccionada y dialogo todo ok
@pyqtSignature("")
def on_actionNuevo_triggered(self):
self.isadding = True
self.clear_fields()
self.frame_2.setEnabled(True)
self.frame_3.setEnabled(True)
@pyqtSignature("")
def on_actionModificar_triggered(self):
self.isediting = True
self.frame_2.setEnabled(True)
self.frame_3.setEnabled(True)
# self.actionGuardar.setEnabled(True)
# self.actionNuevo.setEnabled(False)
# self.actionEliminar.setEnabled(False)
# self.actionModificar.setEnabled(False)
@pyqtSignature("")
def on_actionEliminar_triggered(self):
"""
Slot documentation goes here.
"""
self.msgBox.setText('Esta seguro de eliminar registro?')
self.msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
self.msgBox.setDefaultButton(QMessageBox.Cancel)
result = self.msgBox.exec_()
#print sssss
if result == QMessageBox.Ok:
datos = ['cf_empresa', self.empid]
rs = self.datos.delete_record(datos)
if rs:
self.mensaje = 'Registro eliminado'
self.msgBox.setText(self.mensaje)
self.msgBox.exec_()
if self.datos.check_havedata('cf_empresa'):
self.fill_data()
else:
self.clear_fields()
@pyqtSignature("")
def on_actionGuardar_triggered(self):
"""
Slot documentation goes here.
"""
#nombre,razon_social,rif,nit,email,tlf,fax,ruta_foto
if self.isadding:
datos = [
self.lineEdit_2.text(),
self.lineEdit_3.text(),
self.lineEdit_4.text(),
self.lineEdit_5.text(),
self.lineEdit_6.text(),
self.lineEdit_7.text(),
self.lineEdit_8.text(),
self.lineEdit.text()
]
self.lastid = self.datos.save_empresa(datos)
self.mensaje = 'Datos salvados con exito'
elif self.isediting:
datos = [
self.lineEdit_2.text(),
self.lineEdit_3.text(),
self.lineEdit_4.text(),
self.lineEdit_5.text(),
self.lineEdit_6.text(),
self.lineEdit_7.text(),
self.lineEdit_8.text(),
self.lineEdit.text(), self.empid
]
self.datos.update_empresa(datos)
self.lastid = self.empid
self.mensaje = 'Datos actualizados con exito'
self.frame_2.setEnabled(False)
self.frame_3.setEnabled(False)
self.msgBox.setText(self.mensaje)
self.msgBox.exec_()
self.isediting = False
self.isadding = False
self.fill_data(self.lastid)
@pyqtSignature("")
def on_actionSalir_triggered(self):
"""
Slot documentation goes here.
"""
self.msgBox.setText('Esta seguro que desea salir?')
self.msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
self.msgBox.setDefaultButton(QMessageBox.Cancel)
result = self.msgBox.exec_()
if result == QMessageBox.Ok:
self.close()
else:
pass
