def must_glow(widget_list):
" apply an glow effect to the widget "
for glow, each_widget in enumerate(widget_list):
try:
if each_widget.graphicsEffect() is None:
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
each_widget.setGraphicsEffect(glow)
# glow.setEnabled(False)
try:
each_widget.clicked.connect(
lambda: each_widget.graphicsEffect().setEnabled(True)
if each_widget.graphicsEffect().isEnabled() is False
else each_widget.graphicsEffect().setEnabled(False)
)
except:
each_widget.sliderPressed.connect(
lambda: each_widget.graphicsEffect().setEnabled(True)
if each_widget.graphicsEffect().isEnabled() is False
else each_widget.graphicsEffect().setEnabled(False)
)
except:
pass
def enableHoverEffect(self):
e = QGraphicsDropShadowEffect()
e.setEnabled(False)
e.setBlurRadius(2 * _trackWidth)
e.setColor(_hoverColor)
e.setOffset(0, 0)
self.setGraphicsEffect(e)
self.setAcceptHoverEvents(True)
class Meterbar(Button):
def __init__(self, max=255, filename=None, width=None, height=None, x=0, y=0, pixmap=None, group=None, pos=None, size=None, padding=None):
Button.__init__(self, filename, width, height, x, y, pixmap, group, pos, size, padding)
self.max = max
self.outer = QGraphicsRectItem(x,y,width,max + 2)
self.outer.setPen(QPen(QColor(Qt.black), 1, Qt.SolidLine))
self.outer.setBrush(Qt.green)
# self.outer.hide()
self.inner = QGraphicsRectItem(x + 1,y + 1,width - 2,max)
self.inner.setPen(QPen(QColor(Qt.green), 1, Qt.SolidLine))
self.inner.setBrush(Qt.blue)
self.items = [self.outer, self.inner]
self.current = 255
self.effect = QGraphicsDropShadowEffect()
self.effect.setOffset(0, 0)
self.effect.setBlurRadius(0)
self.effect.setColor(Qt.green)
self.item = self.outer
self.addEffect('shadow', self.effect, True)
self.addAnimation('glow', Glow(15, 300, self, maxRadius=80, minRadius=5))
# self.test(10)
def test(self, x):
self.tl = QTimeLine(10000)
self.tl.setFrameRange(0, 10000)
self.a = QGraphicsItemAnimation()
self.a.setItem(self.inner)
self.a.setTimeLine(self.tl)
# self.a.setPosAt(0, QPointF(self.getX(), self.current))
# self.a.setTranslationAt(1, self.getX(), self.getY() + self.max - x + 1)
self.a.setScaleAt(0, 1, 1)
self.a.setScaleAt(1, 1, 0.1)
self.current = x
self.tl.start()
def update(self, x):
x2 = 1 - (float(x) * 1.0 / float(self.max))
# print x
# return
self.tl = QTimeLine(10)
self.tl.setFrameRange(0, 10)
self.a = QGraphicsItemAnimation()
self.a.setItem(self.inner)
self.a.setTimeLine(self.tl)
# self.a.setPosAt(0, QPointF(self.getX(), self.current))
# self.a.setTranslationAt(1, self.getX(), self.getY() + self.max - x + 1)
self.a.setScaleAt(0, 1, self.current)
self.a.setScaleAt(1, 1, x2)
self.current = x
self.tl.start()
if x > 3 :
self.play('glow')
def setScene(self, scene):
self.scene = scene
for item in self.items :
self.scene.addItem(item)
class FaceButtonsView(QGraphicsView):
def __init__(self, *args):
QGraphicsView.__init__(self, *args)
self.move(170, 90)
self.btnSize = 40
self.padding = 5
self.setMaximumHeight(self.btnSize * 4)
self.setMaximumWidth(self.btnSize * 4)
self.setMinimumHeight(self.btnSize * 4)
self.setMinimumWidth(self.btnSize * 4)
self.adjustSize()
self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;')
self.scene = QGraphicsScene(self)
self.psButtons = QPixmap(os.getcwd() + '/../icons/PS3_Buttons.png')
self.triangle = self.psButtons.copy(0, 0, 220, 225)
self.triangle = self.triangle.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.square = self.psButtons.copy(220, 0, 220, 225)
self.square = self.square.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.circle = self.psButtons.copy(440, 0, 220, 225)
self.circle = self.circle.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.cross = self.psButtons.copy(660, 0, 220, 225)
self.cross = self.cross.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.triangleItem = QGraphicsPixmapItem(self.triangle)
self.triangleItem.setOffset(QPointF(self.btnSize + self.padding, 0))
self.scene.addItem(self.triangleItem)
self.squareItem = QGraphicsPixmapItem(self.square)
self.squareItem.setOffset(QPointF(0, self.btnSize + self.padding))
self.scene.addItem(self.squareItem)
self.circleItem = QGraphicsPixmapItem(self.circle)
self.circleItem.setOffset(QPointF(self.btnSize * 2 + self.padding * 2, self.btnSize + self.padding))
self.scene.addItem(self.circleItem)
self.crossItem = QGraphicsPixmapItem(self.cross)
self.crossItem.setOffset(QPointF(self.btnSize + self.padding, self.btnSize * 2 + self.padding * 2))
self.scene.addItem(self.crossItem)
self.effect = QGraphicsDropShadowEffect()
self.effect.setOffset(0, 0)
self.effect.setBlurRadius(20)
self.effect.setColor(Qt.green)
self.triangleItem.setGraphicsEffect(self.effect)
self.setScene(self.scene)
self.tl2 = QTimeLine(10000)
self.tl2.setFrameRange(0, 10000)
self.t = QGraphicsItemAnimation()
self.t.setItem(self.triangleItem)
self.t.setTimeLine(self.tl2)
self.tl2.connect(self.tl2, SIGNAL('frameChanged(int)'), self.updateEffect)
self.effectd = 3
self.tl2.start()
def updateEffect(self):
if self.effect.blurRadius() > 50:
self.effectd = -3
elif self.effect.blurRadius() < 5:
self.effectd = 3
self.effect.setBlurRadius(self.effect.blurRadius() + self.effectd)
def __init__(self, id_, ad, nm, ip, ms='', gw='', dns='', parent=None):
super(NetConfigTile, self).__init__(parent)
self.animation = QPropertyAnimation(self, "size")
self.setObjectName('tile')
self.setCursor(QCursor(Qt.PointingHandCursor))
effect = QGraphicsDropShadowEffect(self)
effect.setOffset(0, 0)
effect.setBlurRadius(20)
self.setGraphicsEffect(effect)
# self.setContextMenuPolicy(Qt.ActionsContextMenu)
# action = QAction('edit', self)
# self.addAction(action)
self.setToolTip(
'interfaz: %s\nnombre: %s\nip: %s\nmascara: %s\ngateway: %s\ndns: %s'
% (ad, nm, ip, ms, gw, dns))
self.setFixedWidth(300)
self.setMinimumHeight(90)
self.ID = id_
self.lbl_nm = QLabel(nm)
self.lbl_nm.setObjectName('lbl_nm')
self.lbl_ad = QLabel(ad)
self.lbl_ad.setObjectName('lbl_ad')
self.lbl_ip = QLabel(ip)
self.lbl_ip.setObjectName('lbl_ip')
self.lbl_ms = QLabel(ms)
self.lbl_ms.setObjectName('lbl_ms')
self.lbl_gw = QLabel(gw)
self.lbl_gw.setObjectName('lbl_gw')
self.lbl_dns = QLabel(dns)
self.lbl_dns.setObjectName('lbl_dns')
layout_left = QVBoxLayout()
layout_left.addWidget(self.lbl_ad)
layout_left.addWidget(self.lbl_nm)
layout_left.addWidget(self.lbl_ip)
layout_lbl = QHBoxLayout()
layout_lbl.addLayout(layout_left)
self.btn_remove = QPushButton()
self.btn_remove.setFixedSize(QSize(60, 60))
self.btn_remove.setObjectName('btn_remove')
self.btn_remove.setCursor(QCursor(Qt.ArrowCursor))
self.grid_layout = QGridLayout()
self.grid_layout.addWidget(self.btn_remove, 1, 0)
self.grid_layout.addLayout(layout_lbl, 1, 1, 1, 2)
self.setLayout(self.grid_layout)
self.setStyleSheet(self.load_style_sheet())
self.connect(self.btn_remove, SIGNAL('released()'), self.remove_tile)
class DpadView(QGraphicsView):
def __init__(self, *args):
QGraphicsView.__init__(self, *args)
self.move(2, 90)
self.btnSize = 75
self.padding = -35
self.setMaximumHeight(self.btnSize * 2 + 20)
self.setMaximumWidth(self.btnSize * 2 + 20)
self.setMinimumHeight(self.btnSize * 2 + 20)
self.setMinimumWidth(self.btnSize * 2 + 20)
self.adjustSize()
self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;')
self.scene = QGraphicsScene(self)
self.left = QPixmap(os.getcwd() + '/../icons/left.png')
self.left = self.left.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.right = QPixmap(os.getcwd() + '/../icons/right.png')
self.right = self.right.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.up = QPixmap(os.getcwd() + '/../icons/up.png')
self.up = self.up.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.down = QPixmap(os.getcwd() + '/../icons/down.png')
self.down = self.down.scaled(self.btnSize, self.btnSize, Qt.KeepAspectRatio)
self.leftItem = QGraphicsPixmapItem(self.left)
self.leftItem.setOffset(QPointF(0, self.btnSize + self.padding))
self.scene.addItem(self.leftItem)
self.rightItem = QGraphicsPixmapItem(self.right)
self.rightItem.setOffset(QPointF(self.btnSize * 2 + self.padding * 2, self.btnSize + self.padding))
self.scene.addItem(self.rightItem)
self.upItem = QGraphicsPixmapItem(self.up)
self.upItem.setOffset(QPointF(self.btnSize + self.padding, 0))
self.scene.addItem(self.upItem)
self.downItem = QGraphicsPixmapItem(self.down)
self.downItem.setOffset(QPointF(self.btnSize + self.padding, self.btnSize * 2 + self.padding * 2))
self.scene.addItem(self.downItem)
self.effect = QGraphicsDropShadowEffect()
self.effect.setOffset(0, 0)
self.effect.setBlurRadius(20)
self.effect.setColor(Qt.green)
self.downItem.setGraphicsEffect(self.effect)
self.setScene(self.scene)
self.tl2 = QTimeLine(10000)
self.tl2.setFrameRange(0, 10000)
self.t = QGraphicsItemAnimation()
self.t.setItem(self.downItem)
self.t.setTimeLine(self.tl2)
self.tl2.connect(self.tl2, SIGNAL('frameChanged(int)'), self.updateEffect)
self.effectd = 3
self.tl2.start()
def updateEffect(self):
if self.effect.blurRadius() > 50:
self.effectd = -3
elif self.effect.blurRadius() < 5:
self.effectd = 3
self.effect.setBlurRadius(self.effect.blurRadius() + self.effectd)
def must_glow(widget_list):
' apply an glow effect to the widget '
for glow, each_widget in enumerate(widget_list):
try:
if each_widget.graphicsEffect() is None:
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
each_widget.setGraphicsEffect(glow)
glow.setEnabled(True)
except:
pass
def createImageLabel(page, frameName, properties):
imageLabel = QLabel(page)
imageLabel.setObjectName(frameName + properties['name'])
imageLabel.setStyleSheet("#" + frameName + properties['name'] +
" { background-color: transparent; }")
if properties['shadow']:
textEffect = QGraphicsDropShadowEffect()
textEffect.setOffset(properties['shadow']['offset'])
textEffect.setBlurRadius(properties['shadow']['blur'])
textEffect.setColor(QColor(properties['shadow']['color']))
imageLabel.setGraphicsEffect(textEffect)
imageLabel.setGeometry(properties['location'][0],
properties['location'][1],
properties['location'][2],
properties['location'][3])
return imageLabel
class HighlightEdit(QLineEdit):
clicked = pyqtSignal(name="clicked")
def __init__(self, parent):
QLineEdit.__init__(self, parent)
self._highlight_effect = QGraphicsDropShadowEffect(self)
self._highlight_effect.setOffset(0.0)
self._highlight_effect.setBlurRadius(5.0)
self._highlight_effect.setColor(QColor(50, 50, 200))
self.setGraphicsEffect(self._highlight_effect)
self._highlight_effect.setEnabled(False)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(QIcon.fromTheme("edit-clear", QIcon("icons/delete_icon.png")))
self.clear_button.setCursor(Qt.ArrowCursor)
self.clear_button.setStyleSheet("QToolButton { border: none; padding: 1.5px; }")
icon_size = int(self.sizeHint().height() * 0.65)
self.clear_button.setIconSize(QSize(icon_size, icon_size))
self.clear_button.clicked.connect(self.clear)
# self.clear_button.hide()
# some padding stuff
frameWidth = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
self.setStyleSheet(
"QLineEdit {{ padding-right: {}px; }} ".format(self.clear_button.sizeHint().width() + frameWidth)
)
# create a signal on doubleclick events
def mouseDoubleClickEvent(self, ev):
ev.accept()
self.clicked.emit()
# fix up the clear button positioning
def resizeEvent(self, ev):
sz = self.clear_button.sizeHint()
frameWidth = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
self.clear_button.move(
self.rect().right() - frameWidth - sz.width(), (self.rect().bottom() + 1 - sz.height()) / 2
)
# a slot for turning the graphics effect on and off
@pyqtSlot(bool)
def highlight(self, val):
self._highlight_effect.setEnabled(val)
class HighlightEdit(QLineEdit):
clicked = pyqtSignal(name='clicked')
def __init__(self, parent):
QLineEdit.__init__(self, parent)
self._highlight_effect = QGraphicsDropShadowEffect(self)
self._highlight_effect.setOffset(0.0)
self._highlight_effect.setBlurRadius(5.0)
self._highlight_effect.setColor(QColor(50, 50, 200))
self.setGraphicsEffect(self._highlight_effect)
self._highlight_effect.setEnabled(False)
self.clear_button = QToolButton(self)
self.clear_button.setIcon(
QIcon.fromTheme("edit-clear", QIcon("icons/delete_icon.png")))
self.clear_button.setCursor(Qt.ArrowCursor)
self.clear_button.setStyleSheet(
"QToolButton { border: none; padding: 1.5px; }")
icon_size = int(self.sizeHint().height() * 0.65)
self.clear_button.setIconSize(QSize(icon_size, icon_size))
self.clear_button.clicked.connect(self.clear)
#self.clear_button.hide()
# some padding stuff
frameWidth = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
self.setStyleSheet("QLineEdit {{ padding-right: {}px; }} ".format(
self.clear_button.sizeHint().width() + frameWidth))
#create a signal on doubleclick events
def mouseDoubleClickEvent(self, ev):
ev.accept()
self.clicked.emit()
# fix up the clear button positioning
def resizeEvent(self, ev):
sz = self.clear_button.sizeHint()
frameWidth = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
self.clear_button.move(self.rect().right() - frameWidth - sz.width(),
(self.rect().bottom() + 1 - sz.height()) / 2)
# a slot for turning the graphics effect on and off
@pyqtSlot(bool)
def highlight(self, val):
self._highlight_effect.setEnabled(val)
def createTextLabel(page, frameName, properties):
textLabel = QLabel(page)
textLabel.setObjectName(frameName + properties['name'])
textLabel.setStyleSheet("#" + frameName + properties['name'] +
"{ font-family:" + properties['font'] +
"; color: " + properties['color'] +
"; background-color: transparent; font-size: " +
properties['fontsize'] + "px; " +
properties['fontattr'] + "}")
textLabel.setAlignment(align(properties['alignment']))
if properties['shadow']:
textEffect = QGraphicsDropShadowEffect()
textEffect.setOffset(properties['shadow']['offset'])
textEffect.setBlurRadius(properties['shadow']['blur'])
textEffect.setColor(QColor(properties['shadow']['color']))
textLabel.setGraphicsEffect(textEffect)
textLabel.setGeometry(properties['location'][0], properties['location'][1],
properties['location'][2], properties['location'][3])
return textLabel
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.configOptions, self.checkBoxList, self.configBool = {}, {}, None
# Check for root privileges
if geteuid() != 0:
msg = ("{} is not root. You need to run with root priviliges\n"
"Please use kdesudo, gksu or sudo/sux.").format(getuser())
QMessageBox.critical(self, __doc__ + "- Error", msg)
sys.exit(1)
else:
msg = "This tool is running with root priviliges."
QMessageBox.warning(self, __doc__ + "- Warning", msg)
# title, icon and sizes
self.setWindowTitle(__doc__)
self.setMinimumSize(400, 400)
self.setMaximumSize(2048, 2048)
self.resize(600, 600)
self.setWindowIcon(QIcon.fromTheme("preferences-system"))
self.menuBar().addMenu("&File").addAction("Exit", exit)
QShortcut("Ctrl+q", self, activated=lambda: self.close())
# main group
main_group = QGroupBox("Module configuration")
self.setCentralWidget(main_group)
self.layout = QVBoxLayout(main_group)
# scrollarea widgets
self.scrollArea, self.window = QScrollArea(), QWidget()
self.layout.addWidget(self.scrollArea)
self.vbox = QVBoxLayout(self.window)
# Graphic effect
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.scrollArea.setGraphicsEffect(glow)
glow.setEnabled(True)
# config loading stuff
self.findConfig(CONFIG_DIR)
for eachOption in tuple(self.configOptions.keys()):
self.readConfig(eachOption, self.configOptions)
self.subLayout = QHBoxLayout()
self.checkBoxName = "checkBox_" + eachOption
checkBoxList = QCheckBox(self.checkBoxName, self)
self.checkBoxList[self.checkBoxName] = checkBoxList
checkBoxList.setObjectName(self.checkBoxName)
checkBoxList.setText("Enable module {}".format(eachOption))
if self.tooltip is not '':
checkBoxList.setToolTip(self.tooltip)
else:
tooltip = "Configuration settings for {}".format(eachOption)
checkBoxList.setToolTip(tooltip)
if self.configBool:
checkBoxList.setChecked(True)
self.subLayout.addWidget(checkBoxList)
self.vbox.addLayout(self.subLayout)
self.scrollArea.setWidget(self.window)
# Bottom Buttons Bar
self.pushButtonSleep = QPushButton("Sleep")
self.pushButtonSleep.setToolTip("Trigger Suspend to RAM aka Sleep")
self.pushButtonSleep.clicked.connect(self.sleep)
self.pushButtonHibernate = QPushButton("Hibernate")
self.pushButtonHibernate.setToolTip(
"Trigger Suspend to Disk Hibernate")
self.pushButtonHibernate.clicked.connect(self.hibernate)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Close
| QDialogButtonBox.Help)
self.buttonBox.addButton(self.pushButtonHibernate,
QDialogButtonBox.ActionRole)
self.buttonBox.addButton(self.pushButtonSleep,
QDialogButtonBox.ActionRole)
self.layout.addWidget(self.buttonBox)
self.buttonBox.rejected.connect(exit)
self.buttonBox.accepted.connect(self.writeConfig)
self.buttonBox.helpRequested.connect(lambda: open_new_tab(WEBPAGE_URL))
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self.readOutput)
self.process.readyReadStandardError.connect(self.readErrors)
self.process.finished.connect(self._process_finished)
# self.process.error.connect(self._process_error)
self.sourceDirectory, self.outputDirectory = None, None
self.group2 = QGroupBox()
self.group2.setTitle(' Paths ')
self.inf = QLineEdit(path.expanduser("~"))
self.inf.setPlaceholderText(' /full/path/to/directory ')
self.out, self.fle = QLineEdit(path.expanduser("~")), QLineEdit()
self.out.setPlaceholderText(' /full/path/to/directory ')
self.fle.setPlaceholderText(' /full/path/to/single/file ')
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.inf.setCompleter(self.completer)
self.out.setCompleter(self.completer)
self.fle.setCompleter(self.completer)
self.open1 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open1.setCursor(QCursor(Qt.PointingHandCursor))
self.open1.clicked.connect(lambda: self.inf.setText(str(
QFileDialog.getExistingDirectory(self.dock, "Open Source Directory",
path.expanduser("~")))))
self.open2 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open2.setCursor(QCursor(Qt.PointingHandCursor))
self.open2.clicked.connect(lambda: self.out.setText(str(
QFileDialog.getExistingDirectory(self.dock, "Open Target Directory",
path.expanduser("~")))))
self.open3 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open3.setCursor(QCursor(Qt.PointingHandCursor))
self.open3.clicked.connect(lambda: self.fle.setText(str(
QFileDialog.getOpenFileName(self.dock, "Open a Target File...",
path.expanduser("~"), ';;'.join(['{}(*.{})'.format(e.upper(), e)
for e in ['py', 'pyw', '*']])))))
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (
QLabel('Source Directory Project:'), self.inf, self.open1,
QLabel(' Target Directory Outputs: '), self.out, self.open2,
QLabel(' Source Single File (Optional):'), self.fle, self.open3, ):
vboxg2.addWidget(each_widget)
self.group1 = QGroupBox()
self.group1.setTitle(' Options ')
self.chckbx1 = QCheckBox(' Inject Twitter Bootstrap CSS3 ')
self.chckbx1.toggled.connect(self.toggle_styles_group)
self.chckbx2 = QCheckBox(' Warn all missing references ')
self.chckbx3 = QCheckBox(' Open Docs when done building ')
self.chckbx4 = QCheckBox('Save Bash script to reproduce Sphinx Builds')
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (self.chckbx1, self.chckbx2,
self.chckbx3, self.chckbx4):
vboxg1.addWidget(each_widget)
each_widget.setChecked(True)
self.group3 = QGroupBox()
self.group3.setTitle(' Styles ')
self.group3.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group3.graphicsEffect().setEnabled(False)
self.basecss, self.fontcss = QComboBox(), QComboBox()
self.basecss.addItems(['slate', 'united', 'spacelab', 'superhero',
'simplex', 'journal', 'flatly', 'cyborg', 'cosmo', 'cerulean'])
self.fontcss.addItems(['Ubuntu Light', 'Oxygen', 'Roboto', 'Droid Sans',
'Open Sans', 'Pacifico', 'Rancho', 'Arvo', 'Fresca', 'Graduate'])
self.backcss = QComboBox()
self.backcss.addItems(['shattered', 'retina_wood', 'ricepaper',
'brickwall', 'sneaker_mesh_fabric', 'diagonales_decalees',
'noisy_grid', 'pw_pattern', 'escheresque', 'diamond_upholstery'])
vboxg3 = QVBoxLayout(self.group3)
for each_widget in (QLabel('<b>Twitter Bootstrap Theme'), self.basecss,
QLabel('<b>Fonts Family'), self.fontcss,
QLabel('<b>Background Seamless Tiled Pattern'), self.backcss):
vboxg3.addWidget(each_widget)
self.output = QTextEdit('''
My brain is something more than merely mortal; As time will show.
- Ada Lovelace ''')
self.output.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.button = QPushButton('Document My Code')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(75, 50)
self.button.clicked.connect(self.build)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((self.group2, self.group1, self.group3,
QLabel(linesep + ' Logs: '), self.output, self.button))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Sphinx")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda:
QMessageBox.information(self.dock, __doc__, HELPMSG))
class Dial(QGraphicsItem):
"""
Dial
"""
def __init__(self):
super(Dial, self).__init__()
self.angle = 0
# Colors
self.color = QColor(120, 120, 120, 255)
self.notchColor = QColor(115, 115, 115, 255)
self.normalBorderColor = QColor( 255, 255, 255, 30 )
self.selectedBorderColor = QColor( 255, 191, 0, 102 )
self.textColor = QColor( 30, 30, 30, 255 )
self.shadowColor = QColor(0, 0, 0, 75)
self.selectedShadowColor = QColor( 100, 100, 100, 255 )
# Settings
self.width, self.height = 75, 75
# Drop Shadow
self.shadowBlurRadius = 8
self.shadow = QGraphicsDropShadowEffect()
self.shadow.setBlurRadius(self.shadowBlurRadius)
self.shadow.setOffset(0, 0.5)
self.shadow.setColor(self.shadowColor)
self.setGraphicsEffect(self.shadow)
# Painter Definitions
self.pen = QPen()
gradient = QRadialGradient(self.boundingRect().center() + QPointF(0, -20), 80)
gradient.setColorAt(0, self.color.lighter(117))
gradient.setColorAt(1, self.color)
self.brush = QBrush(gradient)
self.font = QFont()
self.pen.setWidth(1)
self.pen.setColor(self.normalBorderColor)
self.brush.setColor(self.color)
self.font.setPointSize(10)
# Nodegraph Definitions
self.dragPoint = None
self.dragAngle = 0
self.dragFactor = 0
# Notch Specifications
self.notch = DialNotch()
self.notch.setParentItem(self)
self.updateNotch()
def boundingRect(self):
"""
Overrides QGraphicsItem's boundingRect() virtual public function and
returns a valid bounding rect based on calculated width and height.
"""
return QRectF(0, 0, self.width, self.height).adjusted(
-self.shadowBlurRadius, -self.shadowBlurRadius,
self.shadowBlurRadius, self.shadowBlurRadius)
def paint(self, painter, option, widget):
"""
Overrides QGraphicsItem's paint() virtual public function.
"""
painter.setPen(self.pen)
painter.setBrush(self.brush)
painter.drawEllipse(self.boundingRect())
def mousePressEvent(self, event):
self.dragPoint = event.scenePos()
self.dragAngle = self.angle
part = self.height / 2
distance = event.pos().y() - part
if distance == 0:
self.dragFactor = 0
else:
self.dragFactor = part / distance
def mouseMoveEvent(self, event):
scenePos = event.scenePos()
d = scenePos - self.dragPoint
self.angle = self.dragAngle + d.x() * self.dragFactor
self.updateNotch()
def mouseReleaseEvent(self, event):
self.dragPoint = None
self.dragAngle = 0
def updateNotch(self):
f = 0.02
dx = (self.width - self.notch.width) / 2
dy = (self.height - self.notch.height) / 2
x = math.sin(math.radians(self.angle)) * dx + dx
y = math.cos(math.radians(self.angle)) * dy + dy
self.notch.setPos(x, y)
def initialize(self, *args, **kwargs):
" Init Main Class "
ec = ExplorerContainer()
super(Main, self).initialize(*args, **kwargs)
# directory auto completer
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.RUNS, self.FAILS = 0, 0
self.group0 = QGroupBox()
self.group0.setTitle(' Source and Target ')
self.baseurl = QLineEdit('http://google.com')
self.outfile = QLineEdit(path.join(path.expanduser("~"), 'test.py'))
self.outfile.setCompleter(self.completer)
self.open = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open.clicked.connect(lambda: self.outfile.setText(
QFileDialog.getSaveFileName(self.dock, "Save", path.expanduser(
"~"), 'PYTHON(*.py)')))
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (QLabel('<b>Base URL'), self.baseurl,
QLabel('<b>Local File Target'), self.outfile,
self.open):
vboxg0.addWidget(each_widget)
self.group1 = QGroupBox()
self.group1.setTitle(' Selenium ')
self.group1.setCheckable(True)
self.group1.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group1.graphicsEffect().setEnabled(False)
self.group1.toggled.connect(self.toggle_group)
self.ckcss1 = QCheckBox('Test for correct Page Loading behaviour')
self.ckcss2 = QCheckBox('Test for Sucessfull Status Code return')
self.ckcss3 = QCheckBox('Test for valid Title of the web page')
self.ckcss4 = QCheckBox('Test for Cookies Basic functionality')
self.ckcss5 = QCheckBox('Test for Back, Forward, Reload behaviour')
self.ckcss6 = QCheckBox('Take a Screenshot of page (CSS Debug)')
self.ckcss7 = QCheckBox('Test for Search Form Field of the page')
self.ckcss8 = QCheckBox(
'Test for Arbitrary Javascript (User provided)')
self.ckcss9 = QCheckBox('Test for iFrame of the web page')
self.ckcss10 = QCheckBox('Test for HTML5 Canvas element on the page')
self.ckcss11 = QCheckBox('Test for HTML5 SVG element on the page')
self.ckcss12 = QCheckBox('Test for HTML5 Audio element on the page')
self.ckcss13 = QCheckBox('Test for HTML5 Video element on the page')
self.ckcss14 = QCheckBox('Test for File Upload form on the page')
self.ckcss15 = QCheckBox('Add ChromeDriver path to sys.path')
self.webdriver = QComboBox()
self.webdriver.addItems(
['firefox', 'chrome', 'zope.testbrowser', 'phantomjs'])
self.titletxt = QLineEdit('Google')
self.javascript = QLineEdit('console.log("test")')
self.authdata, self.formdata = QLineEdit(), QLineEdit()
self.authdata.setPlaceholderText(
"{'username':'******','password':'******'}")
self.formdata.setPlaceholderText("{'name': 'Joe', 'age': '25'}")
self.iframurl = QLineEdit()
self.chrmedrv = QLineEdit('/usr/bin/chromedriver')
self.timeout = QSpinBox()
self.timeout.setMaximum(99)
self.timeout.setMinimum(0)
self.timeout.setValue(9)
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (
self.ckcss1, self.ckcss2, self.ckcss3, self.ckcss4,
self.ckcss5, self.ckcss6, self.ckcss7, self.ckcss8,
self.ckcss9, self.ckcss10, self.ckcss11,
self.ckcss12, self.ckcss13, self.ckcss14, self.ckcss15,
QLabel('<b>WebDriver'), self.webdriver,
QLabel('''<center><small><i>Firefox is only Driver that dont
require additional configuration'''),
QLabel('<b>Title Content must contain'), self.titletxt,
QLabel('<b>Minified Javascript for Test'), self.javascript,
QLabel('<b>Arbitrary Authentication Data for Test'),
self.authdata, QLabel('<b>Arbitrary Form Data for Test'),
self.formdata, QLabel('<b>iFrame URL for Test'), self.iframurl,
QLabel('<b>Chrome Driver'), self.chrmedrv,
QLabel('<b>Timeout Timer Limit'), self.timeout):
vboxg1.addWidget(each_widget)
try:
each_widget.setToolTip(each_widget.text())
except:
each_widget.setToolTip(each_widget.currentText())
self.group4 = QGroupBox()
self.group4.setTitle(' General ')
self.chckbx1 = QCheckBox('Run the Tests after Writing')
self.chckbx2 = QCheckBox('Open the Tests with Ninja after Writing')
self.chckbx3 = QCheckBox('Add SheBang, Encoding and Metadata to Tests')
self.nice = QSpinBox()
self.nice.setMaximum(20)
self.nice.setMinimum(0)
self.nice.setValue(20)
self.help1 = QLabel(
'''<a href="http://splinter.cobrateam.info/docs/api"
><center><b>API Reference</a>''')
self.help1.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
self.help1.setOpenExternalLinks(True)
vboxg4 = QVBoxLayout(self.group4)
for each_widget in (self.chckbx1, self.chckbx2, self.chckbx3,
QLabel('Backend CPU priority:'), self.nice,
self.help1):
vboxg4.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
[
a.setChecked(True)
for a in (self.ckcss1, self.ckcss2, self.ckcss3, self.ckcss4,
self.ckcss5, self.ckcss6, self.ckcss7, self.ckcss8,
self.ckcss15, self.chckbx1, self.chckbx2, self.chckbx3)
]
self.button = QPushButton(QIcon.fromTheme("face-cool"),
'Write and Run Test')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
glow.setEnabled(True)
self.output = QPlainTextEdit()
self.runs = QLabel('<font color="green"><b>Runs: 0')
self.failures = QLabel('<font color="red"><b>Failures: 0')
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget(
(QLabel('<b>Selenium Tests'), self.group0, self.group1,
self.group4, QLabel('<b>Log'), self.output, self.runs,
self.failures, self.button))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ec.addTab(self.dock, "Selenium")
QPushButton(
QIcon.fromTheme("help-about"), 'About', self.dock).clicked.connect(
lambda: QMessageBox.information(self.dock, __doc__, HELPMSG))
QPushButton(
QIcon.fromTheme("media-record"),
'Record',
self.group1,
).clicked.connect(lambda: QMessageBox.information(
self.dock, __doc__,
'Not working. If you know how to make it Record, send me Pull Request'
))
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.locator.get_service("menuApp").add_action(
QAction(QIcon.fromTheme("edit-select-all"), "Create Setup.py", self, triggered=lambda: self.get_dialog())
)
self.dialog, self.group0 = QDialog(), QGroupBox()
self.group0.setTitle(" Setup.py Creator ")
self.pkgname, self.version = QLineEdit(), QDoubleSpinBox()
self.urlproj, self.licence = QLineEdit("https://www."), QLineEdit("GPL")
self.authors, self.emails = QLineEdit(getuser()), QLineEdit("@mail.com")
self.descrip, self.button = QLineEdit(), QPushButton("Make Setup.py !")
self.choices, self.indents = QComboBox(), QSpinBox()
self.metada = QCheckBox("Use SheBang and Metadata")
self.nosetest = QCheckBox("Use Nose Tests Framework integration")
self.metada.setChecked(True)
self.chckbx1 = QCheckBox("Copy output to ClipBoard when done")
self.choices.addItems(["from distutils.core import setup", "import distutils.core"])
self.indents.setValue(4)
self.indents.setMaximum(8)
self.indents.setMinimum(0)
self.indents.setSingleStep(2)
self.version.setValue(0.1)
self.version.setMinimum(0.1)
self.version.setDecimals(1)
self.version.setSingleStep(0.1)
self.button.setMinimumSize(400, 50)
self.button.clicked.connect(self.make_setupy)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
inf = QLabel(
"""<a href="http://guide.python-distribute.org/future.html"
><center><i>INFO: This is Deprecated Legacy Packaging.</a>"""
)
inf.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
inf.setOpenExternalLinks(True)
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (
QLabel("<b>Package Name"),
self.pkgname,
QLabel("<b>Version"),
self.version,
QLabel("<b>URL"),
self.urlproj,
QLabel("<b>Licence"),
self.licence,
QLabel("<b>Author"),
self.authors,
QLabel("<b>Mail"),
self.emails,
QLabel("<b>Description"),
self.descrip,
QLabel("<b>Imports"),
self.choices,
QLabel("<b>Indentation Spaces "),
self.indents,
self.metada,
self.chckbx1,
self.nosetest,
inf,
QLabel("<center><small><i>{}".format(HELPMSG)),
self.button,
):
vboxg0.addWidget(each_widget)
try:
each_widget.setToolTip(each_widget.text())
except:
pass
QVBoxLayout(self.dialog).addWidget(self.group0)
class FreezeTableWidget(QTableView):
def __init__(self, table_data, headers, parent=None, *args):
"""
Creates two QTableViews one of which is a frozen table while the
other one can scroll behind it.
:param table_data: The data that goes into the tables
:type table_data: List
:param headers: The header data of the tables.
:type headers: List
:param parent: The parent of the QTableView
:type parent: QWidget
:param args:
:type args:
"""
QTableView.__init__(self, parent)
# set the table model
self.table_model = BaseSTDMTableModel(table_data, headers, parent)
# set the proxy model
proxy_model = QSortFilterProxyModel(self)
proxy_model.setSourceModel(self.table_model)
# Assign a data model for TableView
self.setModel(self.table_model)
# frozen_table_view - first column
self.frozen_table_view = QTableView(self)
# Set the model for the widget, fixed column
self.frozen_table_view.setModel(self.table_model)
# Hide row headers
self.frozen_table_view.verticalHeader().hide()
# Widget does not accept focus
self.frozen_table_view.setFocusPolicy(Qt.StrongFocus | Qt.TabFocus
| Qt.ClickFocus)
# The user can not resize columns
self.frozen_table_view.horizontalHeader().\
setResizeMode(QHeaderView.Fixed)
self.frozen_table_view.setObjectName('frozen_table')
self.setSelectionMode(QAbstractItemView.NoSelection)
self.set_style()
# Remove the scroll bar
self.frozen_table_view.setHorizontalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
self.frozen_table_view.setVerticalScrollBarPolicy(
Qt.ScrollBarAlwaysOff)
# Puts more widgets to the foreground
self.viewport().stackUnder(self.frozen_table_view)
# # Log in to edit mode - even with one click
# Set the properties of the column headings
hh = self.horizontalHeader()
# Text alignment centered
hh.setDefaultAlignment(Qt.AlignCenter)
self.set_column_width()
# Set properties header lines
vh = self.verticalHeader()
vh.setDefaultSectionSize(25) # height lines
# text alignment centered
vh.setDefaultAlignment(Qt.AlignCenter)
vh.setVisible(True)
# Height of rows - as in the main widget
self.frozen_table_view.verticalHeader().\
setDefaultSectionSize(
vh.defaultSectionSize()
)
# Show frozen table view
self.frozen_table_view.show()
# Set the size of him like the main
self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.setVerticalScrollMode(QAbstractItemView.ScrollPerPixel)
self.frozen_table_view.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel)
## select the first column (STR Type)
self.frozen_table_view.selectColumn(0)
self.frozen_table_view.setEditTriggers(
QAbstractItemView.AllEditTriggers)
self.set_size()
self.signals()
def set_size(self):
"""
Sets the size and size policy of the tables.
:return:
:rtype:
"""
size_policy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(size_policy)
self.setMinimumSize(QSize(55, 75))
self.setMaximumSize(QSize(5550, 5555))
self.SelectionMode(QAbstractItemView.SelectColumns)
# set column width to fit contents
self.frozen_table_view.resizeColumnsToContents()
# set row height
self.frozen_table_view.resizeRowsToContents()
def signals(self):
"""
Connects signals of the tables.
"""
# Connect the headers and scrollbars of
# both tableviews together
self.horizontalHeader().sectionResized.connect(
self.update_section_width)
self.verticalHeader().sectionResized.connect(
self.update_section_height)
self.frozen_table_view.verticalScrollBar(). \
valueChanged.connect(
self.verticalScrollBar().setValue
)
self.verticalScrollBar().valueChanged.connect(
self.frozen_table_view.verticalScrollBar().setValue)
def set_column_width(self):
"""
Sets the column width of the frozen QTableView.
"""
# Set the width of columns
columns_count = self.table_model.columnCount(self)
for col in range(columns_count):
if col == 0:
# Set the size
self.horizontalHeader().resizeSection(col, 60)
# Fix width
self.horizontalHeader().setResizeMode(col, QHeaderView.Fixed)
# Width of a fixed column - as in the main widget
self.frozen_table_view.setColumnWidth(col,
self.columnWidth(col))
elif col == 1:
self.horizontalHeader().resizeSection(col, 150)
self.horizontalHeader().setResizeMode(col, QHeaderView.Fixed)
self.frozen_table_view.setColumnWidth(col,
self.columnWidth(col))
else:
self.horizontalHeader().resizeSection(col, 150)
# Hide unnecessary columns in the
# widget fixed columns
self.frozen_table_view.setColumnHidden(col, True)
def set_style(self):
"""
Sets the style of the frozen table.
"""
# Style frozentable view
self.frozen_table_view.setStyleSheet('''
#frozen_table{
border-top:none;
}
''')
self.shadow = QGraphicsDropShadowEffect(self)
self.shadow.setBlurRadius(5)
self.shadow.setOffset(2)
self.shadow.setYOffset(0)
self.frozen_table_view.setGraphicsEffect(self.shadow)
def add_widgets(self, str_type_id, insert_row):
"""
Adds widget delete into the frozen table.
:param str_type_id: The STR type id of the tenure type combobox
:type str_type_id: Integer
:param insert_row: The row number the widgets to be added.
:type insert_row: Integer
"""
delegate = STRTypeDelegate(str_type_id)
# Set delegate to add combobox under
# social tenure type column
self.frozen_table_view.setItemDelegate(delegate)
self.frozen_table_view.setItemDelegateForColumn(0, delegate)
index = self.frozen_table_view.model().index(insert_row, 0,
QModelIndex())
self.frozen_table_view.model().setData(index, '', Qt.EditRole)
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 0))
self.frozen_table_view.openPersistentEditor(
self.frozen_table_view.model().index(insert_row, 1))
def update_section_width(self, logicalIndex, oldSize, newSize):
"""
Updates frozen table column width and geometry.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
if logicalIndex == 0 or logicalIndex == 1:
self.frozen_table_view.setColumnWidth(logicalIndex, newSize)
self.update_frozen_table_geometry()
def update_section_height(self, logicalIndex, oldSize, newSize):
"""
Updates frozen table column height.
:param logicalIndex: The section's logical number
:type logicalIndex: Integer
:param oldSize: The old size of the section
:type oldSize: Integer
:param newSize: The new size of the section
:type newSize: Integer
"""
self.frozen_table_view.setRowHeight(logicalIndex, newSize)
def resizeEvent(self, event):
"""
Handles the resize event of the frozen table view.
It updates the frozen table view geometry on resize of table.
:param event: The event
:type event: QEvent
"""
QTableView.resizeEvent(self, event)
try:
self.update_frozen_table_geometry()
except Exception as log:
LOGGER.debug(str(log))
def scrollTo(self, index, hint):
"""
Scrolls the view if necessary to ensure that the item at index is
visible. The view will try to position the item according to the
given hint.
:param index: The scroll index
:type index: QModelIndex
:param hint: The scroll hint
:type hint: Integer
"""
if index.column() > 1:
QTableView.scrollTo(self, index, hint)
def update_frozen_table_geometry(self):
"""
Updates the frozen table view geometry.
"""
if self.verticalHeader().isVisible():
self.frozen_table_view.setGeometry(
self.verticalHeader().width() + self.frameWidth(),
self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() + self.horizontalHeader().height())
else:
self.frozen_table_view.setGeometry(
self.frameWidth(), self.frameWidth(),
self.columnWidth(0) + self.columnWidth(1),
self.viewport().height() + self.horizontalHeader().height())
def move_cursor(self, cursor_action, modifiers):
"""
Override function for correct left to scroll the keyboard.
Returns a QModelIndex object pointing to the next object in the
table view, based on the given cursorAction and keyboard modifiers
specified by modifiers.
:param cursor_action: The cursor action
:type cursor_action: Integer
:param modifiers: Qt.KeyboardModifier value.
:type modifiers: Object
:return: The current cursor position.
:rtype: QModelIndex
"""
current = QTableView.move_cursor(self, cursor_action, modifiers)
if cursor_action == self.MoveLeft and current.column() > 1 and \
self.visualRect(current).topLeft().x() < \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1)):
new_value = self.horizontalScrollBar().value() + \
self.visualRect(current).topLeft().x() - \
(self.frozen_table_view.columnWidth(0) +
self.frozen_table_view.columnWidth(1))
self.horizontalScrollBar().setValue(new_value)
return current
class QSwitch(QSlider):
""" Custom Switch Widget, inspired from some QML desktop components """
style_knob, style_off, style_on = qss_knob, qss_off, qss_on
clicked, animationOk = pyqtSignal(), pyqtSignal()
def __init__(self, parent=None):
""" Init Custom Switch Widget, set Animation and Glow effects """
QSlider.__init__(self, parent)
self.setOrientation(Qt.Horizontal)
self.animationType = QEasingCurve.OutExpo
self.animation = QPropertyAnimation(self, "value")
self.animation.setDuration(1000)
self.animation.finished.connect(self.animationDone)
self.clicked.connect(self.changeValue)
self.setStyleSheet(self.style_knob + self.style_off)
self.glow = QGraphicsDropShadowEffect(self)
self.glow.setOffset(0)
self.glow.setBlurRadius(99)
self.glow.setColor(QColor(99, 255, 255))
self.setGraphicsEffect(self.glow)
self.glow.setEnabled(False)
def changeValue(self):
""" method to change the actual state ON <--> OFF """
self.animation.setEasingCurve(self.animationType)
if self.value() == self.maximum():
self.animation.setStartValue(self.maximum())
self.animation.setEndValue(self.minimum())
self.animation.start()
self.setStyleSheet(self.style_knob + self.style_off)
self.glow.setEnabled(False)
return
else:
self.animation.setStartValue(self.minimum())
self.animation.setEndValue(self.maximum())
self.setStyleSheet(self.style_knob + self.style_on)
self.glow.setEnabled(True)
self.animation.start()
@pyqtSignature("setAtMax()")
def setAtMax(self):
""" method to set at Maximum, aka ON """
if self.value() == self.minimum():
self.animation.setEasingCurve(self.animationType)
self.animation.setStartValue(self.minimum())
self.animation.setEndValue(self.maximum())
self.animation.start()
self.setStyleSheet(self.style_knob + self.style_on)
@pyqtSignature("setAtMin()")
def setAtMin(self):
""" method to set at Minimum, aka OFF """
if self.value() == self.maximum():
self.animation.setEasingCurve(self.animationType)
self.animation.setStartValue(self.maximum())
self.animation.setEndValue(self.minimum())
self.animation.start()
self.setStyleSheet(self.style_knob + self.style_off)
def mousePressEvent(self, event):
""" method to respond a signal to mouse pointer clicks """
self.clicked.emit()
def isChecked(self):
""" method to return a bool based on actual state """
return self.value() == self.maximum()
def wheelEvent(self, event):
""" dumb method, its not a bug leave it alone """
return
def animationDone(self):
""" method to respond a signal to animation effects """
self.animationOk.emit()
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.desktop, self.project, menu = '', '', QMenu('Vagrant')
menu.addAction('UP', lambda: self.vagrant_c('up'))
menu.addAction('HALT', lambda: self.vagrant_c('halt'))
menu.addAction('RELOAD', lambda: self.vagrant_c('reload'))
menu.addAction('STATUS', lambda: self.vagrant_c('status'))
menu.addAction('SUSPEND', lambda: self.vagrant_c('suspend'))
menu.addAction('RESUME', lambda: self.vagrant_c('resume'))
menu.addAction('PROVISION', lambda: self.vagrant_c('provision'))
menu.addAction('PACKAGE', lambda: self.vagrant_c('package'))
menu.addAction('INIT', lambda: self.vagrant_c('init'))
menu.addSeparator()
menu.addAction('DESTROY (!!!)', lambda: self.vagrant_c('destroy'))
self.locator.get_service('explorer').add_project_menu(menu, lang='all')
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self.readOutput)
self.process.readyReadStandardError.connect(self.readErrors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_finished)
# Proxy support, by reading http_proxy os env variable
proxy_url = QUrl(environ.get('http_proxy', ''))
QNetworkProxy.setApplicationProxy(QNetworkProxy(QNetworkProxy.HttpProxy
if str(proxy_url.scheme()).startswith('http')
else QNetworkProxy.Socks5Proxy, proxy_url.host(), proxy_url.port(),
proxy_url.userName(), proxy_url.password())) \
if 'http_proxy' in environ else None
self.mainwidget = QTabWidget()
self.mainwidget.tabCloseRequested.connect(lambda:
self.mainwidget.setTabPosition(1)
if self.mainwidget.tabPosition() == 0
else self.mainwidget.setTabPosition(0))
self.mainwidget.setStyleSheet('QTabBar{font-weight:bold;}')
self.mainwidget.setMovable(True)
self.mainwidget.setTabsClosable(True)
self.dock, self.scrollable = QDockWidget(), QScrollArea()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(self.mainwidget)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
self.locator.get_service('misc').add_widget(self.dock,
QIcon.fromTheme("virtualbox"), __doc__)
self.tab1, self.tab2, self.tab3 = QGroupBox(), QGroupBox(), QGroupBox()
self.tab4, self.tab5, self.tab6 = QGroupBox(), QGroupBox(), QGroupBox()
for a, b in ((self.tab1, 'Basics'), (self.tab2, 'General Options'),
(self.tab3, 'VM Package Manager'), (self.tab4, 'VM Provisioning'),
(self.tab5, 'VM Desktop GUI'), (self.tab6, 'Run')):
a.setTitle(b)
a.setToolTip(b)
self.mainwidget.addTab(a, QIcon.fromTheme("virtualbox"), b)
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
HELPMSG))
self.vmname = QLineEdit(self.get_name())
self.vmname.setPlaceholderText('type_your_VM_name_here_without_spaces')
self.vmname.setToolTip('Type VM name, no spaces or special characters')
self.target = QLabel('<b>Vagrant Target Folder: ' +
path.join(BASE, self.vmname.text()))
self.vmname.textChanged.connect(lambda: self.target.setText(
'<b>Vagrant Target Folder: ' + path.join(BASE, self.vmname.text())))
self.btn1 = QPushButton(QIcon.fromTheme("face-smile-big"), 'Suggestion')
self.btn1.setToolTip('Suggest me a Random VM name !')
self.btn1.clicked.connect(lambda: self.vmname.setText(self.get_name()))
self.vmcode, self.vmarch = QComboBox(), QComboBox()
self.vmcode.addItems(['saucy', 'raring', 'quantal', 'precise'])
self.vmarch.addItems(['x86_64 (amd64) 64-Bits', 'x86 (i386) 32-Bits'])
vboxg1 = QVBoxLayout(self.tab1)
for each_widget in (QLabel('<b>Name for VM'), self.vmname, self.btn1,
QLabel('<b>Choose Ubuntu Codename for the VM:</b>'), self.vmcode,
QLabel('<b>Choose Architecture for VM:'), self.vmarch, self.target):
vboxg1.addWidget(each_widget)
self.chrt = QCheckBox('LOW CPU priority for Backend Process')
self.chttps = QComboBox()
self.chttps.addItems(['https', 'http'])
try:
self.vinfo1 = QLabel('''<b> Vagrant Backend Version: </b> {},
<b> VirtualBox Backend Version: </b> {}. '''.format(
getoutput('vagrant --version', shell=1).strip(),
getoutput('vboxmanage --version', shell=1).strip()))
except:
self.vinfo1 = QLabel('<b>Warning: Failed to query Vagrant Backend!')
self.qckb1 = QCheckBox(' Open target directory later')
self.qckb1.setToolTip('Open the target directory when finished')
self.qckb2 = QCheckBox(' Save a LOG file to target later')
self.qckb2.setToolTip('Save a read-only .LOG file to target')
self.qckb3 = QCheckBox(' NO run Headless Mode, use a Window')
self.qckb3.setToolTip('Show the VM on a Window GUI instead of Headless')
self.cpu, self.ram = QSpinBox(), QSpinBox()
self.cpu.setRange(25, 99)
self.cpu.setValue(99)
self.ram.setRange(512, 4096)
self.ram.setValue(1024)
vboxg2 = QVBoxLayout(self.tab2)
for each_widget in (self.qckb1, self.qckb2, self.qckb3, self.chrt,
QLabel('<b>Max CPU Limit for VM:</b>'), self.cpu,
QLabel('<b>Max RAM Limit for VM:</b>'), self.ram,
QLabel('<b>Download Protocol Type:</b>'), self.chttps, self.vinfo1):
vboxg2.addWidget(each_widget)
self.qckb10 = QCheckBox('Run apt-get update on the created VM')
self.qckb11 = QCheckBox('Run apt-get dist-upgrade on the created VM')
self.qckb12 = QCheckBox('Run apt-get check on the created VM')
self.qckb12 = QCheckBox('Run apt-get clean on the created VM')
self.qckb13 = QCheckBox('Run apt-get autoremove on the created VM')
self.qckb14 = QCheckBox('Try to Fix Broken packages if any on the VM')
self.aptproxy, self.portredirect = QLineEdit(), QLineEdit('8000, 9000')
self.aptproxy.setPlaceholderText(' user:password@proxyaddress:port ')
vboxg3 = QVBoxLayout(self.tab3)
for each_widget in (self.qckb10, self.qckb11, self.qckb12, self.qckb13,
self.qckb14,
QLabel('<b>Network Proxy for apt-get on the VM'), self.aptproxy,
QLabel('<b>Network Port Redirects for the VM'), self.portredirect):
vboxg3.addWidget(each_widget)
self.aptpkg = QTextEdit('build-essential git python-pip vim mc wget')
self.aptppa, self.pippkg = QLineEdit(), QTextEdit('virtualenv yolk')
self.aptppa.setPlaceholderText(' ppa:ninja-ide-developers/daily ')
self.requirements = QLineEdit()
self.requirements.setPlaceholderText(' /full/path/to/requirements.txt ')
self.requirements.setCompleter(self.completer)
vboxg4 = QVBoxLayout(self.tab4)
for each_widget in (QLabel('<b>Custom APT Ubuntu package'), self.aptpkg,
QLabel('<b>Custom APT Ubuntu PPA:</b> '), self.aptppa,
QLabel('<b>Custom PIP Python packages:</b> '), self.pippkg,
QLabel('<b>Custom PIP Python requirements: '), self.requirements):
vboxg4.addWidget(each_widget)
self.buttonGroup = QButtonGroup()
self.buttonGroup.buttonClicked[QAbstractButton].connect(self.get_de_pkg)
vboxg5 = QVBoxLayout(self.tab5)
for i, d in enumerate(('Ubuntu Unity', 'KDE Plasma', 'LXDE', 'XFCE')):
button = QPushButton(d)
button.setCheckable(True)
button.setMinimumSize(75, 50)
button.setToolTip(d)
vboxg5.addWidget(button)
self.buttonGroup.addButton(button)
self.output = QTextEdit('''
We have persistent objects, they are called files. -Ken Thompson. ''')
self.runbtn = QPushButton(QIcon.fromTheme("media-playback-start"),
'Start Vagrant Instrumentation Now !')
self.runbtn.setMinimumSize(75, 50)
self.runbtn.clicked.connect(self.build)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.runbtn.setGraphicsEffect(glow)
self.stopbt = QPushButton(QIcon.fromTheme("media-playback-stop"),
'Stop Vagrant')
self.stopbt.clicked.connect(lambda: self.process.stop())
self.killbt = QPushButton(QIcon.fromTheme("application-exit"),
'Force Kill Vagrant')
self.killbt.clicked.connect(lambda: self.process.kill())
vboxg6 = QVBoxLayout(self.tab6)
for each_widget in (QLabel('<b>Multiprocess Output Logs'), self.output,
self.runbtn, self.stopbt, self.killbt):
vboxg6.addWidget(each_widget)
[a.setChecked(True) for a in (self.qckb1, self.qckb2, self.qckb3,
self.qckb10, self.qckb11, self.qckb12, self.qckb13, self.qckb14,
self.chrt)]
self.mainwidget.setCurrentIndex(5)
def initialize(self, *args, **kwargs):
" Init Main Class "
ec = ExplorerContainer()
super(Main, self).initialize(*args, **kwargs)
# directory auto completer
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.RUNS, self.FAILS = 0, 0
self.group0 = QGroupBox()
self.group0.setTitle(' Source and Target ')
self.baseurl = QLineEdit('http://google.com')
self.outfile = QLineEdit(path.join(path.expanduser("~"), 'test.py'))
self.outfile.setCompleter(self.completer)
self.open = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open.clicked.connect(lambda: self.outfile.setText(
QFileDialog.getSaveFileName(self.dock, "Save", path.expanduser("~"),
'PYTHON(*.py)')))
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (QLabel('<b>Base URL'), self.baseurl,
QLabel('<b>Local File Target'), self.outfile, self.open):
vboxg0.addWidget(each_widget)
self.group1 = QGroupBox()
self.group1.setTitle(' Selenium ')
self.group1.setCheckable(True)
self.group1.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group1.graphicsEffect().setEnabled(False)
self.group1.toggled.connect(self.toggle_group)
self.ckcss1 = QCheckBox('Test for correct Page Loading behaviour')
self.ckcss2 = QCheckBox('Test for Sucessfull Status Code return')
self.ckcss3 = QCheckBox('Test for valid Title of the web page')
self.ckcss4 = QCheckBox('Test for Cookies Basic functionality')
self.ckcss5 = QCheckBox('Test for Back, Forward, Reload behaviour')
self.ckcss6 = QCheckBox('Take a Screenshot of page (CSS Debug)')
self.ckcss7 = QCheckBox('Test for Search Form Field of the page')
self.ckcss8 = QCheckBox('Test for Arbitrary Javascript (User provided)')
self.ckcss9 = QCheckBox('Test for iFrame of the web page')
self.ckcss10 = QCheckBox('Test for HTML5 Canvas element on the page')
self.ckcss11 = QCheckBox('Test for HTML5 SVG element on the page')
self.ckcss12 = QCheckBox('Test for HTML5 Audio element on the page')
self.ckcss13 = QCheckBox('Test for HTML5 Video element on the page')
self.ckcss14 = QCheckBox('Test for File Upload form on the page')
self.ckcss15 = QCheckBox('Add ChromeDriver path to sys.path')
self.webdriver = QComboBox()
self.webdriver.addItems(['firefox', 'chrome',
'zope.testbrowser', 'phantomjs'])
self.titletxt = QLineEdit('Google')
self.javascript = QLineEdit('console.log("test")')
self.authdata, self.formdata = QLineEdit(), QLineEdit()
self.authdata.setPlaceholderText("{'username':'******','password':'******'}")
self.formdata.setPlaceholderText("{'name': 'Joe', 'age': '25'}")
self.iframurl = QLineEdit()
self.chrmedrv = QLineEdit('/usr/bin/chromedriver')
self.timeout = QSpinBox()
self.timeout.setMaximum(99)
self.timeout.setMinimum(0)
self.timeout.setValue(9)
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (self.ckcss1, self.ckcss2, self.ckcss3, self.ckcss4,
self.ckcss5, self.ckcss6, self.ckcss7, self.ckcss8, self.ckcss9,
self.ckcss10, self.ckcss11, self.ckcss12, self.ckcss13,
self.ckcss14, self.ckcss15, QLabel('<b>WebDriver'), self.webdriver,
QLabel('''<center><small><i>Firefox is only Driver that dont
require additional configuration'''),
QLabel('<b>Title Content must contain'), self.titletxt,
QLabel('<b>Minified Javascript for Test'), self.javascript,
QLabel('<b>Arbitrary Authentication Data for Test'), self.authdata,
QLabel('<b>Arbitrary Form Data for Test'), self.formdata,
QLabel('<b>iFrame URL for Test'), self.iframurl,
QLabel('<b>Chrome Driver'), self.chrmedrv,
QLabel('<b>Timeout Timer Limit'), self.timeout):
vboxg1.addWidget(each_widget)
try:
each_widget.setToolTip(each_widget.text())
except:
each_widget.setToolTip(each_widget.currentText())
self.group4 = QGroupBox()
self.group4.setTitle(' General ')
self.chckbx1 = QCheckBox('Run the Tests after Writing')
self.chckbx2 = QCheckBox('Open the Tests with Ninja after Writing')
self.chckbx3 = QCheckBox('Add SheBang, Encoding and Metadata to Tests')
self.nice = QSpinBox()
self.nice.setMaximum(20)
self.nice.setMinimum(0)
self.nice.setValue(20)
self.help1 = QLabel('''<a href="http://splinter.cobrateam.info/docs/api"
><center><b>API Reference</a>''')
self.help1.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
self.help1.setOpenExternalLinks(True)
vboxg4 = QVBoxLayout(self.group4)
for each_widget in (self.chckbx1, self.chckbx2, self.chckbx3,
QLabel('Backend CPU priority:'), self.nice, self.help1):
vboxg4.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
[a.setChecked(True) for a in (self.ckcss1, self.ckcss2, self.ckcss3,
self.ckcss4, self.ckcss5, self.ckcss6, self.ckcss7, self.ckcss8,
self.ckcss15, self.chckbx1, self.chckbx2, self.chckbx3)]
self.button = QPushButton(QIcon.fromTheme("face-cool"),
'Write and Run Test')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
glow.setEnabled(True)
self.output = QPlainTextEdit()
self.runs = QLabel('<font color="green"><b>Runs: 0')
self.failures = QLabel('<font color="red"><b>Failures: 0')
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((QLabel('<b>Selenium Tests'), self.group0,
self.group1, self.group4, QLabel('<b>Log'), self.output, self.runs,
self.failures, self.button))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ec.addTab(self.dock, "Selenium")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
HELPMSG))
QPushButton(QIcon.fromTheme("media-record"), 'Record', self.group1,
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
'Not working. If you know how to make it Record, send me Pull Request'))
class Button(QWidget):
LEFT = "left"
RIGHT = "right"
TOP = "top"
BOTTOM = "bottom"
def __init__(self, filename=None, width=None, height=None, x=0, y=0, pixmap=None, group=None, pos=None, size=None, padding=None):
self.effects = {}
self.animations = {}
self.filename = filename if isinstance(filename, str) else None
if pixmap :
self.pixmap = pixmap
elif isinstance(filename, QPixmap) :
self.pixmap = filename
elif isinstance(filename, str) :
self.pixmap = QPixmap(os.path.dirname(__file__) + '/../buttons/' + filename)
else :
self.pixmap = None
if (width != None or height != None) and self.pixmap != None :
self.pixmap = self.pixmap.scaled(width if width != None else height,
height if height != None else width, Qt.KeepAspectRatio)
self.group = group
self.pos = pos
self.size = size
self.padding = padding
self.x = x
self.y = y
if isinstance(self.pixmap, QPixmap) :
self.item = QGraphicsPixmapItem(self.pixmap)
self.item.setOffset(QPointF(self.getX(), self.getY()))
self.effect = QGraphicsDropShadowEffect()
self.effect.setOffset(0, 0)
self.effect.setBlurRadius(0)
self.effect.setColor(Qt.green)
self.addEffect('shadow', self.effect, True)
self.addAnimation('glow', Glow(15, 300, self, maxRadius=80, minRadius=5))
# self.item.setGraphicsEffect(effect)
# self.tl = QTimeLine(10000)
# self.t = QGraphicsItemAnimation()
# self.t.setItem(self.item)
# self.t.setTimeLine(self.tl)
# self.tl.connect(self.tl, SIGNAL('frameChanged(int)'), self.test)
# self.tl.start()
# print 'added'
def test(self):
print 1
def getX(self):
x = self.x
if self.group != None :
x += self.group.x
if self.pos != None :
x += self.getPositionX()
return x
def getY(self):
y = self.y
if self.group != None :
y += self.group.getY()
if self.pos != None :
y += self.getPositionY()
return y
def getPositionX(self):
if self.pos == Button.TOP or self.pos == Button.BOTTOM:
return self.getSize() + self.getPadding() if self.getCols() > 1 else 0
elif self.pos == Button.RIGHT :
return self.getSize() * (self.getCols() - 1) + self.getPadding() * (self.getCols() - 1)
elif self.pos == Button.LEFT :
return 0
def getPositionY(self):
if self.pos == Button.LEFT or self.pos == Button.RIGHT:
return self.getSize() + self.getPadding() if self.getRows() > 1 else 0
elif self.pos == Button.BOTTOM :
return self.getSize() * (self.getRows() - 1) + self.getPadding() * (self.getRows() - 1)
elif self.pos == Button.TOP :
return 0
def getSize(self):
if self.size != None :
return self.size
if isinstance(self.group, ButtonGroup) :
return self.group.getSize()
return 0
def getPadding(self):
if self.padding != None :
return self.padding
if isinstance(self.group, ButtonGroup) :
return self.group.getPadding()
return 0
def getRows(self):
if isinstance(self.group, ButtonGroup) :
return self.group.getRows()
return 1;
def getCols(self):
if isinstance(self.group, ButtonGroup) :
return self.group.getCols()
return 1;
def addEffect(self, name, effect, show=True):
self.effects[name] = effect
if show :
self.setEffect(name)
def setEffect(self, name):
self.item.setGraphicsEffect(self.effects[name])
def setScene(self, scene):
self.scene = scene
self.scene.addItem(self.item)
def addAnimation(self, name, animation):
self.animations[name] = animation
def play(self, name):
print 'start'
self.animations[name].start()
def update(self, pressed):
if pressed :
print 'pressed'
self.play('glow')
class SixAxisView(QGraphicsView):
def __init__(self, *args):
QGraphicsView.__init__(self, *args)
self.move(20, 240)
self.outerD = 125
self.innerD = 35
self.innerRange = 48
self.inputRange = 256
self.thresh = 3
self.padding = 40
self.marginTop = 10
self.worker = QSixAxisThread()
self.worker.valueUpdated.connect(self.moveJoysticks)
self.worker.start()
self.setContentsMargins(0, 0, 0, 0)
self.setMaximumHeight(180)
self.setMaximumWidth(420)
self.setMinimumHeight(240)
self.setMinimumWidth(300)
self.adjustSize()
self.scene = QGraphicsScene(self)
self.outerCircle1 = QGraphicsEllipseItem(0, self.marginTop, self.outerD, self.outerD)
self.outerCircle1.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine))
self.outerCircle1.setBrush(Qt.gray)
self.innerCircle1 = QGraphicsEllipseItem(self.outerD / 2 - self.innerD / 2, self.outerD / 2 - self.innerD / 2 + self.marginTop, self.innerD, self.innerD)
self.innerCircle1.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine))
self.innerCircle1.setBrush(Qt.lightGray)
self.scene.addItem(self.outerCircle1)
self.scene.addItem(self.innerCircle1)
self.outerCircle2 = QGraphicsEllipseItem(self.outerD + self.padding, self.marginTop, self.outerD, self.outerD)
self.outerCircle2.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine))
self.outerCircle2.setBrush(Qt.gray)
self.innerCircle2 = QGraphicsEllipseItem(self.outerD + self.padding + self.outerD / 2 - self.innerD / 2, self.outerD / 2 - self.innerD / 2 + self.marginTop, self.innerD, self.innerD)
self.innerCircle2.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine))
self.innerCircle2.setBrush(Qt.lightGray)
self.scene.addItem(self.outerCircle2)
self.scene.addItem(self.innerCircle2)
self.setScene(self.scene)
self.setStyleSheet('background-color:transparent; border-width: 0px; border: 0px;')
self.currentX = 0
self.currentY = 0
self.currentA = 0
self.currentZ = 0
self.psBtn = QPixmap(os.getcwd() + '/../icons/bt_PS.png')
self.psBtn = self.psBtn.scaled(50, 50, Qt.KeepAspectRatio)
self.psItem = QGraphicsPixmapItem(self.psBtn)
self.psItem.setOffset(QPointF(self.outerD - 4, 0))
self.effect = QGraphicsDropShadowEffect()
self.effect.setOffset(0, 0)
self.effect.setBlurRadius(20)
self.effect.setColor(Qt.green)
self.psItem.setGraphicsEffect(self.effect)
self.scene.addItem(self.psItem)
self.tl2 = QTimeLine(10000)
self.tl2.setFrameRange(0, 10000)
self.c = QGraphicsItemAnimation()
self.c.setItem(self.psItem)
self.c.setTimeLine(self.tl2)
self.tl2.connect(self.tl2, SIGNAL('frameChanged(int)'), self.updateEffect)
self.effectd = 3
self.tl2.start()
def updateEffect(self):
if self.effect.blurRadius() > 50:
self.effectd = -3
elif self.effect.blurRadius() < 5:
self.effectd = 3
self.effect.setBlurRadius(self.effect.blurRadius() + self.effectd)
def update(self, *args, **kwargs):
return QGraphicsView.update(self, *args, **kwargs)
def moveJoysticks(self, x, y, a, z, l3, r3):
x2 = x * self.innerRange / self.inputRange - self.innerRange / 2
y2 = y * self.innerRange / self.inputRange - self.innerRange / 2
a2 = a * self.innerRange / self.inputRange - self.innerRange / 2
z2 = z * self.innerRange / self.inputRange - self.innerRange / 2
if -self.thresh <= x2 <= self.thresh:
x2 = 0
if -self.thresh <= y2 <= self.thresh:
y2 = 0
if -self.thresh <= a2 <= self.thresh:
a2 = 0
if -self.thresh <= z2 <= self.thresh:
z2 = 0
self.tl = QTimeLine(10)
self.tl.setFrameRange(0, 10)
self.a = QGraphicsItemAnimation()
self.a.setItem(self.innerCircle1)
self.a.setTimeLine(self.tl)
self.a.setPosAt(0, QPointF(self.currentX, self.currentY))
self.a.setTranslationAt(1, x2, y2)
if l3:
self.innerCircle1.setPen(QPen(QColor(Qt.white), 1, Qt.SolidLine))
self.innerCircle1.setBrush(QColor(200, 225, 3))
else:
self.innerCircle1.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine))
self.innerCircle1.setBrush(Qt.lightGray)
if r3:
self.innerCircle2.setPen(QPen(QColor(Qt.white), 1, Qt.SolidLine))
self.innerCircle2.setBrush(QColor(200, 225, 3))
else:
self.innerCircle2.setPen(QPen(QColor(Qt.darkGray), 1, Qt.SolidLine))
self.innerCircle2.setBrush(Qt.lightGray)
self.b = QGraphicsItemAnimation()
self.b.setItem(self.innerCircle2)
self.b.setTimeLine(self.tl)
self.b.setPosAt(0, QPointF(self.currentA, self.currentZ))
self.b.setTranslationAt(1, a2, z2)
self.currentX = x2
self.currentY = y2
self.currentA = a2
self.currentZ = z2
self.tl.start()
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self.readOutput)
self.process.readyReadStandardError.connect(self.readErrors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_finished)
# directory auto completer
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.group0 = QGroupBox()
self.group0.setTitle(' Source ')
self.source, self.infile = QComboBox(), QLineEdit(path.expanduser("~"))
self.source.addItems(['Local File', 'Remote URL'])
self.source.currentIndexChanged.connect(self.on_source_changed)
self.infile.setPlaceholderText(' /full/path/to/file.html ')
self.infile.setCompleter(self.completer)
self.open = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open.setCursor(QCursor(Qt.PointingHandCursor))
self.open.clicked.connect(lambda: self.infile.setText(str(
QFileDialog.getOpenFileName(self.dock, "Open a File to read from",
path.expanduser("~"), ';;'.join(['{}(*.{})'.format(e.upper(), e)
for e in ['html', 'webp', 'webm', 'svg', 'css', 'js', '*']])))))
self.inurl, self.output = QLineEdit('http://www.'), QTextEdit()
self.inurl.setPlaceholderText('http://www.full/url/to/remote/file.html')
self.inurl.hide()
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (self.source, self.infile, self.open, self.inurl):
vboxg0.addWidget(each_widget)
self.group1 = QGroupBox()
self.group1.setTitle(' Mobile ')
self.ckcss1 = QCheckBox('Run in full screen using current resolution')
self.ckcss2 = QCheckBox('Disable touch mode and use keypad mode')
self.ckcss3 = QCheckBox('Disable touch mode but allow to use the mouse')
self.ckcss4 = QCheckBox('Enable mouse,disable pointer & zoom emulation')
self.ckcss5 = QCheckBox('Start the Mobile version of the browser')
self.ckcss6 = QCheckBox('Start the Tablet version of the browser')
self.ckcss7 = QCheckBox('Emulate hardware with Menu and Back keys')
self.ckcss8 = QCheckBox('Start the browser in Kiosk mode')
self.width, self.height = QSpinBox(), QSpinBox()
self.zoom, self.ram, self.dpi = QSpinBox(), QSpinBox(), QSpinBox()
self.cpulag, self.gpulag = QSpinBox(), QSpinBox()
self.lang, self.agent = QComboBox(), QComboBox()
self.lang.addItems(['EN', 'ES', 'PT', 'JA', 'ZH', 'DE', 'RU', 'FR'])
self.agent.addItems(['Default', 'Android', 'MeeGo', 'Desktop'])
self.fonts = QLineEdit()
self.width.setMaximum(9999)
self.width.setMinimum(100)
self.width.setValue(480)
self.height.setMaximum(9999)
self.height.setMinimum(100)
self.height.setValue(800)
self.zoom.setMaximum(999)
self.zoom.setMinimum(1)
self.zoom.setValue(100)
self.ram.setMaximum(999)
self.ram.setMinimum(1)
self.ram.setValue(100)
self.dpi.setMaximum(200)
self.dpi.setMinimum(50)
self.dpi.setValue(96)
self.cpulag.setMaximum(9999)
self.cpulag.setMinimum(0)
self.cpulag.setValue(1)
self.gpulag.setMaximum(9999)
self.gpulag.setMinimum(0)
self.gpulag.setValue(1)
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (self.ckcss1, self.ckcss2, self.ckcss3, self.ckcss4,
self.ckcss5, self.ckcss6, self.ckcss7, self.ckcss8,
QLabel('Width Pixels of the emulated device screen'), self.width,
QLabel('Height Pixels of the emulated device screen'), self.height,
QLabel('Zoom Percentage of emulated screen'), self.zoom,
QLabel('RAM MegaBytes of the emulated device'), self.ram,
QLabel('Language of the emulated device'), self.lang,
QLabel('D.P.I. of the emulated device'), self.dpi,
QLabel('User-Agent of the emulated device'), self.agent,
QLabel('CPU Core Lag Miliseconds of emulated device'), self.cpulag,
QLabel('GPU Video Lag Miliseconds of emulated device'), self.gpulag,
QLabel('Extra Fonts Directory Full Path'), self.fonts):
vboxg1.addWidget(each_widget)
self.group2 = QGroupBox()
self.group2.setTitle(' General ')
self.nice, self.opera = QSpinBox(), QLineEdit(path.expanduser("~"))
self.nice.setValue(20)
self.nice.setMaximum(20)
self.nice.setMinimum(0)
self.opera.setCompleter(self.completer)
if path.exists(CONFIG_FILE):
with codecs.open(CONFIG_FILE, encoding='utf-8') as fp:
self.opera.setText(fp.read())
self.open2 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open2.setCursor(QCursor(Qt.PointingHandCursor))
self.open2.clicked.connect(lambda: self.opera.setText(str(
QFileDialog.getOpenFileName(self.dock, "Open Opera Mobile Emulator",
path.expanduser("~"),
'Opera Mobile Emulator Executable(opera-mobile-emulator)'))))
self.help1 = QLabel('''<a href=
"http://www.opera.com/developer/mobile-emulator">
<small><center>Download Opera Mobile Emulator !</a>''')
self.help1.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
self.help1.setOpenExternalLinks(True)
vboxg4 = QVBoxLayout(self.group2)
for each_widget in (QLabel(' Backend CPU priority: '), self.nice,
QLabel(' Opera Mobile Emulator Full Path: '), self.opera,
self.open2, self.help1):
vboxg4.addWidget(each_widget)
self.button = QPushButton('Preview on Mobile')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
glow.setEnabled(True)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((QLabel('<b>Mobile Browser Emulator'),
self.group0, self.group1, self.group2, self.output, self.button, ))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Mobile")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
HELPMSG))
def initialize(self, *args, **kwargs):
' class init '
super(Main, self).initialize(*args, **kwargs)
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self.readOutput)
self.process.readyReadStandardError.connect(self.readErrors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_finished)
# directory auto completer
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.Dirs | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
menu = QMenu('Clones')
menu.addAction('Analyze for Code Clones here', lambda: self.make_clon())
self.locator.get_service('explorer').add_project_menu(menu, lang='all')
self.group1 = QGroupBox()
self.group1.setTitle(' Target ')
self.outdir, self.igndir = QLineEdit(path.expanduser("~")), QLineEdit()
self.outdir.setCompleter(self.completer)
self.btn1 = QPushButton(QIcon.fromTheme("document-open"), ' Open ')
self.btn1.clicked.connect(lambda: self.outdir.setText(str(
QFileDialog.getExistingDirectory(self.dock,
'Please, Open a Target Directory...', path.expanduser("~")))))
self.btn1a = QPushButton(QIcon.fromTheme("face-smile"),
'Get from Ninja active project')
self.btn1a.clicked.connect(lambda: self.outdir.setText(
self.locator.get_service('explorer').get_current_project_item().path))
self.ignckb, self.ignmor = QComboBox(), QTextEdit()
self.ignckb.addItems(['Single Directory', 'Multiple Directories CSV'])
self.ignckb.currentIndexChanged.connect(self.on_ignore_changed)
self.ignmor.hide()
self.igndir.setPlaceholderText('Exclude directory')
self.igndir.setCompleter(self.completer)
self.btn2 = QPushButton(QIcon.fromTheme("document-open"), ' Open ')
self.btn2.clicked.connect(lambda: self.igndir.setText(str(
QFileDialog.getExistingDirectory(self.dock,
'Please, Open a Ignore Directory...', path.expanduser("~")))))
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (QLabel('<b>Target directory path: '), self.outdir,
self.btn1, self.btn1a, QLabel('<b>Ignore directory path: '),
self.ignckb, self.ignmor, self.igndir, self.btn2, ):
vboxg1.addWidget(each_widget)
self.group2 = QGroupBox()
self.group2.setTitle(' Output ')
self.outfle = QLineEdit(path.join(path.expanduser("~"), 'output.html'))
self.outfle.setPlaceholderText('Exclude directory')
self.outfle.setCompleter(self.completer)
self.btn3 = QPushButton(QIcon.fromTheme("document-save"), ' Save ')
self.btn3.clicked.connect(lambda: self.outfle.setText(
QFileDialog.getSaveFileName(self.dock, 'Save', path.expanduser("~"),
'XML(*.xml)' if self.xmlo.isChecked() is True else 'HTML(*.html)')))
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (QLabel('<b>Output report file path:'),
self.outfle, self.btn3):
vboxg2.addWidget(each_widget)
self.group3 = QGroupBox()
self.group3.setTitle(' Options ')
self.group3.setCheckable(True)
self.group3.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group3.graphicsEffect().setEnabled(False)
self.group3.toggled.connect(self.toggle_options_group)
self.qckb1, self.qckb2 = QCheckBox('Recursive'), QCheckBox('Time-less')
self.qckb3, self.qckb4 = QCheckBox('Force Diff'), QCheckBox('Fast Mode')
self.qckb5, self.tm = QCheckBox('Save a LOG file to target'), QLabel('')
self.xmlo = QCheckBox('XML Output instead of HTML')
self.opeo = QCheckBox('Open Clones Report when done')
self.chrt = QCheckBox('LOW CPU priority for Backend Process')
self.mdist, self.hdep, self.output = QSpinBox(), QSpinBox(), QTextEdit()
self.ign_func = QLineEdit('test, forward, backward, Migration')
self.mdist.setValue(5)
self.hdep.setValue(1)
self.mdist.setToolTip('''<b>Maximum amount of difference between pair of
sequences in clone pair (5 default).Larger value more false positive''')
self.hdep.setToolTip('''<b>Computation can be speeded up by increasing
this value, but some clones can be missed (1 default)''')
[a.setChecked(True) for a in (self.qckb1, self.qckb3, self.qckb5,
self.chrt, self.opeo)]
vboxg3 = QVBoxLayout(self.group3)
for each_widget in (self.qckb1, self.qckb2, self.qckb3, self.qckb4,
self.qckb5, self.chrt, self.xmlo, self.opeo,
QLabel('<b>Max Distance Threshold:'), self.mdist,
QLabel('<b>Max Hashing Depth:'), self.hdep,
QLabel('<b>Ignore code block prefix:'), self.ign_func):
vboxg3.addWidget(each_widget)
self.group4, self.auto = QGroupBox(), QComboBox()
self.group4.setTitle(' Automation ')
self.group4.setCheckable(True)
self.group4.setToolTip('<font color="red"><b>WARNING:Advanced Setting!')
self.group4.toggled.connect(lambda: self.group4.hide())
self.auto.addItems(['Never run automatically', 'Run when File Saved',
'Run when File Executed', 'Run when Tab Changed',
'Run when File Opened', 'Run before File Saved'])
self.auto.currentIndexChanged.connect(self.on_auto_changed)
QVBoxLayout(self.group4).addWidget(self.auto)
self.button = QPushButton(' Analyze for Clones ')
self.button.setMinimumSize(75, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
self.butkil = QPushButton(' Force Kill Clones ')
self.butkil.clicked.connect(lambda: self.process.kill())
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((QLabel('<i>D.R.Y. principle analyzer'),
self.group1, self.group2, self.group3, self.group4,
QLabel('<b>Backend Logs'), self.output, self.tm, self.button,
self.butkil))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Clones")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda:
QMessageBox.information(self.dock, __doc__, HELPMSG))
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.locator.get_service("menuApp").add_action(QAction(QIcon.fromTheme(
"edit-select-all"), __doc__, self, triggered=lambda: self.get_dialog()))
self.dialog, self.group0 = QDialog(), QGroupBox()
self.group0.setTitle('Coviolations')
self.pep8 = QCheckBox('PEP-8 Style Guide for Python Code')
self.sloc = QCheckBox('Sloccount Source Code Lines counter')
self.unit = QCheckBox('UnitTest Python Unit Tests')
self.pipr = QCheckBox('PIP-Review PIP Packages Review')
self.tstm = QCheckBox('Testem JavaScript Tests')
self.cove = QCheckBox('Coverage Code Tests Coverage report')
self.jsli = QCheckBox('JSLint JavaScript Linter')
self.metada = QCheckBox('Add Date and Time on a Comment')
self.button = QPushButton('Generate YML Files !')
self.button.setMinimumSize(400, 50)
self.button.clicked.connect(self.make_yml)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
help1 = QLabel('''<a href="https://coviolations.io"><center>
GitHub Login to Coviolations Libre C.I.</a>''')
help1.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
help1.setOpenExternalLinks(True)
help1.setMaximumSize(400, 50)
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (self.pep8, self.sloc, self.unit, self.pipr,
self.tstm, self.cove, self.jsli, help1):
vboxg0.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group1, self.group2 = QGroupBox(), QGroupBox()
self.group1.setTitle('Travis')
self.group2.setTitle('Travis')
self.py25 = QCheckBox('Python 2.5 (Deprecated)')
self.py26 = QCheckBox('Python 2.6 (Deprecated)')
self.py27 = QCheckBox('Python 2.7 (Default)')
self.py32, self.py33 = QCheckBox('Python 3.2'), QCheckBox('Python 3.3')
self.pypy = QCheckBox('Python PyPy (Experimental)')
self.cach = QCheckBox('Use Network-Local APT Cache for faster apt-get')
self.mong, self.couc = QCheckBox('Mongo DB'), QCheckBox('Couch DB')
self.elas, self.kres = QCheckBox('ElasticSearch'), QCheckBox('Kestrel')
self.memc, self.rabb = QCheckBox('MemCacheD'), QCheckBox('RabbitMQ')
self.redi, self.cass = QCheckBox('Redis'), QCheckBox('Cassandra')
self.riak, self.neo4 = QCheckBox('Riak'), QCheckBox('Neo4J')
[a.setChecked(True) for a in(self.pep8, self.sloc, self.unit, self.pipr,
self.tstm, self.cove, self.jsli, self.metada, self.py27, self.cach)]
self.b4in, self.container = QLineEdit(B4INSTL), QWidget()
self.inst = QLineEdit('pip install -r requirements.txt --use-mirrors')
self.b4sc = QLineEdit('rm --recursive --force --verbose *.pyc')
self.scrp = QLineEdit('nosetests --verbose --detailed-errors')
self.sucs, self.when = QLineEdit('covio'), QComboBox()
self.when.addItems(['change', 'always', 'never'])
self.mail = QLineEdit(getuser() + '@gmail.com')
self.ircc = QLineEdit(getuser() + 's_channel')
self.host = QLineEdit(getuser() + '-dev-server.com')
help2 = QLabel('''<a href="https://travis-ci.org"><center>
GitHub Login to Travis Libre C.I.</a>''')
help2.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
help2.setOpenExternalLinks(True)
help3 = QLabel('''<a href="http://lint.travis-ci.org/"><center>
Travis Lint .travis.yml Config Validator</a>''')
help3.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
help3.setOpenExternalLinks(True)
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (QLabel('<b>Try to Build / Run / Test my App on'),
self.py25, self.py26, self.py27, self.py32, self.py33, self.pypy,
QLabel('<b>Bash command to run Before install your App'), self.b4in,
QLabel('<b>Bash command to Install your App'), self.inst,
QLabel('<b>Bash command to run Before C.I. process'), self.b4sc,
QLabel('<b>Bash command to Build / Run / Test your App'), self.scrp,
QLabel('<b>Bash command to run on Sucess of your App'), self.sucs,
help2):
vboxg1.addWidget(each_widget)
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (QLabel('<b>Servers to Start on Boot'), self.mong,
self.couc, self.elas, self.kres, self.memc, self.rabb, self.redi,
self.cass, self.riak, self.neo4,
QLabel('<b>Mail to send C.I. Notifications of your App'), self.mail,
QLabel('<b>IRC to send C.I. Notifications of your App'), self.ircc,
QLabel('<b>When to Send Notifications'), self.when,
QLabel('<b>Custom Hostname DNS /etc/hosts for IPv4/6'), self.host,
QLabel('<b>Cache'), self.cach, help3):
vboxg2.addWidget(each_widget)
hboxg, vboxg = QHBoxLayout(self.container), QVBoxLayout(self.dialog)
[hboxg.addWidget(a) for a in (self.group1, self.group2, self.group0)]
for each_widget in (QLabel('<center><h3>' + __doc__), self.container,
self.metada, self.button):
vboxg.addWidget(each_widget)
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dialog
).clicked.connect(lambda:
QMessageBox.information(self.dialog, __doc__, HELPMSG))
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.configOptions, self.checkBoxList, self.configBool = {}, {}, None
# Check for root privileges
if geteuid() != 0:
msg = ("{} is not root. You need to run with root priviliges\n"
"Please use kdesudo, gksu or sudo/sux.").format(getuser())
QMessageBox.critical(self, __doc__ + "- Error", msg)
sys.exit(1)
else:
msg = "This tool is running with root priviliges."
QMessageBox.warning(self, __doc__ + "- Warning", msg)
# title, icon and sizes
self.setWindowTitle(__doc__)
self.setMinimumSize(600, 600)
self.setMaximumSize(2048, 2048)
self.resize(600, 600)
self.setWindowIcon(QIcon.fromTheme("preferences-system"))
self.menuBar().addMenu("&File").addAction("Exit", exit)
QShortcut("Ctrl+q", self, activated=lambda: self.close())
# main group
main_group = QGroupBox("Module configuration")
self.setCentralWidget(main_group)
self.layout = QVBoxLayout(main_group)
# scrollarea widgets
self.scrollArea, self.window = QScrollArea(), QWidget()
self.layout.addWidget(self.scrollArea)
self.vbox = QVBoxLayout(self.window)
# Graphic effect
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.scrollArea.setGraphicsEffect(glow)
glow.setEnabled(True)
# config loading stuff
self.findConfig(CONFIG_DIR)
for eachOption in tuple(self.configOptions.keys()):
self.readConfig(eachOption, self.configOptions)
self.subLayout = QHBoxLayout()
self.checkBoxName = "checkBox_" + eachOption
checkBoxList = QCheckBox(self.checkBoxName, self)
self.checkBoxList[self.checkBoxName] = checkBoxList
checkBoxList.setObjectName(self.checkBoxName)
checkBoxList.setText("Enable module {}".format(eachOption))
if self.tooltip is not '':
checkBoxList.setToolTip(self.tooltip)
else:
tooltip = "Configuration settings for {}".format(eachOption)
checkBoxList.setToolTip(tooltip)
if self.configBool:
checkBoxList.setChecked(True)
self.subLayout.addWidget(checkBoxList)
self.vbox.addLayout(self.subLayout)
self.scrollArea.setWidget(self.window)
# Bottom Buttons Bar
self.pushButtonSleep = QPushButton("Sleep")
self.pushButtonSleep.setToolTip("Trigger Suspend to RAM aka Sleep")
self.pushButtonSleep.clicked.connect(self.sleep)
self.pushButtonHibernate = QPushButton("Hibernate")
self.pushButtonHibernate.setToolTip("Trigger Suspend to Disk Hibernate")
self.pushButtonHibernate.clicked.connect(self.hibernate)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setStandardButtons(
QDialogButtonBox.Ok | QDialogButtonBox.Close |
QDialogButtonBox.Help)
self.buttonBox.addButton(self.pushButtonHibernate,
QDialogButtonBox.ActionRole)
self.buttonBox.addButton(self.pushButtonSleep,
QDialogButtonBox.ActionRole)
self.layout.addWidget(self.buttonBox)
self.buttonBox.rejected.connect(exit)
self.buttonBox.accepted.connect(self.writeConfig)
self.buttonBox.helpRequested.connect(lambda: open_new_tab(WEBPAGE_URL))
def createShadow():
'''Create shadow effect'''
shadow = QGraphicsDropShadowEffect()
shadow.setOffset(QPointF(3,3))
shadow.setBlurRadius(8)
return shadow
def initialize(self, *args, **kwargs):
' class init '
super(Main, self).initialize(*args, **kwargs)
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self.readOutput)
self.process.readyReadStandardError.connect(self.readErrors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_finished)
# directory auto completer
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.Dirs | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
# menu
menu = QMenu('VirtualEnv')
menu.addAction('Make VirtualEnv here', lambda: self.make_virtualenv())
self.locator.get_service('explorer').add_project_menu(menu, lang='all')
self.group1 = QGroupBox()
self.group1.setTitle(' Paths ')
self.outdir = QLineEdit(path.expanduser("~"))
self.outdir.setPlaceholderText('Target Directory for Virtualenv files')
self.outdir.setCompleter(self.completer)
self.btn1 = QPushButton(QIcon.fromTheme("document-open"), ' Open ')
self.btn1.clicked.connect(lambda: self.outdir.setText(str(
QFileDialog.getExistingDirectory(self.dock,
'Please, Open a Target Directory for the Python VirtualEnv...',
path.expanduser("~")))))
self.srcdir, self.prefx = QLineEdit(), QLineEdit()
self.srcdir.setPlaceholderText(
'Extra search path to look for setuptools/distribute/pip')
self.srcdir.setToolTip('''
Specify Extra search path to look for setuptools/distribute/pip.
Defaults to Empty, then the setting is ignored.Defaults are OK.''')
self.srcdir.setCompleter(self.completer)
self.btn2 = QPushButton(QIcon.fromTheme("document-open"), ' Open ')
self.btn2.setToolTip(
'Specify Extra search path to look for setuptools/distribute/pip')
self.btn2.clicked.connect(lambda: self.srcdir.setText(str(
QFileDialog.getExistingDirectory(self.dock,
'Please, Open a Extra search path to look for setuptools/pip...',
path.expanduser("~")))))
self.prefx.setPlaceholderText('Prompt prefix for this environment')
self.prefx.setToolTip('''
Specify a custom alternative prompt prefix for this environment.
Defaults to Empty,this is optional,short prefix are recommended.''')
self.btn3 = QPushButton(QIcon.fromTheme("face-smile-big"), 'Suggestion')
self.btn3.setToolTip('Suggest me a Random CLI prompt prefix !')
self.btn3.clicked.connect(lambda: self.prefx.setText(choice((getuser(),
'tesla', 'einstein', 'turing', 'ritchie', 'darwin', 'curie', 'planck',
'lovelace', 'dijsktra', 'galileo', 'schroedinger', 'perlman', 'hopper',
'newton', 'pasteur', 'maxwell', 'aristotle', 'volta', 'mendelev',
'bohr', 'crick', 'watson', 'archimedes', 'nash', 'fermi', 'dirac',
'feynman', 'kepler', 'copernicus', 'lorentz', 'faraday', 'heisenberg',
))))
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (
QLabel(' Target directory dath: '), self.outdir, self.btn1,
QLabel(' Extra search path: '), self.srcdir, self.btn2,
QLabel(' CLI Prompt prefix (Optional): '), self.prefx, self.btn3):
vboxg1.addWidget(each_widget)
self.group2 = QGroupBox()
self.group2.setTitle(' Options ')
self.group2.setCheckable(True)
self.group2.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group2.graphicsEffect().setEnabled(False)
self.group2.toggled.connect(self.toggle_options_group)
self.qckb1, self.combo1 = QCheckBox(' Use Debug'), QDoubleSpinBox()
self.qckb2 = QCheckBox(' Clear out the target directory')
self.qckb3 = QCheckBox(' System-wide Python Packages')
self.qckb4 = QCheckBox(' Unzip Setuptool or Distribute to virtualenv')
self.qckb5 = QCheckBox(' Force the use of SetupTools')
self.qckb6 = QCheckBox(' Never download packages')
self.qckb7 = QCheckBox(' Delete .PYC files from virtualenv')
self.qckb8 = QCheckBox(' Open target directory later')
self.qckb9 = QCheckBox(' Save a LOG file to target later')
self.qckb10 = QCheckBox(' No install PIP in the new virtualenv')
self.qckb11 = QCheckBox('Save Bash script to reproduce virtenv later')
self.chrt = QCheckBox('LOW CPU priority for Backend Process')
self.combo1.setValue(2.7)
self.combo1.setMaximum(3.4)
self.combo1.setMinimum(2.4)
self.combo1.setDecimals(1)
self.combo1.setSingleStep(0.1)
try:
self.vinfo = QLabel('<small><b> Virtualenv Version: </b>' +
getoutput('virtualenv --version', shell=1).strip())
except:
self.vinfo = QLabel('Warning: Failed to query Virtualenv Backend!')
[a.setChecked(True) for a in (self.qckb1, self.qckb4, self.qckb7,
self.chrt, self.qckb8, self.qckb9, self.qckb11)]
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (self.qckb1, self.qckb2, self.qckb3, self.qckb4,
self.qckb5, self.qckb6, self.qckb7, self.qckb8, self.qckb9,
self.qckb10, self.qckb11, QLabel(' Python interpreter version: '),
self.combo1, QLabel(' Backend CPU priority: '), self.chrt):
vboxg2.addWidget(each_widget)
self.button = QPushButton(' Make Virtualenv ')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(75, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
self.output = QTextEdit(''' " Let the future tell the truth,
and evaluate each one according to his work and accomplishments.
The present is theirs; the future, for which I really worked, is mine. "
-Nikola Tesla. ''')
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((self.group1, self.group2, QLabel('Backend Logs'),
self.output, self.vinfo, self.button))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Virtualenv")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda:
QMessageBox.information(self.dock, __doc__, HELPMSG))
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.infile = QLineEdit(path.expanduser("~"))
self.infile.setPlaceholderText(' /full/path/to/file ')
self.infile.returnPressed.connect(self.run)
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.infile.setCompleter(self.completer)
self.menu = QMenu('Base64')
self.menu.aboutToShow.connect(self.build_submenu)
self.ex_locator = self.locator.get_service('explorer')
self.ex_locator.add_project_menu(self.menu, lang='all')
self.open = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open.setCursor(QCursor(Qt.PointingHandCursor))
self.open.clicked.connect(lambda: self.infile.setText(str(
QFileDialog.getOpenFileName(self.dock, "Open a File to Encode...",
path.expanduser("~"), ';;'.join(['{}(*.{})'.format(e.upper(), e)
for e in ['*', 'jpg', 'png', 'webp', 'svg', 'gif', 'webm']])))))
self.chckbx1 = QCheckBox('Use basic Caesar Cipher (ROT13)')
self.chckbx1.setToolTip('Use "string".decode("rot13") to Decipher ! ')
self.chckbx2 = QCheckBox('Use "data:type/subtype;base64,..."')
self.chckbx2.setChecked(True)
self.chckbx3 = QCheckBox('Copy encoded output to Clipboard')
self.chckbx4 = QCheckBox('Use URL-Safe Base64 Encoder')
self.combo1 = QComboBox()
self.combo1.addItems(['Do Not Generate Code', 'Generate CSS embed Code',
'Generate Python Embed Code', 'Generate HTML embed Code',
'Generate JS embed Code', 'Generate QML embed Code'])
self.combo1.currentIndexChanged.connect(self.combo_changed)
self.output = QTextEdit('''
We can only see a short distance ahead,
but we can see plenty there that needs to be done.
- Alan Turing ''')
self.output.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.button = QPushButton(QIcon.fromTheme("face-cool"), 'Encode BASE64')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
glow.setEnabled(True)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((QLabel('<i>Encode file as plain text string</i>'),
QLabel('<b>File to Encode:'), self.infile, self.open, self.chckbx2,
self.chckbx3, self.chckbx1, self.chckbx4,
QLabel('<b>Embedding Template Code:'), self.combo1,
QLabel(' <b>Base64 String Output: '), self.output,
QLabel('<center><small><i>' + ''.join((__doc__, __version__,
__license__, 'by', __author__))), self.button
))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Base64")
self.guimode = QComboBox(self.dock)
self.guimode.addItems(['Full Mode', 'Simple Mode'])
self.guimode.currentIndexChanged.connect(self.guimode_change)
class QSwitch(QSlider):
""" Custom Switch Widget, inspired from some QML desktop components """
style_knob, style_off, style_on = qss_knob, qss_off, qss_on
clicked, animationOk = pyqtSignal(), pyqtSignal()
def __init__(self, parent=None):
""" Init Custom Switch Widget, set Animation and Glow effects """
QSlider.__init__(self, parent)
self.setOrientation(Qt.Horizontal)
self.animationType = QEasingCurve.OutExpo
self.animation = QPropertyAnimation(self, "value")
self.animation.setDuration(1000)
self.animation.finished.connect(self.animationDone)
self.clicked.connect(self.changeValue)
self.setStyleSheet(self.style_knob + self.style_off)
self.glow = QGraphicsDropShadowEffect(self)
self.glow.setOffset(0)
self.glow.setBlurRadius(99)
self.glow.setColor(QColor(99, 255, 255))
self.setGraphicsEffect(self.glow)
self.glow.setEnabled(False)
def changeValue(self):
""" method to change the actual state ON <--> OFF """
self.animation.setEasingCurve(self.animationType)
if self.value() == self.maximum():
self.animation.setStartValue(self.maximum())
self.animation.setEndValue(self.minimum())
self.animation.start()
self.setStyleSheet(self.style_knob + self.style_off)
self.glow.setEnabled(False)
return
else:
self.animation.setStartValue(self.minimum())
self.animation.setEndValue(self.maximum())
self.setStyleSheet(self.style_knob + self.style_on)
self.glow.setEnabled(True)
self.animation.start()
@pyqtSignature("setAtMax()")
def setAtMax(self):
""" method to set at Maximum, aka ON """
if self.value() == self.minimum():
self.animation.setEasingCurve(self.animationType)
self.animation.setStartValue(self.minimum())
self.animation.setEndValue(self.maximum())
self.animation.start()
self.setStyleSheet(self.style_knob + self.style_on)
@pyqtSignature("setAtMin()")
def setAtMin(self):
""" method to set at Minimum, aka OFF """
if self.value() == self.maximum():
self.animation.setEasingCurve(self.animationType)
self.animation.setStartValue(self.maximum())
self.animation.setEndValue(self.minimum())
self.animation.start()
self.setStyleSheet(self.style_knob + self.style_off)
def mousePressEvent(self, event):
""" method to respond a signal to mouse pointer clicks """
self.clicked.emit()
def isChecked(self):
""" method to return a bool based on actual state """
return self.value() == self.maximum()
def wheelEvent(self, event):
""" dumb method, its not a bug leave it alone """
return
def animationDone(self):
""" method to respond a signal to animation effects """
self.animationOk.emit()
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.process, self.mainwidget = QProcess(), QTabWidget()
self.process.readyReadStandardOutput.connect(self.readOutput)
self.process.readyReadStandardError.connect(self.readErrors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_finished)
self.mainwidget.tabCloseRequested.connect(lambda:
self.mainwidget.setTabPosition(1)
if self.mainwidget.tabPosition() == 0
else self.mainwidget.setTabPosition(0))
self.mainwidget.setStyleSheet('QTabBar{font-weight:bold;}')
self.mainwidget.setMovable(True)
self.mainwidget.setTabsClosable(True)
self.dock, self.scrollable = QDockWidget(), QScrollArea()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(self.mainwidget)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
self.locator.get_service('misc').add_widget(self.dock,
QIcon.fromTheme("face-sad"), __doc__)
self.tab1, self.tab2, self.tab3 = QGroupBox(), QGroupBox(), QGroupBox()
self.tab4, self.tab5, self.tab6 = QGroupBox(), QGroupBox(), QGroupBox()
for a, b in ((self.tab1, 'Basics'), (self.tab2, 'Coverage'),
(self.tab3, 'Extensions'), (self.tab5, 'Regex'),
(self.tab4, 'Paths'), (self.tab6, 'Run')):
a.setTitle(b)
a.setToolTip(b)
self.mainwidget.addTab(a, QIcon.fromTheme("face-sad"), b)
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
''.join((__doc__, __version__, __license__, 'by', __author__))))
groupl, groupr, co = QWidget(), QWidget(), QGroupBox()
self.qckb1 = QCheckBox('Open target directory later')
self.qckb2 = QCheckBox('Save a LOG file to target later')
self.qckb3 = QCheckBox('Verbose operation')
self.qckb4 = QCheckBox('Force Stop on Error')
self.qckb5 = QCheckBox('Scan Executable files for Tests')
vboxgl, vboxgr = QVBoxLayout(groupl), QVBoxLayout(groupr)
for a in (self.qckb1, self.qckb2, self.qckb3, self.qckb4, self.qckb5):
vboxgl.addWidget(a)
a.setToolTip(a.text())
self.qckb6 = QCheckBox('No Byte Compile to .PYC or Delete .PYC later')
self.qckb7 = QCheckBox('Dont touch sys.path when running tests')
self.qckb8 = QCheckBox('Traverse all paths of a package')
self.qckb9 = QCheckBox('Dont capture STDOUT, print STDOUT on the fly')
self.qckb10 = QCheckBox('Clear all Logging handlers')
for a in (self.qckb6, self.qckb7, self.qckb8, self.qckb9, self.qckb10):
vboxgr.addWidget(a)
a.setToolTip(a.text())
vboxcon, self.framew = QHBoxLayout(co), QComboBox()
[vboxcon.addWidget(a) for a in (groupl, groupr)]
self.chrt = QCheckBox('LOW CPU priority for Backend Process')
self.framew.addItems(['nosetests', 'PyTest', 'DocTest', 'Unittest',
'Django_Test', 'Django-Nose', 'None'])
self.framew.currentIndexChanged.connect(lambda: #FIXME refactor for 3
QMessageBox.information(self.dock, __doc__, '<b>Only Nose for now'))
self.framew.currentIndexChanged.connect(lambda: #FIXME refactor for 3
self.framew.setCurrentIndex(0))
vboxg1 = QVBoxLayout(self.tab1)
for each_widget in (QLabel('<b>Framework'), self.framew, self.chrt, co):
vboxg1.addWidget(each_widget)
self.t2ck1, self.t2sp1 = QCheckBox('Activate Coverage'), QSpinBox()
self.t2ck2 = QCheckBox('Erase previously collected Coverage before run')
self.t2ck3 = QCheckBox('Include all tests modules in Coverage reports')
self.t2ck4 = QCheckBox('Include all python files on working directory')
self.t2ck5 = QCheckBox('Produce HTML Coverage reports information')
self.t2ck6 = QCheckBox('Include Branch Coverage in Coverage reports')
self.t2sp1.setRange(10, 90)
self.t2sp1.setValue(75)
vboxg2 = QVBoxLayout(self.tab2)
for each_widget in (QLabel('<b>Min Percentage'), self.t2sp1, self.t2ck1,
self.t2ck2, self.t2ck3, self.t2ck4, self.t2ck5, self.t2ck6):
vboxg2.addWidget(each_widget)
groupi, groupd, vbxg3 = QGroupBox(), QGroupBox(), QHBoxLayout(self.tab3)
vboxgi, vboxgd = QVBoxLayout(groupi), QVBoxLayout(groupd)
self.t3ck1 = QCheckBox('Activate DocTest to find and run doctests')
self.t3ck2 = QCheckBox('Look for any doctests in tests modules too')
self.t3ck3 = QCheckBox('Activate isolation (Do Not use with Coverage!)')
self.t3ck4 = QCheckBox('Use Detailed Errors, evaluate failed asserts')
for a in (self.t3ck1, self.t3ck2, self.t3ck3, self.t3ck4):
vboxgi.addWidget(a)
a.setToolTip(a.text())
self.t3ck5 = QCheckBox('Disable special handling of SkipTest exception')
self.t3ck6 = QCheckBox('Run the tests that failed in the last test run')
self.t3ck7 = QCheckBox('Use AllModules, Collect tests from all modules')
self.t3ck8 = QCheckBox('Collect tests names only, do Not run any tests')
for a in (self.t3ck5, self.t3ck6, self.t3ck7, self.t3ck8):
vboxgd.addWidget(a)
a.setToolTip(a.text())
[vbxg3.addWidget(a) for a in (groupi, groupd)]
self.t4le1, self.t4le2 = QLineEdit(), QLineEdit(path.expanduser("~"))
self.t4le1.setCompleter(self.completer)
self.t4le2.setCompleter(self.completer)
self.t4le1.setPlaceholderText(' /full/path/to/a/folder/ ')
self.t4le2.setPlaceholderText(' /full/path/to/a/folder/ ')
le1b = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
le1b.setMinimumSize(50, 50)
le1b.clicked.connect(lambda: self.t4le1.setText(
QFileDialog.getExistingDirectory(None, '', path.expanduser("~"))))
le2b = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
le2b.clicked.connect(lambda: self.t4le2.setText(
QFileDialog.getExistingDirectory(None, '', path.expanduser("~"))))
vboxg4 = QVBoxLayout(self.tab4)
for a in (QLabel('<b>Directory to look for Tests'), self.t4le1, le1b,
QLabel('<b>Directory to generate HTML Coverage'), self.t4le2, le2b):
vboxg4.addWidget(a)
a.setToolTip(a.text())
self.t5le1 = QLineEdit(r'(?:^|[\b_\./-])[Tt]est')
self.t5le2 = QLineEdit()
self.t5le3, vboxg5 = QLineEdit(), QVBoxLayout(self.tab5)
r = QPushButton('Reset')
r.clicked.connect(lambda: self.t5le1.setText(r'(?:^|[\b_\./-])[Tt]est'))
for a in (QLabel('<b>Matching Name Regex to be test'), self.t5le1, r,
QLabel('<b>Force Include Regex Tests'), self.t5le2,
QLabel('<b>Force Exclude Regex Tests'), self.t5le3):
vboxg5.addWidget(a)
a.setToolTip(a.text())
self.output = QTextEdit(''' Engineering is the art of making what you
want from things you can get. -Dhobi''')
self.runbtn = QPushButton(QIcon.fromTheme("face-sad"), 'Start Testing!')
self.runbtn.setMinimumSize(75, 50)
self.runbtn.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.runbtn.setGraphicsEffect(glow)
self.kbt = QPushButton(QIcon.fromTheme("application-exit"), 'Kill')
self.kbt.clicked.connect(lambda: self.process.kill())
vboxg6 = QVBoxLayout(self.tab6)
for each_widget in (QLabel('Logs'), self.output, self.runbtn, self.kbt):
vboxg6.addWidget(each_widget)
[a.setChecked(True) for a in (self.chrt, self.qckb2, self.qckb3,
self.qckb10, self.t2ck1, self.t2ck2,
self.t2ck5, self.t3ck1, self.t3ck4)]
self.mainwidget.setCurrentIndex(4)
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.locator.get_service("menuApp").add_action(
QAction(QIcon.fromTheme("edit-select-all"),
"Create Setup.py",
self,
triggered=lambda: self.get_dialog()))
self.dialog, self.group0 = QDialog(), QGroupBox()
self.group0.setTitle(' Setup.py Creator ')
self.pkgname, self.version = QLineEdit(), QDoubleSpinBox()
self.urlproj, self.licence = QLineEdit('https://www.'), QLineEdit(
'GPL')
self.authors, self.emails = QLineEdit(
getuser()), QLineEdit('@mail.com')
self.descrip, self.button = QLineEdit(), QPushButton('Make Setup.py !')
self.choices, self.indents = QComboBox(), QSpinBox()
self.metada = QCheckBox('Use SheBang and Metadata')
self.nosetest = QCheckBox('Use Nose Tests Framework integration')
self.metada.setChecked(True)
self.chckbx1 = QCheckBox('Copy output to ClipBoard when done')
self.choices.addItems(
['from distutils.core import setup', 'import distutils.core'])
self.indents.setValue(4)
self.indents.setMaximum(8)
self.indents.setMinimum(0)
self.indents.setSingleStep(2)
self.version.setValue(0.1)
self.version.setMinimum(0.1)
self.version.setDecimals(1)
self.version.setSingleStep(0.1)
self.button.setMinimumSize(400, 50)
self.button.clicked.connect(self.make_setupy)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
inf = QLabel(
'''<a href="http://guide.python-distribute.org/future.html"
><center><i>INFO: This is Deprecated Legacy Packaging.</a>'''
)
inf.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
inf.setOpenExternalLinks(True)
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (QLabel('<b>Package Name'), self.pkgname,
QLabel('<b>Version'),
self.version, QLabel('<b>URL'), self.urlproj,
QLabel('<b>Licence'), self.licence,
QLabel('<b>Author'), self.authors,
QLabel('<b>Mail'), self.emails,
QLabel('<b>Description'), self.descrip,
QLabel('<b>Imports'), self.choices,
QLabel('<b>Indentation Spaces '), self.indents,
self.metada, self.chckbx1, self.nosetest, inf,
QLabel('<center><small><i>{}'.format(HELPMSG)),
self.button):
vboxg0.addWidget(each_widget)
try:
each_widget.setToolTip(each_widget.text())
except:
pass
QVBoxLayout(self.dialog).addWidget(self.group0)
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self.readOutput)
self.process.readyReadStandardError.connect(self.readErrors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_finished)
self.editor_s = self.locator.get_service('editor')
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.group0 = QGroupBox()
self.group0.setTitle(' Source ')
self.infile = QLineEdit(path.expanduser("~"))
self.infile.setPlaceholderText(' /full/path/to/file.html ')
self.infile.setCompleter(self.completer)
self.open = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open.setCursor(QCursor(Qt.PointingHandCursor))
self.open.clicked.connect(lambda: self.infile.setText(str(
QFileDialog.getOpenFileName(self.dock, "Open a File to read from",
path.expanduser("~"), ';;'.join(['{}(*.{})'.format(e.upper(), e)
for e in ['py', 'pyw', 'txt', '*']])))))
self.output = QTextEdit()
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (self.infile, self.open, self.output):
vboxg0.addWidget(each_widget)
self.group1 = QGroupBox()
self.group1.setTitle(' General ')
self.group1.setCheckable(True)
self.group1.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group1.graphicsEffect().setEnabled(False)
self.group1.toggled.connect(self.toggle_gral_group)
self.ckgrl1 = QCheckBox('Create standalone executable')
self.ckgrl2 = QCheckBox('Use Python debug')
self.ckgrl3 = QCheckBox('Force compilation for MS Windows')
self.ckgrl4 = QCheckBox('When compiling, disable the console window')
self.ckgrl5 = QCheckBox('Use link time optimizations if available')
self.ckgrl6 = QCheckBox('Force the use of clang')
self.ckgrl7 = QCheckBox('Allow minor devitations from Python behaviour')
self.ckgrl8 = QCheckBox('Warnings implicit exceptions at compile time')
self.pyver, self.jobs = QComboBox(), QSpinBox()
self.pyver.addItems(['2.7', '2.6', '3.2', '3.3'])
self.jobs.setValue(1)
self.jobs.setMaximum(12)
self.jobs.setMinimum(1)
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (self.ckgrl1, self.ckgrl2, self.ckgrl3, self.ckgrl4,
self.ckgrl5, self.ckgrl6, self.ckgrl7, self.ckgrl8,
QLabel('Python Version to Target'), self.pyver,
QLabel('Multi-Processing Parallel Workers'), self.jobs):
vboxg1.addWidget(each_widget)
try:
each_widget.setToolTip(each_widget.text())
except:
pass
self.group2 = QGroupBox()
self.group2.setTitle(' Recursion Control ')
self.ckrec0 = QCheckBox('Descend to imported modules from standard lib')
self.ckrec1 = QCheckBox('Force not descend to any imported modules')
self.ckrec2 = QCheckBox('Try to descend into all imported modules')
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (self.ckrec0, self.ckrec1, self.ckrec2):
vboxg2.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group3 = QGroupBox()
self.group3.setTitle(' Execution after compilation ')
self.ckexe0 = QCheckBox('Execute created binary (or import the module)')
self.ckexe1 = QCheckBox('When executing binary dont reset PYTHONPATH')
vboxg2 = QVBoxLayout(self.group3)
for each_widget in (self.ckexe0, self.ckexe1):
vboxg2.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group4, self.dumptree = QGroupBox(), QTextEdit()
self.group4.setTitle(' Dump of internal tree ')
QVBoxLayout(self.group4).addWidget(self.dumptree)
self.group5 = QGroupBox()
self.group5.setTitle(' Code generation ')
self.chdmp1 = QCheckBox('Statements shall have their line numbers set')
self.chdmp2 = QCheckBox('Disable all unnecessary Python optimization')
vboxg5 = QVBoxLayout(self.group5)
for each_widget in (self.chdmp1, self.chdmp2):
vboxg5.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group6 = QGroupBox()
self.group6.setTitle(' Output ')
self.outdir = QLineEdit(path.expanduser("~"))
self.outdir.setPlaceholderText(' /full/path/to/target/directory ')
self.outdir.setCompleter(self.completer)
self.open2 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open2.setCursor(QCursor(Qt.PointingHandCursor))
self.open2.clicked.connect(lambda: self.outdir.setText(str(
QFileDialog.getExistingDirectory(self.dock, "Open Target Folder",
path.expanduser("~")))))
self.ckcgn2 = QCheckBox('Remove build dir after compile module or exe')
vboxg6 = QVBoxLayout(self.group6)
for each_widget in (QLabel('Target Output Directory'), self.outdir,
self.open2, self.ckcgn2):
vboxg6.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group7 = QGroupBox()
self.group7.setTitle(' Debug ')
self.ckdbg1 = QCheckBox('Execute self checks to find errors in Nuitka')
self.ckdbg2 = QCheckBox('Keep debug info in resulting file')
self.ckdbg3 = QCheckBox('Traced execution output')
self.ckdbg4 = QCheckBox('Allow compile edited C++ file, debug changes')
self.ckdbg5 = QCheckBox('Use experimental features')
vboxg7 = QVBoxLayout(self.group7)
for each_widget in (self.ckdbg1, self.ckdbg2, self.ckdbg3,
self.ckdbg4, self.ckdbg5):
vboxg7.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group8 = QGroupBox()
self.group8.setTitle(' Tracing ')
self.cktrc1 = QCheckBox('Show Scons in non-quiet mode, showing command')
self.cktrc2 = QCheckBox('Show Progress information and statistics')
self.cktrc3 = QCheckBox('Show Verbose output details')
vboxg8 = QVBoxLayout(self.group8)
for each_widget in (self.cktrc1, self.cktrc2, self.cktrc3):
vboxg8.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group9 = QGroupBox()
self.group9.setTitle(' Extras ')
self.group9.setCheckable(True)
self.group9.toggled.connect(self.group9.hide)
self.nice = QSpinBox()
self.nice.setValue(20)
self.nice.setMaximum(20)
self.nice.setMinimum(0)
self.ckxtr1 = QCheckBox('Open Target Directory later')
self.ckxtr2 = QCheckBox('Save a LOG file to target later')
self.ckxtr3 = QCheckBox('Save SH Bash script to reproduce Nuitka build')
try:
self.vinfo = QLabel('<center> <b> Nuitka Backend Version: </b>' +
getoutput('nuitka --version',).strip())
except:
self.vinfo = QLabel('<b>Warning: Failed to query Nuitka Backend!')
vboxg9 = QVBoxLayout(self.group9)
for each_widget in (QLabel('Backend CPU Priority'), self.nice,
self.ckxtr1, self.ckxtr2, self.ckxtr3, self.vinfo):
vboxg9.addWidget(each_widget)
self.group10 = QGroupBox()
self.group10.setTitle(' Documentation ')
self.group10.setCheckable(True)
self.group10.toggled.connect(self.group10.hide)
vboxg10 = QVBoxLayout(self.group10)
for each_widget in (QLabel('''<a href=
"file:///usr/share/doc/nuitka/README.pdf.gz">
<small><center> Nuitka User Documentation Local PDF </a>'''),
QLabel('''<a href=
"file:///usr/share/doc/nuitka/Developer_Manual.pdf.gz">
<small><center> Nuitka Developer Documentation Local PDF </a>'''),
QLabel('''<a href="http://nuitka.net/doc/user-manual.html">
<small><center> Nuitka User Documentation On Line HTML </a>'''),
QLabel('''<a href="http://nuitka.net/doc/developer-manual.html">
<small><center> Nuitka Developer Documentation On Line HTML </a>''')
):
vboxg10.addWidget(each_widget)
each_widget.setOpenExternalLinks(True)
each_widget.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
[a.setChecked(True) for a in (self.ckgrl1, self.ckgrl2, self.ckgrl4,
self.ckgrl5, self.ckgrl6, self.ckgrl7, self.ckgrl8, self.ckrec0,
self.ckrec1, self.ckrec2, self.ckexe1, self.ckcgn2, self.ckdbg1,
self.ckdbg3, self.ckdbg4, self.ckdbg5, self.cktrc1, self.cktrc2,
self.cktrc3, self.ckxtr1, self.ckxtr2, self.ckxtr3,)]
self.button = QPushButton(QIcon.fromTheme("face-cool"),
'Compile Python')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((
QLabel('<b>Python Code to Binary Executable Compiler'), self.group0,
self.group6, self.group1, self.group2, self.group3, self.group4,
self.group5, self.group7, self.group8, self.group9, self.group10,
self.button, ))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Nuitka")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
HELPMSG))
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.chooser, self.process = QComboBox(), QProcess()
self.chooser.addItems([' Ubuntu Unity QuickList .desktop ',
' KDE Plasma MetaData .desktop ',
' FreeDesktop Standard .desktop '])
self.chooser.currentIndexChanged.connect(self.on_index_changed)
self.chooser.setToolTip('Select a target .desktop file format')
# Standard FreeDesktop
self.group1 = QGroupBox()
self.group1.setTitle(' Standard ')
self.ledVersion, self.ledCategories = QDoubleSpinBox(), QComboBox()
self.ledVersion.setMinimum(0.1)
self.ledVersion.setMaximum(999.9)
self.ledVersion.setValue(1.0)
self.ledVersion.setDecimals(1)
self.ledType, self.ledName = QLineEdit('Application'), QLineEdit('App')
self.ledGenericName = QLineEdit('Generic App')
self.ledComment, self.ledIcon = QLineEdit('App'), QLineEdit('icon.svg')
self.ledCategories.addItems(['Python Programming Language',
'Development', 'Ruby', 'C++', 'Amateur Radio', 'Communication',
'Cross Platform', 'Databases', 'Debug', 'Documentation', 'Editors',
'Education', 'Electronics', 'Email', 'Embebed Devices', 'Fonts',
'GNOME Desktop Environment', 'GNU R Statistical System',
'GObject Introspection Data', 'Games and Amusement',
'Gnustep Desktop Environtment', 'Graphics',
'Haskell Programming Language',
'Internationalization and Localization', 'Internet',
'Interpreted Computer Languages', 'KDE Software Compilation',
'Kernel and Modules', 'Libraries', 'Libraries - Development',
'Libraries - Old', 'Lisp Programming Language', 'Localization',
'Mathematics', 'Meta Packages', 'Miscelaneous - Graphical',
'Miscelaneous - Text Based', 'Mono/CLI Infraestructure',
'Multimedia', 'Networking', 'Newsgroups',
'OCaml Programming Language', 'PHP Programming Language',
'Perl Programming Language', 'Ruby Programming Language',
'Science', 'Shells', 'System Administration', 'TeX Authoring',
'Utilities', 'Version Control Systems', 'Video Software',
'Web Servers', 'Word Processing', 'Xfce Desktop Environment',
'Zope/Plone Environment'])
self.ledExec, self.ledTryExec = QLineEdit('myapp'), QLineEdit('myapp')
self.ledMymeType = QLineEdit('application/x-desktop')
self.ledTerminal = QComboBox()
self.ledTerminal.addItems(['False', 'True'])
self.ledActions = QLineEdit('Next;Previous')
self.ledOnlyShowIn = QLineEdit('Unity;KDE')
self.ledNotShowIn = QLineEdit('Gnome2')
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (QLabel('Version'), self.ledVersion, QLabel('Type'),
self.ledType, QLabel('Name'), self.ledName, QLabel('GenericName'),
self.ledGenericName, QLabel('Comment'), self.ledComment,
QLabel('Icon'), self.ledIcon, QLabel('Categories'),
self.ledCategories, QLabel('Exec'), self.ledExec, QLabel('TryExec'),
self.ledTryExec, QLabel('MymeType'), self.ledMymeType,
QLabel('Terminal'), self.ledTerminal, QLabel('Actions'),
self.ledActions, QLabel('OnlyShowIn'), self.ledOnlyShowIn,
QLabel('NotShowIn'), self.ledNotShowIn):
vboxg1.addWidget(each_widget)
# KDE Plasma
self.group2 = QGroupBox()
self.group2.setTitle(' KDE Plasma ')
self.group2.setGraphicsEffect(QGraphicsBlurEffect(self))
self.ledEncoding, self.ledXPlasmaAPI = QComboBox(), QComboBox()
self.ledEncoding.addItems(['UTF-8', 'ISO-8859-1'])
self.ledServiceType = QLineEdit('Plasma/Applet')
self.ledXPlasmaAPI.addItems([
'Python', 'Javascript', 'Ruby', 'C++', 'HTML5', 'QML'])
self.ledXPlasmaMainScript = QLineEdit('path/to/your/code.py')
self.ledXKDEPluginInfoAuthor = QLineEdit(getuser())
self.ledXKDEPluginInfoEmail = QLineEdit(getuser() + '@gmail.com')
self.ledXKDEPluginInfoName = QLineEdit('Hello-World')
self.ledXKDEPluginInfoVersion = QLineEdit('1.0')
self.ledXKDEPluginInfoWebsite = QLineEdit('http:plasma.kde.org')
self.ledXKDEPluginInfoCategory = QComboBox()
self.ledXKDEPluginInfoCategory.addItems(['Application Launchers',
'Accessibility', 'Astronomy', 'Date and Time',
'Development Tools', 'Education', 'Environment', 'Examples',
'File System', 'Fun and Games', 'Graphics', 'Language', 'Mapping',
'Multimedia', 'Online Services', 'System Information', 'Utilities',
'Windows and Tasks', 'Miscelaneous'])
self.ledXKDEPluginInfoDepends = QLineEdit()
self.ledXKDEPluginInfoLicense = QLineEdit('GPL')
self.ledXKDEPluginInfoEnabledByDefault = QComboBox()
self.ledXKDEPluginInfoEnabledByDefault.addItems(['True', 'False'])
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (
QLabel('Encoding'), self.ledEncoding,
QLabel('ServiceType'), self.ledServiceType,
QLabel('X-Plasma-API'), self.ledXPlasmaAPI,
QLabel('X-Plasma-MainScript'), self.ledXPlasmaMainScript,
QLabel('X-KDE-PluginInfo-Author'), self.ledXKDEPluginInfoAuthor,
QLabel('X-KDE-PluginInfo-Email'), self.ledXKDEPluginInfoEmail,
QLabel('X-KDE-PluginInfo-Name'), self.ledXKDEPluginInfoName,
QLabel('X-KDE-PluginInfo-Version'), self.ledXKDEPluginInfoVersion,
QLabel('X-KDE-PluginInfo-Website'), self.ledXKDEPluginInfoWebsite,
QLabel('X-KDE-PluginInfo-Category'), self.ledXKDEPluginInfoCategory,
QLabel('X-KDE-PluginInfo-Depends'), self.ledXKDEPluginInfoDepends,
QLabel('X-KDE-PluginInfo-License'), self.ledXKDEPluginInfoLicense,
QLabel('X-KDE-PluginInfo-EnabledByDefault'),
self.ledXKDEPluginInfoEnabledByDefault):
vboxg2.addWidget(each_widget)
# Ubuntu Unity
self.ledXAyatanaDesktopShortcuts = QLineEdit('Next;Previous')
self.checkbox1 = QCheckBox('Open .desktop file when done')
self.checkbox2 = QCheckBox('Make .desktop file Executable')
[a.setChecked(True) for a in (self.checkbox1, self.checkbox2)]
self.button = QPushButton(' Make .Desktop File ! ')
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.writeFile)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
glow.setEnabled(True)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((self.chooser, self.group1, self.group2,
QLabel('X-Ayatana-Desktop-Shortcuts'),
self.ledXAyatanaDesktopShortcuts, QLabel(''),
self.checkbox1, self.checkbox2, self.button))
self.dock, self.scrollable = QDockWidget(), QScrollArea()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "DotDesktop")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
''.join((__doc__, __version__, __license__, 'by', __author__))))
def __init__(self, manager, name, image=None, message=None, position=None, size=None, high_quality=False):
super(PreviewWindow, self).__init__()
self.setObjectName("Preview window {}".format(name))
self.setWindowTitle(name)
self.manager = manager
desktop = QApplication.instance().desktop()
if self.maxsize:
self.maxsize = QSize(*self.maxsize)
else:
self.maxsize = desktop.screenGeometry(desktop.screenNumber(self)).size() * 0.95
self.setMinimumSize(*self.minsize)
self.setMaximumSize(self.maxsize)
self.image = None
self.original = None
self.message = message
self.scale = 1.
self.rotation = 0
self.quality = Qt.SmoothTransformation if high_quality else Qt.FastTransformation
self.fixed_size = size
self.scrollarea = PreviewScrollArea()
self.scrollarea.setFrameStyle(0)
self.scrollarea.setFocusPolicy(Qt.NoFocus)
layout = QGridLayout()
layout.setMargin(0)
layout.setContentsMargins(0,0,0,0)
self.setLayout(layout)
layout.addWidget(self.scrollarea, 0, 0)
self.preview = QLabel()
self.preview.setMouseTracking(False)
self.preview.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.scrollarea.setWidget(self.preview)
self.message_label = QLabel(" ")
self.layout().addWidget(self.message_label, 0, 0, Qt.AlignTop)
self.message_label.setStyleSheet("QLabel {color:black;background:rgba(255,255,255,32)}")
self.message_label.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.message_label.setText("")
shadow = QGraphicsDropShadowEffect()
shadow.setBlurRadius(4)
shadow.setColor(Qt.white)
shadow.setOffset(0,0)
self.message_label.setGraphicsEffect(shadow)
self.blink_widget = QWidget()
self.blink_widget.hide()
self.blink_widget.setStyleSheet("border:3px solid red")
self.blink_timer = QTimer()
self.blink_timer.setInterval(1000)
self.blink_timer.timeout.connect(self.blink_)
layout.addWidget(self.blink_widget, 0, 0)
self.setImage(image, show=False)
if image is not None and not size:
size = self.autoSize()
if size:
self.resize(*size)
if position == 'cursor':
position = (QCursor.pos().x() - self.size().width()//2, QCursor.pos().y() - self.size().height()//2)
if position:
self.move(*position)
self.showNormal()
def initialize(self, *args, **kwargs):
' class init '
super(Main, self).initialize(*args, **kwargs)
self.group0 = QGroupBox()
self.group0.setTitle(' Options ')
self.group0.setCheckable(True)
self.group0.toggled.connect(lambda: self.group0.hide())
self.spin1, self.spin2, self.spin3 = QSpinBox(), QSpinBox(), QSpinBox()
self.spin4, self.spin5, self.spin6 = QSpinBox(), QSpinBox(), QSpinBox()
self.spin7, self.spin8, self.spin9 = QSpinBox(), QSpinBox(), QSpinBox()
self.spin10, self.output = QSpinBox(), QTextEdit()
self.reset = QPushButton(QIcon.fromTheme("face-smile"), 'Reset Options')
self.reset.clicked.connect(self.reset_options)
self.reset_options()
self.output.setReadOnly(True)
vboxg3 = QVBoxLayout(self.group0)
for each_widget in (QLabel('<b>Max Attributes Per Class:'), self.spin1,
QLabel('<b>Max Methods Per Class:'), self.spin2,
QLabel('<b>Max Functions Per File:'), self.spin3,
QLabel('<b>Max Classes Per File:'), self.spin4,
QLabel('<b>Max Parameters Per Function:'), self.spin5,
QLabel('<b>Max Lines Per Function:'), self.spin6,
QLabel('<b>Max ControlStatements Per Function:'), self.spin7,
QLabel('<b>Max Lines Per File:'), self.spin8,
QLabel('<b>Max Indentation Levels:'), self.spin9,
QLabel('<b>Max Tabs:'), self.spin10, self.reset):
vboxg3.addWidget(each_widget)
self.group1, self.auto = QGroupBox(), QComboBox()
self.group1.setTitle(' Automation ')
self.group1.setCheckable(True)
self.group1.setToolTip('<font color="red"><b>WARNING:Advanced Setting!')
self.group1.toggled.connect(lambda: self.group1.hide())
self.auto.addItems(['Never run automatically', 'Run when File Saved',
'Run when File Executed', 'Run when Tab Changed',
'Run when File Opened', 'Run before File Saved'])
self.auto.currentIndexChanged.connect(self.on_auto_changed)
QVBoxLayout(self.group1).addWidget(self.auto)
self.button = QPushButton(' Analyze for Best Practice ')
self.button.setMinimumSize(75, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((QLabel('<i>Best Practice analyzer'),
self.group0, self.group1, QLabel('<b>Best Practice Errors:'),
self.output, self.button))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Check")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda:
QMessageBox.information(self.dock, __doc__, HELPMSG))
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.process = QProcess()
self.process.readyReadStandardOutput.connect(self.readOutput)
self.process.readyReadStandardError.connect(self.readErrors)
self.process.finished.connect(self._process_finished)
self.process.error.connect(self._process_finished)
# directory auto completer
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.group0 = QGroupBox()
self.group0.setTitle(' Source ')
self.source, self.infile = QComboBox(), QLineEdit(path.expanduser("~"))
self.source.addItems(['Local File', 'Remote URL'])
self.source.currentIndexChanged.connect(self.on_source_changed)
self.infile.setPlaceholderText(' /full/path/to/file.html ')
self.infile.setCompleter(self.completer)
self.open = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open.setCursor(QCursor(Qt.PointingHandCursor))
self.open.clicked.connect(lambda: self.infile.setText(
str(
QFileDialog.getOpenFileName(
self.dock, "Open a File to read from", path.expanduser(
"~"), ';;'.join([
'{}(*.{})'.format(e.upper(), e) for e in
['html', 'webp', 'webm', 'svg', 'css', 'js', '*']
])))))
self.inurl, self.output = QLineEdit('http://www.'), QTextEdit()
self.inurl.setPlaceholderText(
'http://www.full/url/to/remote/file.html')
self.inurl.hide()
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (self.source, self.infile, self.open, self.inurl):
vboxg0.addWidget(each_widget)
self.group1 = QGroupBox()
self.group1.setTitle(' Mobile ')
self.ckcss1 = QCheckBox('Run in full screen using current resolution')
self.ckcss2 = QCheckBox('Disable touch mode and use keypad mode')
self.ckcss3 = QCheckBox(
'Disable touch mode but allow to use the mouse')
self.ckcss4 = QCheckBox(
'Enable mouse,disable pointer & zoom emulation')
self.ckcss5 = QCheckBox('Start the Mobile version of the browser')
self.ckcss6 = QCheckBox('Start the Tablet version of the browser')
self.ckcss7 = QCheckBox('Emulate hardware with Menu and Back keys')
self.ckcss8 = QCheckBox('Start the browser in Kiosk mode')
self.width, self.height = QSpinBox(), QSpinBox()
self.zoom, self.ram, self.dpi = QSpinBox(), QSpinBox(), QSpinBox()
self.cpulag, self.gpulag = QSpinBox(), QSpinBox()
self.lang, self.agent = QComboBox(), QComboBox()
self.lang.addItems(['EN', 'ES', 'PT', 'JA', 'ZH', 'DE', 'RU', 'FR'])
self.agent.addItems(['Default', 'Android', 'MeeGo', 'Desktop'])
self.fonts = QLineEdit()
self.width.setMaximum(9999)
self.width.setMinimum(100)
self.width.setValue(480)
self.height.setMaximum(9999)
self.height.setMinimum(100)
self.height.setValue(800)
self.zoom.setMaximum(999)
self.zoom.setMinimum(1)
self.zoom.setValue(100)
self.ram.setMaximum(999)
self.ram.setMinimum(1)
self.ram.setValue(100)
self.dpi.setMaximum(200)
self.dpi.setMinimum(50)
self.dpi.setValue(96)
self.cpulag.setMaximum(9999)
self.cpulag.setMinimum(0)
self.cpulag.setValue(1)
self.gpulag.setMaximum(9999)
self.gpulag.setMinimum(0)
self.gpulag.setValue(1)
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (
self.ckcss1, self.ckcss2, self.ckcss3, self.ckcss4,
self.ckcss5, self.ckcss6, self.ckcss7, self.ckcss8,
QLabel('Width Pixels of the emulated device screen'),
self.width,
QLabel('Height Pixels of the emulated device screen'),
self.height,
QLabel('Zoom Percentage of emulated screen'), self.zoom,
QLabel('RAM MegaBytes of the emulated device'), self.ram,
QLabel('Language of the emulated device'), self.lang,
QLabel('D.P.I. of the emulated device'), self.dpi,
QLabel('User-Agent of the emulated device'), self.agent,
QLabel('CPU Core Lag Miliseconds of emulated device'),
self.cpulag,
QLabel('GPU Video Lag Miliseconds of emulated device'),
self.gpulag, QLabel('Extra Fonts Directory Full Path'),
self.fonts):
vboxg1.addWidget(each_widget)
self.group2 = QGroupBox()
self.group2.setTitle(' General ')
self.nice, self.opera = QSpinBox(), QLineEdit(path.expanduser("~"))
self.nice.setValue(20)
self.nice.setMaximum(20)
self.nice.setMinimum(0)
self.opera.setCompleter(self.completer)
if path.exists(CONFIG_FILE):
with codecs.open(CONFIG_FILE, encoding='utf-8') as fp:
self.opera.setText(fp.read())
self.open2 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open2.setCursor(QCursor(Qt.PointingHandCursor))
self.open2.clicked.connect(lambda: self.opera.setText(
str(
QFileDialog.getOpenFileName(
self.dock, "Open Opera Mobile Emulator",
path.expanduser("~"),
'Opera Mobile Emulator Executable(opera-mobile-emulator)'))
))
self.help1 = QLabel('''<a href=
"http://www.opera.com/developer/mobile-emulator">
<small><center>Download Opera Mobile Emulator !</a>''')
self.help1.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
self.help1.setOpenExternalLinks(True)
vboxg4 = QVBoxLayout(self.group2)
for each_widget in (QLabel(' Backend CPU priority: '), self.nice,
QLabel(' Opera Mobile Emulator Full Path: '),
self.opera, self.open2, self.help1):
vboxg4.addWidget(each_widget)
self.button = QPushButton('Preview on Mobile')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.run)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
glow.setEnabled(True)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((
QLabel('<b>Mobile Browser Emulator'),
self.group0,
self.group1,
self.group2,
self.output,
self.button,
))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Mobile")
QPushButton(
QIcon.fromTheme("help-about"), 'About', self.dock).clicked.connect(
lambda: QMessageBox.information(self.dock, __doc__, HELPMSG))
