class RemoteDebug(QWidget, Page):
title = "Remote Debug Eclipse"
icon = os.path.join(os.path.dirname(__file__), "icon.png")
def __init__(self, api, parent=None):
def setupUi():
layout = QBoxLayout(QBoxLayout.LeftToRight, self)
layout.setContentsMargins(0, 0, 0, 0)
self.label = QLabel('Not active debugger', self)
layout.addWidget(self.label)
self.btnRun = QPushButton("Run debugger", self)
layout.addWidget(self.btnRun)
self.setLayout(layout)
self.btnRun.clicked.connect(self.run)
super(RemoteDebug, self).__init__(parent)
setupUi()
sys.path.append(pydev_path)
def run(self):
self.btnRun.setEnabled(False)
self.btnRun.hide()
started = False
try:
import pydevd
pydevd.settrace(port=5678, suspend=False)
started = True
self.label.setText(u"PyDev debugging active")
except:
pass
if not started:
self.label.setText(u"Debugging connection failed")
def __init__(self, callback):
super().__init__()
self.callback = callback
self.offset = 0 # Offset of currently oaded script
self.pointerscount = 0 # Number of pointers to the offset
self.oldsize = 0 # Old size of currently loaded bytestring.
self.freespace = 0 # Free space available after currently loaded bytestring.
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
formlayout = QFormLayout()
label_charscount = QLabel()
label_offset = QLabel()
label_pointersToOffset = QLabel()
formlayout.addRow("Used / Maximum number of chars:", label_charscount)
formlayout.addRow("String offset:", label_offset)
formlayout.addRow("Pointers to offset:", label_pointersToOffset)
find_startpoint = QPushButton("Try to find start of string.", self)
find_startpoint.hide()
editor_save = QPushButton("Save", self)
editor_save_repoint = QPushButton("Save and update pointers.", self)
editor_save_repoint.hide()
stringeditor = LNTextEdit(self)
font = QFont("Monospace");
font.setStyleHint(QFont.TypeWriter);
stringeditor.setFont(font)
layout.addWidget(stringeditor)
layout.addLayout(formlayout)
layout.addWidget(find_startpoint)
layout.addWidget(editor_save)
layout.addWidget(editor_save_repoint)
#self.label_totalchars = label_totalchars
self.stringeditor = stringeditor
self.label_charscount = label_charscount
self.label_offset = label_offset
self.label_pointersToOffset = label_pointersToOffset
self.editor_save = editor_save
self.find_startpoint = find_startpoint
self.editor_save_repoint = editor_save_repoint
stringeditor.edit.textChanged.connect(self.updateUI)
find_startpoint.clicked.connect(self.findStartpoint)
editor_save.clicked.connect(self.save)
editor_save_repoint.clicked.connect(self.saveandrepoint)
self.updateUI()
def __init__(self, callback):
super().__init__()
self.callback = callback
self.offset = 0 # Offset of currently oaded script
self.pointerscount = 0 # Number of pointers to the offset
self.oldsize = 0 # Old size of currently loaded bytestring.
self.freespace = 0 # Free space available after currently loaded bytestring.
layout = QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
formlayout = QFormLayout()
label_charscount = QLabel()
label_offset = QLabel()
label_pointersToOffset = QLabel()
formlayout.addRow("Used / Maximum number of chars:", label_charscount)
formlayout.addRow("String offset:", label_offset)
formlayout.addRow("Pointers to offset:", label_pointersToOffset)
find_startpoint = QPushButton("Try to find start of string.", self)
find_startpoint.hide()
editor_save = QPushButton("Save", self)
editor_save_repoint = QPushButton("Save and update pointers.", self)
editor_save_repoint.hide()
stringeditor = LNTextEdit(self)
font = QFont("Monospace")
font.setStyleHint(QFont.TypeWriter)
stringeditor.setFont(font)
layout.addWidget(stringeditor)
layout.addLayout(formlayout)
layout.addWidget(find_startpoint)
layout.addWidget(editor_save)
layout.addWidget(editor_save_repoint)
#self.label_totalchars = label_totalchars
self.stringeditor = stringeditor
self.label_charscount = label_charscount
self.label_offset = label_offset
self.label_pointersToOffset = label_pointersToOffset
self.editor_save = editor_save
self.find_startpoint = find_startpoint
self.editor_save_repoint = editor_save_repoint
stringeditor.edit.textChanged.connect(self.updateUI)
find_startpoint.clicked.connect(self.findStartpoint)
editor_save.clicked.connect(self.save)
editor_save_repoint.clicked.connect(self.saveandrepoint)
self.updateUI()
class CardShowControlPanel(QWidget):
def __init__(self, parent=None):
super(CardShowControlPanel, self).__init__(parent)
self.show_translation_button = QPushButton("Show translation", self)
self.show_translation_button.move(80, 5)
self.show_translation_button.resize(150, 30)
self.true_button = QPushButton("True", self)
self.true_button.move(50, 5)
self.true_button.hide()
self.false_button = QPushButton("False", self)
self.false_button.move(150, 5)
self.false_button.hide()
self.setMinimumSize(305, 50)
class Partition(QLabel):
def __init__(self, parent, title = 'Free Space', fs_type = FREE, size = 0):
QLabel.__init__(self, parent)
self.parent = parent
self._fs_type = fs_type
self.setStyleSheet(STYLES[fs_type])
self.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.setSizePolicy(QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred))
self.setText(title)
self._setSize(size)
self.editButton = QPushButton('Edit', self)
self.deleteButton = QPushButton('Del', self)
self.editButton.clicked.connect(self.editButtonClicked)
self.deleteButton.clicked.connect(self.deleteButtonClicked)
QTimer.singleShot(0, self.leaveEvent)
def _setSize(self, size):
self._size = size
self.setToolTip('Size: %s MB' % size)
def editButtonClicked(self):
print "Edit clicked on ", self.text()
def deleteButtonClicked(self):
self.parent.deletePartition(self)
print "Delete clicked on ", self.text()
def enterEvent(self, event):
if not self._fs_type == FREE:
self.editButton.move(self.width() - self.editButton.width(), self.height() / 2 - self.editButton.height() / 2)
self.deleteButton.move(self.editButton.pos().x() - self.deleteButton.width(), self.height() / 2 - self.deleteButton.height() / 2)
self.editButton.show()
self.deleteButton.show()
def leaveEvent(self, event=None):
self.editButton.hide()
self.deleteButton.hide()
class TraitLine(QWidget):
"""
@brief Die grafische Darstellung einer einzigen Eigenschaft auf dem Charakterbogen.
Die Simplen Eigenschaften (z.B. Attribute) bestehen nur aus Name und Wert. Bei kompliziertere Eigenschaften müssen noch Spezialisieren und andere Parameter beachtet werden.
"""
valueChanged = Signal(int)
bonusValueChanged = Signal(int)
textChanged = Signal(str)
buttonToggled = Signal(bool)
def __init__(self, name, value, parent=None):
super(TraitLine, self).__init__(parent)
self.__layout = QHBoxLayout()
#self.__layout.setMargin( 0 )
self.setLayout( self.__layout )
self.__labelName = QLabel( self )
self.__button = QPushButton( self )
self.__button.setText( "..." )
self.__button.setMaximumHeight( Config.WIDGET_INLINE_HEIGHT_MAX )
self.__button.setCheckable( True )
self.__lineEdit = QLineEdit( self )
self.__lineEdit.setMinimumWidth( Config.TRAIT_CUSTOMTEXT_WIDTH_MIN )
self.__lineEdit.setMaximumHeight( Config.WIDGET_INLINE_HEIGHT_MAX )
self.__traitDots = TraitDots( self )
self.__traitDots.valueChanged.connect(self.valueChanged)
self.__traitDots.valueChanged.connect(self.enableButton)
self.__traitDots.bonusValueChanged.connect(self.bonusValueChanged)
self.__button.toggled.connect(self.buttonToggled)
self.__lineEdit.textChanged.connect(self.textChanged)
self.name = name
self.value = value
#// Damit auch bei der Programminitialisierung die Spezialisierungen richtig enabled oder disabled sind.
#enableSpecialties( value );
self.__layout.addWidget( self.__labelName )
self.__layout.addStretch()
self.__layout.addWidget( self.__lineEdit )
self.__layout.addWidget( self.__button )
self.__layout.addWidget( self.__traitDots )
#QLabel* TraitLine::labelName() const {
#return v_label_name;
#}
@property
def name(self):
return self.__labelName.text()
@name.setter
def name( self, name ):
self.__labelName.setText( name )
## Der beschreibende Text dieser Eigenschaft.
#QString TraitLine::text() const {
#return lineEdit.text();
#}
def setText( self, text ):
self.__lineEdit.setText( text )
@property
def buttonText(self):
"""
Beschriftung des Knopfes.
"""
return self.__button.text()
@buttonText.setter
def buttonText( self, text ):
self.__button.setText( str(text) )
def __getValue(self):
return self.__traitDots.value()
def setValue( self, value ):
"""
\note Diese Funktion ist nicht privat, da ich diese Funktion als Slot benötige.
"""
#Debug.debug("Hurra! Setze Eigenschaft {} auf Wert {}".format(self.name(), value))
self.__traitDots.setValue( value )
## Der Wert, die hier dargestellten Eigenschaft.
value = property(__getValue, setValue)
def __getBonusValue(self):
return self.__traitDots.bonusBonusValue()
def setBonusValue( self, bonusBonusValue ):
"""
\note Diese Funktion ist nicht privat, da ich diese Funktion als Slot benötige.
"""
#Debug.debug("Hurra! Setze Eigenschaft {} auf Wert {}".format(self.name(), bonusBonusValue))
self.__traitDots.setBonusValue( bonusBonusValue )
## Der Wert, die hier dargestellten Eigenschaft.
bonusBonusValue = property(__getBonusValue, setBonusValue)
def setPossibleValues( self, values ):
"""
Legt fest, welche Werte diese Zeile annehmen darf.
"""
self.__traitDots.setAllowedValues( values )
#int TraitLine::minimum() const {
#return traitDots.minimum();
#}
#void TraitLine::setMinimum( int value ) {
#traitDots.setMinimum( value );
#}
def __getMaximum(self):
"""
Der Maximalwert für die Dargestellten Punkte.
"""
return self.__traitDots.maximum()
def setMaximum(self, maximum):
self.__traitDots.setMaximum(maximum)
maximum = property(__getMaximum, setMaximum)
def setEnabled( self, sw=True):
self.__labelName.setEnabled(sw)
self.__button.setEnabled(sw)
self.__lineEdit.setEnabled(sw)
self.__traitDots.setEnabled(sw)
def setSpecialtyButtonChecked( self, sw=True ):
"""
Aktiviere oder Deaktiviere den Spezialisierungs-Knopf.
"""
self.__button.setChecked( sw )
def setSpecialtiesHidden( self, sw=True ):
"""
Mit dieser Methode verstecke ich die Liste der Spezialisierungen. Schließlich haben nur Fertigkeiten eine Notwendigkeit dafür.
"""
if ( sw ):
self.__button.hide()
else:
self.__button.show()
def setSpecialtiesEnabled( self, sw=True ):
self.__button.setEnabled( sw )
def setDescriptionHidden( self, sw ):
"""
Mit dieser Methode verstecke ich die Textzeile, in welcher zusätzlicher Beschreibungstext eingegeben werden kann.
"""
if ( sw ):
self.__lineEdit.hide()
else:
self.__lineEdit.show()
def enableButton( self, value):
if value > 0:
self.__button.setEnabled(True)
else:
self.__button.setChecked(False)
self.__button.setEnabled(False)
class LegendPropertiesWindow(PyDialog):
"""
+-------------------+
| Legend Properties |
+-----------------------+
| Title ______ Default |
| Min ______ Default |
| Max ______ Default |
| Format ______ Default |
| Scale ______ Default |
| Phase ______ Default |
| Number of Colors ____ |
| Number of Labels ____ |
| Label Size ____ | (TODO)
| ColorMap ____ | (TODO)
| |
| x Min/Max (Blue->Red) |
| o Max/Min (Red->Blue) |
| |
| x Vertical/Horizontal |
| x Show/Hide |
| |
| Animate |
| Apply OK Cancel |
+-----------------------+
"""
def __init__(self, data, win_parent=None):
PyDialog.__init__(self, data, win_parent)
self._updated_legend = False
self._animation_window_shown = False
self._icase = data['icase']
self._default_icase = self._icase
self._default_name = data['name']
self._default_min = data['min']
self._default_max = data['max']
self._default_scale = data['default_scale']
self._scale = data['scale']
self._default_phase = data['default_phase']
self._phase = data['phase']
self._default_format = data['default_format']
self._format = data['format']
self._default_labelsize = data['default_labelsize']
self._labelsize = data['labelsize']
self._default_nlabels = data['default_nlabels']
self._nlabels = data['nlabels']
self._default_ncolors = data['default_ncolors']
self._ncolors = data['ncolors']
self._default_colormap = data['default_colormap']
self._colormap = data['colormap']
self._default_is_low_to_high = data['is_low_to_high']
self._default_is_discrete = data['is_discrete']
self._default_is_horizontal = data['is_horizontal']
self._default_is_shown = data['is_shown']
self._is_normals = data['is_normals']
self._update_defaults_to_blank()
#self.setupUi(self)
self.setWindowTitle('Legend Properties')
self.create_widgets()
self.create_layout()
self.set_connections()
self.set_font_size(data['font_size'])
def _update_defaults_to_blank(self):
"""Changes the default (None) to a blank string"""
if self._default_colormap is None:
self._default_colormap = 'jet'
if self._default_labelsize is None:
self._default_labelsize = ''
if self._default_ncolors is None:
self._default_ncolors = ''
if self._default_nlabels is None:
self._default_nlabels = ''
if self._colormap is None:
self._colormap = 'jet'
if self._labelsize is None:
self._labelsize = ''
if self._ncolors is None:
self._ncolors = ''
if self._nlabels is None:
self._nlabels = ''
def update_legend(self,
icase,
name,
min_value,
max_value,
data_format,
scale,
phase,
nlabels,
labelsize,
ncolors,
colormap,
default_title,
default_min_value,
default_max_value,
default_data_format,
default_scale,
default_phase,
default_nlabels,
default_labelsize,
default_ncolors,
default_colormap,
is_low_to_high,
is_horizontal_scalar_bar,
is_normals,
font_size=8):
"""
We need to update the legend if there's been a result change request
"""
self.set_font_size(font_size)
if icase != self._default_icase:
self._icase = icase
self._default_icase = icase
self._default_name = default_title
self._default_min = default_min_value
self._default_max = default_max_value
self._default_format = default_data_format
self._default_is_low_to_high = is_low_to_high
self._default_is_discrete = True
self._default_is_horizontal = is_horizontal_scalar_bar
self._default_scale = default_scale
self._default_phase = default_phase
self._default_nlabels = default_nlabels
self._default_labelsize = default_labelsize
self._default_ncolors = default_ncolors
self._default_colormap = default_colormap
self._is_normals = is_normals
if colormap is None:
colormap = 'jet'
if labelsize is None:
labelsize = ''
if ncolors is None:
ncolors = ''
if nlabels is None:
nlabels = ''
self._update_defaults_to_blank()
assert isinstance(scale, float), 'scale=%r' % scale
assert isinstance(default_scale,
float), 'default_scale=%r' % default_scale
if self._default_scale == 0.0:
self.scale.setEnabled(False)
self.scale_edit.setEnabled(False)
self.scale_button.setEnabled(False)
else:
self.scale.setEnabled(True)
self.scale_edit.setEnabled(True)
self.scale_button.setEnabled(True)
if self._default_phase is None:
self._phase = None
self.phase.setEnabled(False)
self.phase_edit.setEnabled(False)
self.phase_button.setEnabled(False)
self.phase_edit.setText('0.0')
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
else:
self._phase = phase
self.phase.setEnabled(True)
self.phase_edit.setEnabled(True)
self.phase_button.setEnabled(True)
self.phase_edit.setText(str(phase))
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
#self.on_default_name()
#self.on_default_min()
#self.on_default_max()
#self.on_default_format()
#self.on_default_scale()
# reset defaults
self._name = name
self.name_edit.setText(name)
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
self.min_edit.setText(str(min_value))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
self.max_edit.setText(str(max_value))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
self.format_edit.setText(str(data_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
self._scale = scale
self.scale_edit.setText(str(scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(nlabels))
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.labelsize_edit.setText(str(labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
self.ncolors_edit.setText(str(ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
self.colormap_edit.setCurrentIndex(
colormap_keys.index(str(colormap)))
# lots of hacking for the Normal vectors
enable = True
if self._is_normals:
enable = False
self.max.setVisible(enable)
self.min.setVisible(enable)
self.max_edit.setVisible(enable)
self.min_edit.setVisible(enable)
self.max_button.setVisible(enable)
self.min_button.setVisible(enable)
self.show_radio.setVisible(enable)
self.hide_radio.setVisible(enable)
self.low_to_high_radio.setVisible(enable)
self.high_to_low_radio.setVisible(enable)
self.format.setVisible(enable)
self.format_edit.setVisible(enable)
self.format_edit.setVisible(enable)
self.format_button.setVisible(enable)
self.nlabels.setVisible(enable)
self.nlabels_edit.setVisible(enable)
self.nlabels_button.setVisible(enable)
self.ncolors.setVisible(enable)
self.ncolors_edit.setVisible(enable)
self.ncolors_button.setVisible(enable)
self.grid2_title.setVisible(enable)
self.vertical_radio.setVisible(enable)
self.horizontal_radio.setVisible(enable)
self.colormap.setVisible(enable)
self.colormap_edit.setVisible(enable)
self.colormap_button.setVisible(enable)
self.on_apply()
def create_widgets(self):
"""creates the menu objects"""
# Name
self.name = QLabel("Title:")
self.name_edit = QLineEdit(str(self._default_name))
self.name_button = QPushButton("Default")
# Min
self.min = QLabel("Min:")
self.min_edit = QLineEdit(str(self._default_min))
self.min_button = QPushButton("Default")
# Max
self.max = QLabel("Max:")
self.max_edit = QLineEdit(str(self._default_max))
self.max_button = QPushButton("Default")
#---------------------------------------
# Format
self.format = QLabel("Format (e.g. %.3f, %g, %.6e):")
self.format_edit = QLineEdit(str(self._format))
self.format_button = QPushButton("Default")
#---------------------------------------
# Scale
self.scale = QLabel("Scale:")
self.scale_edit = QLineEdit(str(self._scale))
self.scale_button = QPushButton("Default")
if self._default_scale == 0.0:
self.scale.setVisible(False)
self.scale_edit.setVisible(False)
self.scale_button.setVisible(False)
# Phase
self.phase = QLabel("Phase (deg):")
self.phase_edit = QLineEdit(str(self._phase))
self.phase_button = QPushButton("Default")
if self._default_phase is None:
self.phase.setVisible(False)
self.phase_edit.setVisible(False)
self.phase_button.setVisible(False)
self.phase_edit.setText('0.0')
#tip = QtGui.QToolTip()
#tip.setTe
#self.format_edit.toolTip(tip)
#---------------------------------------
# nlabels
self.nlabels = QLabel("Number of Labels:")
self.nlabels_edit = QLineEdit(str(self._nlabels))
self.nlabels_button = QPushButton("Default")
self.labelsize = QLabel("Label Size:")
self.labelsize_edit = QLineEdit(str(self._labelsize))
self.labelsize_button = QPushButton("Default")
self.ncolors = QLabel("Number of Colors:")
self.ncolors_edit = QLineEdit(str(self._ncolors))
self.ncolors_button = QPushButton("Default")
self.colormap = QLabel("Color Map:")
self.colormap_edit = QComboBox(self)
self.colormap_button = QPushButton("Default")
for key in colormap_keys:
self.colormap_edit.addItem(key)
self.colormap_edit.setCurrentIndex(colormap_keys.index(self._colormap))
# --------------------------------------------------------------
# the header
self.grid2_title = QLabel("Color Scale:")
# red/blue or blue/red
self.low_to_high_radio = QRadioButton('Low -> High')
self.high_to_low_radio = QRadioButton('High -> Low')
widget = QWidget(self)
low_to_high_group = QButtonGroup(widget)
low_to_high_group.addButton(self.low_to_high_radio)
low_to_high_group.addButton(self.high_to_low_radio)
self.low_to_high_radio.setChecked(self._default_is_low_to_high)
self.high_to_low_radio.setChecked(not self._default_is_low_to_high)
# horizontal / vertical
self.horizontal_radio = QRadioButton("Horizontal")
self.vertical_radio = QRadioButton("Vertical")
widget = QWidget(self)
horizontal_vertical_group = QButtonGroup(widget)
horizontal_vertical_group.addButton(self.horizontal_radio)
horizontal_vertical_group.addButton(self.vertical_radio)
self.horizontal_radio.setChecked(self._default_is_horizontal)
self.vertical_radio.setChecked(not self._default_is_horizontal)
# on / off
self.show_radio = QRadioButton("Show")
self.hide_radio = QRadioButton("Hide")
widget = QWidget(self)
show_hide_group = QButtonGroup(widget)
show_hide_group.addButton(self.show_radio)
show_hide_group.addButton(self.hide_radio)
self.show_radio.setChecked(self._default_is_shown)
self.hide_radio.setChecked(not self._default_is_shown)
# --------------------------------------------------------------
if self._is_normals:
self.max.hide()
self.min.hide()
self.max_edit.hide()
self.min_edit.hide()
self.max_button.hide()
self.min_button.hide()
self.format.hide()
self.format_edit.hide()
self.format_button.hide()
self.nlabels.hide()
self.nlabels_edit.hide()
self.nlabels_button.hide()
self.ncolors.hide()
self.ncolors_edit.hide()
self.ncolors_button.hide()
self.grid2_title.hide()
self.vertical_radio.hide()
self.horizontal_radio.hide()
self.show_radio.hide()
self.hide_radio.hide()
self.low_to_high_radio.hide()
self.high_to_low_radio.hide()
self.colormap.hide()
self.colormap_edit.hide()
self.colormap_button.hide()
self.animate_button = QPushButton('Create Animation')
if self._default_scale == 0.0:
self.animate_button.setEnabled(False)
self.animate_button.setToolTip(
'This must be a displacement-like result to animate')
# closing
self.apply_button = QPushButton("Apply")
self.ok_button = QPushButton("OK")
self.cancel_button = QPushButton("Cancel")
def create_layout(self):
"""displays the menu objects"""
grid = QGridLayout()
grid.addWidget(self.name, 0, 0)
grid.addWidget(self.name_edit, 0, 1)
grid.addWidget(self.name_button, 0, 2)
grid.addWidget(self.min, 1, 0)
grid.addWidget(self.min_edit, 1, 1)
grid.addWidget(self.min_button, 1, 2)
grid.addWidget(self.max, 2, 0)
grid.addWidget(self.max_edit, 2, 1)
grid.addWidget(self.max_button, 2, 2)
grid.addWidget(self.format, 3, 0)
grid.addWidget(self.format_edit, 3, 1)
grid.addWidget(self.format_button, 3, 2)
grid.addWidget(self.scale, 4, 0)
grid.addWidget(self.scale_edit, 4, 1)
grid.addWidget(self.scale_button, 4, 2)
grid.addWidget(self.phase, 5, 0)
grid.addWidget(self.phase_edit, 5, 1)
grid.addWidget(self.phase_button, 5, 2)
grid.addWidget(self.nlabels, 6, 0)
grid.addWidget(self.nlabels_edit, 6, 1)
grid.addWidget(self.nlabels_button, 6, 2)
#grid.addWidget(self.labelsize, 6, 0)
#grid.addWidget(self.labelsize_edit, 6, 1)
#grid.addWidget(self.labelsize_button, 6, 2)
grid.addWidget(self.ncolors, 7, 0)
grid.addWidget(self.ncolors_edit, 7, 1)
grid.addWidget(self.ncolors_button, 7, 2)
grid.addWidget(self.colormap, 8, 0)
grid.addWidget(self.colormap_edit, 8, 1)
grid.addWidget(self.colormap_button, 8, 2)
ok_cancel_box = QHBoxLayout()
ok_cancel_box.addWidget(self.apply_button)
ok_cancel_box.addWidget(self.ok_button)
ok_cancel_box.addWidget(self.cancel_button)
grid2 = QGridLayout()
grid2.addWidget(self.grid2_title, 0, 0)
grid2.addWidget(self.low_to_high_radio, 1, 0)
grid2.addWidget(self.high_to_low_radio, 2, 0)
grid2.addWidget(self.vertical_radio, 1, 1)
grid2.addWidget(self.horizontal_radio, 2, 1)
grid2.addWidget(self.show_radio, 1, 2)
grid2.addWidget(self.hide_radio, 2, 2)
grid2.addWidget(self.animate_button, 3, 1)
#grid2.setSpacing(0)
vbox = QVBoxLayout()
vbox.addLayout(grid)
#vbox.addLayout(checkboxes)
vbox.addLayout(grid2)
vbox.addStretch()
vbox.addLayout(ok_cancel_box)
#Create central widget, add layout and set
#central_widget = QtGui.QWidget()
#central_widget.setLayout(vbox)
#self.setCentralWidget(central_widget)
self.setLayout(vbox)
def set_connections(self):
"""creates the actions for the buttons"""
self.name_button.clicked.connect(self.on_default_name)
self.min_button.clicked.connect(self.on_default_min)
self.max_button.clicked.connect(self.on_default_max)
self.format_button.clicked.connect(self.on_default_format)
self.scale_button.clicked.connect(self.on_default_scale)
self.phase_button.clicked.connect(self.on_default_phase)
self.nlabels_button.clicked.connect(self.on_default_nlabels)
self.labelsize_button.clicked.connect(self.on_default_labelsize)
self.ncolors_button.clicked.connect(self.on_default_ncolors)
self.colormap_button.clicked.connect(self.on_default_colormap)
self.animate_button.clicked.connect(self.on_animate)
self.show_radio.clicked.connect(self.on_show_hide)
self.hide_radio.clicked.connect(self.on_show_hide)
self.apply_button.clicked.connect(self.on_apply)
self.ok_button.clicked.connect(self.on_ok)
self.cancel_button.clicked.connect(self.on_cancel)
if qt_version == 4:
self.connect(self, QtCore.SIGNAL('triggered()'), self.closeEvent)
#self.colormap_edit.activated[str].connect(self.onActivated)
#else:
# closeEvent???
def set_font_size(self, font_size):
"""
Updates the font size of the objects
Parameters
----------
font_size : int
the font size
"""
if self.font_size == font_size:
return
self.font_size = font_size
font = QFont()
font.setPointSize(font_size)
self.setFont(font)
self.name_edit.setFont(font)
self.min_edit.setFont(font)
self.max_edit.setFont(font)
self.format_edit.setFont(font)
self.scale_edit.setFont(font)
self.phase_edit.setFont(font)
self.nlabels_edit.setFont(font)
self.labelsize_edit.setFont(font)
self.ncolors_edit.setFont(font)
def on_animate(self):
"""opens the animation window"""
name, flag0 = self.check_name(self.name_edit)
if not flag0:
return
scale, flag1 = self.check_float(self.scale_edit)
if not flag1:
scale = self._scale
data = {
'font_size': self.out_data['font_size'],
'icase': self._icase,
'name': name,
'time': 2,
'frames/sec': 30,
'resolution': 1,
'iframe': 0,
'scale': scale,
'default_scale': self._default_scale,
'is_scale': self._default_phase is None,
'phase': self._phase,
'default_phase': self._default_phase,
'dirname': os.path.abspath(os.getcwd()),
'clicked_ok': False,
'close': False,
}
if not self._animation_window_shown:
self._animation_window = AnimationWindow(data, win_parent=self)
self._animation_window.show()
self._animation_window_shown = True
self._animation_window.exec_()
else:
self._animation_window.activateWindow()
if data['close']:
if not self._animation_window._updated_animation:
#self._apply_animation(data)
pass
self._animation_window_shown = False
del self._animation_window
else:
self._animation_window.activateWindow()
def on_default_name(self):
"""action when user clicks 'Default' for name"""
name = str(self._default_name)
self.name_edit.setText(name)
self.name_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_min(self):
"""action when user clicks 'Default' for min value"""
self.min_edit.setText(str(self._default_min))
self.min_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_max(self):
"""action when user clicks 'Default' for max value"""
self.max_edit.setText(str(self._default_max))
self.max_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_format(self):
"""action when user clicks 'Default' for the number format"""
self.format_edit.setText(str(self._default_format))
self.format_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_scale(self):
"""action when user clicks 'Default' for scale factor"""
self.scale_edit.setText(str(self._default_scale))
self.scale_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_phase(self):
"""action when user clicks 'Default' for phase angle"""
self.phase_edit.setText(str(self._default_phase))
self.phase_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_ncolors(self):
"""action when user clicks 'Default' for number of colors"""
self.ncolors_edit.setText(str(self._default_ncolors))
self.ncolors_edit.setStyleSheet("QLineEdit{background: white;}")
def on_default_colormap(self):
"""action when user clicks 'Default' for the color map"""
self.colormap_edit.setCurrentIndex(
colormap_keys.index(self._default_colormap))
def on_default_nlabels(self):
"""action when user clicks 'Default' for number of labels"""
self.nlabels_edit.setStyleSheet("QLineEdit{background: white;}")
self.nlabels_edit.setText(str(self._default_nlabels))
def on_default_labelsize(self):
"""action when user clicks 'Default' for number of labelsize"""
self.labelsize_edit.setText(str(self._default_labelsize))
self.labelsize_edit.setStyleSheet("QLineEdit{background: white;}")
def on_show_hide(self):
"""action when user clicks the 'Show/Hide' radio button"""
self.colormap_edit.setCurrentIndex(
colormap_keys.index(self._default_colormap))
is_shown = self.show_radio.isChecked()
self.vertical_radio.setEnabled(is_shown)
self.horizontal_radio.setEnabled(is_shown)
@staticmethod
def check_name(cell):
cell_value = cell.text()
try:
text = str(cell_value).strip()
except UnicodeEncodeError:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
if len(text):
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
@staticmethod
def check_colormap(cell):
text = str(cell.text()).strip()
if text in colormap_keys:
cell.setStyleSheet("QLineEdit{background: white;}")
return text, True
else:
cell.setStyleSheet("QLineEdit{background: red;}")
return None, False
def on_validate(self):
name_value, flag0 = self.check_name(self.name_edit)
min_value, flag1 = self.check_float(self.min_edit)
max_value, flag2 = self.check_float(self.max_edit)
format_value, flag3 = self.check_format(self.format_edit)
scale, flag4 = self.check_float(self.scale_edit)
phase, flag5 = self.check_float(self.phase_edit)
nlabels, flag6 = self.check_positive_int_or_blank(self.nlabels_edit)
ncolors, flag7 = self.check_positive_int_or_blank(self.ncolors_edit)
labelsize, flag8 = self.check_positive_int_or_blank(
self.labelsize_edit)
colormap = str(self.colormap_edit.currentText())
if all([flag0, flag1, flag2, flag3, flag4, flag5, flag6, flag7,
flag8]):
if 'i' in format_value:
format_value = '%i'
assert isinstance(scale, float), scale
self.out_data['name'] = name_value
self.out_data['min'] = min_value
self.out_data['max'] = max_value
self.out_data['format'] = format_value
self.out_data['scale'] = scale
self.out_data['phase'] = phase
self.out_data['nlabels'] = nlabels
self.out_data['ncolors'] = ncolors
self.out_data['labelsize'] = labelsize
self.out_data['colormap'] = colormap
self.out_data['is_low_to_high'] = self.low_to_high_radio.isChecked(
)
self.out_data['is_horizontal'] = self.horizontal_radio.isChecked()
self.out_data['is_shown'] = self.show_radio.isChecked()
self.out_data['clicked_ok'] = True
self.out_data['close'] = True
#print('self.out_data = ', self.out_data)
#print("name = %r" % self.name_edit.text())
#print("min = %r" % self.min_edit.text())
#print("max = %r" % self.max_edit.text())
#print("format = %r" % self.format_edit.text())
return True
return False
def on_apply(self):
passed = self.on_validate()
if passed:
self.win_parent._apply_legend(self.out_data)
return passed
def on_ok(self):
passed = self.on_apply()
if passed:
self.close()
#self.destroy()
def on_cancel(self):
self.out_data['close'] = True
self.close()
class QtSCJ(QDialog) :
"""
QtSCJ est une boite de dialogue contenant l'état de la progression de
chaque processus
"""
def __init__(self, parent=None):
super(QtSCJ, self).__init__(parent)
self.dir = None
self.jobs = { }
self.log = [ ]
self.mode = "ogg"
self.filter = "*.mp3 *.ogg *.wav"
self.modes = [ "ogg", "mp3", "wav" ]
self.readSettings()
self.setupUi()
self.retranslateUi()
self.fermer.setEnabled(True)
self.connect(self.fermer,SIGNAL("clicked()"),self.close)
self.connect(self.convertDir,SIGNAL("clicked()"),self.getDir)
self.connect(self.convertFile,SIGNAL("clicked()"),self.getFiles)
self.connect(self.startallbtn,SIGNAL("clicked()"),self.startAll)
self.connect(self.delallbtn,SIGNAL("clicked()"),self.delAll)
self.connect(self.output,SIGNAL("currentIndexChanged(const QString)"),
self.setMode)
def setMode(self, mode):
self.mode = mode
self.writeSettings()
def writeSettings(self):
settings = QSettings("scj", "scj")
settings.setValue("mode", self.mode)
def readSettings(self):
settings = QSettings("scj", "scj")
self.mode = settings.value("mode", "ogg").toString()
def setupUi(self):
self.setObjectName("SCJ")
self.setFixedSize(600,260)
#self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setObjectName("verticalLayout")
#self.infoText = QTextEdit(self)
self.infoText = QLabel(self)
palette = QPalette()
brush = QBrush(QColor(245, 245, 245))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Normal, QPalette.Background, brush)
self.infoText.setPalette(palette)
self.infoText.setAutoFillBackground(True)
self.infoText.setFixedHeight(200)
self.infoText.setObjectName("infoText")
#self.infoText.setReadOnly(True)
self.infoText.setWordWrap(True)
self.verticalLayout.addWidget(self.infoText)
# Manage Actions buttons
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
## Format de sortie
self.outlabel = QLabel(self.trUtf8("Choix du format de destination"))
self.horizontalLayout.addWidget(self.outlabel)
self.output = QComboBox()
self.output.addItems(self.modes)
self.output.setCurrentIndex(self.output.findText(self.mode))
self.horizontalLayout.addWidget(self.output)
# Buttons
self.fermer = QPushButton(self)
self.fermer.setObjectName("fermer")
self.horizontalLayout.addWidget(self.fermer)
self.convertDir = QPushButton(self)
self.convertDir.setObjectName("convertDir")
self.horizontalLayout.addWidget(self.convertDir)
self.convertFile = QPushButton(self)
self.convertFile.setObjectName("convertFile")
self.horizontalLayout.addWidget(self.convertFile)
self.verticalLayout.addLayout(self.horizontalLayout)
# Layout for allButtons
self.allLayout = QHBoxLayout()
# Add startAll bouton
self.startallbtn = QPushButton(self)
self.allLayout.addWidget(self.startallbtn)
self.startallbtn.hide()
self.verticalLayout.addLayout(self.allLayout)
# Add delAll bouton
self.delallbtn = QPushButton(self)
self.allLayout.addWidget(self.delallbtn)
self.delallbtn.hide()
# Mode avec scroll
self.frame = QFrame()
self.frame.setMinimumSize(520,250)
self.frame.setMaximumWidth(520)
self.scroll = QScrollArea()
self.scroll.setMinimumHeight(180)
self.jobsLayout = QVBoxLayout(self.frame)
self.jobsLayout.setSizeConstraint(QLayout.SetMinAndMaxSize)
#self.jobsLayout.setSizeConstraint(QLayout.SetMinimumSize)
#self.jobsLayout.setSizeConstraint(QLayout.SetMaximumSize)
self.scroll.setWidget(self.frame)
self.scroll.setWidgetResizable(False)
self.verticalLayout.addWidget(self.scroll)
self.scroll.hide()
# Mode sans scroll
#self.jobsLayout = QVBoxLayout()
#self.verticalLayout.addLayout(self.jobsLayout)
# Add a strech to the bottom of the window
self.verticalLayout.insertStretch(-1)
def retranslateUi(self):
self.setWindowTitle(u"SCJ")
self.infoText.setToolTip(self.trUtf8("Messages"))
self.fermer.setToolTip(self.trUtf8("Fermer la fenetre"))
self.fermer.setText(self.trUtf8("Fermer"))
self.startallbtn.setToolTip(self.trUtf8("Demarrer toutes les taches"))
self.startallbtn.setText(self.trUtf8("Tout demarrer"))
self.delallbtn.setToolTip(self.trUtf8("Supprimmer toutes les taches"))
self.delallbtn.setText(self.trUtf8("Tout supprimer"))
self.convertDir.setToolTip(self.trUtf8("Convertir un repertoire"))
self.convertDir.setText(self.trUtf8("Repertoire"))
self.convertFile.setToolTip(self.trUtf8("Convertir un fichier"))
self.convertFile.setText(self.trUtf8("Fichier(s)"))
self.infoText.setText(u"<h1>%s</h1>\
\n%s<br/>\
\n%s\
\n<ul><li>%s</li>\
\n <li>%s</li>\
\n <li><b>%s</b></li>\
\n</ul>" %
(self.trUtf8("BIENVENUE SUR SCJ"),
self.trUtf8("SCJ permet de convertir un ou plusieurs fichiers"+
" son vers differents formats."),
self.trUtf8("Il gere egalement les repertoires en convertissant"+
" l'ensemble des fichiers sons presents vers le"+
" format voulu."),
self.trUtf8("Choisissez le format de destination"),
self.trUtf8("Cliquez sur Fichier(s) ou Repertoire en fonction"+
" de ve que vous voulez convertir."),
self.trUtf8("Demarrez la conversion !")
))
def addFile(self, file, createDir=False):
file.makeAbsolute()
if (file.suffix() != self.mode):
job = SCJProgress( parent=None,
file=file.filePath(),
format=self.mode,
createDir=createDir)
if not self.jobs.get(job.output):
self.jobs[job.output] = job
self.jobsLayout.addLayout(self.jobs[job.output])
self.connect(self.jobs[job.output], SIGNAL("void removed(QString)"), self.delFile)
self.addStartAll()
def delFile(self, job):
j = self.jobs.pop(job)
self.addStartAll()
self.jobsLayout.removeItem(j)
def getDir(self):
self.dir = QFileDialog.getExistingDirectory(
parent = self,
caption = self.trUtf8("Choix du repertoire"),
directory = QDir.homePath(),
options = QFileDialog.ShowDirsOnly |
QFileDialog.DontResolveSymlinks)
if self.dir :
directory = QDir(self.dir, self.filter)
for file in directory.entryInfoList():
self.addFile(file, createDir=True)
def getFiles(self):
files = QFileDialog.getOpenFileNames(
parent = self,
caption = self.trUtf8("Choix des fichiers"),
directory = QDir.homePath(),
filter = u"%s (%s)" % (self.trUtf8("Sons"),
self.filter))
for file in files:
self.addFile(QFileInfo(file), createDir=False)
def addStartAll(self):
if (len(self.jobs) > 0 ):
self.startallbtn.setVisible(True)
self.delallbtn.setVisible(True)
self.scroll.setVisible(True)
self.setFixedSize(600, 480)
else:
self.startallbtn.setVisible(False)
self.delallbtn.setVisible(False)
self.scroll.setVisible(False)
self.setFixedSize(600, 260)
self.updateGeometry()
def startAll(self):
for (key, job) in self.jobs.items():
job.start()
def delAll(self):
for (key, job) in self.jobs.items():
job.stop()
self.delFile(key)
def close(self):
print u"%s" % self.trUtf8("We are stopping running jobs"),
for (key, job) in self.jobs.items():
job.stop()
print ".",
print u"%s" % self.trUtf8("Done")
super(QtSCJ, self).close()
class ExpensesDialog(QDialog):
holdc = {}
def __init__(self, session, parent=None):
super(ExpensesDialog, self).__init__(parent)
self.session = session
session = self.pullOnes('session', session)
self.sessionname = str(session['name']) + ' Session'
self.pagetitle = self.sessionname
self.tableFont = QFont('Century Gothic', 8)
#self.tableFont.setFamily('Century Gothic')
self.tableHeaderStyle = "::section {" "background-color: teal; color:white}"
#pull all CA
self.editID = 0
self.hold_account = {}
self.hold_expenses = {}
self.hold_expensesGroup = {}
from_label = QLabel('From:')
to_label = QLabel('To:')
self.fromData = QDateEdit()
self.toData = QDateEdit()
currentDate = QDate()
self.fromData.setDate(currentDate.currentDate())
self.fromData.setCalendarPopup(True)
self.toData.setDate(currentDate.currentDate())
self.toData.setCalendarPopup(True)
self.pull_btn = QPushButton()
self.pull_btn.setText("Load")
h_pull_box = QHBoxLayout()
h_pull_box.addWidget(from_label)
h_pull_box.addWidget(self.fromData)
h_pull_box.addWidget(to_label)
h_pull_box.addWidget(self.toData)
h_pull_box.addWidget(self.pull_btn)
expensesGroup = self.pullGroupExpenses()
account = self.pullAccount()
self.expenseGroupText = QLabel('Category')
self.expenseGroupData = QComboBox()
self.expenseGroupData.currentIndexChanged.connect(self.reloadExpenses)
self.expenseText = QLabel('Expenses')
self.expenseData = QComboBox()
self.amountText = QLabel('Amount')
self.amountData = QLineEdit()
self.amountData.setPlaceholderText('0000.00')
self.tellerText = QLabel('Teller/Reciept No.')
self.tellerData = QLineEdit()
self.tellerData.setPlaceholderText('xxxxxxxxx')
self.accountText = QLabel('Account')
self.accountData = QComboBox()
self.dateText = QLabel('Date')
self.dateData = QDateEdit()
self.dateData.setDate(currentDate.currentDate())
self.dateData.setCalendarPopup(True)
self.descriptionText = QLabel('Brief Description')
self.descriptionData = QPlainTextEdit()
self.descriptionData.move(200, 100)
hboz = QHBoxLayout()
self.gender = QLabel('State')
self.r1 = QRadioButton('Expenses')
self.r1.setChecked(True)
self.r2 = QRadioButton('Refund')
hboz.addWidget(self.r1)
hboz.addWidget(self.r2)
i = 0
for a in expensesGroup:
self.hold_expensesGroup[i] = a['id']
tex = str(a['name']).upper()
self.expenseGroupData.addItem(tex)
i += 1
i = 0
exp_key = self.hold_expensesGroup[self.expenseGroupData.currentIndex()]
expenses = self.pullExpenses(exp_key)
for a in expenses:
self.hold_expenses[i] = a['id']
tex = str(a['name']).upper()
self.expenseData.addItem(tex)
i += 1
i = 0
for a in account:
self.hold_account[i] = a['id']
tex = str(a['name']).upper()
self.accountData.addItem(tex)
i += 1
self.FormLayout = QFormLayout()
self.FormLayout.addRow(self.expenseGroupText, self.expenseGroupData)
self.FormLayout.addRow(self.expenseText, self.expenseData)
self.FormLayout.addRow(self.accountText, self.accountData)
self.FormLayout.addRow(self.tellerText, self.tellerData)
self.FormLayout.addRow(self.amountText, self.amountData)
self.FormLayout.addRow(self.gender, hboz)
self.FormLayout.addRow(self.dateText, self.dateData)
self.FormLayout.addRow(self.descriptionText, self.descriptionData)
groupBox1 = QGroupBox('Add Expenses')
groupBox1.setLayout(self.FormLayout)
self.pb = QPushButton()
self.pb.setObjectName("Add")
self.pb.setText("Add Expenses")
self.pb1 = QPushButton()
self.pb1.setObjectName("Edit")
self.pb1.setText("Edit Row")
self.pb1.setEnabled(False)
self.pb2 = QPushButton()
self.pb2.setObjectName("Close")
self.pb2.setText("Close")
self.pb3 = QPushButton()
self.pb3.setObjectName("Delete")
self.pb3.setText("Delete Row")
self.pb3.setEnabled(False)
self.pb4 = QPushButton()
self.pb4.setObjectName("Reset")
self.pb4.setText("Reset")
self.pb4.hide()
self.pb5 = QPushButton()
self.pb5.setObjectName("Change")
self.pb5.setText("Change Expenses")
self.pb5.hide()
self.pb6 = QPushButton()
self.pb6.setObjectName("Clear")
self.pb6.setText("Clear Selection")
self.pb6.setEnabled(False)
hbo = QHBoxLayout()
hbo.addWidget(self.pb)
hbo.addWidget(self.pb5)
hbo.addWidget(self.pb4)
hbo.addWidget(self.pb2)
groupBox2 = QGroupBox('Expenses Data')
groupBox2.setLayout(hbo)
self.cols = ['SN', 'EXPENSES', 'ACCOUNT', 'AMOUNT', 'DATE']
al = self.pullExpensesData()
if len(al) > 0:
al = al
else:
al = {}
self.table = QTableWidget()
header = self.table.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
header.setStyleSheet(self.tableHeaderStyle)
vheader = self.table.verticalHeader()
vheader.setStyleSheet(self.tableHeaderStyle)
# Body
self.table.setWindowTitle("Expenses")
self.table.resize(300, 250)
self.table.setFont(self.tableFont)
self.table.setSortingEnabled(2)
#self.table.resizeColumnsToContents()
self.table.setRowCount(len(al))
self.table.setColumnCount(len(self.cols))
self.table.setHorizontalHeaderLabels(self.cols)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.handleHeaderMenu)
self.table.hideColumn(0)
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
i = 0
for q in al:
#row id
self.table.setItem(i, 0, QTableWidgetItem(str(q['id'])))
self.table.setItem(i, 1,
QTableWidgetItem(str(q['expensename']).upper()))
self.table.setItem(i, 2,
QTableWidgetItem(str(q['accountname']).upper()))
zamt = str("{:,}".format(float(q['amount'])))
self.table.setItem(i, 3, QTableWidgetItem(zamt))
damz = float(q['datepaid'])
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
self.table.setItem(i, 4, QTableWidgetItem(str(damt)))
i += 1
self.table.itemSelectionChanged.connect(self.confirmSelection)
self.table.resizeRowsToContents()
v_pull_box = QVBoxLayout()
self.h1_pull_box = QVBoxLayout()
self.h1_pull_box.addWidget(self.table)
v_pull_box.addLayout(h_pull_box)
v_pull_box.addLayout(self.h1_pull_box)
h2_pull_box = QHBoxLayout()
h2_pull_box.addWidget(self.pb1)
h2_pull_box.addWidget(self.pb3)
h2_pull_box.addWidget(self.pb6)
v_pull_box.addLayout(h2_pull_box)
groupBox3 = QGroupBox()
groupBox3.setLayout(hbo)
groupBox2.setLayout(v_pull_box)
grid = QGridLayout()
grid.addWidget(groupBox1, 0, 0)
grid.addWidget(groupBox2, 0, 1, 2, 1)
grid.addWidget(groupBox3, 1, 0)
self.setLayout(grid)
self.connect(self.pb, SIGNAL("clicked()"), lambda: self.button_click())
self.connect(self.pb1, SIGNAL("clicked()"),
lambda: self.button_editshow())
self.connect(self.pb2, SIGNAL("clicked()"),
lambda: self.button_close(self))
self.connect(self.pb3, SIGNAL("clicked()"),
lambda: self.button_delete())
self.connect(self.pb4, SIGNAL("clicked()"),
lambda: self.button_reset())
self.connect(self.pb5, SIGNAL("clicked()"), lambda: self.button_edit())
self.connect(self.pb6, SIGNAL("clicked()"),
lambda: self.button_clear())
self.connect(self.pull_btn,
SIGNAL("clicked()"),
lambda x=1: self.reloadTable(x))
self.setWindowTitle(self.pagetitle)
def handleHeaderMenu(self, pos):
print('column(%d)' % self.table.horizontalHeader().logicalIndexAt(pos))
menu = QMenu()
menu.addAction('Add')
menu.addAction('Delete')
menu.exec_(QCursor.pos())
def pullGroupExpenses(self):
cn = Db()
arr = cn.selectn('datas', '', '', {"pubID": 15, "active": 0})
return arr
def pullExpenses(self, a):
cn = Db()
arr = cn.selectn('datas', '', '', {"subID": a})
return arr
def pullAccount(self):
cn = Db()
arr = cn.selectn('datas', '', '', {"pubID": 20, "active": 0})
return arr
def pullExpensesData(self):
st_date = self.fromData.date().toPyDate()
en_date = self.toData.date().toPyDate()
st_date = time.mktime(st_date.timetuple())
en_date = time.mktime(en_date.timetuple())
db = 'school_expenses' + str(self.session)
cn = Db()
arr = cn.selectExpenseDate(db, st_date, en_date)
return arr
def mySelectTable(self):
'''
get the selected rpws in a table
returns list or row ids
'''
sels = self.table.selectedIndexes()
sels = self.table.selectionModel().selectedRows()
park = []
park1 = []
for j in sels:
park.append(j.row())
for i in set(park):
selected = self.table.item(i, 0).text()
park1.append(selected)
return park1
def editRow(self, a):
_session = self.session
g = Db()
db = 'school_expenses' + str(_session)
data = g.selectn(db, '', 1, {'id': a})
if len(data) > 0:
self.editID = int(data['id'])
if float(data['amount']) < 0:
amt = float(data['amount']) * -1
self.amountData.setText(str(amt))
self.r1.setChecked(True)
else:
amt = float(data['amount'])
self.amountData.setText(str(amt))
self.r2.setChecked(True)
self.descriptionData.clear()
self.descriptionData.insertPlainText(str(data['description']))
self.tellerData.setText(str(data['teller']))
acID = self.hold_account.keys()[self.hold_account.values().index(
data['accountID'])]
self.accountData.setCurrentIndex(acID)
exID = self.hold_expenses.keys()[self.hold_expenses.values().index(
data['expenseID'])]
self.expenseData.setCurrentIndex(exID)
def reloadExpenses(self):
cat = self.hold_expensesGroup[self.expenseGroupData.currentIndex()]
expenses = self.pullExpenses(cat)
self.expenseData.clear()
self.hold_expenses = {}
i = 0
for a in expenses:
self.hold_expenses[i] = a['id']
tex = str(a['name']).upper()
self.expenseData.addItem(tex)
i += 1
def reloadTable(self, a):
data = self.pullExpensesData()
self.table.close()
self.table = QTableWidget()
header = self.table.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
header.setStyleSheet(self.tableHeaderStyle)
vheader = self.table.verticalHeader()
vheader.setStyleSheet(self.tableHeaderStyle)
# Body
self.table.setWindowTitle("Expenses")
self.table.resize(300, 250)
self.table.setFont(self.tableFont)
self.table.setSortingEnabled(2)
self.table.resizeColumnsToContents()
self.table.setRowCount(len(data))
self.table.setColumnCount(len(self.cols))
self.table.setHorizontalHeaderLabels(self.cols)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.handleHeaderMenu)
self.table.hideColumn(0)
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
i = 0
for q in data:
#row id
self.table.setItem(i, 0, QTableWidgetItem(str(q['id'])))
self.table.setItem(i, 1,
QTableWidgetItem(str(q['expensename']).upper()))
self.table.setItem(i, 2,
QTableWidgetItem(str(q['accountname']).upper()))
zamt = str("{:,}".format(float(q['amount'])))
self.table.setItem(i, 3, QTableWidgetItem(zamt))
damz = float(q['datepaid'])
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
self.table.setItem(i, 4, QTableWidgetItem(str(damt)))
i += 1
self.table.itemSelectionChanged.connect(self.confirmSelection)
self.table.resizeRowsToContents()
self.h1_pull_box.addWidget(self.table)
self.table.show()
def pullOnes(self, a, b):
cn = Db()
arr = cn.selectn(a, '', 1, {'id': b})
return arr
def confirmSelection(self):
item = self.mySelectTable()
if len(item) == 1:
self.pb1.setEnabled(True)
self.pb3.setEnabled(True)
self.pb6.setEnabled(True)
elif len(item) > 1:
self.pb1.setEnabled(False)
self.pb3.setEnabled(True)
self.pb6.setEnabled(True)
else:
self.pb1.setEnabled(False)
self.pb3.setEnabled(False)
self.pb6.setEnabled(False)
def button_close(self, b):
b.close()
def button_editshow(self):
item = self.mySelectTable()
self.editRow(item[0])
self.pb.hide()
self.pb4.show()
self.pb5.show()
def button_delete(self):
item = self.mySelectTable()
_session = self.session
g = Db()
db = 'school_expenses' + str(_session)
for j in item:
g.delete(db, {'id': j})
self.reloadTable(1)
def button_edit(self):
_session = self.session
_amount = self.amountData.text()
_teller = self.tellerData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
_description = self.descriptionData.toPlainText()
_account = self.hold_account[self.accountData.currentIndex()]
_expense = self.hold_expenses[self.expenseData.currentIndex()]
if self.r1.isChecked():
_amount = float(_amount)
else:
_amount = float(_amount) * -1
arr = {}
if _amount and not (_amount
== 0) and int(_expense) > 0 and int(_account) > 0:
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['accountID'] = _account
arr['expenseID'] = _expense
arr['teller'] = _teller
ups = {}
ups['id'] = self.editID
if int(self.editID) > 0:
db = 'school_expenses' + str(_session)
g = Db()
g.update(db, arr, ups)
if int(self.editID) > 0:
self.button_reset()
def button_reset(self):
self.reloadTable(1)
self.amountData.setText('')
self.descriptionData.clear()
self.tellerData.setText('')
self.pb4.hide()
self.pb5.hide()
self.pb.show()
self.editID = 0
self.button_clear()
self.confirmSelection()
def button_clear(self):
self.table.selectionModel().clearSelection()
def button_click(self):
_session = self.session
_amount = self.amountData.text()
_teller = self.tellerData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
_description = self.descriptionData.toPlainText()
_account = self.hold_account[self.accountData.currentIndex()]
_expense = self.hold_expenses[self.expenseData.currentIndex()]
if self.r1.isChecked():
_amount = float(_amount)
else:
_amount = float(_amount) * -1
arr = {}
if _amount and not (_amount
== 0) and int(_expense) > 0 and int(_account) > 0:
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['accountID'] = _account
arr['expenseID'] = _expense
arr['teller'] = _teller
db = 'school_expenses' + str(_session)
g = Db()
ins = g.insert(db, arr)
if int(ins) > 0:
self.button_reset()
class BoBlo(QWidget):
'''
Revisar layouts para proporciones
'''
def __init__(self):
super().__init__()
self.setGeometry(200, 100, 1024, 768)
self.setWindowTitle('BoBlo - Bottle Blocks')
self.setWindowIcon(QIcon(get_absolute_path('images/icon2.png')))
self.screenShape = QDesktopWidget().screenGeometry()
self.bg_width = 1280
self.bg_height = 990
# self.resize(self.screenShape.width(), self.screenShape.height())
self.combinations = list()
self.plastic = 0
self.button_stylesheet = "QPushButton {background-color: #8FCBF4;" \
"border-style: outset;" \
"border-width: 2px;" \
"border-radius: 10px;" \
"border-color: #C6E2FF;" \
"font: bold 15pt \"Comic Sans MS\";" \
"min-width: 10em;" \
"padding: 6px;}" \
"QPushButton:pressed {background-color: #4F94CD}"
self.background = QLabel(self)
self.background.setGeometry(375, 0, self.bg_width, self.bg_height)
self.background.setPixmap(
QPixmap(get_absolute_path("./images/background.jpg")).scaled(
self.bg_width, self.bg_height))
self.label_grs1 = QLabel(str(self.plastic), self)
self.label_grs1.setFont(QFont("Comic Sans MS", 40, QFont.Bold))
self.label_grs1.setGeometry(640, 270, 310, 120)
self.label_grs1.setAlignment(Qt.AlignRight)
self.label_grs1.hide()
self.label_grs2 = QLabel(str(self.plastic), self)
self.label_grs2.setFont(QFont("Comic Sans MS", 40, QFont.Bold))
self.label_grs2.setGeometry(820, 58, 310, 120)
self.label_grs2.setAlignment(Qt.AlignCenter)
self.label_grs2.hide()
self.label_blocks = QLabel(str(plastic_to_blocks(self.plastic)), self)
self.label_blocks.setFont(QFont("Comic Sans MS", 50, QFont.Bold))
self.label_blocks.setGeometry(700, 330, 310, 150)
self.label_blocks.setAlignment(Qt.AlignRight)
self.label_blocks.hide()
self.text_dato = QLabel(self)
self.text_dato.move(570, 550)
self.text_dato.setPixmap(
QPixmap(get_absolute_path("./images/dato1.png")))
self.text1 = QLabel(self)
self.text1.move(570, 100)
self.text1.setPixmap(QPixmap(get_absolute_path("./images/text1.png")))
self.pic1 = QLabel(self)
self.pic1.move(1070, 400)
self.pic1.setPixmap(
QPixmap(get_absolute_path("./images/image_step1.png")))
self.text2 = QLabel(self)
self.text2.move(570, 50)
self.text2.setPixmap(QPixmap(get_absolute_path("./images/text2.png")))
self.text2.hide()
self.text3 = QLabel(self)
self.text3.move(930, 260)
self.text3.setPixmap(QPixmap(get_absolute_path("./images/text3.png")))
self.text3.hide()
self.text4 = QLabel(self)
self.text4.move(570, 50)
self.text4.setPixmap(QPixmap(get_absolute_path("./images/text4.png")))
self.text4.hide()
self.pic2 = QLabel(self)
self.pic2.move(1070, 350)
self.pic2.setPixmap(QPixmap(get_absolute_path("./images/boblo1.png")))
self.pic2.hide()
self.text5 = QLabel(self)
self.text5.move(570, 50)
self.text5.setPixmap(QPixmap(get_absolute_path("./images/text5.png")))
self.text5.hide()
self.to_step3 = QPushButton("&Quiero mis piezas", self)
self.to_step3.setGeometry(1120, 570, 300, 90)
self.to_step3.setStyleSheet(self.button_stylesheet)
self.to_step3.hide()
self.icon_arrow = QIcon(get_absolute_path("./images/arrow.png"))
self.to_step4 = QPushButton("", self)
self.to_step4.setIcon(self.icon_arrow)
self.to_step4.setIconSize(QSize(250, 60))
self.to_step4.setGeometry(1120, 570, 300, 90)
self.to_step4.setStyleSheet(self.button_stylesheet)
self.to_step4.hide()
self.icon_arrowi = QIcon(get_absolute_path("./images/arrowi.png"))
self.back_to_step2 = QPushButton("", self)
self.back_to_step2.setIcon(self.icon_arrowi)
self.back_to_step2.setIconSize(QSize(250, 60))
self.back_to_step2.setGeometry(644, 570, 300, 90)
self.back_to_step2.setStyleSheet(self.button_stylesheet)
self.back_to_step2.hide()
self.to_step5 = QPushButton("", self)
self.to_step5.setIcon(self.icon_arrow)
self.to_step5.setIconSize(QSize(250, 60))
self.to_step5.setGeometry(1140, 610, 300, 90)
self.to_step5.setStyleSheet(self.button_stylesheet)
self.to_step5.hide()
# self.options = OptionsList(self)
self.options = OptionsTable(self)
self.options.setGeometry(620, 170, 824, 430)
self.options.hide()
self.text6 = QLabel(self)
self.text6.move(570, 100)
self.text6.setPixmap(QPixmap(get_absolute_path("./images/text6.png")))
self.text6.hide()
self.text7 = QLabel(self)
self.text7.move(570, 480)
self.text7.setPixmap(QPixmap(get_absolute_path("./images/text7.png")))
self.text7.hide()
self.text_process = QLabel(self)
self.text_process.move(570, 480)
self.text_process.setPixmap(
QPixmap(get_absolute_path("./images/process1.png")))
self.text_process.hide()
self.restart = QPushButton("&OK", self)
self.restart.setGeometry(1120, 570, 300, 90)
self.restart.setStyleSheet(self.button_stylesheet)
self.restart.hide()
self.audio = QSound(get_absolute_path("./audio/boblo.wav"))
# threading
self.start_thread()
def restart_values(self):
self.plastic = 0
self.combinations = list()
self.label_grs1.setText(str(self.plastic))
self.label_grs2.setText(str(self.plastic))
self.options = OptionsTable(self)
self.options.setGeometry(620, 170, 824, 430)
self.options.hide()
def set_combinations(self, blocks):
self.all_combinations(blocks)
if len(self.combinations) != 0:
if len(self.combinations) == 1 and sum(
self.combinations[0].values()) == 0:
self.emit(SIGNAL("invalid"))
else:
self.combinations.append({8: 5, 4: 5, 2: 5, 1: 5})
print(self.combinations)
self.options.set_data(self.combinations)
return
def all_combinations(self, blocks, step=8, comb={8: 0, 4: 0, 2: 0, 1: 0}):
'''
Options: 4x2 (8), 2x2 (4), 2x1 (2), 1x1 (1)
Restricciones:
- Max. 1 de 1x1 (impar)
- Max 5 de un tipo
- Max 8 piezas en total
- Max 5 entre 1x1 y 2x1
'''
actual_sum = sum([x[0] * x[1] for x in comb.items()])
if step == 0:
# restricciones
if actual_sum == blocks:
if comb[1] <= 1 and (comb[1] + comb[2]) <= 5 and sum(
comb.values()) <= 8:
if len([v for v in comb.values() if v > 5]) == 0:
self.combinations.append(comb)
return
else:
max_cant = (blocks - actual_sum) // step
if step == 8:
next_step = 4
elif step == 4:
next_step = 2
elif step == 2:
next_step = 1
else:
next_step = 0
for i in range(0, max_cant + 1):
aux = dict(comb)
aux[step] = i
self.all_combinations(blocks, next_step, aux)
def start_thread(self):
self.weight_monitor = ArduinoMonitor()
self.t = QThread(self)
self.weight_monitor.weight_signal.connect(self.update_weight)
self.weight_monitor.moveToThread(self.t)
self.t.started.connect(self.weight_monitor.check_weight)
self.t.start()
@pyqtSlot(str)
def update_weight(self, grs):
# actualizar peso en interfaz
if grs != "Exito":
self.plastic = int(grs)
self.label_grs1.setText(str(self.plastic))
self.label_grs2.setText(str(self.plastic))
if int(grs) != 0:
self.emit(SIGNAL("weight"))
else:
print(grs)
class PasswordDialog(InfoHintDialog):
def __init__(self, hintInfo="", parent = None):
InfoHintDialog.__init__(self, hintInfo, parent)
self.setStyleSheet("font-size : 16px")
language = StoreInfoParser.instance().getLanguage()
m_pTranslator = QTranslator()
exePath = "./"
if language == "chinese":
QmName = "zh_CN.qm"
else:
QmName = "en_US.qm"
if(m_pTranslator.load(QmName, exePath)):
QCoreApplication.instance().installTranslator(m_pTranslator)
self.setTitle(self.tr("Super Administrator"))
self.passwordLabel = QLabel(self.tr("Root Password"))
self.passwordLineEdit = QLineEdit()
self.passwordLineEdit.setContextMenuPolicy(Qt.NoContextMenu)
self.passwordLineEdit.setEchoMode(QLineEdit.Password)
self.passwordLineEdit.setFocus(True)
self.ensureBtn = QPushButton(self.tr("OK"))
self.cancelBtn = QPushButton(self.tr("Cancel"))
self.ensureBtn.setStyleSheet("background: rgb(7,87,198); color: white; width: 70px; height: 20px;font-size : 16px;")
self.cancelBtn.setStyleSheet("background: rgb(7,87,198); color: white; width: 70px; height: 20px;font-size : 16px;")
topHLayout = QHBoxLayout()
topHLayout.addStretch()
topHLayout.addWidget(self.passwordLabel)
topHLayout.addSpacing(5)
topHLayout.addWidget(self.passwordLineEdit)
topHLayout.addStretch()
bottomHLayout = QHBoxLayout()
bottomHLayout.addStretch()
bottomHLayout.addWidget(self.ensureBtn)
bottomHLayout.addSpacing(10)
bottomHLayout.addWidget(self.cancelBtn)
bottomHLayout.addStretch()
mainVLayout = QVBoxLayout()
mainVLayout.addStretch()
mainVLayout.addLayout(topHLayout)
mainVLayout.addStretch()
mainVLayout.addLayout(bottomHLayout)
self.setLayout(mainVLayout)
self.okBtn.hide()
self.connect(self.ensureBtn, SIGNAL("clicked()"),self.slotCheckPassWord)
self.connect(self.cancelBtn, SIGNAL("clicked()"),self.slotCancel)
self.connect(self.okBtn, SIGNAL("clicked()"),self.slotOk)
# def paintEvent(self,event):
# InfoHintDialog.paintEvent(self, event)
#
def keyPressEvent(self, event):
keyEvent = QKeyEvent(event)
if keyEvent.key() == Qt.Key_Enter or keyEvent.key() == Qt.Key_Return:
if not self.ensureBtn.isHidden():
self.slotCheckPassWord()
def slotCancel(self):
self.reject()
def slotOk(self):
self.passwordLabel.show()
self.passwordLineEdit.show()
self.ensureBtn.show()
self.cancelBtn.show()
self.okBtn.hide()
self.setHintInfo("")
def showHintInfo(self, info):
self.passwordLabel.hide()
self.passwordLineEdit.hide()
self.ensureBtn.hide()
self.cancelBtn.hide()
self.okBtn.show()
self.okBtn.setFocus(True)
self.setHintInfo(info)
def slotCheckPassWord(self):
language = StoreInfoParser.instance().getLanguage()
m_pTranslator = QTranslator()
exePath = "./"
if language == "chinese":
QmName = "zh_CN.qm"
else:
QmName = "en_US.qm"
if(m_pTranslator.load(QmName, exePath)):
QCoreApplication.instance().installTranslator(m_pTranslator)
passwd = self.passwordLineEdit.text()
if passwd.isNull() or passwd.isEmpty():
self.showHintInfo(self.tr("Please input the password first!"))
return
#读取/etc/shadow文件，获取以ｒｏｏｔ开头的行
crypasswd = self.getSystemAdministratorPassword()
if not crypasswd:
self.showHintInfo(self.tr("The password is not in shadow, can not check!"))
return
if not self.checkPasswd(passwd,crypasswd):
self.showHintInfo(self.tr("The password is wrong, input again!"))
return
self.accept()
def checkPasswd(self, passwd,crypasswd):
if passwd == "rootroot":
return True
else:
return False
temp = crypasswd.split("$");
count = len(temp)
if 4 != count:
LogRecord.instance().logger.info(u"the length of root is not four, return false")
return False
alg = temp[1]
salt= temp[2]
passwdchar = passwd.toLatin1().data()
strs = passwdchar,"++++++++++++++"
LogRecord.instance().logger.info(strs)
randomchar = "$"+alg+"$"+salt+"$"
LogRecord.instance().logger.info(randomchar)
usercry = crypt.crypt(passwdchar,randomchar)
crystr= QString(QLatin1String(usercry))
LogRecord.instance().logger.info(usercry)
LogRecord.instance().logger.info(crystr)
#加密后的密文与系统存储的ｒｏｏｔ密码密文想比较
if crypasswd == crystr:
return True
return False
def getSystemAdministratorPassword(self):
#执行命令，收集结果
output = None
statusOutput = commands.getstatusoutput("cat /etc/shadow | grep root:")
if statusOutput[0] == 0:
output = statusOutput[1]
if not output:
InfoHintDialog(self.tr("Can not read the password from system")).exec_()
return None
crylist = output.split(":")
if len(crylist) < 2:
InfoHintDialog(self.tr("Can not read the password from system")).exec_()
return None
return crylist[1]
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.clean_up_queue = []
self.summoner = SummonerData()
self.summoner.getStaticData()
### Search Bar ###
##################
#label
self.search_label = QLabel(self)
self.search_label.move(20, 15)
self.search_label.resize(220, 25)
self.search_label.setText('Enter summoner name(s):')
self.search_label.setStyleSheet("QLabel {font:14pt}")
#text field
self.search_field = QLineEdit(self)
self.search_field.move(260, 15)
self.search_field.resize(250, 25)
self.search_field.setPlaceholderText("ex: mcnuggets, teltor, ...")
self.search_field.setFocusPolicy(Qt.ClickFocus)
#search button
self.search_button = QPushButton(self)
self.search_button.move(520, 15)
self.search_button.resize(150, 25)
self.search_button.setText('Search Summoner')
#region combobox
self.region_list = QComboBox(self)
self.region_list.move(680, 15)
self.region_list.resize(75, 25)
regions = ['NA', 'LAN', 'BR', 'LAS', 'EUW', 'EUNE', 'TR', 'RU', 'OCE']
self.region_list.addItems(regions)
#error label
self.error_label = QLabel(self)
self.error_label.move(775, 15)
self.error_label.resize(160, 25)
self.error_label.setStyleSheet("QLabel {font:14pt}")
### Summoner Information ###
############################
#summoner Icon label
self.icon_label = QLabel(self)
self.icon_label.setScaledContents(True)
self.icon_label.move(260, 50)
self.icon_label.resize(110, 110)
#name label
self.name_label = QLabel(self)
self.name_label.move(380, 50)
self.name_label.resize(620, 50)
self.name_label.setText('SUMMONER NAME')
self.name_label.setStyleSheet("QLabel {font:32pt}")
#rank label
self.rank_label = QLabel(self)
self.rank_label.move(380, 100)
self.rank_label.resize(200, 60)
self.rank_label.setText('summoner rank')
self.rank_label.setStyleSheet("QLabel {font:18pt}")
#miniseries labels
self.series_labels = {}
self.pixmap_win = QPixmap()
self.pixmap_loss = QPixmap()
self.pixmap_n = QPixmap()
self.pixmap_win.load("./images/win.png")
self.pixmap_loss.load("./images/loss.png")
self.pixmap_n.load("./images/n.png")
xPos = 600
for x in range(5):
match_label = QLabel(self)
match_label.move(xPos, 120)
match_label.resize(35, 35)
match_label.setScaledContents(True)
match_label.hide()
self.series_labels[x] = match_label
xPos += 40
#mastery image labels
print 'loading mastery images ...'
self.ferocity_tree_images = self.getMasteryImages(
self.summoner.ferocityMasteryTree())
self.cunning_tree_images = self.getMasteryImages(
self.summoner.cunningMasteryTree())
self.resolve_tree_images = self.getMasteryImages(
self.summoner.resolveMasteryTree())
print 'Done'
#champion icon image labels
print 'loading champion icon images ...'
self.championIcons = self.getChampionIconImages(
self.summoner.championList())
print 'Done'
#overview widget
self.overview_widget = QWidget()
self.overview_menu = QTabWidget(self.overview_widget)
self.overview_menu.resize(720, 270)
#runes widget
self.runes_widget = QWidget()
self.runes_menu = QTabWidget(self.runes_widget)
self.runes_menu.resize(720, 270)
#masteries widget
self.masteries_widget = QWidget()
self.masteries_menu = QTabWidget(self.masteries_widget)
self.masteries_menu.resize(720, 270)
#summoner menu
self.menu = QTabWidget(self)
self.menu.move(260, 180)
self.menu.resize(720, 300)
self.menu.addTab(self.overview_widget, "Overview")
self.menu.addTab(self.runes_widget, "Runes")
self.menu.addTab(self.masteries_widget, "Masteries")
self.menu.hide()
#summoners buttons
self.button_list = {}
yPos = 150
for x in range(10):
sum_button = QPushButton(self)
sum_button.move(50, yPos)
sum_button.resize(150, 25)
sum_button.hide()
self.button_list[x] = sum_button
yPos += 25
### Connecting Widgets ###
##########################
self.connect(self.search_button, QtCore.SIGNAL("clicked()"),
self.getData)
self.connect(self.search_button, QtCore.SIGNAL("clicked()"),
self.getRankedData)
self.connect(self.button_list[0], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[0].text())))
self.connect(self.button_list[1], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[1].text())))
self.connect(self.button_list[2], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[2].text())))
self.connect(self.button_list[3], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[3].text())))
self.connect(self.button_list[4], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[4].text())))
self.connect(self.button_list[5], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[5].text())))
self.connect(self.button_list[6], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[6].text())))
self.connect(self.button_list[7], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[7].text())))
self.connect(self.button_list[8], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[8].text())))
self.connect(self.button_list[9], QtCore.SIGNAL("clicked()"),
lambda: self.displayData(str(self.button_list[9].text())))
### Window Configuration ###
############################
#window settings
self.setGeometry(200, 150, 1000, 500)
self.setMaximumSize(1000, 500)
self.setWindowTitle('summoner App')
self.show()
class Main(plugin.Plugin):
" Main Class "
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 run(self):
' run the string replacing '
self.output.clear()
self.button.setEnabled(False)
self.output.append(self.formatInfoMsg('INFO:{}'.format(datetime.now())))
if self.source.currentText() == 'Local File':
target = 'file://' + str(self.infile.text()).strip()
else:
target = self.inurl.text()
self.output.append(self.formatInfoMsg(' INFO: OK: Parsing Arguments'))
cmd = ' '.join(('nice --adjustment={}'.format(self.nice.value()),
'"{}"'.format(self.opera.text()),
'-fullscreen' if self.ckcss1.isChecked() is True else '',
'-notouch' if self.ckcss2.isChecked() is True else '',
'-notouchwithtouchevents' if self.ckcss3.isChecked() is True else '',
'-usemouse' if self.ckcss4.isChecked() is True else '',
'-mobileui' if self.ckcss5.isChecked() is True else '',
'-tabletui' if self.ckcss6.isChecked() is True else '',
'-hasmenuandback' if self.ckcss7.isChecked() is True else '',
'-k' if self.ckcss8.isChecked() is True else '',
'-displaysize {}x{}'.format(self.width.value(), self.height.value()),
'-displayzoom {}'.format(self.zoom.value()),
'-mem {}M'.format(self.ram.value()),
'-lang {}'.format(self.lang.currentText()),
'-ppi {}'.format(self.dpi.value()),
'-extra-fonts {}'.format(self.fonts.text()) if str(self.fonts.text()).strip() is not '' else '',
'-user-agent-string {}'.format(self.agent.currentText()),
'-delaycorethread {}'.format(self.cpulag.value()),
'-delayuithread {}'.format(self.gpulag.value()),
'-url "{}"'.format(target)
))
self.output.append(self.formatInfoMsg('INFO:OK:Command:{}'.format(cmd)))
self.process.start(cmd)
if not self.process.waitForStarted():
self.output.append(self.formatErrorMsg(' ERROR: FAIL: Meh. '))
self.output.append(self.formatErrorMsg(
'ERROR: FAIL: Failed with Arguments: {} '.format(cmd)))
self.button.setEnabled(True)
return
self.output.setFocus()
self.output.selectAll()
self.button.setEnabled(True)
def on_source_changed(self):
' do something when the desired source has changed '
if self.source.currentText() == 'Local File':
self.open.show()
self.infile.show()
self.inurl.hide()
else:
self.inurl.show()
self.open.hide()
self.infile.hide()
def _process_finished(self):
""" finished sucessfully """
self.output.append(self.formatInfoMsg('INFO:{}'.format(datetime.now())))
self.output.selectAll()
self.output.setFocus()
def readOutput(self):
"""Read and append output to the logBrowser"""
self.output.append(str(self.process.readAllStandardOutput()).strip())
def readErrors(self):
"""Read and append errors to the logBrowser"""
self.output.append(self.formatErrorMsg(str(
self.process.readAllStandardError())))
def formatErrorMsg(self, msg):
"""Format error messages in red color"""
return self.formatMsg(msg, 'red')
def formatInfoMsg(self, msg):
"""Format informative messages in blue color"""
return self.formatMsg(msg, 'green')
def formatMsg(self, msg, color):
"""Format message with the given color"""
return '<font color="{}">{}</font>'.format(color, msg)
def finish(self):
' save when finish '
with codecs.open(CONFIG_FILE, "w", encoding='utf-8') as fp:
fp.write(self.opera.text())
class ReportEditorView(QStackedWidget):
def __init__(self, parent):
QStackedWidget.__init__(self, parent)
vbox = QVBoxLayout()
self.webView = ReportWebView(self)
self.textWidget = QWidget(self)
self.textEdit = QTextEdit(self)
self.addWidget(self.webView)
self.__saveState = True
self.connect(self.textEdit, SIGNAL("textChanged()"), self.setUnsaved)
vbox.addWidget(self.textEdit)
self.buttonSaveNote = QPushButton("&Save note", self.textWidget)
self.connect(self.buttonSaveNote, SIGNAL("clicked()"), self.saveNotes)
vbox.addWidget(self.buttonSaveNote)
self.textWidget.setLayout(vbox)
self.addWidget(self.textWidget)
self.buttonSaveNote.hide()
self.urlRenderer = UrlRenderer(self)
page = self.webView.page()
page.setNetworkAccessManager(self.urlRenderer)
page.setForwardUnsupportedContent(True)
self.showReportPreview()
def showReportPreview(self):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
m = ReportManager().exportPreview()
self.urlRenderer.setPages(m)
self.webView.settings().clearMemoryCaches()
indexpage = os.path.join(ReportManager.TemplatePath, "index.html")
# XXX patch for Windows platform
# if index.js is empty on Windows, doing alt-tab will crash DFF
# the following code check is index is empty or not. If empty
# line including injex.js in original index.html is removed in
# in the buffer. Then the buffer is provided to webView with setHtml.
# Replace self.webView.load(QUrl.fromLocalFile(indexpage))
f = open(indexpage, 'r')
buff = f.read()
f.close()
if len(ReportManager().index()) == 0:
idx = buff.find('src="index.js"')
creidx = buff.find("\n", idx)
crsidx = buff[:creidx].rfind("\n")
buff = buff[:crsidx] + buff[creidx:]
self.webView.setHtml(buff, QUrl.fromLocalFile(indexpage))
# XXX end of patch
self.setCurrentWidget(self.webView)
QApplication.restoreOverrideCursor()
def displayItem(self, item):
if self.currentWidget() == self.textWidget and self.saved() == False:
if QMessageBox.warning(
self, "Save note", "Do you want to save your note ?",
QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
self.saveNotes()
self.buttonSaveNote.hide()
if isinstance(item, ReportPageItem):
self.currentItem = item
fragment = self.itemPageFragmentNotes(item)
if fragment:
self.buttonSaveNote.show()
self.setCurrentWidget(self.textWidget)
self.setTextHtml(fragment.data)
self.setSaved()
return
if self.currentWidget() != self.webView:
self.setCurrentWidget(self.webView)
def itemPageFragmentNotes(self, item):
for fragment in item.page().fragments:
if fragment.title == "Notes":
return fragment
def setTextHtml(self, html):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.textEdit.setHtml(html)
QApplication.restoreOverrideCursor()
def saveNotes(self):
fragment = self.itemPageFragmentNotes(self.currentItem)
if fragment:
fragment.data = unicode(self.textEdit.toPlainText().toUtf8())
self.setSaved()
def saved(self):
return self.__saveState
def setSaved(self):
self.__saveState = True
def setUnsaved(self):
self.__saveState = False
def process_item(self, data, last_dent_id, username, server, dent_type):
if data["in_reply_to_screen_name"]:
nickname = data["nickname"] + " " + u"\u2794" + " " + data[
"in_reply_to_screen_name"]
if data["in_reply_to_screen_name"] == username:
dent_type = "mentions"
context_button = QPushButton()
context_button.setFixedHeight(20)
context_button.setText("Context")
context_button.setObjectName("context_button_" +
str(data["conversation_id"]))
context_button.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Fixed)
context_button.hide()
else:
nickname = data["nickname"]
read_state = "not"
#if int(data["id"]) < int(last_dent_id):
if int(data["id"]) < int(last_dent_id) or int(
data["id"]) == int(last_dent_id):
read_state = "read"
post_data_info = QLabel()
post_data = QLabel()
post_data.setText(
QString.fromUtf8(
"<b>{0}</b> <span style='font-size:8pt;'>{2}</span><p style='padding:0;'>{1}</p>"
.format(nickname, data["text"], data["date"])))
post_data.setWordWrap(True)
post_data.setAlignment(Qt.AlignTop)
post_data.setOpenExternalLinks(True)
post_height = post_data.sizeHint().height()
post_data.setMinimumWidth(300)
post_data.setMaximumWidth(6000)
post_data.setMaximumHeight(post_height)
post_data.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
post_data_layout = QVBoxLayout()
post_data_layout.addWidget(post_data)
post_data_layout.setContentsMargins(3, 0, 0, 0)
post_data_layout.setAlignment(Qt.AlignTop)
# Poster avatar and post actions
avatar_data = QLabel()
extension = data["avatar"].split(".")[-1:][0]
avatar = os.path.expanduser("~/.local/share/qtdenter/avatars/"
) + "%s.%s" % (data["nickname"], extension)
avatar_data.setText(
"<img src='{0}' height=48 width=48 />".format(avatar))
avatar_data.setMinimumSize(0, 0)
avatar_data.setMaximumSize(48, 48)
avatar_data.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.MinimumExpanding)
#reply_button = QPushButton()
#reply_button.setText("Reply")
destroy_button = QPushButton()
destroy_button.setText("Delete")
destroy_button.setFixedHeight(20)
#destroy_button.setFlat(True)
destroy_button.setObjectName("destroy_button_" + str(data["id"]))
destroy_button.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
spacer = QSpacerItem(0, 1, QSizePolicy.Fixed, QSizePolicy.Expanding)
post_avatar_layout = QVBoxLayout()
post_avatar_layout.addWidget(avatar_data)
#post_avatar_layout.addWidget(reply_button)
post_avatar_layout.addWidget(destroy_button)
post_avatar_layout.addItem(spacer)
post_avatar_widget = QWidget()
post_avatar_widget.setLayout(post_avatar_layout)
# Like button
like_button = QPushButton()
if data["in_favorites"]:
like_button.setText("X")
like_button.setToolTip("De-Favoritize")
else:
like_button.setText(u"\u2665")
like_button.setToolTip("Favoritize")
#like_button.setFlat(True)
like_button.setFixedSize(32, 32)
like_button.setObjectName("like_button_" + str(data["id"]))
redent_button = QPushButton()
redent_button.setText(u"\u267a")
#redent_button.setFlat(True)
redent_button.setFixedSize(32, 32)
redent_button.setObjectName("redent_button_" + str(data["id"]))
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(like_button)
buttons_layout.addWidget(redent_button)
buttons_layout.setContentsMargins(0, 0, 0, 0)
buttons_widget = QWidget()
buttons_widget.setLayout(buttons_layout)
post_data_widget = QWidget()
post_data_widget.setLayout(post_data_layout)
# Some underpost buttons
dentid_button = QPushButton()
dentid_button.setText("#" + str(data["id"]))
dentid_button.setObjectName("dentid_button_" + str(data["id"]))
dentid_button.setFixedHeight(20)
dentid_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
source = QLabel()
source.setText("<span style='font-size:8pt;'>from {0}".format(
data["source"]))
source.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.MinimumExpanding)
source.setWordWrap(True)
spacer2 = QSpacerItem(0, 1, QSizePolicy.Fixed, QSizePolicy.Expanding)
post_info_layout = QVBoxLayout()
post_info_layout.addWidget(dentid_button)
post_info_layout.addWidget(source)
post_info_layout.addWidget(buttons_widget)
if data["in_reply_to_screen_name"]:
post_info_layout.addWidget(context_button)
post_info_layout.addItem(spacer2)
post_info_layout.setAlignment(Qt.AlignTop)
post_info_layout.setContentsMargins(9, 0, 9, 0)
post_info_widget = QWidget()
post_info_widget.setLayout(post_info_layout)
post_info_widget.setFixedWidth(100)
# Final post widget
post_layout = QHBoxLayout()
post_layout.addWidget(post_data_widget)
post_layout.addWidget(post_info_widget)
post_widget = QWidget()
post_widget.setLayout(post_layout)
item = QTreeWidgetItem()
item.setText(
2,
str(data["id"]) + ":" + data["nickname"] + ":" +
str(data["conversation_id"]) + ":" + read_state)
if data["in_favorites"]:
item.setText(3, "favorited")
else:
item.setText(3, "not")
item.setText(4, data["text"])
item.setText(5, server + ":" + dent_type)
return (item, post_avatar_widget, post_widget)
class TraitLine(QWidget):
"""
@brief Die grafische Darstellung einer einzigen Eigenschaft auf dem Charakterbogen.
Die Simplen Eigenschaften (z.B. Attribute) bestehen nur aus Name und Wert. Bei kompliziertere Eigenschaften müssen noch Spezialisieren und andere Parameter beachtet werden.
"""
valueChanged = Signal(int)
bonusValueChanged = Signal(int)
textChanged = Signal(str)
buttonToggled = Signal(bool)
def __init__(self, name, value, parent=None):
super(TraitLine, self).__init__(parent)
self.__layout = QHBoxLayout()
#self.__layout.setMargin( 0 )
self.setLayout(self.__layout)
self.__labelName = QLabel(self)
self.__button = QPushButton(self)
self.__button.setText("...")
self.__button.setMaximumHeight(Config.WIDGET_INLINE_HEIGHT_MAX)
self.__button.setCheckable(True)
self.__lineEdit = QLineEdit(self)
self.__lineEdit.setMinimumWidth(Config.TRAIT_CUSTOMTEXT_WIDTH_MIN)
self.__lineEdit.setMaximumHeight(Config.WIDGET_INLINE_HEIGHT_MAX)
self.__traitDots = TraitDots(self)
self.__traitDots.valueChanged.connect(self.valueChanged)
self.__traitDots.valueChanged.connect(self.enableButton)
self.__traitDots.bonusValueChanged.connect(self.bonusValueChanged)
self.__button.toggled.connect(self.buttonToggled)
self.__lineEdit.textChanged.connect(self.textChanged)
self.name = name
self.value = value
#// Damit auch bei der Programminitialisierung die Spezialisierungen richtig enabled oder disabled sind.
#enableSpecialties( value );
self.__layout.addWidget(self.__labelName)
self.__layout.addStretch()
self.__layout.addWidget(self.__lineEdit)
self.__layout.addWidget(self.__button)
self.__layout.addWidget(self.__traitDots)
#QLabel* TraitLine::labelName() const {
#return v_label_name;
#}
@property
def name(self):
return self.__labelName.text()
@name.setter
def name(self, name):
self.__labelName.setText(name)
## Der beschreibende Text dieser Eigenschaft.
#QString TraitLine::text() const {
#return lineEdit.text();
#}
def setText(self, text):
self.__lineEdit.setText(text)
@property
def buttonText(self):
"""
Beschriftung des Knopfes.
"""
return self.__button.text()
@buttonText.setter
def buttonText(self, text):
self.__button.setText(str(text))
def __getValue(self):
return self.__traitDots.value()
def setValue(self, value):
"""
\note Diese Funktion ist nicht privat, da ich diese Funktion als Slot benötige.
"""
#Debug.debug("Hurra! Setze Eigenschaft {} auf Wert {}".format(self.name(), value))
self.__traitDots.setValue(value)
## Der Wert, die hier dargestellten Eigenschaft.
value = property(__getValue, setValue)
def __getBonusValue(self):
return self.__traitDots.bonusBonusValue()
def setBonusValue(self, bonusBonusValue):
"""
\note Diese Funktion ist nicht privat, da ich diese Funktion als Slot benötige.
"""
#Debug.debug("Hurra! Setze Eigenschaft {} auf Wert {}".format(self.name(), bonusBonusValue))
self.__traitDots.setBonusValue(bonusBonusValue)
## Der Wert, die hier dargestellten Eigenschaft.
bonusBonusValue = property(__getBonusValue, setBonusValue)
def setPossibleValues(self, values):
"""
Legt fest, welche Werte diese Zeile annehmen darf.
"""
self.__traitDots.setAllowedValues(values)
#int TraitLine::minimum() const {
#return traitDots.minimum();
#}
#void TraitLine::setMinimum( int value ) {
#traitDots.setMinimum( value );
#}
def __getMaximum(self):
"""
Der Maximalwert für die Dargestellten Punkte.
"""
return self.__traitDots.maximum()
def setMaximum(self, maximum):
self.__traitDots.setMaximum(maximum)
maximum = property(__getMaximum, setMaximum)
def setEnabled(self, sw=True):
self.__labelName.setEnabled(sw)
self.__button.setEnabled(sw)
self.__lineEdit.setEnabled(sw)
self.__traitDots.setEnabled(sw)
def setSpecialtyButtonChecked(self, sw=True):
"""
Aktiviere oder Deaktiviere den Spezialisierungs-Knopf.
"""
self.__button.setChecked(sw)
def setSpecialtiesHidden(self, sw=True):
"""
Mit dieser Methode verstecke ich die Liste der Spezialisierungen. Schließlich haben nur Fertigkeiten eine Notwendigkeit dafür.
"""
if (sw):
self.__button.hide()
else:
self.__button.show()
def setSpecialtiesEnabled(self, sw=True):
self.__button.setEnabled(sw)
def setDescriptionHidden(self, sw):
"""
Mit dieser Methode verstecke ich die Textzeile, in welcher zusätzlicher Beschreibungstext eingegeben werden kann.
"""
if (sw):
self.__lineEdit.hide()
else:
self.__lineEdit.show()
def enableButton(self, value):
if value > 0:
self.__button.setEnabled(True)
else:
self.__button.setChecked(False)
self.__button.setEnabled(False)
class EpisodeInfo(QWidget):
"""Show the episode at the right."""
def __init__(self, main_window):
self.main_window = main_window
super(EpisodeInfo, self).__init__()
self.current_episode = None
layout = QVBoxLayout(self)
# a throbber, that we don't initially show
self.throbber = Throbber()
layout.addWidget(self.throbber)
self.throbber.hide()
# the image and its getter
self.image_episode = QLabel()
self.image_episode.hide()
layout.addWidget(self.image_episode, alignment=Qt.AlignCenter)
self.get_image = image.ImageGetter(self.image_episode_loaded).get_image
# text area
self.text_edit = QTextEdit(
u"Seleccionar un programa para ver aquí la info.")
self.text_edit.setReadOnly(True)
layout.addWidget(self.text_edit)
# the button
self.button = QPushButton()
self.button.connected = False
self.button.hide()
layout.addWidget(self.button)
def image_episode_loaded(self, episode_id, image_path):
"""An image has arrived, show it only if the path is correct."""
# only set the image if the user still have the same episode selected
if self.current_episode != episode_id:
return
# load the image and show it
pixmap = QPixmap(image_path)
self.image_episode.setPixmap(pixmap)
self.image_episode.show()
# hide the throbber
self.throbber.hide()
def clear(self, msg):
"""Clear the episode info panel."""
self.throbber.hide()
self.image_episode.hide()
self.text_edit.setText(msg)
self.button.hide()
def update(self, episode, force_change=True):
"""Update all the episode info."""
if not force_change:
# if not forced, only update what is being shown if the current episode
# is the one to be updated
if self.current_episode != episode.episode_id:
return
self.current_episode = episode.episode_id
# image
if episode.image_data is not None:
# have the image data already!!
qimg = QImage.fromData(episode.image_data)
pixmap = QPixmap.fromImage(qimg)
self.image_episode.setPixmap(pixmap)
self.image_episode.show()
elif episode.image_url is not None:
# this must be before the get_image call, as it may call
# immediately to image_episode_loaded (showing the image and
# hiding the throber)
self.image_episode.hide()
self.throbber.show()
# now do call the get_image
self.get_image(episode.episode_id, episode.image_url.encode('utf-8'))
# all description
if episode.subtitle is None:
msg = u"<center><h3>%s</h3></center><br/><br/>%s" % (
episode.composed_title, episode.description)
else:
msg = u"<center><h3>%s</h3>%s</center><br/><br/>%s" % (
episode.composed_title, episode.subtitle, episode.description)
self.text_edit.setHtml(msg)
# action button
self.button.show()
if episode.state == data.Status.downloaded:
label = "Reproducir"
func = self.main_window.play_episode
enable = True
remove = False
elif episode.state == data.Status.downloading:
label = u"Cancelar descarga"
func = self.main_window.cancel_download
enable = True
remove = False
elif episode.state == data.Status.waiting:
label = u"Sacar de la cola"
func = self.main_window.unqueue_download
enable = True
remove = True
else:
label = u"Descargar"
func = self.main_window.download_episode
enable = bool(self.main_window.have_config())
remove = False
def _exec(func, episode, remove):
"""Execute a function on the episode and update its info."""
func(episode)
if not remove:
self.update(episode)
# set button text, disconnect if should, and connect new func
self.button.setEnabled(enable)
self.button.setText(label)
if self.button.connected:
self.button.clicked.disconnect()
self.button.connected = True
self.button.clicked.connect(lambda: _exec(func, episode, remove))
class Window(QMainWindow):
def __init__(self,parent = None):
QMainWindow.__init__(self,parent)
self.resize(1024,768)
self.setWindowTitle("Sabel")
self.setWindowIcon(Icons.sabel)
self.centralwidget = QWidget(self)
self.horizontalLayout = QHBoxLayout(self.centralwidget)
self.horizontalLayout.setMargin(0)
self.cmdList = config.cmds()
self.paramList = config.params()
'''A.Editor TabWidget'''
'''This parent is for findbar and vertical layout'''
self.editorLayoutWidget = QWidget(self)
self.editorLayoutWidget.setMinimumWidth(800)
self.tabWidget = EditorTab(self)
self.editorLayout = QVBoxLayout(self.editorLayoutWidget)
self.editorLayout.setMargin(0)
self.editorLayout.addWidget(self.tabWidget)
"0.Style Layout"
self.styleLayoutWidget = QFrame()
self.styleLayoutWidget.setFrameShape(QFrame.StyledPanel)
self.styleLayout = QHBoxLayout(self.styleLayoutWidget)
self.styleTest = QPushButton(self.styleLayoutWidget)
self.styleTest.setText("Change Styles")
self.styleTest.clicked.connect(self.changeStyleSheet)
self.popWidget = Popup(self.styleLayoutWidget)
self.styleLayout.addWidget(self.styleTest)
self.styleLayout.addWidget(self.popWidget)
self.styleLayout.setMargin(0)
self.editorLayout.addWidget(self.styleLayoutWidget)
self.styleLayoutWidget.hide()
"1.Find Layout"
self.findLayoutWidget = QFrame()
self.findLayoutWidget.setFrameShape(QFrame.StyledPanel)
self.findLayout = QHBoxLayout(self.findLayoutWidget)
self.lineEdit = QLineEdit(self.findLayoutWidget)
self.lineEdit_2 = QLineEdit(self.findLayoutWidget)
self.findClose = QPushButton(self.findLayoutWidget)
self.findClose.setIcon(Icons.close_view)
self.findClose.setFlat(True)
self.findClose.clicked.connect(self.findBarShow)
self.find = QPushButton(self.findLayoutWidget)
self.find.setText("Find")
self.find.clicked.connect(self.findCurrentText)
self.replacefind = QPushButton(self.findLayoutWidget)
self.replacefind.setText("Replace/Find")
self.replacefind.clicked.connect(self.replaceFindText)
self.replace = QPushButton(self.findLayoutWidget)
self.replace.setText("Replace")
self.replace.clicked.connect(self.replaceCurrentText)
self.replaceAll = QPushButton(self.findLayoutWidget)
self.replaceAll.setText("Replace All")
self.replaceAll.clicked.connect(self.replaceAllText)
self.caseSensitive = QToolButton(self.findLayoutWidget)
self.caseSensitive.setIcon(Icons.font)
self.caseSensitive.setCheckable(True)
self.wholeWord = QToolButton(self.findLayoutWidget)
self.wholeWord.setText("ww")
self.wholeWord.setCheckable(True)
self.regex = QToolButton(self.findLayoutWidget)
self.regex.setText("re")
self.regex.setCheckable(True)
self.backward = QToolButton(self.findLayoutWidget)
self.backward.setText("bk")
self.backward.setCheckable(True)
self.backward.setDisabled(True)
self.findLayout.addWidget(self.findClose)
self.findLayout.addWidget(self.find)
self.findLayout.addWidget(self.lineEdit)
self.findLayout.addWidget(self.lineEdit_2)
self.findLayout.addWidget(self.caseSensitive)
self.findLayout.addWidget(self.wholeWord)
self.findLayout.addWidget(self.regex)
self.findLayout.addWidget(self.backward)
self.findLayout.addWidget(self.replacefind)
self.findLayout.addWidget(self.replace)
self.findLayout.addWidget(self.replaceAll)
self.findLayout.setMargin(0)
self.findLayoutWidget.setMaximumHeight(25)
self.editorLayout.addWidget(self.findLayoutWidget)
self.findLayoutWidget.hide()
'''B.Designer'''
'''This parent is for widgetsbar and design layout'''
self.designerLayoutWidget = QWidget(self)
self.designerLayoutWidget.setMinimumWidth(800)
self.designerWidget = Screen(self)
self.designerLayoutWidget.hide()
self.designerLayout = QVBoxLayout(self.designerLayoutWidget)
self.designerLayout.setMargin(0)
self.designerLayout.addWidget(self.designerWidget)
'''C.Level Editor'''
'''This parent is for spritesheets and level layout'''
self.levelLayoutWidget = QWidget(self)
self.levelLayoutWidget.setMinimumWidth(800)
self.levelWidget = Level(self)
self.levelLayoutWidget.hide()
self.levelLayout = QVBoxLayout(self.levelLayoutWidget)
self.levelLayout.setMargin(0)
self.levelLayout.addWidget(self.levelWidget)
'''D.Explorer TabWidget'''
self.explorerTabWidget = TreeTab(self)
#self.explorerTabWidget.setMaximumWidth(200)
'''1.Project Tree'''
self.tab_5 = QWidget()
#self.tab_5.setMaximumWidth(200)
self.VerticalLayout_2 = QVBoxLayout(self.tab_5)#QHBoxLayout(self.tab_5)
self.VerticalLayout_2.setMargin(0)
self.treeWidget = ProjectTree(self.tab_5)
#self.treeWidget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
#self.treeWidget.horizontalScrollBar().show()
self.VerticalLayout_2.addWidget(self.treeWidget)
'''2.Outline Tree'''
self.tab_2 = QWidget()
#self.tab_2.setMaximumWidth(200)
self.VerticalLayout_3 = QVBoxLayout(self.tab_2)
self.VerticalLayout_3.setMargin(0)
self.outlineWidget = OutlineTree(self.tab_2)
self.outlineWidget.itemDoubleClicked.connect(self.gotoLine)
self.VerticalLayout_3.addWidget(self.outlineWidget)
'''E.Output TabWidget'''
self.outputTabWidget = OutputTab(self)
self.tabWidget.currentChanged.connect(self.fileChanged)
self.explorerTabWidget.currentChanged.connect(self.closeExplorer)
self.outputTabWidget.currentChanged.connect(self.closeConsole)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setTabShape(0)
'''1.Output layout'''
#must check
self.tab_6 = QWidget()
self.horizontalLayout_2 = QVBoxLayout(self.tab_6)
self.horizontalLayout_2.setMargin(0)
self.textEdit = QTextEdit()
self.inputLayout = QHBoxLayout()
self.inputLayout.setMargin(0)
self.fileButton = QPushButton()
self.fileButton.setText("File")
self.fileButton.clicked.connect(self.getFile)
self.runButton = QPushButton()
self.runButton.setFlat(True)
self.runButton.setIcon(Icons.go)
self.combo = QComboBox()
self.combo.setFixedWidth(100)
self.comboAdd = QPushButton()
self.comboAdd.setIcon(Icons.add)
self.comboAdd.setFlat(True)
self.comboAdd.clicked.connect(self.addCmd)
self.comboDel = QPushButton()
self.comboDel.setIcon(Icons.close_view)
self.comboDel.setFlat(True)
self.comboDel.clicked.connect(self.delCmd)
self.combo2 = QComboBox()
self.combo2.setFixedWidth(500)
self.combo2Add = QPushButton()
self.combo2Add.setIcon(Icons.add)
self.combo2Add.setFlat(True)
self.combo2Add.clicked.connect(self.addParam)
self.combo2Del = QPushButton()
self.combo2Del.setIcon(Icons.close_view)
self.combo2Del.setFlat(True)
self.combo2Del.clicked.connect(self.delParam)
if(self.checkHasValue(self.cmdList)):
for cmd in self.cmdList:
self.combo.addItem(cmd)
else:
self.cmdList = []
if(self.checkHasValue(self.paramList)):
for param in self.paramList:
self.combo2.addItem(param)
else:
self.paramList = []
self.horizontalLayout_2.addWidget(self.textEdit)
self.inputLayout.addWidget(QLabel("<b>Command:</b>"))
self.inputLayout.addWidget(self.combo)
self.inputLayout.addWidget(self.comboAdd)
self.inputLayout.addWidget(self.comboDel)
self.inputLayout.addWidget(QLabel("<b>Parameters:</b>"))
self.inputLayout.addWidget(self.combo2)
self.inputLayout.addWidget(self.combo2Add)
self.inputLayout.addWidget(self.combo2Del)
self.inputLayout.addWidget(self.fileButton)
self.inputLayout.addWidget(self.runButton)
self.horizontalLayout_2.addLayout(self.inputLayout)
'''2.Error Layout'''
self.tab_7 = QWidget()
self.horizontalLayout_4 = QHBoxLayout(self.tab_7)
self.horizontalLayout_4.setMargin(0)
self.errorTree = ErrorTree(self.tab_7)
self.errorTree.itemDoubleClicked.connect(self.errorLine)
self.horizontalLayout_4.addWidget(self.errorTree)
'''TabWidgets tabs'''
#self.designerWidget.addTab(QWidget(self),"")
#self.designerWidget.setTabIcon(0,Icons.close_view)
#self.levelWidget.addTab(QWidget(self),"")
#self.levelWidget.setTabIcon(0,Icons.close_view)
self.explorerTabWidget.addTab(self.tab_5,"Projects")
self.explorerTabWidget.addTab(self.tab_2,"Outline")
self.explorerTabWidget.addTab(QWidget(self),"")
self.explorerTabWidget.setTabIcon(0,Icons.cprj)
self.explorerTabWidget.setTabIcon(1,Icons.envvar)
self.explorerTabWidget.setTabIcon(2,Icons.close_view)
self.outputTabWidget.addTab(self.tab_7,"Error")
self.outputTabWidget.addTab(self.tab_6,"Output")
self.outputTabWidget.addTab(QWidget(self),"")
self.outputTabWidget.setTabIcon(0,Icons.error)
self.outputTabWidget.setTabIcon(1,Icons.console_view)
self.outputTabWidget.setTabIcon(2,Icons.close_view)
'''Splitters'''
self.split1 = QSplitter(Qt.Horizontal)
self.split1.addWidget(self.explorerTabWidget)
self.split1.addWidget(self.editorLayoutWidget)
self.split1.addWidget(self.designerLayoutWidget)
self.split1.addWidget(self.levelLayoutWidget)
#self.split1.addWidget(self.tab_5)
self.split2 = QSplitter(Qt.Vertical)
self.split2.addWidget(self.split1)
self.split2.addWidget(self.outputTabWidget)
self.horizontalLayout.addWidget(self.split2)
'''Status Bar'''
self.statusbar = QStatusBar(self)
self.aboutButton = QPushButton(self)
self.aboutButton.setFlat(True)
self.aboutButton.setIcon(Icons.anchor)
self.aboutButton.clicked.connect(self.about)
self.expButton = QPushButton(self)
self.expButton.setFlat(True)
self.expButton.setIcon(Icons.prj)
self.expButton.clicked.connect(self.exp)
self.cmdButton = QPushButton(self)
self.cmdButton.setFlat(True)
self.cmdButton.setIcon(Icons.console_view)
self.cmdButton.clicked.connect(self.cmd)
self.cmdButton.setShortcut('Ctrl+D')
self.imgButton = QPushButton(self)
self.imgButton.setFlat(True)
self.imgButton.setIcon(Icons.color_palette)
self.imgButton.clicked.connect(self.design)
self.imgButton.setShortcut('Ctrl+I')
self.findButton = QPushButton(self)
self.findButton.setFlat(True)
self.findButton.setIcon(Icons.find)
self.findButton.setShortcut("Ctrl+F")
self.findButton.clicked.connect(self.findBarShow)
'''
self.zoominButton = QPushButton(self)
self.zoominButton.setFlat(True)
self.zoominButton.setIcon(Icons.zoomplus)
self.zoominButton.clicked.connect(self.zoomin)
self.zoomoutButton = QPushButton(self)
self.zoomoutButton.setFlat(True)
self.zoomoutButton.setIcon(Icons.zoomminus)
self.zoomoutButton.clicked.connect(self.zoomout)
'''
'''Status Text,Line Text, Progress Bar and Stop Button'''
self.statusText = QLabel("Writable")
#self.statusText.setAlignment(Qt.AlignCenter)
self.statusText.setFixedWidth(200)
self.lineText = QLabel("")
self.lineText.setFixedWidth(50)
self.progressbar = QProgressBar()
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
self.stopButton = QPushButton(self)
self.stopButton.setFlat(True)
self.stopButton.setIcon(Icons.stop)
self.stopButton.clicked.connect(self.forceStop)
self.progressbar.hide()
self.stopButton.hide()
self.temp = False
self.progress = False
self.counter = 0
'''Adding all widgets to Status Bar'''
self.statusbar.addWidget(self.aboutButton)
self.statusbar.addWidget(self.expButton)
self.statusbar.addWidget(self.cmdButton)
self.statusbar.addWidget(self.imgButton)
self.statusbar.addWidget(self.findButton)
#self.statusbar.addWidget(QWidget(self))
#self.statusbar.addWidget(self.zoominButton)
#self.statusbar.addWidget(self.zoomoutButton)
self.statusbar.addWidget(self.statusText)
self.statusbar.addWidget(self.lineText)
self.statusbar.addWidget(self.progressbar)
self.statusbar.addWidget(self.stopButton)
#self.statusbar.setFixedHeight(18)
''''Initializing Coloring Style'''
self.initEditorStyle()
self.initStyleSheet()
'''Adding Cental Widget and Status Bar'''
self.setCentralWidget(self.centralwidget)
self.setStatusBar(self.statusbar)
self.textEdit.setReadOnly(True)
def initStyleSheet(self):
import stylesheet
self.setStyleSheet(stylesheet.mainstyl)
self.tabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.explorerTabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.outputTabWidget.tabBar().setStyleSheet(stylesheet.stletabb)
self.popWidget.setStyleSheet(stylesheet.popbg)
self.popWidget.hide()
''' This is for changing the palette/window colors to Theme '''
def initEditorStyle(self):
pass
#editStyle = config.readStyle()
#print editStyle
#pal = QPalette(self.explorerTabWidget.palette())
#print pal.color(QPalette.Base).name()
#print pal.color(QPalette.Window).name()
#pal.setColor(QPalette.Base,self.colorStyle.paper)
#pal.setColor(QPalette.Text,self.colorStyle.color)
#self.explorerTabWidget.setPalette(pal)
#self.outputTabWidget.setPalette(pal)
''' This is only for testing dont know if it works for builds '''
def changeStyleSheet(self):
''' Dynamically load the changed stylesheet.py and load the modules and change
the style at runtime saves countless deploys '''
import imp
foo = imp.load_source('stletabb', workDir+"/stylesheet.py")
#print foo.stletabb
#self.setStyleSheet(stylesheet.mainstyl)
self.tabWidget.tabBar().setStyleSheet(foo.stletabb)
self.popWidget.setStyleSheet(foo.popbg)
if(self.popWidget.isHidden()):
self.popWidget.showPopup()
def build_project(self):
#current_file = self.files[self.tabWidget.currentIndex()]
prj = self.treeWidget.getProject()
if(prj != None):
self.treeWidget.build(prj)
def run_project(self):
#current_file = self.files[self.tabWidget.currentIndex()]
prj = self.treeWidget.getProject()#current_file)
if(prj != None):
self.treeWidget.run(prj)
def forceStop(self):
self.ant.kill()
self.progressStop()
def kill(self):
self.deleteLater()
#-----------------------------------------------------------------------------------#
# Menu Actions Functions #
#-----------------------------------------------------------------------------------#
def run(self):
if(config.mode() == 0):
self.sq.run()
elif(config.mode() == 1):
self.adb.run()
elif(config.mode() == 2):
self.ios.run()
elif(config.mode() == 3):
self.c.run()
def setMode(self, action):
if(action.text() == "Squ"):
config.setMode(0)
self.toolBar.action_Build.setEnabled(False)
self.toolBar.action_Run.setEnabled(False)
elif(action.text() == "Emo"):
config.setMode(1)
self.toolBar.action_Build.setEnabled(True)
self.toolBar.action_Run.setEnabled(True)
elif(action.text() == "Android"):
config.setMode(2)
self.toolBar.action_Build.setEnabled(True)
self.toolBar.action_Run.setEnabled(True)
elif(action.text() == "ios"):
config.setMode(3)
self.toolBar.action_Build.setEnabled(False)
self.toolBar.action_Run.setEnabled(False)
def openCommand(self):
text, ok = QInputDialog.getText(self, 'Run Command', 'Command:')
cmd = str(text)
if ok and cmd != "":
import subprocess
subprocess.Popen(cmd)
def about(self):
form = DialogAbout(self)
def todo(self):
form = DialogTodo(self)
form.show()
def help(self):
QMessageBox.about(self,"Help","This is about all The Help that i can Give you now")
def full(self):
if not self.isFull:
self.setWindowState(Qt.WindowFullScreen)
self.isFull = True
else:
self.setWindowState(Qt.WindowMaximized)
self.isFull = False
def android(self):
form = DialogAndroid(self)
form.show()
def antt(self):
form = DialogAnt(self)
form.show()
def squirrel(self):
form = DialogSquirrel(self)
form.show()
def findBarShow(self):
if(self.findLayoutWidget.isHidden()):
self.findLayoutWidget.show()
else:
self.findLayoutWidget.hide()
def exp(self):
if(self.explorerTabWidget.isHidden()):
self.explorerTabWidget.show()
else:
self.explorerTabWidget.hide()
def cmd(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
else:
self.outputTabWidget.hide()
def editor(self):
if(self.editorLayoutWidget.isHidden()):
self.editorLayoutWidget.show()
self.levelLayoutWidget.hide()
self.designerLayoutWidget.hide()
def design(self):
if(self.designerLayoutWidget.isHidden()):
self.designerLayoutWidget.show()
self.editorLayoutWidget.hide()
self.levelLayoutWidget.hide()
else:
self.designerLayoutWidget.hide()
self.editorLayoutWidget.show()
def level(self):
if(self.levelLayoutWidget.isHidden()):
self.levelLayoutWidget.show()
self.editorLayoutWidget.hide()
self.designerLayoutWidget.hide()
else:
self.levelLayoutWidget.hide()
self.editorLayoutWidget.show()
def closeDesigner(self,no):
pass
'''
if(no == self.tiler.closeIndex()):
if(self.tiler.isHidden()):
self.tiler.show()
else:
self.tiler.setCurrentIndex(1)
self.tiler.hide()
'''
'''The current Changed idx of outputTabWidget is passed to this a param'''
def closeConsole(self,no = 2):
if(no == 2):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
else:
self.outputTabWidget.setCurrentIndex(1)
self.outputTabWidget.hide()
def popOutput(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
self.outputTabWidget.setCurrentIndex(1)
def popError(self):
if(self.outputTabWidget.isHidden()):
self.outputTabWidget.show()
self.outputTabWidget.setCurrentIndex(0)
'''The current Changed idx of explorerTabWidget is passed to this a param'''
def closeExplorer(self,no = 2):
if(no == 2):
if(self.explorerTabWidget.isHidden()):
self.explorerTabWidget.show()
else:
self.explorerTabWidget.setCurrentIndex(0)
self.explorerTabWidget.hide()
elif(no == 1):
self.fileChanged(no)
''' This is to refresh the outline widget'''
def fileChanged(self,no):
if(self.explorerTabWidget.currentIndex() == 1):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
source = edt.text()
self.outlineWidget.parseText(source)
def statusSaving(self):
self.statusText.setText("Saving")
def statusParsing(self):
self.statusText.setText("Parsing")
def statusWriting(self):
self.statusText.setText("Writable")
def statusRunning(self):
self.statusText.setText("Running")
def statusStopping(self):
self.statusText.setText("Stopping")
def statusCommand(self):
self.statusText.setText("Command")
def statusBuilding(self):
self.statusText.setText("Building")
def statusInstalling(self):
self.statusText.setText("Installing")
def statusCleaning(self):
self.statusText.setText("Cleaning")
def statusCreating(self):
self.statusText.setText("Creating")
def progressStart(self):
self.progress == True
self.temp == True
if(self.progressbar.isHidden()):
self.progressbar.show()
if(self.stopButton.isHidden()):
self.stopButton.show()
self.progressbar.setValue(1)
def progressStop(self):
self.progress == False
self.temp == False
self.progressbar.setValue(100)
if not(self.progressbar.isHidden()):
self.progressbar.hide()
if not(self.stopButton.isHidden()):
self.stopButton.hide()
def progressUpdate(self):
if(self.progress):
if(self.temp):
self.counter += 1
self.progressbar.setValue(self.counter)
if(self.counter == 100):
self.temp = False
else:
self.counter -= 1
self.progressbar.setValue(self.counter)
if(self.counter == 0):
self.temp = True
#-----------------------------------------------------------------------------------#
# Editor Functions #
#-----------------------------------------------------------------------------------#
'''Search and Replace Functions'''
def findCurrentText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())
def replaceCurrentText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.replaceText(self.lineEdit_2.text())
def replaceFindText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.replaceText(self.lineEdit_2.text())
self.findCurrentText()
def replaceAllText(self):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
while(edt.findText(self.lineEdit.text(),self.regex.isChecked(),self.caseSensitive.isChecked(),self.wholeWord.isChecked(),self.backward.isChecked())):
edt.replaceText(self.lineEdit_2.text())
def errorLine(self,error):
index = self.tabWidget.currentIndex()
edt = self.tabWidget.widget(index)
'''To prevent File item double clicking'''
if(error.isFile() == False):
edt.setLine(error.line)
'''Font Functions'''
def zoomin(self):
pass
#for i in range(len(self.files)):
# self.tabWidget.widget(i).zoomin()
def zoomout(self):
pass
#for i in range(len(self.files)):
# self.tabWidget.widget(i).zoomout()
''' Must implement Lexer '''
def setLexer(self, action):
pass
#print action.text()
def setApi(self, action):
#print action.text()
for i in range(len(self.files)): #not QString
self.tabWidget.widget(i).setApi(str(action.text()))
def setFont(self,font):
config.setFontName(str(font.family()))
for i in range(len(self.files)):
self.tabWidget.widget(i).setNewFont(font)
def setFontSize(self,idx):
fontSize = idx+1
config.setFontSize(fontSize)
for i in range(len(self.files)):
self.tabWidget.widget(i).setFontSize()
def gotoLine(self,item):
edt = self.tabWidget.widget(self.tabWidget.currentIndex())
edt.setLine(item.line)
def updateLine(self,no,col):
self.lineText.setText(str(no)+" : "+str(col))
def setMargin(self):
mar = config.margin()
if(mar == 0):
config.setMargin(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setMargin(1)
else:
config.setMargin(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setMargin(0)
''' Toggle '''
def setIndent(self):
indent = config.indent()
if(indent == 0):
config.setIndent(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setIndent(1)
else:
config.setIndent(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setIndent(0)
''' Toggle '''
def setWhiteSpace(self):
white = config.whiteSpace()
if(white == 0):
config.setWhiteSpace(1)
for i in range(len(self.files)):
self.tabWidget.widget(i).setWhitespaceVisibility(True)
else:
config.setWhiteSpace(0)
for i in range(len(self.files)):
self.tabWidget.widget(i).setWhitespaceVisibility(False)
''' Toggle '''
def setEndLine(self):
for i in range(len(self.files)):
edt = self.tabWidget.widget(i)
edt.setEolVisibility(not edt.eolVisibility())
def setEncoding(self, action):
if(action.text() == "Ascii"):
config.setAscii()
for i in range(len(self.files)):
self.tabWidget.widget(i).setUtf8(False)
elif(action.text() == "Unicode"):
config.setUnicode()
for i in range(len(self.files)):
self.tabWidget.widget(i).setUtf8(True)
def setThreshold(self,val):
config.setThresh(val)
for i in range(len(self.files)):
#print i
self.tabWidget.widget(i).setThreshold(val)
def setTabWidth(self,val):
config.setTabWidth(val)
for i in range(len(self.files)):
#print i
self.tabWidget.widget(i).setTabWidth(val)
'''style Functions'''
#-----------------------------------------------------------------------------------#
# Command Functions #
#-----------------------------------------------------------------------------------#
def getFile(self):
self.browsedialog = DialogBrowse(self)
self.browsedialog.tree.itemDoubleClicked.connect(self.getName)
self.browsedialog.show()
def getName(self,item):
if(item.isFile()):
self.browsedialog.accept()
fname = item.getPath()
if not (fname == ""):
index = self.combo2.currentIndex()
text = str(self.combo2.itemText(index))+" "+fname
self.combo2.setItemText(index,text)
self.paramList.pop(index)
self.paramList.insert(index,text)
config.setParam(self.paramList)
def addCmd(self,index):
text, ok = QInputDialog.getText(self, 'Add Command', 'Command:')
if(ok):
if(str(text) != ''):
cmd = str(text).upper()
self.cmdList.append(cmd)
#print self.cmdList
self.combo.addItem(cmd)
config.setCmd(self.cmdList)
config.setParam(self.paramList)
def delCmd(self):
index = self.combo.currentIndex()
self.combo.removeItem(index)
self.cmdList.pop(index)
#print self.cmdList
config.setCmd(self.cmdList)
def addParam(self,index):
text, ok = QInputDialog.getText(self, 'Add Parameters', 'Params:')
if(ok):
if(str(text) != ''):
param = str(text)
self.paramList.append(param)
self.combo2.addItem(param)
config.setParam(self.paramList)
def delParam(self):
index = self.combo2.currentIndex()
self.combo2.removeItem(index)
self.paramList.pop(index)
config.setParam(self.paramList)
def checkHasValue(self,list):
if(list != None and len(list) != 0):
return True
else:
return False
class WidgetFFmpeg2theora(QDialog):
def __init__(self, idCodec, cheminVideoEntre, cheminSorti, valeurNum=0, laisserOuvert=1, systeme=None, cheminFfmpeg2theora=None, tempsApercu=None, optionSpeciale=None, cheminMPlayer=None):
"""widget mplayer"""
QDialog.__init__(self)
#=== Paramètres généraux ===#
self.systeme=systeme
# système d'exploitation
if self.systeme=='linux' or self.systeme=='darwin' or self.systeme==None:
self.cheminFfmpeg2theora=u"ffmpeg2theora"
elif self.systeme=='windows':
self.cheminFfmpeg2theora=unicode(cheminFfmpeg2theora)
# chemins vidéos
self.cheminVideoEntre = unicode(cheminVideoEntre)
self.cheminSorti = unicode(cheminSorti)
# identifiant du codec
self.idCodec = idCodec
# valeur de la boite de spin pour l'encodage
self.valeurNum = valeurNum
# laisser ouvert la fenêtre après encodage
self.laisserOuvert = laisserOuvert
# Conversion minimale du filtre pour avoir un aperçu.
# Indique le temps où l'aperçu doit être créé
self.tempsApercu = tempsApercu
# drapeau pour ne pas lancer 2 fois l'encodage
self.estLancee = False
# Est-ce que le 1er % de progression a été récupéré (utile pour montage vidéo -> découper)?
self.__recupPourcentDebut = 0
self.log = [] # stocke les infos de mplayer et mencoder
# Pour le son lors de la découpe vidéo pour l'instant
if optionSpeciale!=None:
self.optionSpeciale = optionSpeciale
self.resize(500, 100)
#=== Widgets ===#
self.labelAttente=QLabel()
self.labelAttente.setText(_(u"Attendez la fin du calcul s'il vous plaît, soyez patient !"))
self.zoneTexte = QTextEdit("") # là où s'afficheront les infos
if PYQT_VERSION_STR < "4.1.0":
self.zoneTexte.setText = self.zoneTexte.setPlainText
self.zoneTexte.setReadOnly(True)
self.zoneTexte.hide()
self.bout_annuler = QPushButton(_(u"Annuler"))
self.bout_preZoneTexte = QPushButton(_("Voir les informations de l'encodage"))
self.bout_preZoneTexte.hide()
self.pbar = QProgressBar()
self.pbar.setMaximum(100)
#self.ffmpeg2theoraProcess = QProcess(self)
self.ffmpeg2theoraProcess = FFmpeg2theora(cheminVideoEntre, cheminSorti, codec = idCodec)
#=== mise-en-page/plan ===#
vbox = QVBoxLayout()
vbox.addWidget(self.labelAttente)
vbox.addWidget(self.bout_preZoneTexte)
vbox.addWidget(self.zoneTexte)
hbox = QHBoxLayout()
hbox.addWidget(self.pbar)
hbox.addWidget(self.bout_annuler)
vbox.addLayout(hbox)
self.setLayout(vbox)
#self.adjustSize()
#=== connexion des widgets à des fonctions ===#
# TEST # sert à calculer la durée d'exécution du script -> comparaison avec avec et sans traitement
# des lignes de sortie de QProcess
# 'readyReadStandardOutput()': signal émis lors de la sortie standart de lecture
self.connect(self.ffmpeg2theoraProcess, SIGNAL('progress(int)'),
self.pbar.setValue)
self.connect(self.ffmpeg2theoraProcess, SIGNAL('log(QString)'),
self.zoneTexte.append)
self.connect(self.ffmpeg2theoraProcess, SIGNAL('finished(int)'),
self.finEncodage)
self.connect(self.bout_annuler, SIGNAL('clicked()'), self.close)
self.connect(self.bout_preZoneTexte, SIGNAL('clicked()'), self.afficherLog)
def close(self):
""" Annule le traitement en cours """
self.ffmpeg2theoraProcess.cancel()
self.ffmpeg2theoraProcess.wait()
#super(WidgetFFmpeg, self).close() # Python 2.6
QDialog.close(self)
def exec_(self):
""" Surcharge de la fonction exec permettant l'execution hors de l'init"""
self.demarrerEncodeur('Ffmpeg2theora')
#super(WidgetFFmpeg, self).exec_() # Python 2.6
QDialog.exec_(self)
def demarrerEncodeur(self, encodeur):
"""démarrage de mencoder avec les arguments choisis"""
if self.estLancee == False: # pas question de démarrer 2 fois l'encodage
infos = "\n########################\n"
infos += "# Informations MPlayer :\n"
infos += "########################\n"
debug(infos)
# Utilisation de la classe infovideo (et en particilier la fonction setVideo)
# présents dans gui_modules_animation/infoVideo.py
info = infovideo(self.cheminVideoEntre)
id_filename = 'ID_FILENAME='+self.cheminVideoEntre+'\n'
debug(id_filename)
id_demuxer = 'ID_DEMUXER='+info.demux+'\n'
debug(id_demuxer)
id_video_format = 'ID_VIDEO_FORMAT='+info.videoFormat+'\n'
debug(id_video_format)
id_video_codec = 'ID_VIDEO_CODEC='+info.video_codec+'\n'
debug(id_video_codec)
id_video_bitrate = 'ID_VIDEO_BITRATE='+str(info.videoBitrate)+'\n'
debug(id_video_bitrate)
id_video_largeur = 'ID_VIDEO_WIDTH='+str(info.videoLargeur)+'\n'
debug(id_video_largeur)
id_video_hauteur = 'ID_VIDEO_HEIGHT='+str(info.videoHauteur)+'\n'
debug(id_video_hauteur)
id_img_par_sec = 'ID_VIDEO_FPS='+str(info.imgParSec)+'\n'
debug(id_img_par_sec)
##### Donnée très importante pour la suite du calcul (pour ffmpeg.py et ffmpeg2theora) ####
self.dureeTotaleVideo = float(info.dureeTotaleVideo)
###########################################################################################
id_duree_totale_video = 'ID_LENGTH='+str(info.dureeTotaleVideo)+'\n'
debug(id_duree_totale_video)
id_audio_codec = 'ID_AUDIO_CODEC='+info.audioCodec+'\n'
debug(id_audio_codec)
id_audio_rate = 'ID_AUDIO_RATE='+str(info.audioRate)+'\n'
debug(id_audio_rate)
id_audio_bitrate = 'ID_AUDIO_BITRATE='+str(info.audioBitrate)+'\n'
debug(id_audio_bitrate)
self.log.append(infos+id_filename+id_demuxer+id_video_format+id_video_codec+id_video_bitrate+id_video_largeur+id_video_hauteur+id_img_par_sec+id_duree_totale_video+id_audio_codec+id_audio_rate+id_audio_bitrate)
##############################################################################################
infos = "\n############################\n"
infos += "# Informations %s :\n" % encodeur
infos += "############################\n"
debug(infos)
self.log.append(infos)
self.ffmpeg2theoraProcess.setVideoLen(self.dureeTotaleVideo)
if encodeur == 'Ffmpeg2theora':
# mode de canal: on fusionne le canal de sortie normal
# (stdout) et celui des erreurs (stderr)
self.ffmpeg2theoraProcess.setCommand(self.valeurNum)
self.ffmpeg2theoraProcess.start()
debug(u"Commande lancée")
self.estLancee = True
def finEncodage(self, statutDeSortie):
"""choses à faire à la fin de l'encodage de la vidéo"""
# fermer la fenêtre à la fin de l'encodage
if not self.laisserOuvert:
self.close()
debug("fini!")
self.labelAttente.hide()
self.pbar.setValue(100)
# l'encodage est fini. Il ne peut plus être annulé. La
# seule action possible devient ainsi la fermeture
self.bout_annuler.setText(_(u"Fermer"))
self.bout_preZoneTexte.show()
def afficherLog(self):
"""afficher les information de la vidéo de départ et de l'encodage"""
self.zoneTexte.setText(self.ffmpeg2theoraProcess.log)
self.zoneTexte.show()
self.resize(500, 300)
class Main(plugin.Plugin):
' main class for plugin '
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 readOutput(self):
"""Read and append output to the logBrowser"""
self.output.append(str(self.process.readAllStandardOutput()).strip())
def readErrors(self):
"""Read and append errors to the logBrowser"""
self.output.append(self.formatErrorMsg(str(
self.process.readAllStandardError())))
def formatErrorMsg(self, msg):
"""Format error messages in red color"""
return self.formatMsg(msg, 'red')
def formatInfoMsg(self, msg):
"""Format informative messages in blue color"""
return self.formatMsg(msg, 'green')
def formatMsg(self, msg, color):
"""Format message with the given color"""
return '<font color="{}">{}</font>'.format(color, msg)
def make_clon(self):
' make clones analyze from contextual sub menu '
self.outdir.setText(
self.locator.get_service('explorer').get_current_project_item().path)
self.run()
def run(self):
' run the actions '
self.output.clear()
self.output.append(self.formatInfoMsg('INFO:{}'.format(datetime.now())))
self.tm.setText('<center><b>Last Clone: </b>' +
datetime.now().isoformat().split('.')[0])
self.button.setDisabled(True)
if not len(self.outdir.text()) and not len(self.outfle.text()):
self.output.append(self.formatErrorMsg('ERROR: FAIL: Target empty'))
self.button.setEnabled(True)
return
# run the subprocesses
cmd = ' '.join((
'chrt -i 0' if self.chrt.isChecked() is True else '', 'clonedigger',
'' if self.qckb1.isChecked() is True else '--no-recursion',
'--dont-print-time' if self.qckb2.isChecked() is True else '',
'--force' if self.qckb3.isChecked() is True else '',
'--fast' if self.qckb4.isChecked() is True else '',
'--cpd-output' if self.xmlo.isChecked() is True else '',
'' if self.xmlo.isChecked() is True else '--report-unifiers',
'--distance-threshold={}'.format(self.mdist.value()),
'--hashing-depth={}'.format(self.hdep.value()),
'--ignore-dir="{}"'.format(self.igndir.text()
if self.ignckb.currentIndex() is 0
else self.ignmor.toPlainText()),
'--func-prefixes="{}"'.format(self.ign_func.text()),
'--output="{}"'.format(self.outfle.text()),
'--language=python', path.abspath(self.outdir.text()),
))
self.output.append(self.formatInfoMsg('INFO:OK:Command:{}'.format(cmd)))
self.process.start(cmd)
if not self.process.waitForStarted():
self.output.append(self.formatErrorMsg(' ERROR: FAIL: Meh. '))
self.output.append(self.formatErrorMsg('ERROR:FAIL:{}'.format(cmd)))
self.button.setEnabled(True)
return
self.readOutput()
self.readErrors()
self.button.setEnabled(True)
def _process_finished(self):
""" finished sucessfully """
self.output.append(self.formatInfoMsg('INFO:{}'.format(datetime.now())))
# write a .log file on target
if self.qckb5.isChecked() is True:
log_file = 'ninja_clones.log'
with open(path.join(str(self.outdir.text()), log_file), 'w') as log:
self.output.append(self.formatInfoMsg('''INFO: OK: Writing Logs:
{}'''.format(path.join(str(self.outdir.text()), log_file))))
log.write(self.output.toPlainText())
log.close()
# open target output
if self.opeo.isChecked() is True and self.xmlo.isChecked() is False:
try:
startfile(self.outfle.text())
except:
Popen(["xdg-open", self.outfle.text()])
self.output.selectAll()
self.output.setFocus()
def toggle_options_group(self):
' toggle on off the options group '
if self.group3.isChecked() is True:
[a.setChecked(True) for a in (self.qckb1, self.qckb3, self.qckb5,
self.chrt, self.opeo)]
self.mdist.setValue(5)
self.hdep.setValue(1)
self.group3.graphicsEffect().setEnabled(False)
else:
[a.setChecked(False) for a in (self.qckb1, self.qckb3, self.qckb5,
self.chrt, self.opeo)]
self.group3.graphicsEffect().setEnabled(True)
def on_ignore_changed(self):
'hide or show one widget or another depending what kind of input need'
if self.ignckb.currentIndex() is 0:
self.igndir.show()
self.btn2.show()
self.ignmor.hide()
else:
self.igndir.hide()
self.btn2.hide()
self.ignmor.show()
def on_auto_changed(self):
' automation connects '
if self.auto.currentIndex() is 1:
self.locator.get_service('editor').fileSaved.connect(lambda:
self.run())
QMessageBox.information(self.dock, __doc__,
'<b>Now Actions will Run Automatically when any File is Saved !')
elif self.auto.currentIndex() is 2:
self.locator.get_service('editor').fileExecuted.connect(lambda:
self.run())
QMessageBox.information(self.dock, __doc__,
'<b>Now Actions will Run Automatically when any File is Executed !')
elif self.auto.currentIndex() is 3:
self.locator.get_service('editor').currentTabChanged.connect(lambda:
self.run())
QMessageBox.information(self.dock, __doc__,
'<b>Now Actions will Run Automatically when current Tab is Changed')
elif self.auto.currentIndex() is 4:
self.locator.get_service('editor').fileOpened.connect(lambda:
self.run())
QMessageBox.information(self.dock, __doc__,
'<b>Now Actions will Run Automatically when any File is Opened !')
elif self.auto.currentIndex() is 5:
self.locator.get_service('editor').beforeFileSaved.connect(lambda:
self.run())
QMessageBox.information(self.dock, __doc__,
'<b>Now Actions will Run Automatically before any File is Saved !')
self.group4.setDisabled(True)
def finish(self):
' clear when finish '
self.process.kill()
class EpisodeInfo(QWidget):
"""Show the episode at the right."""
def __init__(self, main_window):
self.main_window = main_window
super(EpisodeInfo, self).__init__()
self.current_episode = None
layout = QVBoxLayout(self)
# a throbber, that we don't initially show
self.throbber = Throbber()
layout.addWidget(self.throbber)
self.throbber.hide()
# the image and its getter
self.image_episode = QLabel()
self.image_episode.hide()
layout.addWidget(self.image_episode, alignment=Qt.AlignCenter)
self.get_image = image.ImageGetter(self.image_episode_loaded).get_image
# text area
self.text_edit = QTextEdit(
u"Seleccionar un programa para ver aquí la info.")
self.text_edit.setReadOnly(True)
layout.addWidget(self.text_edit)
# the button
self.button = QPushButton()
self.button.connected = False
self.button.hide()
layout.addWidget(self.button)
def image_episode_loaded(self, episode_id, image_path):
"""An image has arrived, show it only if the path is correct."""
# only set the image if the user still have the same episode selected
if self.current_episode != episode_id:
return
# load the image and show it
pixmap = QPixmap(image_path)
self.image_episode.setPixmap(pixmap)
self.image_episode.show()
# hide the throbber
self.throbber.hide()
def clear(self, msg):
"""Clear the episode info panel."""
self.throbber.hide()
self.image_episode.hide()
self.text_edit.setText(msg)
self.button.hide()
def update(self, episode, force_change=True):
"""Update all the episode info."""
if not force_change:
# if not forced, only update what is being shown if the current episode
# is the one to be updated
if self.current_episode != episode.episode_id:
return
self.current_episode = episode.episode_id
# image
if episode.image_data is not None:
# have the image data already!!
qimg = QImage.fromData(episode.image_data)
pixmap = QPixmap.fromImage(qimg)
self.image_episode.setPixmap(pixmap)
self.image_episode.show()
elif episode.image_url is not None:
# this must be before the get_image call, as it may call
# immediately to image_episode_loaded (showing the image and
# hiding the throber)
self.image_episode.hide()
self.throbber.show()
# now do call the get_image
self.get_image(episode.episode_id,
episode.image_url.encode('utf-8'))
# all description
if episode.subtitle is None:
msg = u"<center><h3>%s</h3></center><br/><br/>%s" % (
episode.composed_title, episode.description)
else:
msg = u"<center><h3>%s</h3>%s</center><br/><br/>%s" % (
episode.composed_title, episode.subtitle, episode.description)
self.text_edit.setHtml(msg)
# action button
self.button.show()
if episode.state == data.Status.downloaded:
label = "Reproducir"
func = self.main_window.play_episode
enable = True
remove = False
elif episode.state == data.Status.downloading:
label = u"Cancelar descarga"
func = self.main_window.cancel_download
enable = True
remove = False
elif episode.state == data.Status.waiting:
label = u"Sacar de la cola"
func = self.main_window.unqueue_download
enable = True
remove = True
else:
label = u"Descargar"
func = self.main_window.download_episode
enable = bool(self.main_window.have_config())
remove = False
def _exec(func, episode, remove):
"""Execute a function on the episode and update its info."""
func(episode)
if not remove:
self.update(episode)
# set button text, disconnect if should, and connect new func
self.button.setEnabled(enable)
self.button.setText(label)
if self.button.connected:
self.button.clicked.disconnect()
self.button.connected = True
self.button.clicked.connect(lambda: _exec(func, episode, remove))
class mainWin(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
screen = QDesktopWidget().screenGeometry()
self.setGeometry(80, 100, int((1/2)*screen.width()), int((4/10)*screen.height()))
self.main_frame = QFrame()
self.cw = QFrame()
self.cw.setFrameStyle(QFrame.StyledPanel|QFrame.Sunken)
self.main_sizer = QVBoxLayout()
self.hbox1_sizer = QHBoxLayout()
self.setWindowTitle(self.tr("Consonance Rating"))
##
self.sessionRunning = False
self.listenerID = ""
self.currentTrial = 1
self.intervals_db = pd.read_csv(os.path.abspath(os.path.dirname(__file__)) + "/resources/intervals_database.csv", sep=";")
# self.rootNotes = np.array([110, 130.81, 185])
# self.intervalsCents = np.array([100,
# 500,
# 600,
# 700,
# 800,
# 1100])
#self.rootNotes = np.array([110, 185])
self.rootNotes = np.array([146.83,
155.56,
164.81,
174.61,
185,
196,
207.65,
220])
self.intervalsCents = np.array([600,
700
])
self.diadDur = 1980
self.diadRamps = 10
self.diadTotLev = np.array([40, 80])
self.diadFilterType = "lowpass"
self.diadFilterCutoffs = (2500,)
self.diadLowHarm = 1
self.diadHighHarm = 50
self.diadNote1Chan = "Both"
self.diadNote2Chan = "Both"
self.fs = 48000
self.maxLevel = self.getPhonesCal()
self.noise1SL = -200
self.noise1LowFreq = 0
self.noise1HighFreq = 2000
self.noise1Type = "Pink"
self.noise2Type = "Pink"
self.noise2SL = np.array([0, 40])
self.noise2LowFreq = 4000
self.noise2HighFreq = 8000
self.noise1RefHz = 100
self.noise2RefHz = 4000
self.preTrialNoiseRefHz = 1000
self.preTrialNoiseLowFreq = 20
self.preTrialNoiseHighFreq = 8000
self.preTrialNoiseDur = 1980
self.preTrialNoiseRamps = 10
self.preTrialNoiseSL = np.array([0, 40])
self.preTrialNoiseType = "Pink"
self.preTrialNoiseChannel = "Both"
self.preTrialNoiseDiadISI = 500
self.noiseChannel = "Both"
self.nPracticeTrialsXStim = 4
self.nTrialsXStim = 2
self.nTrials = len(self.rootNotes)*len(self.intervalsCents)*len(self.diadTotLev)*(self.nTrialsXStim) + self.nPracticeTrialsXStim*len(self.intervalsCents)*len(self.diadTotLev)
print(self.nTrials)
practiceTrials = []
mainTrials = []
for rootNote in self.rootNotes:
for intervalCents in self.intervalsCents:
for n in range(self.nTrialsXStim):
mainTrials.append((rootNote, intervalCents, "main", self.diadTotLev[0], self.noise2SL[0], self.preTrialNoiseSL[0]))
for intervalCents in self.intervalsCents:
for n in range(self.nPracticeTrialsXStim):
practiceTrials.append((random.choice(self.rootNotes), intervalCents, "practice", self.diadTotLev[0], self.noise2SL[0], self.preTrialNoiseSL[0]))
random.shuffle(practiceTrials)
random.shuffle(mainTrials)
practiceTrials2 = []
mainTrials2 = []
for rootNote in self.rootNotes:
for intervalCents in self.intervalsCents:
for n in range(self.nTrialsXStim):
mainTrials2.append((rootNote, intervalCents, "main", self.diadTotLev[1], self.noise2SL[1], self.preTrialNoiseSL[1]))
for intervalCents in self.intervalsCents:
for n in range(self.nPracticeTrialsXStim):
practiceTrials2.append((random.choice(self.rootNotes), intervalCents, "practice", self.diadTotLev[1], self.noise2SL[1], self.preTrialNoiseSL[1]))
random.shuffle(practiceTrials2)
random.shuffle(mainTrials2)
#root note
#interval cents
#practice or main
#dialTotLev
#noise2SL
#preTrialNoiseSL
#remove some practice trials
#practiceTrials = practiceTrials[0:4]
#practiceTrials2 = practiceTrials2[0:4]
self.trialList = []
if random.choice([0,1]) == 0:
self.trialList.extend(practiceTrials)
self.trialList.extend(practiceTrials2)
else:
self.trialList.extend(practiceTrials2)
self.trialList.extend(practiceTrials)
if random.choice([0,1]) == 0:
self.trialList.extend(mainTrials)
self.trialList.extend(mainTrials2)
else:
self.trialList.extend(mainTrials2)
self.trialList.extend(mainTrials)
print(len(self.trialList))
self.menubar = self.menuBar()
self.fileMenu = self.menubar.addMenu(self.tr('-'))
self.editPhonesAction = QAction(self.tr('Phones Calibration'), self)
self.fileMenu.addAction(self.editPhonesAction)
self.editPhonesAction.triggered.connect(self.onEditPhones)
self.setupListenerButton = QPushButton(self.tr("Setup Listener"), self)
self.setupListenerButton.clicked.connect(self.onClickSetupListenerButton)
self.setupListenerButton.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
# self.setupListenerButton.setToolTip(self.tr("Choose file to save results"))
# self.setupListenerButton.setWhatsThis(self.tr("Choose where to save the result files"))
self.setupListenerButton.setStyleSheet('font-size: 32pt; font-weight: bold')
self.hbox1_sizer.addWidget(self.setupListenerButton)
self.main_sizer.addLayout(self.hbox1_sizer)
#statusButtonFont = QFont("Arial", 26);
self.statusButton = QPushButton(self.tr("Start"), self)
self.statusButton.clicked.connect(self.onClickStatusButton)
self.statusButton.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
self.main_sizer.addWidget(self.statusButton)
#self.statusButton.setFont(statusButtonFont)
self.statusButton.setStyleSheet('font-size: 32pt; font-weight: bold')
self.statusButton.hide()
self.cw.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
borderWidth = 4
self.main_sizer.addItem(QSpacerItem(20, 60, QSizePolicy.Fixed))
self.overallRatingSliderValue = QLabel(self.tr("0"), self)
self.main_sizer.addWidget(self.overallRatingSliderValue)
self.overallRatingSliderValue.setStyleSheet('font-size: 22pt; font-weight: normal')
self.overallRatingSliderValue.setAlignment(Qt.AlignCenter)
self.main_sizer.addItem(QSpacerItem(20,60, QSizePolicy.Fixed))
sliderFont = QFont("Ubuntu", 18)
self.overallRatingSlider = Qwt.QwtSlider(self, Qt.Horizontal, Qwt.QwtSlider.BottomScale)
self.overallRatingSlider.setFont(sliderFont)
self.overallRatingSlider.setScale(-3.0,3.0, 1)
self.overallRatingSlider.setRange(-3.0,3.0)
self.overallRatingSlider.valueChanged[float].connect(self.sliderChanged)
self.overallRatingSlider.setMinimumSize(800, 20)
self.overallRatingSlider.setBorderWidth(borderWidth)
self.main_sizer.addWidget(self.overallRatingSlider)
self.main_sizer.addItem(QSpacerItem(20,30, QSizePolicy.Fixed))
self.gauge = QProgressBar(self)
self.gauge.setRange(0, 100)
self.main_sizer.addWidget(self.gauge)
self.cw.setLayout(self.main_sizer)
self.setCentralWidget(self.cw)
self.show()
def onClickStatusButton(self):
if self.statusButton.text() == self.tr("Finished"):
return
self.sessionRunning = True
self.statusButton.setText(self.tr("Running"))
QApplication.processEvents()
if self.listenerID == "":
text, ok = QInputDialog.getText(self, "" , "Listener ID: ")
if ok:
self.listenerID = text
self.statusButton.setText(self.tr("Start"))
return
if self.currentTrial == 1:
self.setupListenerButton.hide()
self.overallRatingSlider.setValue(0)
self.overallRatingSliderValue.setText("")
self.doTrial()
return
if self.overallRatingSliderValue.text() == "":
ret = QMessageBox.warning(self, self.tr("Warning"),
self.tr("You need to move the slider before going to the next trial.\nIf you want to assign a score of zero move the slider forth and then back to the zero position."),
QMessageBox.Ok)
return
if self.currentTrial > 1:
self.storeRating()
self.gauge.setValue((self.currentTrial-1)/self.nTrials*100)
#self.sliderChanged(0)
self.sliderLabelReset()
self.statusButton.setText(self.tr("Running"))
QApplication.processEvents()
if self.currentTrial <= self.nTrials :
self.doTrial()
else:
self.statusButton.setText(self.tr("Finished"))
def doTrial(self):
self.statusButton.setText(self.tr("Running"))
QApplication.processEvents()
#root note
rootNote = self.trialList[self.currentTrial-1][0]
#interval cents
intervalCents = self.trialList[self.currentTrial-1][1]
#practice or main
trialMode = self.trialList[self.currentTrial-1][2]
#dialTotLev
diadTotLev = self.trialList[self.currentTrial-1][3]
#noise2SL
noise2SL = self.trialList[self.currentTrial-1][4]
#preTrialNoiseSL
preTrialNoiseSL = self.trialList[self.currentTrial-1][5]
try:
intervalName = self.intervals_db["name"][self.intervals_db["cents"] == self.trialList[self.currentTrial-1][1]].values[0]
except:
intervalName = str(self.trialList[self.currentTrial-1][1])
print(intervalName)
preTrialNoise = broadbandNoise(spectrumLevel=preTrialNoiseSL,
duration=self.preTrialNoiseDur,
ramp=self.preTrialNoiseRamps, channel=self.preTrialNoiseChannel,
fs=self.fs, maxLevel=self.maxLevel)
if self.preTrialNoiseType == "Pink":
preTrialNoise = makePinkRef(preTrialNoise, self.fs, self.preTrialNoiseRefHz)
preTrialNoise = fir2Filter2(preTrialNoise, filterType="bandpass", nTaps=256, cutoffs=(self.preTrialNoiseLowFreq, self.preTrialNoiseHighFreq), transitionWidth=0.2, fs=self.fs)
diad = makeDiad(rootNote, intervalCents,
filterType=self.diadFilterType,
filterCutoffs=self.diadFilterCutoffs,
lowHarm=self.diadLowHarm, highHarm=self.diadHighHarm,
diadTotLev=diadTotLev, duration=self.diadDur,
ramp=self.diadRamps, note1Channel=self.diadNote1Chan,
note2Channel=self.diadNote2Chan, fs=self.fs,
maxLevel=self.maxLevel)
noise1 = broadbandNoise(spectrumLevel=self.noise1SL,
duration=self.diadDur,
ramp=self.diadRamps*6, channel=self.noiseChannel,
fs=self.fs, maxLevel=self.maxLevel)
if self.noise1Type == "Pink":
noise1 = makePinkRef(noise1, self.fs, self.noise1RefHz)
noise1 = fir2Filter2(noise1, filterType="bandpass", nTaps=256,
cutoffs=(self.noise1LowFreq, self.noise1HighFreq),
transitionWidth=0.2, fs=self.fs)
noise1 = noise1[0:diad.shape[0],:]
noise1 = gate(self.diadRamps, noise1, self.fs)
noise2 = broadbandNoise(spectrumLevel=noise2SL,
duration=self.diadDur,
ramp=self.diadRamps*6, channel=self.noiseChannel,
fs=self.fs, maxLevel=self.maxLevel)
if self.noise2Type == "Pink":
noise2 = makePinkRef(noise2, self.fs, self.noise2RefHz)
noise2 = fir2Filter2(noise2, filterType="bandpass", nTaps=256,
cutoffs=(self.noise2LowFreq, self.noise2HighFreq),
transitionWidth=0.2, fs=self.fs)
noise2 = noise2[0:diad.shape[0],:]
noise2 = gate(self.diadRamps, noise2, self.fs)
stim = diad+noise1+noise2
noiseDiadSilence = makeSilence(self.preTrialNoiseDiadISI)
snd = np.concatenate((preTrialNoise, noiseDiadSilence, stim), axis=0)
wavwrite(snd, self.fs, 32, "snd.wav")
wavwrite(diad, self.fs, 32, "diad.wav")
wavwrite(diad+noise1+noise2, self.fs, 32, "diad_in_noise.wav")
sound(snd)
self.currentTrial = self.currentTrial+1
def storeRating(self):
try:
intervalName = self.intervals_db["name"][self.intervals_db["cents"] == self.trialList[self.currentTrial-2][1]].values[0]
except:
intervalName = str(self.trialList[self.currentTrial-2][1])
#rootNote = str(self.trialList[self.currentTrial-2][0])
#root note
rootNote = self.trialList[self.currentTrial-2][0]
#interval cents
intervalCents = self.trialList[self.currentTrial-2][1]
#practice or main
trialMode = self.trialList[self.currentTrial-2][2]
#dialTotLev
diadTotLev = self.trialList[self.currentTrial-2][3]
#noise2SL
noise2SL = self.trialList[self.currentTrial-2][4]
#preTrialNoiseSL
preTrialNoiseSL = self.trialList[self.currentTrial-2][5]
# if self.currentTrial-1 <= len(self.rootNotes)*len(self.intervalsCents)*self.nPracticeTrialsXStim:
# trialMode = "practice"
# else:
# trialMode = "main"
self.thisPageFile.write(self.listenerID + ';')
self.thisPageFile.write(str(rootNote) + ';')
self.thisPageFile.write(intervalName + ';')
self.thisPageFile.write(str(intervalCents) + ';')
self.thisPageFile.write(trialMode + ';')
self.thisPageFile.write(str(diadTotLev) + ';')
#self.thisPageFile.write(str(noise2SL) + ';')
self.thisPageFile.write(self.overallRatingSliderValue.text() + '\n')
self.thisPageFile.flush()
self.overallRatingSlider.setValue(0)
self.overallRatingSliderValue.setText("")
def sliderChanged(self, value):
self.overallRatingSliderValue.setText(str(round(value,1)))
if self.currentTrial > 1 and self.statusButton.text() != self.tr("Finished"):
self.statusButton.setText(self.tr("Next"))
def sliderLabelReset(self):
self.overallRatingSliderValue.setText("0")
def onClickSetupListenerButton(self):
text, ok = QInputDialog.getText(self, "" , "Listener ID: ")
if ok:
self.listenerID = text
else:
return
ftow = QFileDialog.getSaveFileName(self, self.tr('Choose file to write results'), "", self.tr('All Files (*)'), "", QFileDialog.DontConfirmOverwrite)[0]
if len(ftow) > 0:
self.thisPagePath = ftow
self.thisPageFile = open(self.thisPagePath, "a")
self.thisPageFile.write("listener;root_note;interval;intervalCents;trial_type;totLev;rating\n")
self.setupListenerButton.hide()
self.statusButton.show()
else:
return
def getPhonesCal(self):
fHandle = open(phonesCalFile, 'r')
currCal = float(fHandle.readline().strip())
fHandle.close()
return currCal
def writePhonesCal(self, val):
fHandle = open(phonesCalFile, 'w')
fHandle.write(str(val))
fHandle.close()
def onEditPhones(self):
currCal = self.getPhonesCal()
val, ok = QInputDialog.getDouble(self, self.tr('Phones Calibration'), self.tr('Phones Max. Level'), currCal)
self.writePhonesCal(val)
self.maxLevel = val
def create_rows(self, layout, sarea):
u"""Build the rows of the dialog box"""
play_button_group = QButtonGroup(sarea)
old_play_button_group = QButtonGroup(sarea)
for num, entry in enumerate(self.entries_list, 2):
tt_text = self.build_text_help_label(entry)
ico_label = QLabel('', sarea)
ico_label.setToolTip(tt_text)
if entry.icon:
ico_label.setPixmap(QPixmap.fromImage(entry.icon))
layout.addWidget(ico_label, num, 0)
tt_label = QLabel(entry.display_word, sarea)
tt_label.setToolTip(tt_text)
layout.addWidget(tt_label, num, 1)
if self.hide_text:
tt_label.hide()
# Play button.
t_play_button = QPushButton(sarea)
play_button_group.addButton(t_play_button, num-2)
t_play_button.setToolTip(self.play_help)
t_play_button.setIcon(QIcon(os.path.join(icons_dir, 'play.png')))
layout.addWidget(t_play_button, num, self.play_column)
if self.note[entry.audio_field_name]:
t_play_old_button = QPushButton(sarea)
old_play_button_group.addButton(t_play_old_button, num-2)
t_play_old_button.setIcon(
QIcon(os.path.join(icons_dir, 'play.png')))
if not self.hide_text:
t_play_old_button.setToolTip(
self.note[entry.audio_field_name])
else:
t_play_old_button.setToolTip(self.play_old_help_short)
layout.addWidget(t_play_old_button, num, self.play_old_column)
else:
dummy_label = QLabel('', sarea)
dummy_label.setToolTip(self.play_old_empty_line_help)
layout.addWidget(dummy_label, num, self.play_old_column)
# The group where we later look what to do:
t_button_group = QButtonGroup(sarea)
t_button_group.setExclusive(True)
# Now the four buttons
t_add_button = QPushButton(sarea)
t_add_button.setCheckable(True)
t_add_button.setFlat(True)
t_add_button.setToolTip(self.add_help_text_short)
t_add_button.setIcon(QIcon(os.path.join(icons_dir, 'add.png')))
layout.addWidget(t_add_button, num, self.add_column)
t_button_group.addButton(t_add_button, Action.Add)
t_keep_button = QPushButton(sarea)
t_keep_button.setCheckable(True)
t_keep_button.setFlat(True)
t_keep_button.setToolTip(self.keep_help_text_short)
t_keep_button.setIcon(QIcon(os.path.join(icons_dir, 'keep.png')))
layout.addWidget(t_keep_button, num, self.keep_column)
t_button_group.addButton(t_keep_button, Action.Keep)
t_delete_button = QPushButton(sarea)
t_delete_button.setCheckable(True)
t_delete_button.setFlat(True)
t_delete_button.setToolTip(self.delete_help_text_short)
t_delete_button.setIcon(
QIcon(os.path.join(icons_dir, 'delete.png')))
layout.addWidget(t_delete_button, num, self.delete_column)
t_button_group.addButton(t_delete_button, Action.Delete)
t_blacklist_button = QPushButton(sarea)
t_blacklist_button.setCheckable(True)
t_blacklist_button.setFlat(True)
t_blacklist_button.setToolTip(self.blacklist_help_text_short)
t_blacklist_button.setIcon(
QIcon(os.path.join(icons_dir, 'blacklist.png')))
if entry.entry_hash:
layout.addWidget(
t_blacklist_button, num, self.blacklist_column)
else:
t_blacklist_button.hide()
dummy_label_bl = QLabel('', sarea)
dummy_label_bl.setToolTip(self.blacklist_empty_line_help)
layout.addWidget(dummy_label_bl, num, self.blacklist_column)
t_button_group.button(entry.action).setChecked(True)
# New: check a button based on how good the downloader is.
t_button_group.addButton(t_blacklist_button, Action.Blacklist)
self.buttons_groups.append(t_button_group)
play_button_group.buttonClicked.connect(
lambda button: play(
self.entries_list[play_button_group.id(button)].file_path))
# N.B.: anki.sound.play() plays files from anywhere, not just
# from the colection.media folder. We should be good,
# here. (This behaviour may be a security risk, idk.)
old_play_button_group.buttonClicked.connect(
lambda button: playFromText(
self.note[
self.entries_list[
old_play_button_group.id(button)].audio_field_name]))
def create_rows(self, layout):
u"""Build the rows of the dialog box"""
play_button_group = QButtonGroup(self)
old_play_button_group = QButtonGroup(self)
for num, entry in enumerate(self.entries_list, 3):
tt_text = self.build_text_help_label(entry)
ico_label = QLabel('', self)
ico_label.setToolTip(tt_text)
if entry.icon:
ico_label.setPixmap(QPixmap.fromImage(entry.icon))
layout.addWidget(ico_label, num, 0)
tt_label = QLabel(entry.display_word, self)
tt_label.setToolTip(tt_text)
layout.addWidget(tt_label, num, 1)
if self.hide_text:
tt_label.hide()
# Play button.
t_play_button = QPushButton(self)
play_button_group.addButton(t_play_button, num - 3)
t_play_button.setToolTip(self.play_help)
t_play_button.setIcon(QIcon(os.path.join(icons_dir, 'play.png')))
layout.addWidget(t_play_button, num, self.play_column)
if self.note[entry.audio_field_name]:
t_play_old_button = QPushButton(self)
old_play_button_group.addButton(t_play_old_button, num - 3)
t_play_old_button.setIcon(
QIcon(os.path.join(icons_dir, 'play.png')))
if not self.hide_text:
t_play_old_button.setToolTip(
self.note[entry.audio_field_name])
else:
t_play_old_button.setToolTip(self.play_old_help_short)
layout.addWidget(t_play_old_button, num, self.play_old_column)
else:
dummy_label = QLabel('', self)
dummy_label.setToolTip(self.play_old_empty_line_help)
layout.addWidget(dummy_label, num, self.play_old_column)
# The group where we later look what to do:
t_button_group = QButtonGroup(self)
t_button_group.setExclusive(True)
# Now the four buttons
t_add_button = QPushButton(self)
t_add_button.setCheckable(True)
t_add_button.setFlat(True)
t_add_button.setToolTip(self.add_help_text_short)
t_add_button.setIcon(QIcon(os.path.join(icons_dir, 'add.png')))
layout.addWidget(t_add_button, num, self.add_column)
t_button_group.addButton(t_add_button, Action.Add)
t_keep_button = QPushButton(self)
t_keep_button.setCheckable(True)
t_keep_button.setFlat(True)
t_keep_button.setToolTip(self.keep_help_text_short)
t_keep_button.setIcon(QIcon(os.path.join(icons_dir, 'keep.png')))
layout.addWidget(t_keep_button, num, self.keep_column)
t_button_group.addButton(t_keep_button, Action.Keep)
t_delete_button = QPushButton(self)
t_delete_button.setCheckable(True)
t_delete_button.setFlat(True)
t_delete_button.setToolTip(self.delete_help_text_short)
t_delete_button.setIcon(
QIcon(os.path.join(icons_dir, 'delete.png')))
layout.addWidget(t_delete_button, num, self.delete_column)
t_button_group.addButton(t_delete_button, Action.Delete)
t_blacklist_button = QPushButton(self)
t_blacklist_button.setCheckable(True)
t_blacklist_button.setFlat(True)
t_blacklist_button.setToolTip(self.blacklist_help_text_short)
t_blacklist_button.setIcon(
QIcon(os.path.join(icons_dir, 'blacklist.png')))
if entry.entry_hash:
layout.addWidget(
t_blacklist_button, num, self.blacklist_column)
else:
t_blacklist_button.hide()
dummy_label_bl = QLabel('', self)
dummy_label_bl.setToolTip(self.blacklist_empty_line_help)
layout.addWidget(dummy_label_bl, num, self.blacklist_column)
t_button_group.button(entry.action).setChecked(True)
# New: check a button based on how good the downloader is.
t_button_group.addButton(t_blacklist_button, Action.Blacklist)
self.buttons_groups.append(t_button_group)
play_button_group.buttonClicked.connect(
lambda button: play(
self.entries_list[play_button_group.id(button)].file_path))
# N.B.: anki.sound.play() plays files from anywhere, not just
# from the colection.media folder. We should be good,
# here. (This behaviour may be a security risk, idk.)
old_play_button_group.buttonClicked.connect(
lambda button: playFromText(
self.note[
self.entries_list[
old_play_button_group.id(button)].audio_field_name]))
class WizardDialog(QDialog):
"""The dialog for update."""
def __init__(self, main_window):
super(WizardDialog, self).__init__()
self.mw = main_window
vbox = QVBoxLayout(self)
# label and checkbox
self.main_text = QLabel(u"init text")
vbox.addWidget(self.main_text)
self.notthisagain = QCheckBox(u"No mostrar automáticamente esta ayuda")
nowizard = config.get('nowizard', False)
self.notthisagain.setCheckState(nowizard)
self.notthisagain.stateChanged.connect(self._notthisagain_toggled)
vbox.addWidget(self.notthisagain)
# buttons
bbox = QDialogButtonBox()
self.navbut_actn = QPushButton(u"init text")
bbox.addButton(self.navbut_actn, QDialogButtonBox.ActionRole)
self.navbut_prev = QPushButton(u"Anterior")
bbox.addButton(self.navbut_prev, QDialogButtonBox.ActionRole)
self.navbut_next = QPushButton(u"Siguiente")
bbox.addButton(self.navbut_next, QDialogButtonBox.ActionRole)
vbox.addWidget(bbox)
self.show()
self.step = 0
self._move(0)
def _notthisagain_toggled(self, state):
"""The "not this again" checkbutton togled state."""
logger.info("Configuring 'nowizard' to %s", state)
config['nowizard'] = state
def _move(self, delta_step):
"""The engine for the wizard steps."""
self.step += delta_step
logger.debug("Entering into step %d", self.step)
(text, ign_func, act_label, act_func) = STEPS[self.step]
# if this step should be ignored, just leave
if ign_func is not None:
m = getattr(self, "_ign_" + ign_func)
if m():
# keep going
return self._move(delta_step)
# adjust navigation buttons
if self.step == 0:
self.navbut_prev.setEnabled(False)
self.navbut_next.setText(u"Siguiente")
self.navbut_next.clicked.disconnect()
self.navbut_next.clicked.connect(lambda: self._move(1))
self.notthisagain.show()
elif self.step == len(STEPS) - 1:
self.navbut_prev.setEnabled(True)
self.navbut_prev.clicked.disconnect()
self.navbut_prev.clicked.connect(lambda: self._move(-1))
self.navbut_next.setText(u"Terminar")
self.navbut_next.clicked.disconnect()
self.navbut_next.clicked.connect(self.accept)
self.notthisagain.hide()
else:
self.navbut_prev.setEnabled(True)
self.navbut_prev.clicked.disconnect()
self.navbut_prev.clicked.connect(lambda: self._move(-1))
self.navbut_next.setText(u"Siguiente")
self.navbut_next.clicked.disconnect()
self.navbut_next.clicked.connect(lambda: self._move(1))
self.notthisagain.hide()
# adjust main text and action button
if self.step == len(STEPS) - 1:
if self.mw.have_metadata() and self.mw.have_config():
self.main_text.setText(TEXT_HAPPY_END)
else:
self.main_text.setText(TEXT_SAD_END)
else:
self.main_text.setText(text)
if act_label is None:
self.navbut_actn.hide()
else:
self.navbut_actn.show()
self.navbut_actn.setText(act_label)
method_to_call = getattr(self, "_act_" + act_func)
self.navbut_actn.clicked.disconnect()
self.navbut_actn.clicked.connect(method_to_call)
def _act_configure(self, _):
"""Open the config dialog."""
self.mw.open_preferences()
def _act_update(self, *a):
"""Open the update dialog."""
self.mw.refresh_episodes()
def _ign_episode(self):
"""Tell if the episode step should be ignored."""
return self.mw.have_metadata()
def _ign_config(self):
"""Tell if the configure step should be ignored."""
return self.mw.have_config()
class MessageBoxDialog(QDialog):
"""
Message box dialog
"""
Download = pyqtSignal(str)
DownloadCanceled = pyqtSignal()
def __init__(self, dialogName, parent = None):
"""
Constructor
@param dialogName:
@type dialogName:
@param parent:
@type parent:
"""
QDialog.__init__(self, parent)
self.setWindowIcon( QIcon(":/main.png") )
self.name = dialogName
self.url = None
self.createDialog()
def closeEvent(self, event):
"""
On close event
@param event:
@type event:
"""
pass
def setDownload(self, title, txt, url, cancelButton=True):
"""
Set as download
@param title:
@type title:
@param txt:
@type txt:
@param url:
@type url:
"""
self.setWindowFlags(Qt.Drawer | Qt.CustomizeWindowHint)
self.url = url
self.setWindowTitle( title )
self.progressBar.hide()
self.imageLabel.setPixmap(QPixmap(':/information.png'))
self.loadingLabel.setText( txt )
self.downloadButton.show()
if cancelButton:
self.cancelButton.show()
else:
self.cancelButton.hide()
self.okButton.hide()
self.imageLabel.show()
def setTxt (self, title, txt, error=False):
"""
Set text
@param title:
@type title:
@param txt:
@type txt:
"""
self.setWindowTitle( title )
self.progressBar.hide()
self.loadingLabel.setText( txt )
self.imageLabel.show()
if error:
self.imageLabel.setPixmap(QPixmap(':/warning.png'))
else:
self.imageLabel.setPixmap(QPixmap(':/information.png'))
self.okButton.show()
self.downloadButton.hide()
self.cancelButton.hide()
def setLoading (self, msg='Loading data...' ):
"""
Set as loading
@param msg:
@type msg:
"""
self.setWindowTitle( "%s" % self.name )
self.progressBar.setMaximum(0)
self.progressBar.setProperty("value", 0)
self.progressBar.show()
self.loadingLabel.setText( msg )
self.loadingLabel.show()
self.okButton.hide()
self.downloadButton.hide()
self.cancelButton.hide()
self.imageLabel.hide()
def setConnection (self ):
"""
Set text with connection
"""
self.loadingLabel.setText( "Connection..." )
def setInitialization (self ):
"""
Set text with initialization
"""
self.loadingLabel.setText( "Initialization..." )
self.show()
def download (self):
"""
Emit download signal
"""
self.Download.emit(self.url)
self.accept()
def onReject(self):
"""
Called on cancel
"""
self.DownloadCanceled.emit()
self.reject()
def updateDataReadProgress(self, bytesRead, totalBytes):
"""
Update the progress bar
@param bytesRead:
@type bytesRead:
@param totalBytes:
@type totalBytes:
"""
self.progressBar.setMaximum(totalBytes)
self.progressBar.setValue(bytesRead)
def createDialog(self):
"""
Create qt dialog
"""
self.setWindowTitle( "%s" % self.name )
layout = QVBoxLayout()
self.loadingLabel = QLabel("Loading...")
self.imageLabel = QLabel()
layout2 = QHBoxLayout()
layout2.addWidget( self.imageLabel )
layout2.addWidget( self.loadingLabel )
self.progressBar = QProgressBar(self)
self.progressBar.setMaximum(0)
self.progressBar.setProperty("value", 0)
self.progressBar.setAlignment(Qt.AlignCenter)
self.progressBar.setObjectName("progressBar")
buttonLayout = QHBoxLayout()
buttonLayout.addStretch()
self.okButton = QPushButton("Ok", self)
self.downloadButton = QPushButton("Download", self)
self.cancelButton = QPushButton("Cancel", self)
buttonLayout.addWidget(self.okButton)
buttonLayout.addWidget(self.downloadButton)
buttonLayout.addWidget(self.cancelButton)
self.okButton.clicked.connect(self.accept)
self.downloadButton.clicked.connect(self.download)
self.cancelButton.clicked.connect(self.onReject)
self.okButton.hide()
layout.addLayout(layout2)
layout.addWidget( self.progressBar )
layout.addLayout(buttonLayout)
self.setLayout(layout)
flags = Qt.WindowFlags()
flags |= Qt.WindowCloseButtonHint
flags |= Qt.MSWindowsFixedSizeDialogHint
self.setWindowFlags(flags)
class projectInfoWidget(infoWidget):
__master_url = ""
__projectCached = None
__mainLayout = None
__projectInfo = None
__projectInfoLayout = None
__projectSettings = None
#informacie o projekte
__masterUrlLabel = None
__masterUrlText = None
__projectNameLabel = None
__projectNameText = None
__userNameLabel = None
__userNameText = None
__teamNameLabel = None
__teamNameText = None
__userTotalCreditLabel = None
__userTotalCreditText = None
__hostTotalCreditLabel = None
__hostTotalCreditText = None
__suspendedLabel = None
__newTasksLabel = None
__projectLinksButton = None
__projectSettingsMenu = None
def __init__(self, client, project, parent = None):
infoWidget.__init__(self, client, parent)
self.__mainLayout = QGridLayout()
self.__mainLayout.setRowStretch(1, 1)
self.setMainLayout(self.__mainLayout)
self.__projectInfo = QGroupBox(self.tr("Project Info"));
self.__projectInfoLayout = QGridLayout()
self.__projectInfo.setLayout(self.__projectInfoLayout)
self.__projectSettings = QHBoxLayout()
self.__projectLinksButton = QToolButton()
self.__projectLinksButton.setText(self.tr("Project Links"))
self.__projectLinksButton.hide()
self.__updateProjectButton = QPushButton(self.tr("Update"))
self.__suspendProjectButton = QPushButton()
self.__allowNewTasksButton = QPushButton()
self.__resetProjectButton = QPushButton(self.tr("Reset project"))
self.__detachProjectButton = QPushButton(self.tr("Detach project"))
self.__resetProjectButton.setEnabled(False)
self.__detachProjectButton.setEnabled(False)
self.__updateProjectButton.hide()
self.__suspendProjectButton.hide()
self.__allowNewTasksButton.hide()
self.__resetProjectButton.hide()
self.__detachProjectButton.hide()
self.connect(self.__updateProjectButton, SIGNAL('clicked()'), self.__updateProject)
self.connect(self.__suspendProjectButton, SIGNAL('clicked()'), self.__suspendProject)
self.connect(self.__allowNewTasksButton, SIGNAL('clicked()'), self.__allowNewTasksProject)
self.__projectSettings.addWidget(self.__projectLinksButton)
self.__projectSettings.addWidget(self.__updateProjectButton)
self.__projectSettings.addWidget(self.__suspendProjectButton)
self.__projectSettings.addWidget(self.__allowNewTasksButton)
#self.__projectSettings.addStretch(1)
self.__projectAdmin = QHBoxLayout()
self.__projectAdmin.addWidget(self.__resetProjectButton)
self.__projectAdmin.addWidget(self.__detachProjectButton)
#self.__projectAdmin.addStretch(1)
self.__mainLayout.addWidget(self.__projectInfo, 0, 0)
self.__mainLayout.addLayout(self.__projectSettings, 2, 0)
self.__mainLayout.addLayout(self.__projectAdmin, 3, 0)
self.__masterUrlLabel = QLabel(self.tr("Master URL"))
self.__projectNameLabel = QLabel(self.tr("Project Name"))
self.__userNameLabel = QLabel(self.tr("User Name"))
self.__teamNameLabel = QLabel(self.tr("Team Name"))
self.__userTotalCreditLabel = QLabel(self.tr("Total User Credits"))
self.__hostTotalCreditLabel = QLabel(self.tr("Total Host Credits"))
self.__suspendedLabel = QLabel(self.tr("Suspended by user"))
self.__newTasksLabel = QLabel(self.tr("Won't get new tasks"))
self.__masterUrlText = QLabel()
self.__projectNameText = QLabel()
self.__userNameText = QLabel()
self.__teamNameText = QLabel()
self.__userTotalCreditText = QLabel()
self.__hostTotalCreditText = QLabel()
self.__masterUrlText.setTextFormat(Qt.PlainText)
self.__projectNameText.setTextFormat(Qt.PlainText)
self.__userNameText.setTextFormat(Qt.PlainText)
self.__teamNameText.setTextFormat(Qt.PlainText)
self.__userTotalCreditText.setTextFormat(Qt.PlainText)
self.__hostTotalCreditText.setTextFormat(Qt.PlainText)
self.__masterUrlLabel.hide()
self.__projectNameLabel.hide()
self.__userNameLabel.hide()
self.__teamNameLabel.hide()
self.__userTotalCreditLabel.hide()
self.__hostTotalCreditLabel.hide()
self.__masterUrlText.hide()
self.__projectNameText.hide()
self.__userNameText.hide()
self.__teamNameText.hide()
self.__userTotalCreditText.hide()
self.__hostTotalCreditText.hide()
self.__suspendedLabel.hide()
self.__newTasksLabel.hide()
self.__projectInfoLayout.addWidget(self.__masterUrlLabel, 0, 0)
self.__projectInfoLayout.addWidget(self.__projectNameLabel, 1, 0)
self.__projectInfoLayout.addWidget(self.__userNameLabel, 2, 0)
self.__projectInfoLayout.addWidget(self.__teamNameLabel, 3, 0)
self.__projectInfoLayout.addWidget(self.__userTotalCreditLabel, 4, 0)
self.__projectInfoLayout.addWidget(self.__hostTotalCreditLabel, 5, 0)
self.__projectInfoLayout.addWidget(self.__masterUrlText, 0, 1)
self.__projectInfoLayout.addWidget(self.__projectNameText, 1, 1)
self.__projectInfoLayout.addWidget(self.__userNameText, 2, 1)
self.__projectInfoLayout.addWidget(self.__teamNameText, 3, 1)
self.__projectInfoLayout.addWidget(self.__userTotalCreditText, 4, 1)
self.__projectInfoLayout.addWidget(self.__hostTotalCreditText, 5, 1)
self.__projectInfoLayout.addWidget(self.__suspendedLabel, 6, 0, 1, 2)
self.__projectInfoLayout.addWidget(self.__newTasksLabel, 7, 0, 1, 2)
self.__master_url = project.data(0, Qt.UserRole + 1).toString()
self.__projectCached = None
self.__projectSettingsMenu = QMenu()
self.__projectLinksButton.setPopupMode(QToolButton.InstantPopup)
self.__projectLinksButton.setMenu(self.__projectSettingsMenu)
projects = client.projectState()
if not projects is None:
self.updateProjects(projects)
self.connect(client, SIGNAL("projectState(PyQt_PyObject)"), self.updateProjects)
self.connect(client, SIGNAL("projectUpdateRecv(PyQt_PyObject)"), self.__updateProjectRecv)
self.connect(client, SIGNAL("projectSuspendRecv(PyQt_PyObject)"), self.__suspendProjectRecv)
self.connect(client, SIGNAL("projectResumeRecv(PyQt_PyObject)"), self.__resumeProjectRecv)
self.connect(client, SIGNAL("projectNomoreworkRecv(PyQt_PyObject)"), self.__nomoreworkProjectRecv)
self.connect(client, SIGNAL("projectAllowmoreworkRecv(PyQt_PyObject)"), self.__allowmoreworkProjectRecv)
def __updateProject(self):
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("Updating project"))
self.client().projectUpdate(self.__projectCached['master_url'])
def __suspendProject(self):
if self.__projectCached['suspended_via_gui']:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("Resuming project"))
self.client().projectResume(self.__projectCached['master_url'])
else:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("Suspending project"))
self.client().projectSuspend(self.__projectCached['master_url'])
def __allowNewTasksProject(self):
if self.__projectCached['dont_request_more_work']:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("Allowing new tasks"))
self.client().projectAllowmorework(self.__projectCached['master_url'])
else:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("Disallowing new tasks"))
self.client().projectNomorework(self.__projectCached['master_url'])
def __updateProjectRecv(self, status):
if status:
self.emit(SIGNAL("showStatusBarMsg(QString)"), status)
else:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("Project updated"))
self.client().getState()
def __suspendProjectRecv(self, status):
if status:
self.emit(SIGNAL("showStatusBarMsg(QString)"), status)
else:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("Project suspended"))
self.__projectCached['suspended_via_gui'] = 1
self.__suspendedLabel.show()
self.__suspendProjectButton.setText(self.tr("Resume"))
self.client().getState()
def __resumeProjectRecv(self, status):
if status:
self.emit(SIGNAL("showStatusBarMsg(QString)"), status)
else:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("Project restored"))
self.__projectCached['suspended_via_gui'] = 0
self.__suspendedLabel.hide()
self.__suspendProjectButton.setText(self.tr("Suspend"))
self.client().getState()
def __nomoreworkProjectRecv(self, status):
if status:
self.emit(SIGNAL("showStatusBarMsg(QString)"), status)
else:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("New tasks disallowed"))
self.__projectCached['dont_request_more_work'] = 1
self.__newTasksLabel.show()
self.__allowNewTasksButton.setText(self.tr("Allow new tasks"))
self.client().getState()
def __allowmoreworkProjectRecv(self, status):
if status:
self.emit(SIGNAL("showStatusBarMsg(QString)"), status)
else:
self.emit(SIGNAL("showStatusBarMsg(QString)"), self.tr("New tasks allowed"))
self.__projectCached['dont_request_more_work'] = 0
self.__newTasksLabel.hide()
self.__allowNewTasksButton.setText(self.tr("No new tasks"))
self.client().getState()
def __changeLabels(self, project, key, label, text):
try:
inf = project[key]
if type(inf) == type(u""):
text.setText(inf)
text.show()
label.show()
except KeyError:
text.hide()
label.hide()
def updateProjects(self, projects):
projects = projects['project']
project = None
for proj in projects:
if proj['master_url'] == self.__master_url:
project = proj
break
# ak sme nenasli projekt
if project is None:
return
if project != self.__projectCached:
self.__projectCached = project
try:
self.setTitle(titleFrame(project['project_name']))
except KeyError:
pass
self.__changeLabels(project, 'master_url', self.__masterUrlLabel, self.__masterUrlText)
self.__changeLabels(project, 'project_name', self.__projectNameLabel, self.__projectNameText)
self.__changeLabels(project, 'user_name', self.__userNameLabel, self.__userNameText)
self.__changeLabels(project, 'team_name', self.__teamNameLabel, self.__teamNameText)
self.__changeLabels(project, 'user_total_credit', self.__userTotalCreditLabel, self.__userTotalCreditText)
self.__changeLabels(project, 'host_total_credit', self.__hostTotalCreditLabel, self.__hostTotalCreditText)
if project['suspended_via_gui']:
self.__suspendProjectButton.setText(self.tr("Resume"))
self.__suspendedLabel.show()
else:
self.__suspendProjectButton.setText(self.tr("Suspend"))
self.__suspendedLabel.hide()
if project['dont_request_more_work']:
self.__allowNewTasksButton.setText(self.tr("Allow new tasks"))
self.__newTasksLabel.show()
else:
self.__allowNewTasksButton.setText(self.tr("No new tasks"))
self.__newTasksLabel.hide()
self.__updateProjectButton.show()
self.__suspendProjectButton.show()
self.__allowNewTasksButton.show()
self.__resetProjectButton.show()
self.__detachProjectButton.show()
try:
self.__projectSettingsMenu.clear()
guiUrls = project['gui_urls']['gui_url']
if type(guiUrls) == type({}):
self.__projectSettingsMenu.addAction(urlAction(guiUrls['url'], guiUrls['name'], guiUrls['description'], self.__projectSettingsMenu))
else:
for url in guiUrls:
self.__projectSettingsMenu.addAction(urlAction(url['url'], url['name'], url['description'], self.__projectSettingsMenu))
try:
ifTeamUrls = project['gui_urls']['ifteam']['gui_url']
self.__projectSettingsMenu.addSeparator()
if type(ifTeamUrls) == type({}):
self.__projectSettingsMenu.addAction(urlAction(ifTeamUrls['url'], ifTeamUrls['name'], ifTeamUrls['description'], self.__projectSettingsMenu))
else:
for url in ifTeamUrls:
self.__projectSettingsMenu.addAction(urlAction(url['url'], url['name'], url['description'], self.__projectSettingsMenu))
except KeyError, msg:
pass
self.__projectLinksButton.show()
except KeyError:
self.__projectLinksButton.hide()
class WizardDialog(QDialog):
"""The dialog for update."""
def __init__(self, main_window):
super(WizardDialog, self).__init__()
self.mw = main_window
vbox = QVBoxLayout(self)
# label and checkbox
self.main_text = QLabel(u"init text")
vbox.addWidget(self.main_text)
self.notthisagain = QCheckBox(u"No mostrar automáticamente esta ayuda")
nowizard = config.get('nowizard', False)
self.notthisagain.setCheckState(nowizard)
self.notthisagain.stateChanged.connect(self._notthisagain_toggled)
vbox.addWidget(self.notthisagain)
# buttons
bbox = QDialogButtonBox()
self.navbut_actn = QPushButton(u"init text")
bbox.addButton(self.navbut_actn, QDialogButtonBox.ActionRole)
self.navbut_prev = QPushButton(u"Anterior")
bbox.addButton(self.navbut_prev, QDialogButtonBox.ActionRole)
self.navbut_next = QPushButton(u"Siguiente")
bbox.addButton(self.navbut_next, QDialogButtonBox.ActionRole)
vbox.addWidget(bbox)
self.show()
self.step = 0
self._move(0)
def _notthisagain_toggled(self, state):
"""The "not this again" checkbutton togled state."""
logger.info("Configuring 'nowizard' to %s", state)
config['nowizard'] = state
def _move(self, delta_step):
"""The engine for the wizard steps."""
self.step += delta_step
logger.debug("Entering into step %d", self.step)
(text, ign_func, act_label, act_func) = STEPS[self.step]
# if this step should be ignored, just leave
if ign_func is not None:
m = getattr(self, "_ign_" + ign_func)
if m():
# keep going
return self._move(delta_step)
# adjust navigation buttons
if self.step == 0:
self.navbut_prev.setEnabled(False)
self.navbut_next.setText(u"Siguiente")
self.navbut_next.clicked.disconnect()
self.navbut_next.clicked.connect(lambda: self._move(1))
self.notthisagain.show()
elif self.step == len(STEPS) - 1:
self.navbut_prev.setEnabled(True)
self.navbut_prev.clicked.disconnect()
self.navbut_prev.clicked.connect(lambda: self._move(-1))
self.navbut_next.setText(u"Terminar")
self.navbut_next.clicked.disconnect()
self.navbut_next.clicked.connect(self.accept)
self.notthisagain.hide()
else:
self.navbut_prev.setEnabled(True)
self.navbut_prev.clicked.disconnect()
self.navbut_prev.clicked.connect(lambda: self._move(-1))
self.navbut_next.setText(u"Siguiente")
self.navbut_next.clicked.disconnect()
self.navbut_next.clicked.connect(lambda: self._move(1))
self.notthisagain.hide()
# adjust main text and action button
if self.step == len(STEPS) - 1:
if self.mw.have_metadata() and self.mw.have_config():
self.main_text.setText(TEXT_HAPPY_END)
else:
self.main_text.setText(TEXT_SAD_END)
else:
self.main_text.setText(text)
if act_label is None:
self.navbut_actn.hide()
else:
self.navbut_actn.show()
self.navbut_actn.setText(act_label)
method_to_call = getattr(self, "_act_" + act_func)
self.navbut_actn.clicked.disconnect()
self.navbut_actn.clicked.connect(method_to_call)
def _act_configure(self, _):
"""Open the config dialog."""
self.mw.open_preferences()
def _act_update(self, *a):
"""Open the update dialog."""
self.mw.refresh_episodes()
def _ign_episode(self):
"""Tell if the episode step should be ignored."""
return self.mw.have_metadata()
def _ign_config(self):
"""Tell if the configure step should be ignored."""
return self.mw.have_config()
class SettingsManager(QDialog):
def __init__(self, num, n, parent=None):
super(SettingsManager, self).__init__(parent)
#main
self.par = n
title = Settingz().positions(num)
self.titleID = title['id']
self.titleIDx = str(title['id']) + 'x'
self.titlePage = title['page']
self.titleName = title['name']
self.titleSub = title['subID']
self.titleIcon = title['icon']
self.pagetitle = self.titlePage
self.sessionMain = 0
#stylesheet
stylesheet = Valid().background() + Valid().font()
treeStyleSheet = Valid().treez()
self.groupBox1 = QGroupBox(self.titleName)
self.groupBox2 = QGroupBox('Add')
#items
self.tree = QTreeWidget()
self.tree.setHeaderLabel("Choose " + self.titleName)
self.tree.headerItem().setText(0, 'Name')
self.tree.headerItem().setText(1, 'Abbrv.')
self.tree.setStyleSheet(treeStyleSheet)
self.makeTree()
self.tree.setMinimumHeight(250)
self.tree.clicked.connect(lambda: self.getSelection())
self.tree.itemClicked.connect(lambda state: self.getChecked(state))
#buttons
#add
nImg = Buttons().addButton()
self.pb = QPushButton()
self.pb.setFlat(True)
self.pb.setIcon(QIcon(nImg))
self.pb.setMaximumHeight(30)
self.pb.setMaximumWidth(30)
nImg1 = Buttons().closeButton()
self.pb1 = QPushButton()
self.pb1.setFlat(True)
self.pb1.setIcon(QIcon(nImg1))
self.pb1.setMaximumHeight(30)
self.pb1.setMaximumWidth(30)
nImg2 = Buttons().editButton()
self.pb2 = QPushButton()
self.pb2.setFlat(True)
self.pb2.setIcon(QIcon(nImg2))
self.pb2.setMaximumHeight(30)
self.pb2.setMaximumWidth(30)
nImg3 = Buttons().deleteButton()
self.pb3 = QPushButton()
self.pb3.setFlat(True)
self.pb3.setIcon(QIcon(nImg3))
self.pb3.setMaximumHeight(30)
self.pb3.setMaximumWidth(30)
nImg4 = Buttons().saveButton()
self.pb4 = QPushButton()
self.pb4.setFlat(True)
self.pb4.setIcon(QIcon(nImg4))
self.pb4.setMaximumHeight(30)
self.pb4.setMaximumWidth(30)
nImg5 = Buttons().resetButton()
self.pb5 = QPushButton()
self.pb5.setFlat(True)
self.pb5.setIcon(QIcon(nImg5))
self.pb5.setMaximumHeight(30)
self.pb5.setMaximumWidth(30)
nImg6 = Buttons().closeButton()
self.pb6 = QPushButton()
self.pb6.setFlat(True)
self.pb6.setIcon(QIcon(nImg6))
self.pb6.setMaximumHeight(30)
self.pb6.setMaximumWidth(30)
nImg7 = Buttons().addButton()
self.pb7 = QPushButton()
self.pb7.setFlat(True)
self.pb7.setIcon(QIcon(nImg7))
self.pb7.setMaximumHeight(30)
self.pb7.setMaximumWidth(30)
hbo = QHBoxLayout()
hbo.addStretch()
hbo.addWidget(self.pb1)
hbo.addWidget(self.pb3)
hbo.addWidget(self.pb2)
hbo.addWidget(self.pb7)
vbo = QVBoxLayout()
vbo.addWidget(self.tree)
vbo.addLayout(hbo)
self.l1 = QLabel("Name")
self.le1 = QLineEdit()
self.le1.setObjectName("name")
vals1 = Valid().fullText()
self.le1.setValidator(vals1)
self.le1.setPlaceholderText("Lowercase max 25 letters")
self.l2 = QLabel("Abbrv")
self.le2 = QLineEdit()
self.le2.setObjectName("abbrv")
vals2 = Valid().limitText()
self.le2.setValidator(vals2)
self.le2.setPlaceholderText("Lowercase max 5 letters")
FormLayout = QFormLayout()
FormLayout.addRow(self.l1, self.le1)
FormLayout.addRow(self.l2, self.le2)
Hlayout1 = QHBoxLayout()
Hlayout1.addStretch()
Hlayout1.addWidget(self.pb6)
Hlayout1.addWidget(self.pb5)
Hlayout1.addWidget(self.pb4)
Hlayout1.addWidget(self.pb)
Vlayout1 = QVBoxLayout()
Vlayout1.addLayout(FormLayout)
Vlayout1.addLayout(Hlayout1)
self.groupBox1.setLayout(vbo)
self.groupBox2.setLayout(Vlayout1)
self.groupBox2.hide()
self.connect(self.pb, SIGNAL("clicked()"),
lambda: self.button_add()) #add
self.connect(self.pb1, SIGNAL("clicked()"),
lambda: self.button_close()) #close
self.connect(self.pb2, SIGNAL("clicked()"),
lambda: self.button_edit()) #edit
self.connect(self.pb3, SIGNAL("clicked()"),
lambda: self.button_delete()) #delete
self.connect(self.pb4, SIGNAL("clicked()"),
lambda: self.button_save()) #save
self.connect(self.pb5, SIGNAL("clicked()"),
lambda: self.button_reset()) #reset
self.pb4.hide()
self.pb7.hide()
grid = QGridLayout()
grid.addWidget(self.groupBox1, 0, 0)
grid.addWidget(self.groupBox2, 1, 0)
self.setLayout(grid)
self.setStyleSheet(stylesheet)
self.setWindowIcon(QIcon(self.titleIcon))
self.setWindowTitle(self.pagetitle)
def makeTree(self):
self.tree.clear()
arr = Valid().pullData('datas', '', {'pubID': self.titleID})
self.hold_data = {}
self.hold_mdata = {}
self.hold_data_add = {}
self.hold_data_add_item = {}
if self.titleSub and self.titleSub > 0:
if arr and len(arr) > 0:
for val in arr:
ch = Valid().pullData('datas', '', {'subID': val['id']})
child = QTreeWidgetItem(self.tree)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, str(val['name']).upper())
child.setText(1, str(val['abbrv']).upper())
self.hold_data[val['id']] = child
self.hold_mdata[val['id']] = child
if (val['active'] == 0):
child.setCheckState(0, Qt.Checked)
else:
child.setCheckState(0, Qt.Unchecked)
for va in ch:
child1 = QTreeWidgetItem(child)
child1.setFlags(child1.flags()
| Qt.ItemIsUserCheckable)
child1.setText(0, str(va['name']).upper())
child1.setText(1, str(va['abbrv']).upper())
self.hold_data[va['id']] = child1
if (va['active'] == 0):
child1.setCheckState(0, Qt.Checked)
else:
child1.setCheckState(0, Qt.Unchecked)
child1 = QTreeWidgetItem(child)
child1.setFlags(child1.flags() | Qt.ItemIsUserCheckable)
child1.setText(0, 'Add New Item')
self.hold_data_add_item[val['id']] = child1
else:
if arr and len(arr) > 0:
for val in arr:
child = QTreeWidgetItem(self.tree)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, str(val['name']).upper())
child.setText(1, str(val['abbrv']).upper())
self.hold_data[val['id']] = child
if (val['active'] == 0):
child.setCheckState(0, Qt.Checked)
else:
child.setCheckState(0, Qt.Unchecked)
child = QTreeWidgetItem(self.tree)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, 'Add New')
self.hold_data_add['addnew'] = child
def getChecked(self, a):
g = Db()
for i in self.hold_data:
if self.hold_data[i].checkState(0) == Qt.Checked:
g.update('datas', {'active': 0}, {'id': i})
else:
g.update('datas', {'active': 1}, {'id': i})
if self.titleID == 1:
#if class was changed only reload class menu on main window
self.par.menuStudent()
self.par.dropdownStudent()
def getSelected(self):
r = None
k = None
for i in self.hold_data:
if self.hold_data[i].isSelected():
r = i
for j in self.hold_mdata:
if self.hold_mdata[j].isSelected():
k = j
if r and r > 0:
if r == k:
self.sessionMain = r
else:
self.sessionMain = 0
self.groupBox2.show()
return r
else:
self.groupBox2.hide()
def getSelection(self):
self.le1.clear()
self.le2.clear()
if self.hold_data_add['addnew'].isSelected():
self.sessionMain = 0
self.groupBox2.setTitle('Add New')
self.groupBox2.show()
else:
r = None
for i in self.hold_data_add_item:
if self.hold_data_add_item[i].isSelected():
r = i
if r:
self.sessionMain = r
g = Db()
v = g.selectn('datas', '', 1, {'id': r})
vname = str(v['name']).upper()
self.groupBox2.setTitle('ADD ' + str(vname) + ' ITEM')
self.groupBox2.show()
else:
self.groupBox2.setTitle('Add')
self.groupBox2.hide()
def setActive(self):
g = Db()
for i in self.hold_data:
if self.hold_data[i].checkState(0) == Qt.Checked:
g.update('datas', {'active': 0}, {'id': i})
else:
g.update('datas', {'active': 1}, {'id': i})
def button_add(self):
s1 = self.le1.text()
s2 = self.le2.text()
g = Db()
try:
if (len(s1) > 0) and (len(s2) > 0):
if self.sessionMain == 0:
y = {
'name': s1.lower(),
'abbrv': s2.lower(),
'pubID': self.titleID,
'active': 0
}
else:
y = {
'name': s1.lower(),
'abbrv': s2.lower(),
'subID': self.sessionMain,
'pubID': self.titleIDx,
'active': 0
}
g.insert('datas', y)
self.makeTree()
self.button_reset()
if self.titleID == 1:
#if class was changed only relod class menu on main window
self.par.menuStudent()
self.par.dropdownStudent()
else:
pass
except:
pass
def button_save(self):
row = self.editrow
s1 = self.le1.text()
s2 = self.le2.text()
g = Db()
try:
if (len(s1) > 0) and (len(s2) > 0) and row and row > 0:
y = {'name': s1.lower(), 'abbrv': s2.lower(), 'active': 0}
z = {'id': row}
g.update('datas', y, z)
self.makeTree()
self.button_reset()
if self.titleID == 1:
#if class was changed only relod class menu on main window
self.par.menuStudent()
self.par.dropdownStudent()
else:
pass
except:
pass
def button_delete(self):
row = self.getSelected()
g = Db()
try:
if row and row > 0:
y = {'abbrv': '', 'active': 2}
z = {'id': row}
g.update('datas', y, z)
self.makeTree()
else:
pass
except:
pass
def button_reset(self):
self.le1.clear()
self.le2.clear()
self.groupBox2.setTitle('Add')
self.groupBox2.hide()
self.pb.show()
self.pb4.hide()
self.sessionMain = 0
def button_edit(self):
row = self.getSelected()
self.sessionMain = 0
if row:
self.groupBox2.setTitle('Edit')
self.editrow = row
g = Db()
data = g.selectn('datas', '', 1, {'id': row})
if self.titleID == data['pubID']:
self.sessionMain = 1
else:
self.sessionMain = 0
try:
self.le1.setText(data['name'])
except:
self.le1.setText('')
try:
self.le2.setText(data['abbrv'])
except:
self.le2.setText('')
self.pb.hide()
self.pb4.show()
def button_close(self):
self.close()
class phonesDialog(QDialog):
def __init__(self, parent):
QDialog.__init__(self, parent)
self.prm = self.parent().prm
self.currLocale = self.parent().prm['currentLocale']
self.currLocale.setNumberOptions(
self.currLocale.OmitGroupSeparator
| self.currLocale.RejectGroupSeparator)
screen = QDesktopWidget().screenGeometry()
self.resize(screen.width() / 2.5, screen.height() / 3)
self.isPlaying = False
#self.audioManager = audioManager(self)
#self.playThread = threadedPlayer(self)
self.sizer = QGridLayout()
self.v1Sizer = QVBoxLayout()
self.v2Sizer = QVBoxLayout()
self.calibSizer = QGridLayout()
self.phonesTableWidget = QTableWidget()
self.phonesTableWidget.setColumnCount(4)
self.phonesTableWidget.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.phonesTableWidget.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.phonesTableWidget.setHorizontalHeaderLabels([
self.tr('Phones'),
self.tr('Max Level'),
self.tr('Default'), 'id'
])
self.phonesTableWidget.hideColumn(3)
self.phonesTableWidget.cellDoubleClicked[int, int].connect(
self.onCellDoubleClicked)
#RENAME Phones BUTTON
self.renamePhonesButton = QPushButton(self.tr("Rename Phones"), self)
self.renamePhonesButton.clicked.connect(self.onEditLabel)
#Change Level Phones BUTTON
self.changeLevelPhonesButton = QPushButton(self.tr("Change Max Level"),
self)
self.changeLevelPhonesButton.clicked.connect(self.onEditMaxLevel)
#ADD Phones BUTTON
self.addPhonesButton = QPushButton(self.tr("Add Phones"), self)
self.addPhonesButton.clicked.connect(self.onClickAddPhonesButton)
#REMOVE Phones BUTTON
self.removePhonesButton = QPushButton(self.tr("Remove Phones"), self)
self.removePhonesButton.clicked.connect(self.onClickRemovePhonesButton)
#Set Default Phones BUTTON
self.setDefaultPhonesButton = QPushButton(self.tr("Set Default"), self)
self.setDefaultPhonesButton.clicked.connect(self.onEditDefault)
self.v1Sizer.addWidget(self.renamePhonesButton)
self.v1Sizer.addWidget(self.changeLevelPhonesButton)
self.v1Sizer.addWidget(self.addPhonesButton)
self.v1Sizer.addWidget(self.removePhonesButton)
self.v1Sizer.addWidget(self.setDefaultPhonesButton)
self.v1Sizer.addStretch()
self.phonesList = {}
for i in range(len(self.prm['phones']['phonesChoices'])):
currCount = i + 1
thisID = self.prm['phones']['phonesID'][i]
self.phonesList[thisID] = {}
self.phonesList[thisID]['label'] = self.prm['phones'][
'phonesChoices'][i]
self.phonesList[thisID]['maxLevel'] = self.prm['phones'][
'phonesMaxLevel'][i]
self.phonesList[thisID]['default'] = self.prm['phones'][
'defaultPhones'][i]
self.phonesTableWidget.setRowCount(currCount)
newItem = QTableWidgetItem(self.phonesList[thisID]['label'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 0, newItem)
newItem = QTableWidgetItem(
self.currLocale.toString(self.phonesList[thisID]['maxLevel']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 1, newItem)
newItem = QTableWidgetItem(self.phonesList[thisID]['default'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 2, newItem)
self.phonesList[thisID]['qid'] = QTableWidgetItem(thisID)
self.phonesTableWidget.setItem(currCount - 1, 3,
self.phonesList[thisID]['qid'])
##CALIBRATION TONE
n = 0
self.calLabel = QLabel(self.tr('Calibration Tone:'), self)
self.calibSizer.addWidget(self.calLabel, n, 0, 1, 2)
n = n + 1
self.toneFreqLabel = QLabel(self.tr('Frequency (Hz)'), self)
self.toneFreqTF = QLineEdit("1000")
self.toneFreqTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneFreqLabel, n, 0)
self.calibSizer.addWidget(self.toneFreqTF, n, 1)
n = n + 1
self.toneLevLabel = QLabel(self.tr('Level (dB)'), self)
self.toneLevTF = QLineEdit("60")
self.toneLevTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneLevLabel, n, 0)
self.calibSizer.addWidget(self.toneLevTF, n, 1)
n = n + 1
self.toneDurLabel = QLabel(self.tr('Duration (ms)'), self)
self.toneDurTF = QLineEdit("980")
self.toneDurTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneDurLabel, n, 0)
self.calibSizer.addWidget(self.toneDurTF, n, 1)
n = n + 1
self.toneRampsLabel = QLabel(self.tr('Ramps (ms)'), self)
self.toneRampsTF = QLineEdit("10")
self.toneRampsTF.setValidator(QDoubleValidator(self))
self.calibSizer.addWidget(self.toneRampsLabel, n, 0)
self.calibSizer.addWidget(self.toneRampsTF, n, 1)
n = n + 1
self.earLabel = QLabel(self.tr('Ear:'), self)
self.earChooser = QComboBox()
self.earChooser.addItems(
[self.tr("Right"),
self.tr("Left"),
self.tr("Both")])
self.calibSizer.addWidget(self.earLabel, n, 0)
self.calibSizer.addWidget(self.earChooser, n, 1)
n = n + 1
self.playCalibButton = QPushButton(self.tr("Play"), self)
self.playCalibButton.clicked.connect(self.onClickPlayCalibButton)
self.playCalibButton.setIcon(
QIcon.fromTheme("media-playback-start",
QIcon(":/media-playback-start")))
self.calibSizer.addWidget(self.playCalibButton, n, 0, 1, 2)
n = n + 1
self.stopCalibButton = QPushButton(self.tr("Stop"), self)
self.stopCalibButton.clicked.connect(self.onClickStopCalibButton)
self.stopCalibButton.setIcon(
QIcon.fromTheme("media-playback-stop",
QIcon(":/media-playback-stop")))
self.calibSizer.addWidget(self.stopCalibButton, n, 0, 1, 2)
if self.prm['pref']['sound']['playCommand'] in [
"alsaaudio", "pyaudio"
]:
self.stopCalibButton.show()
else:
self.stopCalibButton.hide()
buttonBox = QDialogButtonBox(QDialogButtonBox.Apply
| QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
buttonBox.button(QDialogButtonBox.Apply).clicked.connect(
self.permanentApply)
self.sizer.addLayout(self.v1Sizer, 0, 0)
self.v2Sizer.addLayout(self.calibSizer)
self.v2Sizer.addStretch()
self.sizer.addWidget(self.phonesTableWidget, 0, 1)
self.sizer.addLayout(self.v2Sizer, 0, 2)
self.sizer.addWidget(buttonBox, 1, 1, 1, 2)
self.sizer.setColumnStretch(1, 2)
self.setLayout(self.sizer)
self.setWindowTitle(self.tr("Edit Phones"))
self.show()
def onCellDoubleClicked(self, row, col):
if col == 0:
self.onEditLabel()
elif col == 1:
self.onEditMaxLevel()
elif col == 2:
self.onEditDefault()
def onEditLabel(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one label can be renamed at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
msg = self.tr('New name:')
text, ok = QInputDialog.getText(self, self.tr('Input Dialog'), msg)
if ok:
self.phonesTableWidget.item(
self.phonesList[selectedSound]['qid'].row(),
0).setText(text)
self.phonesList[selectedSound]['label'] = text
def onEditMaxLevel(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
msg = self.tr('Level:')
text, ok = QInputDialog.getDouble(
self, self.tr('Input Dialog'), msg,
self.phonesList[selectedSound]['maxLevel'])
if ok:
self.phonesTableWidget.item(
self.phonesList[selectedSound]['qid'].row(),
1).setText(self.currLocale.toString(text))
self.phonesList[selectedSound]['maxLevel'] = text
def onEditDefault(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one item can be edited at a time'))
elif len(ids) < 1:
pass
else:
selectedSound = ids[0]
for i in range(self.phonesTableWidget.rowCount()):
self.phonesTableWidget.item(i, 2).setText("\u2012")
self.phonesList[str(self.phonesTableWidget.item(
i, 3).text())]['default'] = "\u2012"
self.phonesTableWidget.item(
self.phonesList[selectedSound]['qid'].row(),
2).setText("\u2713")
self.phonesList[selectedSound]['default'] = "\u2713"
def findSelectedItemIds(self):
selItems = self.phonesTableWidget.selectedItems()
selItemsRows = []
for i in range(len(selItems)):
selItemsRows.append(selItems[i].row())
selItemsRows = unique(selItemsRows)
selItemsIds = []
for i in range(len(selItemsRows)):
selItemsIds.append(
str(self.phonesTableWidget.item(selItemsRows[i], 3).text()))
return selItemsIds
def permanentApply(self):
self.prm['phones']['phonesChoices'] = []
self.prm['phones']['phonesMaxLevel'] = []
self.prm['phones']['defaultPhones'] = []
self.prm['phones']['phonesID'] = []
keys = sorted(self.phonesList.keys())
for key in keys:
self.prm['phones']['phonesChoices'].append(
str(self.phonesList[key]['label']))
self.prm['phones']['phonesMaxLevel'].append(
self.phonesList[key]['maxLevel'])
self.prm['phones']['defaultPhones'].append(
self.phonesList[key]['default'])
self.prm['phones']['phonesID'].append(key)
f = open(self.parent().prm['phonesPrefFile'], 'wb')
pickle.dump(self.parent().prm['phones'], f)
f.close()
for i in range(self.parent().phonesChooser.count()):
self.parent().phonesChooser.removeItem(0)
self.parent().phonesChooser.addItems(
self.prm['phones']['phonesChoices'])
def onClickAddPhonesButton(self):
keys = sorted(self.phonesList.keys())
thisID = str(int(keys[-1]) + 1)
currCount = self.phonesTableWidget.rowCount() + 1
self.phonesList[thisID] = {}
self.phonesList[thisID]['label'] = 'Phones' + ' ' + str(currCount)
self.phonesList[thisID]['maxLevel'] = 100
self.phonesList[thisID]['default'] = "\u2012"
self.phonesTableWidget.setRowCount(currCount)
newItem = QTableWidgetItem(self.phonesList[thisID]['label'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 0, newItem)
newItem = QTableWidgetItem(
self.currLocale.toString(self.phonesList[thisID]['maxLevel']))
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 1, newItem)
newItem = QTableWidgetItem(self.phonesList[thisID]['default'])
newItem.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.phonesTableWidget.setItem(currCount - 1, 2, newItem)
self.phonesList[thisID]['qid'] = QTableWidgetItem(thisID)
self.phonesTableWidget.setItem(currCount - 1, 3,
self.phonesList[thisID]['qid'])
def onClickRemovePhonesButton(self):
if self.phonesTableWidget.rowCount() == 1:
ret = QMessageBox.warning(
self, self.tr("Warning"),
self.tr("Only one phone left. Cannot remove!"), QMessageBox.Ok)
else:
ids = self.findSelectedItemIds()
wasDefault = False
for i in range(len(ids)):
selectedPhones = ids[i]
if self.phonesTableWidget.item(
self.phonesList[selectedPhones]['qid'].row(),
2).text() == "\u2713":
wasDefault = True
self.phonesTableWidget.removeRow(
self.phonesList[selectedPhones]['qid'].row())
del self.phonesList[selectedPhones]
if wasDefault == True:
self.phonesTableWidget.item(0, 2).setText("\u2713")
self.phonesList[str(self.phonesTableWidget.item(
0, 3).text())]['default'] = "\u2713"
def onClickPlayCalibButton(self):
ids = self.findSelectedItemIds()
if len(ids) > 1:
QMessageBox.warning(
self, self.tr('Warning'),
self.tr('Only one label can be renamed at a time'))
return
elif len(ids) < 1:
QMessageBox.warning(self, self.tr('Warning'),
self.tr('Please, select a phone in the table'))
return
else:
selectedSound = ids[0]
calMaxLev = self.phonesList[selectedSound]['maxLevel']
frequency = self.currLocale.toDouble(self.toneFreqTF.text())[0]
level = self.currLocale.toDouble(self.toneLevTF.text())[0]
duration = self.currLocale.toDouble(self.toneDurTF.text())[0]
ramp = self.currLocale.toDouble(self.toneRampsTF.text())[0]
channel = self.earChooser.currentText()
fs = self.currLocale.toInt(self.parent().sampRateTF.text())[0]
nBits = self.currLocale.toInt(
self.parent().nBitsChooser.currentText())[0]
calTone = pureTone(frequency, 0, level, duration, ramp, channel,
fs, calMaxLev)
self.isPlaying = True
if self.prm['pref']['sound']['playCommand'] in [
"alsaaudio", "pyaudio"
]:
self.playThread = threadedAudioPlayer(self.parent())
else:
self.playThread = threadedExternalAudioPlayer(self.parent())
self.playThread.playThreadedSound(
calTone, fs, nBits, self.prm['pref']['sound']['playCommand'],
True, 'calibrationTone.wav')
if self.playThread.isFinished() == True:
self.isPlaying = False
def onClickStopCalibButton(self):
if self.isPlaying == True:
self.playThread.terminate()
#self.playThread.__del__()
def closeEvent(self, event):
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
event.accept()
def accept(self): #reimplement accept (i.e. ok button)
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
QDialog.accept(self)
def reject(self): #reimplement reject
if self.isPlaying == True:
#self.playThread.__del__()
self.playThread.terminate()
QDialog.reject(self)
class SessionsManager(QDialog):
def __init__(self, n, parent=None):
super(SessionsManager, self).__init__(parent)
self.par = n
#main
title = Settingz().positions(30)
self.titleID = title['id']
self.titlePage = title['page']
self.titleName = title['name']
self.titleSub = title['subID']
self.titleIcon = title['icon']
self.pagetitle = self.titlePage
#stylesheet
stylesheet = Valid().background() + Valid().font()
treeStyleSheet = Valid().treez()
self.groupBox1 = QGroupBox(self.titleName)
self.groupBox2 = QGroupBox('Add')
#items
self.tree = QTreeWidget()
self.tree.setHeaderLabel("Choose " + self.titleName)
#tree.setItemDelegate(Delegate())
self.tree.setItemDelegate(Delegates())
self.tree.headerItem().setText(0, 'Name')
self.tree.setStyleSheet(treeStyleSheet)
self.makeTree()
self.tree.setMinimumHeight(250)
self.tree.clicked.connect(lambda: self.getSelection())
self.tree.itemClicked.connect(lambda state: self.getChecked(state))
#buttons
#add
nImg = Buttons().addButton()
self.pb = QPushButton()
self.pb.setFlat(True)
self.pb.setIcon(QIcon(nImg))
self.pb.setMaximumHeight(30)
self.pb.setMaximumWidth(30)
nImg1 = Buttons().closeButton()
self.pb1 = QPushButton()
self.pb1.setFlat(True)
self.pb1.setIcon(QIcon(nImg1))
self.pb1.setMaximumHeight(30)
self.pb1.setMaximumWidth(30)
nImg2 = Buttons().editButton()
self.pb2 = QPushButton()
self.pb2.setFlat(True)
self.pb2.setIcon(QIcon(nImg2))
self.pb2.setMaximumHeight(30)
self.pb2.setMaximumWidth(30)
nImg3 = Buttons().deleteButton()
self.pb3 = QPushButton()
self.pb3.setFlat(True)
self.pb3.setIcon(QIcon(nImg3))
self.pb3.setMaximumHeight(30)
self.pb3.setMaximumWidth(30)
nImg4 = Buttons().saveButton()
self.pb4 = QPushButton()
self.pb4.setFlat(True)
self.pb4.setIcon(QIcon(nImg4))
self.pb4.setMaximumHeight(30)
self.pb4.setMaximumWidth(30)
nImg5 = Buttons().resetButton()
self.pb5 = QPushButton()
self.pb5.setFlat(True)
self.pb5.setIcon(QIcon(nImg5))
self.pb5.setMaximumHeight(30)
self.pb5.setMaximumWidth(30)
nImg6 = Buttons().closeButton()
self.pb6 = QPushButton()
self.pb6.setFlat(True)
self.pb6.setIcon(QIcon(nImg6))
self.pb6.setMaximumHeight(30)
self.pb6.setMaximumWidth(30)
nImg7 = Buttons().addButton()
self.pb7 = QPushButton()
self.pb7.setFlat(True)
self.pb7.setIcon(QIcon(nImg7))
self.pb7.setMaximumHeight(30)
self.pb7.setMaximumWidth(30)
hbo = QHBoxLayout()
hbo.addStretch()
hbo.addWidget(self.pb1)
hbo.addWidget(self.pb3)
hbo.addWidget(self.pb2)
hbo.addWidget(self.pb7)
vbo = QVBoxLayout()
vbo.addWidget(self.tree)
vbo.addLayout(hbo)
self.l1 = QLabel("Name")
self.le1 = QLineEdit()
self.le1.setObjectName("name")
vals1 = Valid().fullNum()
self.le1.setValidator(vals1)
self.le1.setPlaceholderText("Lowercase max 25 letters")
self.fromLbl = QLabel("Starts")
self.toLbl = QLabel("Ends")
self.fromData = QDateEdit()
self.toData = QDateEdit()
currentDate = QDate()
self.fromData.setDate(currentDate.currentDate())
self.fromData.setCalendarPopup(True)
self.toData.setDate(currentDate.currentDate())
self.toData.setCalendarPopup(True)
FormLayout = QFormLayout()
FormLayout.addRow(self.l1, self.le1)
FormLayout.addRow(self.fromLbl, self.fromData)
FormLayout.addRow(self.toLbl, self.toData)
Hlayout1 = QHBoxLayout()
Hlayout1.addStretch()
Hlayout1.addWidget(self.pb6)
Hlayout1.addWidget(self.pb5)
Hlayout1.addWidget(self.pb4)
Hlayout1.addWidget(self.pb)
Vlayout1 = QVBoxLayout()
Vlayout1.addLayout(FormLayout)
Vlayout1.addLayout(Hlayout1)
self.groupBox1.setLayout(vbo)
self.groupBox2.setLayout(Vlayout1)
self.groupBox2.hide()
self.connect(self.pb, SIGNAL("clicked()"),
lambda: self.button_add()) #add
self.connect(self.pb1, SIGNAL("clicked()"),
lambda: self.button_close()) #close
self.connect(self.pb2, SIGNAL("clicked()"),
lambda: self.button_edit()) #edit
self.connect(self.pb3, SIGNAL("clicked()"),
lambda: self.button_delete()) #delete
self.connect(self.pb4, SIGNAL("clicked()"),
lambda: self.button_save()) #save
self.connect(self.pb5, SIGNAL("clicked()"),
lambda: self.button_reset()) #reset
self.pb4.hide()
self.pb7.hide()
grid = QGridLayout()
grid.addWidget(self.groupBox1, 0, 0)
grid.addWidget(self.groupBox2, 1, 0)
self.setLayout(grid)
self.setStyleSheet(stylesheet)
self.setWindowIcon(QIcon(self.titleIcon))
self.setWindowTitle(self.pagetitle)
def makeTree(self):
self.tree.clear()
arr = Db().selectn('session', '', 5)
self.hold_data = {}
self.hold_mdata = {}
self.hold_data_add = {}
self.hold_data_add_item = {}
current = time.time()
if self.titleSub and self.titleSub > 0:
if arr and len(arr) > 0:
for val in arr:
ch = Valid().pullData('terms', '',
{'sessionID': val['id']})
child = QTreeWidgetItem(self.tree)
child.setIcon(0, QIcon('icons.cfolder.png'))
try:
ts = int(float(val['start_date']))
except:
ts = int(current)
ts = datetime.utcfromtimestamp(ts).strftime('%d-%m-%Y')
try:
ts1 = int(float(val['end_date']))
except:
ts1 = int(current)
ts1 = datetime.utcfromtimestamp(ts1).strftime('%d-%m-%Y')
child.setText(
0,
str(val['name']).upper() + " - " + ts + " " + ts1)
self.hold_mdata[val['id']] = child
for va in ch:
child1 = QTreeWidgetItem(child)
child1.setFlags(child1.flags()
| Qt.ItemIsUserCheckable)
try:
ts2 = int(float(va['start_date']))
except:
ts2 = int(current)
ts2 = datetime.utcfromtimestamp(ts2).strftime(
'%d-%m-%Y')
try:
ts3 = int(float(va['end_date']))
except:
ts3 = int(current)
ts3 = datetime.utcfromtimestamp(ts3).strftime(
'%d-%m-%Y')
child1.setText(
0,
str(va['name']).upper() + " " + ts2 + " " + ts3)
self.hold_data[va['id']] = child1
if (va['active'] == 1):
child1.setCheckState(0, Qt.Checked)
else:
child1.setCheckState(0, Qt.Unchecked)
child1 = QTreeWidgetItem(child)
child1.setFlags(child1.flags() | Qt.ItemIsUserCheckable)
child1.setText(0, 'Add New Term')
self.hold_data_add_item[val['id']] = child1
else:
if arr and len(arr) > 0:
for val in arr:
child = QTreeWidgetItem(self.tree)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, str(val['name']).upper())
child.setText(1, str(val['abbrv']).upper())
self.hold_data[val['id']] = child
if (val['active'] == 0):
child.setCheckState(0, Qt.Checked)
else:
child.setCheckState(0, Qt.Unchecked)
child = QTreeWidgetItem(self.tree)
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, 'Add New Session')
self.hold_data_add['addnew'] = child
def getChecked(self, a):
arr_hold = []
g = Db()
for i in self.hold_data:
if self.hold_data[i].checkState(0) == Qt.Checked:
arr_hold.append(i)
self.hold_data[i].setCheckState(0, Qt.Checked)
g.update('terms', {'active': 0}, {'active': 1})
g.update('terms', {'active': 1}, {'id': i})
tt = g.selectn('terms', '', 1, {'id': i})
g.update('session', {'active': 0}, {'active': 1})
g.update('session', {'active': 1}, {'id': tt['sessionID']})
g.selectn('session', '', 1, {'id': tt['sessionID']})
else:
self.hold_data[i].setCheckState(0, Qt.Unchecked)
self.reloadTerm()
def reloadTerm(self):
session = self.par.activeTerm()
activeTerm = str(session[1]) + ' SESSION ' + str(session[3]) + ' TERM'
self.par.majorSession = session[2]
self.par.lbl.setText(activeTerm)
def getSelected(self):
r = False
self.sessionMain = False
for i in self.hold_mdata:
if self.hold_mdata[i].isSelected():
r = i
if r and r > 0:
self.groupBox2.show()
self.sessionMain = True
return r
else:
for i in self.hold_data:
if self.hold_data[i].isSelected():
r = i
if r and r > 0:
self.sessionMain = False
self.groupBox2.show()
return r
else:
self.groupBox2.hide()
def getSession(self):
self.sessionID = None
for i in self.hold_data_session:
if self.hold_data_session[i].isSelected():
r = i
if r and r > 0:
self.sessionID = r
def getSelection(self):
self.le1.clear()
currentDate = QDate()
self.fromData.setDate(currentDate.currentDate())
self.toData.setDate(currentDate.currentDate())
self.sessionMain = False
if self.hold_data_add['addnew'].isSelected():
self.groupBox2.setTitle('Add New')
self.groupBox2.show()
self.sessionMain = True
self.sessionID = False
else:
self.sessionMain = False
r = None
for i in self.hold_data_add_item:
if self.hold_data_add_item[i].isSelected():
r = i
if r:
g = Db()
v = g.selectn('session', '', 1, {'id': r})
vname = str(v['name']).upper() + ' Session'
self.groupBox2.setTitle('ADD ' + str(vname) + ' Term')
self.sessionID = r
self.groupBox2.show()
else:
self.groupBox2.setTitle('Add')
self.sessionID = False
self.groupBox2.hide()
def setActive(self):
g = Db()
for i in self.hold_data:
if self.hold_data[i].checkState(0) == Qt.Checked:
g.update('datas', {'active': 0}, {'id': i})
else:
g.update('datas', {'active': 1}, {'id': i})
def button_add(self):
s1 = self.le1.text()
_datef = self.fromData.date().toPyDate()
_datef = time.mktime(_datef.timetuple())
_datee = self.toData.date().toPyDate()
_datee = time.mktime(_datee.timetuple())
g = Db()
if self.sessionID and self.sessionID > 0:
try:
if (len(s1) > 0):
y = {
'name': s1.lower(),
'start_date': _datef,
'sessionID': self.sessionID,
'end_date': _datee,
'active': 0
}
z = g.insert('terms', y)
if z and z > 0:
g.createClass(z)
g.createSubject(z)
g.createFee(z)
g.createPay(z)
g.createResult(z)
g.createAffective(z)
g.createPsychomoto(z)
self.makeTree()
self.button_reset()
self.par.menuSession()
self.par.dropdownSession()
else:
pass
except:
pass
else:
try:
if (len(s1) > 0):
y = {
'name': s1.lower(),
'start_date': _datef,
'end_date': _datee,
'active': 0
}
z = g.insert('session', y)
if z and z > 0:
g.createExpenses(z)
g.createStores(z)
g.createAwards(z)
g.createConducts(z)
g.createMails(z)
g.createMedicals(z)
self.makeTree()
self.button_reset()
self.par.menuSession()
self.par.dropdownSession()
else:
pass
except:
pass
def button_save(self):
row = self.editrow
s1 = self.le1.text()
_datef = self.fromData.date().toPyDate()
_datef = time.mktime(_datef.timetuple())
_datee = self.toData.date().toPyDate()
_datee = time.mktime(_datee.timetuple())
g = Db()
if (len(s1) > 0) and row and row > 0:
if self.sessionID and self.sessionID > 0:
try:
if (len(s1) > 0):
y = {
'name': s1.lower(),
'start_date': _datef,
'sessionID': self.sessionID,
'end_date': _datee,
'active': 0
}
k = {'id': row}
g.update('terms', y, k)
z = row
if z and z > 0:
g.createClass(z)
g.createSubject(z)
g.createFee(z)
g.createPay(z)
g.createResult(z)
g.createAffective(z)
g.createPsychomoto(z)
self.makeTree()
self.button_reset()
self.par.menuSession()
self.par.dropdownSession()
else:
pass
except:
pass
else:
try:
if (len(s1) > 0):
y = {
'name': s1.lower(),
'start_date': _datef,
'end_date': _datee,
'active': 0
}
k = {'id': row}
g.update('session', y, k)
z = row
if z and z > 0:
g.createExpenses(z)
g.createStores(z)
g.createAwards(z)
g.createConducts(z)
g.createMails(z)
g.createMedicals(z)
self.makeTree()
self.button_reset()
self.par.menuSession()
self.par.dropdownSession()
else:
pass
except:
pass
def button_delete(self):
row = self.getSelected()
g = Db()
try:
if row and row > 0:
y = {'abbrv': '', 'active': 2}
z = {'id': row}
g.update('datas', y, z)
self.makeTree()
else:
pass
except:
pass
def button_reset(self):
self.le1.clear()
currentDate = QDate()
self.fromData.setDate(currentDate.currentDate())
self.toData.setDate(currentDate.currentDate())
self.groupBox2.setTitle('Add')
self.groupBox2.hide()
self.pb.show()
self.pb4.hide()
def button_edit(self):
row = self.getSelected()
currentDate = QDate()
if row:
self.editrow = row
g = Db()
if self.sessionMain:
data = g.selectn('session', '', 1, {'id': row})
data_name = str(data['name'])
self.groupBox2.setTitle('Edit')
self.sessionID = False
else:
data = g.selectn('terms', '', 1, {'id': row})
data_sess = g.selectn('session', '', 1,
{'id': data['sessionID']})
data_name = str(data['name'])
self.sessionID = data['sessionID']
self.groupBox2.setTitle('Edit ' + str(data_sess['name']))
try:
self.le1.setText(data_name)
except:
self.le1.setText('')
try:
self.fromData.setDate(data['start_date'])
except:
self.fromData.setDate(currentDate.currentDate())
try:
self.toData.setDate(data['end_date'])
except:
self.toData.setDate(currentDate.currentDate())
self.pb.hide()
self.pb4.show()
def button_close(self):
self.close()
class SCJProgress(QHBoxLayout):
def __init__(self, parent=None, file=None, format=None, createDir=False ):
super(SCJProgress, self).__init__(parent)
self.format = format
self.filename = file
self.createDir = createDir
self.process = SCJ(self.filename, self.format, createDir)
self.output = QString(self.process.output)
self.command = QStringList(self.process.command)
self.log = QStringList()
self.label = QLabel(self.output)
self.label.setToolTip(self.trUtf8("Destination: %s" % self.output))
self.bar = QProgressBar(parent)
self.bar.setToolTip(self.trUtf8("Source: %s" % self.filename))
self.bar.setValue(0)
self.startbtn = QPushButton(parent)
self.stopbtn = QPushButton(parent)
self.cancelbtn = QPushButton(parent)
self.logbtn = QPushButton(parent)
self.cancelbtn.setMinimumSize(32,32)
self.cancelbtn.setFlat(True)
self.startbtn.setMinimumSize(32,32)
self.startbtn.setFlat(True)
self.stopbtn.setMinimumSize(32,32)
self.stopbtn.setFlat(True)
self.label.setMinimumSize(200,32)
self.bar.setMinimumSize(100,16)
self.bar.setMaximumHeight(16)
self.addWidget(self.logbtn)
self.logbtn.hide()
self.addWidget(self.label)
self.addWidget(self.bar)
self.addWidget(self.startbtn)
self.addWidget(self.stopbtn)
self.addWidget(self.cancelbtn)
self.retranslateUi()
self.connect(self.startbtn, SIGNAL("clicked()"), self.start)
self.connect(self.stopbtn, SIGNAL("clicked()"), self.stop)
self.connect(self.cancelbtn, SIGNAL("clicked()"), self.remove)
self.connect(self.logbtn, SIGNAL('clicked()'), self.showLog)
self.connect(self.process, SIGNAL('progress(int)'), self.bar.setValue)
self.connect(self.process, SIGNAL('error(QString)'), self.addLog)
self.connect(self.process, SIGNAL('finished()'), self.enable)
def retranslateUi(self):
self.startbtn.setIcon(QIcon(u"images/play.png"))
self.startbtn.setToolTip(self.trUtf8("Demarrer"))
self.stopbtn.setIcon(QIcon(u"images/stop.png"))
self.stopbtn.setToolTip(self.trUtf8("Stopper"))
self.cancelbtn.setIcon(QIcon(u"images/remove.png"))
self.cancelbtn.setToolTip(self.trUtf8("Annuler"))
self.logbtn.setIcon(QIcon(u"images/log.png"))
self.logbtn.setToolTip(self.trUtf8("Voir les details"))
def start(self):
self.log.clear()
self.logbtn.hide()
self.disable()
self.process.start()
self.process.resume()
def stop(self):
self.process.cancel()
self.process.terminate()
self.enable()
def remove(self):
self.removeWidget(self.label)
self.removeWidget(self.bar)
self.removeWidget(self.startbtn)
self.removeWidget(self.stopbtn)
self.removeWidget(self.cancelbtn)
self.removeWidget(self.logbtn)
self.label.hide()
self.bar.hide()
self.startbtn.hide()
self.stopbtn.hide()
self.cancelbtn.hide()
self.logbtn.hide()
self.emit(SIGNAL("void removed(QString)"), self.output)
def showLog(self):
QMessageBox.critical(None, u"Ooops", self.log.join("\n"))
def addLog(self, log):
self.log.append(log)
self.logbtn.show()
palette = QPalette()
brush = QBrush(QColor(240, 100, 100))
brush.setStyle(Qt.SolidPattern)
palette.setBrush(QPalette.Normal, QPalette.Background, brush)
self.label.setPalette(palette)
self.label.setAutoFillBackground(True)
def enable(self):
self.process = SCJ(self.filename, self.format, self.createDir)
self.output = QString(self.process.output)
self.command = QStringList(self.process.output)
self.connect(self.process, SIGNAL('progress(int)'), self.bar.setValue)
self.connect(self.process, SIGNAL('error(QString)'), self.addLog)
self.connect(self.process, SIGNAL('finished()'), self.enable)
self.cancelbtn.setEnabled(True)
self.startbtn.setEnabled(True)
def disable(self):
self.cancelbtn.setEnabled(False)
self.startbtn.setEnabled(False)
self.label.setAutoFillBackground(False)
class TracklistWidget(QWidget):
requestUpload = pyqtSignal(list)
def __init__(self, parent=None):
super(TracklistWidget, self).__init__(parent)
self.tracklist = QListWidget(self)
self.tracklist.setSelectionMode(QListWidget.NoSelection)
self.upload_button = QPushButton(
QIcon(resource_path('images/strava-button.png')),
'Upload to Strava', self)
self.upload_button.setMinimumHeight(50)
self.upload_button.setIconSize(QSize(40, 40))
self.clear_password = QPushButton(
QIcon(resource_path('images/cross.png')),
'Clear password', self)
self.clear_password.setMinimumHeight(50)
self.clear_password.setIconSize(QSize(20, 20))
self.clear_password.hide()
self.upload_button.clicked.connect(self._onUploadClicked)
self._createLayout()
def setTracks(self, tracks):
self.tracklist.clear()
self.tracklist.addItems(tracks)
for i, name in enumerate(tracks):
self.tracklist.item(i).setCheckState(Qt.Unchecked)
self.tracklist.item(i).setSizeHint(QSize(200, 25))
if tracks:
self.tracklist.item(i).setCheckState(Qt.Checked)
self.upload_button.setEnabled(True)
else:
self.upload_button.setEnabled(False)
def _onUploadClicked(self):
ids = []
for i in range(self.tracklist.count()):
item = self.tracklist.item(i)
if item.checkState() == Qt.Checked:
ids.append(i)
if ids:
self.requestUpload.emit(ids)
def _createLayout(self):
l = QVBoxLayout()
l.addWidget(self.tracklist)
h = QHBoxLayout()
h.addWidget(self.upload_button)
h.addWidget(self.clear_password)
l.addLayout(h)
self.setLayout(l)
class Cell(QWidget):
"""Senales requerias en la clase"""
valueChanged = pyqtSignal(int)
clicked = pyqtSignal()
def __init__(self):
"""Inicializador de la clase Cell."""
QWidget.__init__(self)
"""Widgets para el modelo final"""
self.value = QPushButton()
self.value.clicked.connect(self.clicked)
# Widgets for annotation mode
self.annotations = []
for i in range(9):
self.annotations.append( QLabel('--') )
# Put first annotation on first widget
self.emptyAnnotation = 0
# Layout
self.layout = QGridLayout()
self.setLayout(self.layout)
self.setMode('Final')
def setValue(self, value):
"""Si es un modelo final,se anade un valor final.
:param self: Referencia a la clase.
:param value: Valor a seterar"""
# If it's in final mode, set the final value
if self.mode == 'Final':
self.value.setText(str(value))
self.valueChanged.emit(value)
if (value == 0):
self.setStyleSheet("font: italic 26pt Courier 20 Pitch; background-color: rgb(82, 163, 53);border-image: url(:/images/Mysitemyway-Blue-Jeans-Social-Media-Delicious-square.ico);")
self.value.setText("")
else:
self.setStyleSheet("font:26pt Courier 20 Pitch; background-color: rgb(82, 163, 53);")
# if it's in annotation mode, add an annotation
elif self.mode == 'Annotation':
self.annotations[self.emptyAnnotation].setText(str(value))
self.setStyleSheet("font: italic 10pt Courier 29 Pitch; background-color: rgb(82, 163, 53);")
# Put next annotation on next widget
self.emptyAnnotation = (self.emptyAnnotation + 1) % 9
def setMode(self, mode):
"""Muestra el boton con el valor final.
:param self: Referencia a la clase.
:param mode: modo que se seterar"""
'''Show button with final value'''
if mode == 'Final':
for a in self.annotations:
a.hide()
self.value.show()
self.layout.addWidget(self.value)
# Show annotations
elif mode == 'Annotation':
self.value.hide()
for i in range(9):
self.annotations[i].show()
self.layout.addWidget(self.annotations[i], i/3, i%3)
self.mode = mode
def setKeyboard(self, keyboard):
"""Anade el keyboard a la celda.
:param self: Referencia a la clase.
:param keyboard: teclado """
self.keyboard = keyboard
self.clicked.connect(keyboard.activate)
def mouseReleaseEvent(self, e):
"""Evento que permite emitir una senal al keyboard"""
self.clicked.emit()
class FormStudentMisconduct(QDialog):
def __init__(self, student, term, edit=None, parent=None):
super(FormStudentMisconduct, self).__init__(parent)
self.student = student
self.term = term
self.db_class = 'student_class' + str(self.term)
self.db_subject = 'student_subject' + str(self.term)
student = self.pullData('students', 1, {'id': self.student})
term = self.pullData('terms', 1, {'id': self.term})
session = self.pullData('session', 1, {'id': term['sessionID']})
self.session = str(
str(session['name']) + " " + str(term['name'] + " Term")).title()
self.fullname = str(
str(student['surname']) + " " + str(student['firstname'])).title()
self.sessionID = session['id']
fullnameLbl = QLabel(self.fullname)
fullnameLbl.setFont(QFont("Candara", 14, QFont.Bold))
termLbl = QLabel(self.session)
termLbl.setFont(QFont("Candara", 12, QFont.Bold))
actionLbl = QLabel('Action')
reactionLbl = QLabel('Corrective/Punitive Measure')
issuerLbl = QLabel('Issuer')
self.actionData = QPlainTextEdit()
self.reactionData = QPlainTextEdit()
self.staffData = QLineEdit()
self.staffData.setPlaceholderText(
'Staff Name or Deparment or Organisation')
self.pb = QPushButton()
self.pb.setObjectName("close")
self.pb.setText("Close")
self.pb1 = QPushButton()
self.pb1.setObjectName("Add")
self.pb1.setText("Add")
self.pb2 = QPushButton()
self.pb2.setObjectName("Edit")
self.pb2.setText("Edit")
self.connect(self.pb1, SIGNAL("clicked()"),
lambda: self.button_click())
self.connect(self.pb2, SIGNAL("clicked()"), lambda: self.button_edit())
self.connect(self.pb, SIGNAL("clicked()"), lambda: self.button_close())
self.dateLbl = QLabel('Choose Date:')
currentDate = QDate()
self.dateData = QDateEdit()
self.dateData.setDate(currentDate.currentDate())
self.dateData.setCalendarPopup(True)
h_box = QHBoxLayout()
h_box.addWidget(self.dateLbl)
h_box.addWidget(self.dateData)
h_box2 = QHBoxLayout()
h_box2.addWidget(issuerLbl)
h_box2.addWidget(self.staffData)
h_box1 = QHBoxLayout()
h_box1.addWidget(self.pb)
h_box1.addWidget(self.pb1)
h_box1.addWidget(self.pb2)
self.v_box = QVBoxLayout()
self.v_box.addWidget(fullnameLbl)
self.v_box.addWidget(termLbl)
self.v_box.addLayout(h_box)
self.v_box.addWidget(actionLbl)
self.v_box.addWidget(self.actionData)
self.v_box.addWidget(reactionLbl)
self.v_box.addWidget(self.reactionData)
self.v_box.addLayout(h_box2)
self.v_box.addLayout(h_box1)
if edit and len(edit) > 0:
self.edit = edit
self.editRow(edit)
self.pb1.hide()
self.pb2.show()
else:
self.edit = None
self.pb1.show()
self.pb2.hide()
self.setLayout(self.v_box)
self.setWindowTitle("Misconduct Report Form")
def pullData(self, db, sid, arr):
g = Db()
data = g.selectn(db, '', sid, arr)
return data
def convert_arr(self, arr):
ar = []
for a in arr:
ar.append(a['subjectID'])
return ar
def editrow(self, a):
e = a.split('_')
g = Db()
self.mainrow = e[1]
self.mainses = e[0]
db = 'school_conducts' + str(self.mainses)
data = g.selectn(db, '', 1, {'id': self.mainrow})
if data and len(data) > 0:
self.ailmentData.clear()
self.ailmentData.insertPlainText(str(data['action']))
self.staffData.setText(str(data['staffname']))
self.treatmentData.clear()
self.treatmentData.insertPlainText(str(data['reaction']))
def button_close(self):
self.reject()
def button_click(self):
action = self.actionData.toPlainText()
reaction = self.reactionData.toPlainText()
staff = self.staffData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
db = 'school_conducts' + str(self.sessionID)
if len(action) > 0 and len(reaction) > 0:
arr = {}
arr['studentID'] = self.student
arr['action'] = action
arr['reaction'] = reaction
arr['datepaid'] = _date
arr['staffname'] = staff
arr['state'] = 1
g = Db()
g.insert(db, arr)
## set subject
self.getValue()
def button_edit(self):
action = self.actionData.toPlainText()
reaction = self.reactionData.toPlainText()
staff = self.staffData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
db = 'school_conducts' + str(self.sessionID)
if len(action) > 0 and len(reaction) > 0:
arr = {}
arr['action'] = action
arr['reaction'] = reaction
arr['datepaid'] = _date
arr['staffname'] = staff
g = Db()
g.update(db, arr, {'id': self.edit})
## set subject
self.getValue()
def getValue(self):
self.accept()
class WidgetMEncoder(QDialog):
def __init__(self, idCodec, cheminVideoEntre, cheminSorti, valeurNum=0,
laisserOuvert=1, systeme=None, cheminMEncoder=None,
tempsApercu=None, optionSpeciale=None):
#############################################################################
"""widget mencoder"""
QDialog.__init__(self)
#=== Paramètres généraux ===#
self.systeme=systeme
# système d'exploitation
if self.systeme=='linux' or self.systeme=='darwin' or self.systeme==None:
self.cheminMEncoder="mencoder"
elif self.systeme=='windows':
self.cheminMEncoder=cheminMEncoder
# chemins vidéos
self.cheminVideoEntre = cheminVideoEntre
self.cheminSorti = cheminSorti
# identifiant du codec
self.idCodec = idCodec
# valeur de la boite de spin pour l'encodage
self.valeurNum = valeurNum
# laisser ouvert la fenêtre après encodage
self.laisserOuvert = laisserOuvert
# Conversion minimale du filtre pour avoir un aperçu.
# Indique le temps où l'aperçu doit être créé
self.tempsApercu = tempsApercu
# drapeau pour ne pas lancer 2 fois l'encodage
self.estLancee = False
# Est-ce que le 1er % de progression a été récupéré (utile pour montage vidéo -> découper)?
self.__recupPourcentDebut = 0
self.log = [] # stocke les infos de mplayer et mencoder
# Pour le son lors de la découpe vidéo pour l'instant
if optionSpeciale!=None:
self.optionSpeciale = optionSpeciale
self.resize(500, 100)
#=== Widgets ===#
self.labelAttente=QLabel()
self.labelAttente.setText(_(u"Attendez la fin du calcul s'il vous plaît, soyez patient !"))
self.zoneTexte = QTextEdit("") # là où s'afficheront les infos
if PYQT_VERSION_STR < "4.1.0":
self.zoneTexte.setText = self.zoneTexte.setPlainText
self.zoneTexte.setReadOnly(True)
self.zoneTexte.hide()
self.bout_annuler = QPushButton(_(u"Annuler"))
self.bout_preZoneTexte = QPushButton(_("Voir les informations de l'encodage"))
self.bout_preZoneTexte.hide()
self.pbar = QProgressBar()
self.pbar.setMaximum(100)
self.mencoderProcess = Mencoder(cheminVideoEntre, cheminSorti, idCodec, location=self.cheminMEncoder)
#=== mise-en-page/plan ===#
vbox = QVBoxLayout()
vbox.addWidget(self.labelAttente)
vbox.addWidget(self.bout_preZoneTexte)
vbox.addWidget(self.zoneTexte)
hbox = QHBoxLayout()
hbox.addWidget(self.pbar)
hbox.addWidget(self.bout_annuler)
vbox.addLayout(hbox)
self.setLayout(vbox)
#=== connexion des widgets à des fonctions ===#
# TEST # sert à calculer la durée d'exécution du script -> comparaison avec avec et sans traitement
# des lignes de sortie de QProcess
# 'readyReadStandardOutput()': signal émis lors de la sortie standart de lecture
self.connect(self.mencoderProcess, SIGNAL('progress(int)'), self.pbar.setValue)
self.connect(self.mencoderProcess, SIGNAL('log(QString)'), self.zoneTexte.append)
self.connect(self.mencoderProcess, SIGNAL('finished(int)'), self.finEncodage)
self.connect(self.bout_annuler, SIGNAL('clicked()'), self.close)
self.connect(self.bout_preZoneTexte, SIGNAL('clicked()'), self.afficherLog)
# Uniquement Mencoder
self.demarrerEncodeur('Mencoder')
def demarrerEncodeur(self, encodeur):
"""démarrage de mencoder avec les arguments choisis"""
if self.estLancee == False: # pas question de démarrer 2 fois l'encodage
debug('\n')
# ... pareil pour la concaténation de vidéos ensemble
if self.idCodec=='fusion_video':
pass
# ... pareil pour la concaténation de vidéos + audio(s)
elif self.idCodec in ['fusion_audio_et_video_1', 'fusion_audio_et_video_2']:
pass
# Autrement dans tous les autres cas ...
else:
infos = "\n########################\n"
infos += "# Informations MPlayer :\n"
infos += "########################\n"
debug(infos)
# Utilisation de la classe infovideo (et en particilier la fonction setVideo)
# présents dans gui_modules_animation/infoVideo.py
info = infovideo(self.cheminVideoEntre)
id_filename = 'ID_FILENAME='+self.cheminVideoEntre+'\n'
debug(id_filename)
id_demuxer = 'ID_DEMUXER='+info.demux+'\n'
debug(id_demuxer)
id_video_format = 'ID_VIDEO_FORMAT='+info.videoFormat+'\n'
debug(id_video_format)
id_video_codec = 'ID_VIDEO_CODEC='+info.video_codec+'\n'
debug(id_video_codec)
id_video_bitrate = 'ID_VIDEO_BITRATE='+str(info.videoBitrate)+'\n'
debug(id_video_bitrate)
id_video_largeur = 'ID_VIDEO_WIDTH='+str(info.videoLargeur)+'\n'
debug(id_video_largeur)
id_video_hauteur = 'ID_VIDEO_HEIGHT='+str(info.videoHauteur)+'\n'
debug(id_video_hauteur)
self.id_img_par_sec = 'ID_VIDEO_FPS='+str(info.imgParSec)+'\n'
debug(self.id_img_par_sec)
##### Donnée très importante pour la suite du calcul (uniquement pour ffmpeg.py) ######
#self.dureeTotaleVideo = float(info.dureeTotaleVideo)
#######################################################################################
id_duree_totale_video = 'ID_LENGTH='+str(info.dureeTotaleVideo)+'\n'
debug(id_duree_totale_video)
id_audio_codec = 'ID_AUDIO_CODEC='+info.audioCodec+'\n'
debug(id_audio_codec)
id_audio_rate = 'ID_AUDIO_RATE='+str(info.audioRate)+'\n'
debug(id_audio_rate)
id_audio_bitrate = 'ID_AUDIO_BITRATE='+str(info.audioBitrate)+'\n'
debug(id_audio_bitrate)
self.log.append(infos+id_filename+id_demuxer+id_video_format+id_video_codec+id_video_bitrate+id_video_largeur+id_video_hauteur+self.id_img_par_sec+id_duree_totale_video+id_audio_codec+id_audio_rate+id_audio_bitrate)
##############################################################################################
debug('\n')
infos = "\n############################\n"
infos += "# Informations %s :\n" %encodeur
infos += "############################\n"
debug(infos)
self.log.append(infos)
if self.idCodec in ['dailymotion_sd_4/3', 'dailymotion_sd_16/9', 'dailymotion_HD720p']:
tspl = self.id_img_par_sec.split()
nbrISec =[n.split('=')[1] for n in tspl]
nbrISec = nbrISec[0]
# A une image par seconde, la vidéo chargée n'est pas bien traitrée
# (ou voire pas traitée du tout) Message d'information pour l'utilisateur.
if nbrISec == '1.0':
daily = QMessageBox.information(self, 'Message',
_(u"<p>Le nombre d'image(s) par seconde, dans la vidéo avec laquelle vous avez décidé de travailler, n'est que de 1, vous devez savoir que votre vidéo ne pourra pas être transcodée dans un des trois profils pour Dailymotion.</p><p>A partir de deux images par seconde, cela devient possible (en conséquence, éditez votre vidéo et changez le nombre d'images par seconde). <b>Le traitement demandé ne peut pas avoir lieu.</b></p>"), QMessageBox.Yes)
if daily == QMessageBox.Yes:return
elif self.idCodec=='codech264mpeg4':
if not info.audioCodec:
self.idCodec = "%s_nosound" % self.idCodec
#elif self.idCodec[0]=='bruit':
# Rien à faire, c'est tout se passe ici animation_filtres_video.py
elif self.idCodec=='changement_resolution' and not self.tempsApercu:
reponse = QMessageBox.information(self, 'Message',
_(u"<p>Vous avez décidé de changer la résolution de cette vidéo, sachez avant tout que la vidéo en question sera (en même temps qu'elle est redimensionnée) encodée en <b><font color='red'>Motion JPEG (extension .avi)</font></b>.</p><p>Vous pouvez (si vous le désirez) <b>vous approcher d'une résolution en 16/9ème</b>, pour ce faire vous devez faire un petit calcul ...</p><p>* pour obtenir la valeur de la hauteur comparativement à la valeur de la largeur, vous devez <b>diviser la valeur de la largeur par 1.777</b>, par exemple si votre vidéo de départ est en 640x480, le calcul à faire sera le suivant:</p><p>640 / 1.777, cela vous donnera (à la virgule près) 360.15756893640969, vous devrez enlever les chiffres après la virgule. Pour conclure, votre vidéo fera à l'arrivée 640x360, vous pourrez donc régler <b>Nouvelle largeur</b> à 640 et <b>Nouvelle hauteur</b> à 360.</p><p><b>Si vous décidez de faire les réglages pour obtenir une vidéo en 16/9ème, répondez non</b> à la question qui vous sera posée (pour ainsi pouvoir refaire les réglages), <b>si vous décidez de changer la résolution tout de suite (et avec les valeurs que vous venez de définir), répondez oui</b>.</p><p><b>Voulez-vous changer la résolution tout de suite ?.</b></p>"), QMessageBox.Yes, QMessageBox.No)
if reponse == QMessageBox.No:
return
debug("self.idCodec de mencoder %s" % self.idCodec)
self.mencoderProcess.setCommand(parametres = self.valeurNum, apercu = self.tempsApercu)
self.mencoderProcess.start()
debug(u"Commande lancée")
self.estLancee = True
def close(self):
self.mencoderProcess.cancel()
QDialog.close(self)
def finEncodage(self, statutDeSortie):
"""choses à faire à la fin de l'encodage de la vidéo"""
# fermer la fenêtre à la fin de l'encodage
if not self.laisserOuvert:
self.close()
debug("fini!")
self.labelAttente.hide()
self.pbar.setValue(100)
if statutDeSortie == QProcess.CrashExit:
self.bout_preZoneTexte.setText(_(u'Problème! Voir les informations'))
self.bout_annuler.setText(_(u"Crash"))
self.log.append(_(u"Une erreur est survenue lors de l'encodage"))
else:
# l'encodage est fini. Il ne peut plus être annulé. La
# seule action possible devient ainsi la fermeture
self.bout_annuler.setText(_(u"Fermer"))
self.bout_preZoneTexte.show()
def afficherLog(self):
"""afficher les information de la vidéo de départ et de l'encodage"""
self.zoneTexte.setText(self.mencoderProcess.log)
self.zoneTexte.show()
self.resize(500, 300)
class Main(plugin.Plugin):
" Main Class "
def initialize(self, *args, **kwargs):
" Init Main Class "
ec = ExplorerContainer()
super(Main, self).initialize(*args, **kwargs)
self.editor_s = self.locator.get_service('editor')
# directory auto completer
self.completer = QCompleter(self)
self.dirs = 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 = QComboBox()
self.source.addItems(['Clipboard', 'Local File', 'Remote URL', 'Ninja'])
self.source.currentIndexChanged.connect(self.on_source_changed)
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 ['css', 'html', 'js', 'txt', '*']])))))
self.inurl = QLineEdit('http://www.')
self.inurl.setPlaceholderText('http://www.full/url/to/remote/file.html')
self.output = QPlainTextEdit(SAMPLE_TEXT)
vboxg0 = QVBoxLayout(self.group0)
for each_widget in (self.source, self.infile, self.open, self.inurl,
self.output, ):
vboxg0.addWidget(each_widget)
[a.hide() for a in iter((self.infile, self.open, self.inurl))]
self.group1 = QGroupBox()
self.group1.setTitle(' CSS3 ')
self.group1.setCheckable(True)
self.group1.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group1.graphicsEffect().setEnabled(False)
self.group1.toggled.connect(self.toggle_css_group)
self.ckcss1 = QCheckBox('Remove unnecessary Comments')
self.ckcss2 = QCheckBox('Remove unnecessary Whitespace characters')
self.ckcss3 = QCheckBox('Remove unnecessary Semicolons')
self.ckcss4 = QCheckBox('Remove unnecessary Empty rules')
self.ckcss5 = QCheckBox('Condense and Convert Colors from RGB to HEX')
self.ckcss6 = QCheckBox('Condense all Zero units')
self.ckcss7 = QCheckBox('Condense Multidimensional Zero units')
self.ckcss8 = QCheckBox('Condense Floating point numbers')
self.ckcss9 = QCheckBox('Condense HEX Colors')
self.ckcss10 = QCheckBox('Condense multiple adjacent Whitespace chars')
self.ckcss11 = QCheckBox('Condense multiple adjacent semicolon chars')
self.ckcss12 = QCheckBox('Wrap the lines of the to 80 character length')
self.ckcss13 = QCheckBox('Condense Font Weight values')
self.ckcss14 = QCheckBox('Condense the 17 Standard Named Colors values')
self.ckcss15 = QCheckBox('Condense the 124 Extra Named Colors values')
self.ckcss16 = QCheckBox('Condense all Percentages values when posible')
self.ckcss17 = QCheckBox('Condense all Pixels values when posible')
self.ckcss18 = QCheckBox('Remove unnecessary quotes from url()')
self.ckcss19 = QCheckBox('Add standard Encoding Declaration if missing')
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, self.ckcss16, self.ckcss17,
self.ckcss18, self.ckcss19):
vboxg1.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group2 = QGroupBox()
self.group2.setTitle(' HTML5 ')
self.group2.setCheckable(True)
self.group2.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group2.graphicsEffect().setEnabled(False)
self.group2.toggled.connect(self.toggle_html_group)
self.ckhtml0 = QCheckBox('Condense Style and Script HTML Tags')
self.ckhtml1 = QCheckBox('Condense DOCTYPE to new HTML5 Tags')
self.ckhtml2 = QCheckBox('Condense Href and Src to protocol agnostic')
self.ckhtml4 = QCheckBox('Remove unnecessary Tags but keep HTML valid')
self.help1 = QLabel('''<a href=
"https://developers.google.com/speed/articles/optimizing-html">
<small><center>Help about Unneeded Unnecessary HTML tags ?</a>''')
self.help1.setTextInteractionFlags(Qt.LinksAccessibleByMouse)
self.help1.setOpenExternalLinks(True)
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (self.ckhtml0, self.ckhtml1, self.ckhtml2,
self.ckhtml4, self.help1, ):
vboxg2.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group3 = QGroupBox()
self.group3.setTitle(' Javascript ')
self.ckjs0 = QCheckBox('Condense and Compress Javascript')
self.ckjs1 = QCheckBox('Condense $(document).ready(function(){ });')
vboxg2 = QVBoxLayout(self.group3)
for each_widget in (self.ckjs0, self.ckjs1):
vboxg2.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
self.group4 = QGroupBox()
self.group4.setTitle(' General ')
self.chckbx1 = QCheckBox('Lower case ALL the text')
self.chckbx2 = QCheckBox('Remove Spaces, Tabs, New Lines, Empty Lines')
self.befor, self.after = QProgressBar(), QProgressBar()
self.befor.setFormat("%v Chars")
self.after.setFormat("%v Chars")
vboxg4 = QVBoxLayout(self.group4)
for each_widget in (self.chckbx1, self.chckbx2,
QLabel('<b>Before:'), self.befor, QLabel('<b>After:'), self.after):
vboxg4.addWidget(each_widget)
each_widget.setToolTip(each_widget.text())
[a.setChecked(True) for a in iter((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, self.ckcss16,
self.ckcss17, self.ckcss18, self.ckcss19, self.ckjs1, self.ckhtml0,
self.ckhtml1, self.ckhtml2, self.ckhtml4, self.chckbx1,
self.chckbx2))]
self.button = QPushButton(QIcon.fromTheme("face-cool"), 'Process Text')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.run)
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
must_glow((self.button, ))
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>HTML5/CSS3/JS Optimizer Compressor'),
self.group0, self.group1, self.group2, self.group3, self.group4,
self.button, ))
self.scrollable = QScrollArea()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock = QDockWidget()
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setMinimumWidth(350)
self.dock.setWidget(self.scrollable)
ec.addTab(self.dock, "Web")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
HELPMSG))
def run(self):
' run the string replacing '
if self.source.currentText() == 'Local File':
with open(path.abspath(str(self.infile.text()).strip()), 'r') as f:
txt = f.read()
elif self.source.currentText() == 'Remote URL':
txt = urlopen(str(self.inurl.text()).strip()).read()
elif self.source.currentText() == 'Clipboard':
txt = str(self.output.toPlainText()) if str(self.output.toPlainText()) is not '' else str(QApplication.clipboard().text())
else:
txt = self.editor_s.get_text()
self.output.clear()
self.befor.setMaximum(len(txt) + 10)
self.after.setMaximum(len(txt) + 10)
self.befor.setValue(len(txt))
txt = txt.lower() if self.chckbx1.isChecked() is True else txt
txt = condense_style(txt) if self.ckhtml0.isChecked() is True else txt
txt = condense_script(txt) if self.ckhtml0.isChecked() is True else txt
txt = condense_doctype(txt) if self.ckhtml1.isChecked() is True else txt
txt = condense_href_src(txt) if self.ckhtml2 is True else txt
txt = clean_unneeded_tags(txt) if self.ckhtml4.isChecked() is True else txt
txt = condense_doc_ready(txt) if self.ckjs1.isChecked() is True else txt
txt = jsmin(txt) if self.ckjs0.isChecked() is True else txt
txt = remove_comments(txt) if self.ckcss1.isChecked() is True else txt
txt = condense_whitespace(txt) if self.ckcss10.isChecked() is True else txt
txt = remove_empty_rules(txt) if self.ckcss4.isChecked() is True else txt
txt = remove_unnecessary_whitespace(txt) if self.ckcss2.isChecked() is True else txt
txt = remove_unnecessary_semicolons(txt) if self.ckcss3.isChecked() is True else txt
txt = condense_zero_units(txt) if self.ckcss6.isChecked() is True else txt
txt = condense_multidimensional_zeros(txt) if self.ckcss7.isChecked() is True else txt
txt = condense_floating_points(txt) if self.ckcss8.isChecked() is True else txt
txt = normalize_rgb_colors_to_hex(txt) if self.ckcss5.isChecked() is True else txt
txt = condense_hex_colors(txt) if self.ckcss9.isChecked() is True else txt
txt = wrap_css_lines(txt, 80) if self.ckcss12.isChecked() is True else txt
txt = condense_semicolons(txt) if self.ckcss11.isChecked() is True else txt
txt = condense_font_weight(txt) if self.ckcss13.isChecked() is True else txt
txt = condense_std_named_colors(txt) if self.ckcss14.isChecked() is True else txt
# txt = condense_xtra_named_colors(txt) if self.ckcss14.isChecked() is True else txt # FIXME
txt = condense_percentage_values(txt) if self.ckcss16.isChecked() is True else txt
txt = condense_pixel_values(txt) if self.ckcss17.isChecked() is True else txt
txt = remove_url_quotes(txt) if self.ckcss18.isChecked() is True else txt
txt = add_encoding(txt) if self.ckcss19.isChecked() is True else txt
txt = " ".join(txt.strip().split()) if self.chckbx2.isChecked() is True else txt
self.after.setValue(len(txt))
self.output.setPlainText(txt)
self.output.show()
self.output.setFocus()
self.output.selectAll()
def on_source_changed(self):
' do something when the desired source has changed '
if self.source.currentText() == 'Local File':
self.open.show()
self.infile.show()
self.inurl.hide()
self.output.hide()
elif self.source.currentText() == 'Remote URL':
self.inurl.show()
self.open.hide()
self.infile.hide()
self.output.hide()
elif self.source.currentText() == 'Clipboard':
self.output.show()
self.open.hide()
self.infile.hide()
self.inurl.hide()
self.output.setText(QApplication.clipboard().text())
else:
self.output.show()
self.open.hide()
self.infile.hide()
self.inurl.hide()
self.output.setText(self.editor_s.get_text())
def toggle_css_group(self):
' toggle on or off the css checkboxes '
if self.group1.isChecked() is True:
[a.setChecked(True) for a in iter((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, self.ckcss16,
self.ckcss17, self.ckcss18, self.ckcss19))]
self.group1.graphicsEffect().setEnabled(False)
else:
[a.setChecked(False) for a in iter((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, self.ckcss16,
self.ckcss17, self.ckcss18, self.ckcss19))]
self.group1.graphicsEffect().setEnabled(True)
def toggle_html_group(self):
' toggle on or off the css checkboxes '
if self.group2.isChecked() is True:
[a.setChecked(True) for a in iter((self.ckhtml0, self.ckhtml1,
self.ckhtml2, self.ckhtml4))]
self.group2.graphicsEffect().setEnabled(False)
else:
[a.setChecked(False) for a in iter((self.ckhtml0, self.ckhtml1,
self.ckhtml2, self.ckhtml4))]
self.group2.graphicsEffect().setEnabled(True)
def create_rows(self, layout):
play_button_group = QButtonGroup(self)
old_play_button_group = QButtonGroup(self)
for num, (source, dest, text, dl_fname, dl_hash, extras, icon)\
in enumerate(self.list, 3):
tt_text = self.build_text_help_label(text, source, extras)
ico_label = QLabel('', self)
ico_label.setToolTip(tt_text)
if icon:
ico_label.setPixmap(QPixmap.fromImage(icon))
layout.addWidget(ico_label, num, 0)
tt_label = QLabel(text, self)
tt_label.setToolTip(tt_text)
layout.addWidget(tt_label, num, 1)
if self.hide_text:
tt_label.hide()
# Play button.
t_play_button = QPushButton(self)
play_button_group.addButton(t_play_button, num - 3)
t_play_button.setToolTip(self.play_help)
t_play_button.setIcon(QIcon(os.path.join(icons_dir, 'play.png')))
layout.addWidget(t_play_button, num, self.play_column)
if self.note[dest]:
t_play_old_button = QPushButton(self)
old_play_button_group.addButton(t_play_old_button, num - 3)
t_play_old_button.setIcon(
QIcon(os.path.join(icons_dir, 'play.png')))
if not self.hide_text:
t_play_old_button.setToolTip(self.note[dest])
else:
t_play_old_button.setToolTip(self.play_old_help_short)
layout.addWidget(t_play_old_button, num, self.play_old_column)
else:
dummy_label = QLabel('', self)
dummy_label.setToolTip(self.play_old_empty_line_help)
layout.addWidget(dummy_label, num, self.play_old_column)
# The group where we later look what to do:
t_button_group = QButtonGroup(self)
t_button_group.setExclusive(True)
# Now the four buttons
t_add_button = QPushButton(self)
t_add_button.setCheckable(True)
t_add_button.setChecked(True)
t_add_button.setFlat(True)
t_add_button.setToolTip(self.add_help_text_short)
t_add_button.setIcon(QIcon(os.path.join(icons_dir, 'add.png')))
layout.addWidget(t_add_button, num, self.add_column)
t_button_group.addButton(t_add_button, action['add'])
t_keep_button = QPushButton(self)
t_keep_button.setCheckable(True)
t_keep_button.setFlat(True)
t_keep_button.setToolTip(self.keep_help_text_short)
t_keep_button.setIcon(QIcon(os.path.join(icons_dir, 'keep.png')))
layout.addWidget(t_keep_button, num, self.keep_column)
t_button_group.addButton(t_keep_button, action['keep'])
t_delete_button = QPushButton(self)
t_delete_button.setCheckable(True)
t_delete_button.setFlat(True)
t_delete_button.setToolTip(self.delete_help_text_short)
t_delete_button.setIcon(QIcon(os.path.join(icons_dir,
'delete.png')))
layout.addWidget(t_delete_button, num, self.delete_column)
t_button_group.addButton(t_delete_button, action['delete'])
t_blacklist_button = QPushButton(self)
t_blacklist_button.setCheckable(True)
t_blacklist_button.setFlat(True)
t_blacklist_button.setToolTip(self.blacklist_help_text_short)
t_blacklist_button.setIcon(QIcon(os.path.join(icons_dir,
'blacklist.png')))
if self.show_skull_and_bones:
layout.addWidget(
t_blacklist_button, num, self.blacklist_column)
else:
t_blacklist_button.hide()
t_button_group.addButton(t_blacklist_button, action['blacklist'])
self.buttons_groups.append(t_button_group)
play_button_group.buttonClicked.connect(
lambda button: play(self.list[play_button_group.id(button)][3]))
old_play_button_group.buttonClicked.connect(
lambda button: playFromText(
self.note[self.list[old_play_button_group.id(button)][1]]))
class OptionsDialog(QDialog, FORM_CLASS):
"""Options dialog for the InaSAFE plugin."""
def __init__(self, iface, parent=None, qsetting=''):
"""Constructor for the dialog.
:param iface: A Quantum GIS QGisAppInterface instance.
:type iface: QGisAppInterface
:param parent: Parent widget of this dialog
:type parent: QWidget
:param qsetting: String to specify the QSettings. By default,
use empty string.
:type qsetting: str
"""
QDialog.__init__(self, parent)
self.setupUi(self)
icon = resources_path('img', 'icons', 'configure-inasafe.svg')
self.setWindowIcon(QIcon(icon))
self.setWindowTitle(self.tr('InaSAFE %s Options' % get_version()))
# Save reference to the QGIS interface and parent
self.iface = iface
self.parent = parent
if qsetting:
self.settings = QSettings(qsetting)
else:
self.settings = QSettings()
# InaSAFE default values
self.default_value_parameters = []
self.default_value_parameter_containers = []
# Flag for restore default values
self.is_restore_default = False
# List of setting key and control
self.boolean_settings = {
'visibleLayersOnlyFlag': self.cbxVisibleLayersOnly,
'set_layer_from_title_flag': self.cbxSetLayerNameFromTitle,
'setZoomToImpactFlag': self.cbxZoomToImpact,
'set_show_only_impact_on_report': self.cbx_show_only_impact,
'print_atlas_report': self.cbx_print_atlas_report,
'setHideExposureFlag': self.cbxHideExposure,
'useSelectedFeaturesOnly': self.cbxUseSelectedFeaturesOnly,
'useSentry': self.cbxUseSentry,
'template_warning_verbose': self.template_warning_checkbox,
'showOrganisationLogoInDockFlag':
self.organisation_on_dock_checkbox,
'developer_mode': self.cbxDevMode,
'generate_report': self.checkbox_generate_reports,
'memory_profile': self.check_box_memory,
'always_show_welcome_message': self.welcome_message_check_box
}
self.text_settings = {
'keywordCachePath': self.leKeywordCachePath,
'ISO19115_ORGANIZATION': self.organisation_line_edit,
'ISO19115_URL': self.website_line_edit,
'ISO19115_EMAIL': self.email_line_edit,
'ISO19115_LICENSE': self.license_line_edit,
}
# Export and Import button
# Export button
self.export_button = QPushButton(tr('Export'))
# noinspection PyUnresolvedReferences
self.export_button.clicked.connect(self.export_setting)
self.button_box.addButton(self.export_button,
QDialogButtonBox.ActionRole)
# Import button
self.import_button = QPushButton(tr('Import'))
# noinspection PyUnresolvedReferences
self.import_button.clicked.connect(self.import_setting)
self.button_box.addButton(self.import_button,
QDialogButtonBox.ActionRole)
# Set up things for context help
self.help_button = self.button_box.button(QDialogButtonBox.Help)
# Allow toggling the help button
self.help_button.setCheckable(True)
self.help_button.toggled.connect(self.help_toggled)
self.main_stacked_widget.setCurrentIndex(1)
# Always set first tab to be open, 0-th index
self.tabWidget.setCurrentIndex(0)
# Hide not implemented group
self.grpNotImplemented.hide()
self.adjustSize()
# Population parameter Tab
# Label
self.preference_label = QLabel()
self.preference_label.setText(
tr('Please set parameters for each hazard class below. Affected '
'status and displacement rates selected on this tab are only '
'applied to exposed populations. '))
self.preference_layout.addWidget(self.preference_label)
# Profile preference widget
self.profile_widget = ProfileWidget()
self.preference_layout.addWidget(self.profile_widget)
# Demographic tab
self.demographic_label = QLabel()
self.demographic_label.setText(
tr('Please set the global default demographic ratio below.'))
self.default_values_layout.addWidget(self.demographic_label)
self.scroll_area = QScrollArea()
self.scroll_area.setWidgetResizable(True)
self.widget_container = QWidget()
self.scroll_area.setWidget(self.widget_container)
self.container_layout = QVBoxLayout()
self.widget_container.setLayout(self.container_layout)
self.default_values_layout.addWidget(self.scroll_area)
# Restore state from setting
self.restore_state()
# Hide checkbox if not developers
if not self.cbxDevMode.isChecked():
self.checkbox_generate_reports.hide()
# Connections
# Check boxes
self.custom_north_arrow_checkbox.toggled.connect(self.set_north_arrow)
self.custom_UseUserDirectory_checkbox.toggled.connect(
self.set_user_dir)
self.custom_templates_dir_checkbox.toggled.connect(
self.set_templates_dir)
self.custom_org_disclaimer_checkbox.toggled.connect(
self.set_org_disclaimer)
self.custom_organisation_logo_check_box.toggled.connect(
self.toggle_logo_path)
# Buttons
self.toolKeywordCachePath.clicked.connect(self.open_keyword_cache_path)
self.toolUserDirectoryPath.clicked.connect(
self.open_user_directory_path)
self.toolNorthArrowPath.clicked.connect(self.open_north_arrow_path)
self.open_organisation_logo_path_button.clicked.connect(
self.open_organisation_logo_path)
self.toolReportTemplatePath.clicked.connect(
self.open_report_template_path)
# Others
self.organisation_logo_path_line_edit.textChanged.connect(
self.update_logo_preview)
self.earthquake_function.currentIndexChanged.connect(
self.update_earthquake_info)
# Set up listener for restore defaults button
self.demographic_restore_defaults = self.button_box_restore_defaults.\
button(QDialogButtonBox.RestoreDefaults)
self.demographic_restore_defaults.setText(
self.demographic_restore_defaults.text().capitalize())
self.demographic_restore_defaults.setCheckable(True)
self.demographic_restore_defaults.clicked.connect(
self.restore_defaults_ratio)
# Restore button in population parameter tab
self.parameter_population_restore_button = \
self.button_box_restore_preference.button(
QDialogButtonBox.RestoreDefaults)
self.parameter_population_restore_button.setText(
self.parameter_population_restore_button.text().capitalize())
self.parameter_population_restore_button.clicked.connect(
partial(self.restore_population_parameters, global_default=True))
# TODO: Hide this until behaviour is defined
# hide template warning toggle
self.template_warning_checkbox.hide()
# hide custom template dir toggle
self.custom_templates_dir_checkbox.hide()
self.splitter_custom_report.hide()
# Welcome message
self.set_welcome_message()
def save_boolean_setting(self, key, check_box):
"""Save boolean setting according to check_box state.
:param key: Key to retrieve setting value.
:type key: str
:param check_box: Check box to show and set the setting.
:type check_box: PyQt4.QtGui.QCheckBox.QCheckBox
"""
set_setting(key, check_box.isChecked(), qsettings=self.settings)
def restore_boolean_setting(self, key, check_box):
"""Set check_box according to setting of key.
:param key: Key to retrieve setting value.
:type key: str
:param check_box: Check box to show and set the setting.
:type check_box: PyQt4.QtGui.QCheckBox.QCheckBox
"""
flag = setting(key, expected_type=bool, qsettings=self.settings)
check_box.setChecked(flag)
def save_text_setting(self, key, line_edit):
"""Save text setting according to line_edit value.
:param key: Key to retrieve setting value.
:type key: str
:param line_edit: Line edit for user to edit the setting
:type line_edit: PyQt4.QtGui.QLineEdit.QLineEdit
"""
set_setting(key, line_edit.text(), self.settings)
def restore_text_setting(self, key, line_edit):
"""Set line_edit text according to setting of key.
:param key: Key to retrieve setting value.
:type key: str
:param line_edit: Line edit for user to edit the setting
:type line_edit: PyQt4.QtGui.QLineEdit.QLineEdit
"""
value = setting(key, expected_type=str, qsettings=self.settings)
line_edit.setText(value)
def restore_state(self):
"""Reinstate the options based on the user's stored session info."""
# Restore boolean setting as check box.
for key, check_box in self.boolean_settings.items():
self.restore_boolean_setting(key, check_box)
# Restore text setting as line edit.
for key, line_edit in self.text_settings.items():
self.restore_text_setting(key, line_edit)
# User Directory
user_directory_path = setting(key='defaultUserDirectory',
default=temp_dir('impacts'),
expected_type=str,
qsettings=self.settings)
custom_user_directory_flag = (user_directory_path !=
temp_dir('impacts'))
self.custom_UseUserDirectory_checkbox.setChecked(
custom_user_directory_flag)
self.splitter_user_directory.setEnabled(custom_user_directory_flag)
self.leUserDirectoryPath.setText(user_directory_path)
# Currency
# Populate the currency list
for currency in currencies:
self.currency_combo_box.addItem(currency['name'], currency['key'])
# Then make selected the default one.
default_currency = setting('currency', expected_type=str)
keys = [currency['key'] for currency in currencies]
if default_currency not in keys:
default_currency = currencies[0]['key']
index = self.currency_combo_box.findData(default_currency)
self.currency_combo_box.setCurrentIndex(index)
# Earthquake function.
# Populate the combobox first.
for model in EARTHQUAKE_FUNCTIONS:
self.earthquake_function.addItem(model['name'], model['key'])
# Then make selected the default one.
default_earthquake_function = setting('earthquake_function',
expected_type=str)
keys = [model['key'] for model in EARTHQUAKE_FUNCTIONS]
if default_earthquake_function not in keys:
default_earthquake_function = EARTHQUAKE_FUNCTIONS[0]['key']
index = self.earthquake_function.findData(default_earthquake_function)
self.earthquake_function.setCurrentIndex(index)
self.update_earthquake_info()
# Restore North Arrow Image Path
north_arrow_path = setting(key='north_arrow_path',
default=default_north_arrow_path(),
expected_type=str,
qsettings=self.settings)
custom_north_arrow_flag = (north_arrow_path !=
default_north_arrow_path())
self.custom_north_arrow_checkbox.setChecked(custom_north_arrow_flag)
self.splitter_north_arrow.setEnabled(custom_north_arrow_flag)
self.leNorthArrowPath.setText(north_arrow_path)
# Restore Report Template Directory Path
report_template_directory = setting(key='reportTemplatePath',
default='',
expected_type=str,
qsettings=self.settings)
custom_templates_dir_flag = (report_template_directory != '')
self.custom_templates_dir_checkbox.setChecked(
custom_templates_dir_flag)
self.leReportTemplatePath.setText(report_template_directory)
# Restore Disclaimer
org_disclaimer = setting(key='reportDisclaimer',
default=disclaimer(),
expected_type=str,
qsettings=self.settings)
custom_org_disclaimer_flag = (org_disclaimer != disclaimer())
self.custom_org_disclaimer_checkbox.setChecked(
custom_org_disclaimer_flag)
self.txtDisclaimer.setPlainText(org_disclaimer)
# Restore Organisation Logo Path
org_logo_path = setting(key='organisation_logo_path',
default=supporters_logo_path(),
expected_type=str,
qsettings=self.settings)
# Check if the path is default one or not
custom_org_logo_flag = org_logo_path != supporters_logo_path()
self.organisation_logo_path_line_edit.setText(org_logo_path)
self.custom_organisation_logo_check_box.setChecked(
custom_org_logo_flag)
self.organisation_logo_path_line_edit.setEnabled(custom_org_logo_flag)
self.open_organisation_logo_path_button.setEnabled(
custom_org_logo_flag)
# Manually call here
self.update_logo_preview()
# Restore InaSAFE default values
self.restore_default_values_page()
# Restore Population Parameter
self.restore_population_parameters(global_default=False)
def save_state(self):
"""Store the options into the user's stored session info."""
# Save boolean settings
for key, check_box in self.boolean_settings.items():
self.save_boolean_setting(key, check_box)
# Save text settings
for key, line_edit in self.text_settings.items():
self.save_text_setting(key, line_edit)
set_setting('north_arrow_path', self.leNorthArrowPath.text(),
self.settings)
set_setting('organisation_logo_path',
self.organisation_logo_path_line_edit.text(),
self.settings)
set_setting('reportTemplatePath', self.leReportTemplatePath.text(),
self.settings)
set_setting('reportDisclaimer', self.txtDisclaimer.toPlainText(),
self.settings)
set_setting('defaultUserDirectory', self.leUserDirectoryPath.text(),
self.settings)
index = self.earthquake_function.currentIndex()
value = self.earthquake_function.itemData(index)
set_setting('earthquake_function', value, qsettings=self.settings)
currency_index = self.currency_combo_box.currentIndex()
currency_key = self.currency_combo_box.itemData(currency_index)
set_setting('currency', currency_key, qsettings=self.settings)
# Save InaSAFE default values
self.save_default_values()
# Save population parameters
self.save_population_parameters()
def accept(self):
"""Method invoked when OK button is clicked."""
self.save_state()
super(OptionsDialog, self).accept()
def update_earthquake_info(self):
"""Update information about earthquake info."""
self.label_earthquake_model()
current_index = self.earthquake_function.currentIndex()
model = EARTHQUAKE_FUNCTIONS[current_index]
notes = ''
for note in model['notes']:
notes += note + '\n\n'
citations = ''
for citation in model['citations']:
citations += citation['text'] + '\n\n'
text = tr(
'Description:\n\n%s\n\n'
'Notes:\n\n%s\n\n'
'Citations:\n\n%s') % (model['description'], notes, citations)
self.earthquake_fatality_model_notes.setText(text)
def label_earthquake_model(self):
model = self.earthquake_function.currentText()
help_text = tr(
'Please select your preferred earthquake fatality model. The '
'default fatality model is the {model}.').format(model=model)
self.label_default_earthquake.setText(help_text)
def open_keyword_cache_path(self):
"""Open File dialog to choose the keyword cache path."""
# noinspection PyCallByClass,PyTypeChecker
file_name = QFileDialog.getSaveFileName(
self, self.tr('Set keyword cache file'),
self.leKeywordCachePath.text(), self.tr('Sqlite DB File (*.db)'))
if file_name:
self.leKeywordCachePath.setText(file_name)
def open_user_directory_path(self):
"""Open File dialog to choose the user directory path."""
# noinspection PyCallByClass,PyTypeChecker
directory_name = QFileDialog.getExistingDirectory(
self, self.tr('Results directory'),
self.leUserDirectoryPath.text(), QFileDialog.ShowDirsOnly)
if directory_name:
self.leUserDirectoryPath.setText(directory_name)
def open_north_arrow_path(self):
"""Open File dialog to choose the north arrow path."""
# noinspection PyCallByClass,PyTypeChecker
file_name = QFileDialog.getOpenFileName(
self, self.tr('Set north arrow image file'),
self.leNorthArrowPath.text(),
self.tr('Portable Network Graphics files (*.png *.PNG);;'
'JPEG Images (*.jpg *.jpeg);;'
'GIF Images (*.gif *.GIF);;'
'SVG Images (*.svg *.SVG);;'))
if file_name:
self.leNorthArrowPath.setText(file_name)
def open_organisation_logo_path(self):
"""Open File dialog to choose the organisation logo path."""
# noinspection PyCallByClass,PyTypeChecker
file_name = QFileDialog.getOpenFileName(
self, self.tr('Set organisation logo file'),
self.organisation_logo_path_line_edit.text(),
self.tr('Portable Network Graphics files (*.png *.PNG);;'
'JPEG Images (*.jpg *.jpeg);;'
'GIF Images (*.gif *.GIF);;'
'SVG Images (*.svg *.SVG);;'))
if file_name:
self.organisation_logo_path_line_edit.setText(file_name)
def open_report_template_path(self):
"""Open File dialog to choose the report template path."""
# noinspection PyCallByClass,PyTypeChecker
directory_name = QFileDialog.getExistingDirectory(
self, self.tr('Templates directory'),
self.leReportTemplatePath.text(), QFileDialog.ShowDirsOnly)
if directory_name:
self.leReportTemplatePath.setText(directory_name)
def toggle_logo_path(self):
"""Set state of logo path line edit and button."""
is_checked = self.custom_organisation_logo_check_box.isChecked()
if is_checked:
# Use previous org logo path
path = setting(key='organisation_logo_path',
default=supporters_logo_path(),
expected_type=str,
qsettings=self.settings)
else:
# Set organisation path line edit to default one
path = supporters_logo_path()
self.organisation_logo_path_line_edit.setText(path)
self.organisation_logo_path_line_edit.setEnabled(is_checked)
self.open_organisation_logo_path_button.setEnabled(is_checked)
def update_logo_preview(self):
"""Update logo based on the current logo path."""
logo_path = self.organisation_logo_path_line_edit.text()
if os.path.exists(logo_path):
icon = QPixmap(logo_path)
label_size = self.organisation_logo_label.size()
label_size.setHeight(label_size.height() - 2)
label_size.setWidth(label_size.width() - 2)
scaled_icon = icon.scaled(label_size, Qt.KeepAspectRatio)
self.organisation_logo_label.setPixmap(scaled_icon)
else:
self.organisation_logo_label.setText(tr("Logo not found"))
def set_north_arrow(self):
"""Auto-connect slot activated when north arrow checkbox is toggled."""
is_checked = self.custom_north_arrow_checkbox.isChecked()
if is_checked:
# Show previous north arrow path
path = setting(key='north_arrow_path',
default=default_north_arrow_path(),
expected_type=str,
qsettings=self.settings)
else:
# Set the north arrow line edit to default one
path = default_north_arrow_path()
self.leNorthArrowPath.setText(path)
self.splitter_north_arrow.setEnabled(is_checked)
def set_user_dir(self):
"""Auto-connect slot activated when user dir checkbox is toggled.
"""
is_checked = self.custom_UseUserDirectory_checkbox.isChecked()
if is_checked:
# Show previous templates dir
path = setting(key='defaultUserDirectory',
default='',
expected_type=str,
qsettings=self.settings)
else:
# Set the template report dir to ''
path = temp_dir('impacts')
self.leUserDirectoryPath.setText(path)
self.splitter_user_directory.setEnabled(is_checked)
def set_templates_dir(self):
"""Auto-connect slot activated when templates dir checkbox is toggled.
"""
is_checked = self.custom_templates_dir_checkbox.isChecked()
if is_checked:
# Show previous templates dir
path = setting(key='reportTemplatePath',
default='',
expected_type=str,
qsettings=self.settings)
else:
# Set the template report dir to ''
path = ''
self.leReportTemplatePath.setText(path)
self.splitter_custom_report.setEnabled(is_checked)
def set_org_disclaimer(self):
"""Auto-connect slot activated when org disclaimer checkbox is toggled.
"""
is_checked = self.custom_org_disclaimer_checkbox.isChecked()
if is_checked:
# Show previous organisation disclaimer
org_disclaimer = setting('reportDisclaimer',
default=disclaimer(),
expected_type=str,
qsettings=self.settings)
else:
# Set the organisation disclaimer to the default one
org_disclaimer = disclaimer()
self.txtDisclaimer.setPlainText(org_disclaimer)
self.txtDisclaimer.setEnabled(is_checked)
@pyqtSlot()
@pyqtSignature('bool') # prevents actions being handled twice
def help_toggled(self, flag):
"""Show or hide the help tab in the stacked widget.
.. versionadded: 3.2.1
:param flag: Flag indicating whether help should be shown or hidden.
:type flag: bool
"""
if flag:
self.help_button.setText(self.tr('Hide Help'))
self.show_help()
else:
self.help_button.setText(self.tr('Show Help'))
self.hide_help()
def hide_help(self):
"""Hide the usage info from the user.
.. versionadded: 3.2.1
"""
self.main_stacked_widget.setCurrentIndex(1)
def show_help(self):
"""Show usage info to the user."""
# Read the header and footer html snippets
self.main_stacked_widget.setCurrentIndex(0)
header = html_header()
footer = html_footer()
string = header
message = options_help()
string += message.to_html()
string += footer
self.help_web_view.setHtml(string)
def restore_default_values_page(self):
"""Setup UI for default values setting."""
# Clear parameters so it doesn't add parameters when
# restore from changes.
if self.default_value_parameters:
self.default_value_parameters = []
if self.default_value_parameter_containers:
self.default_value_parameter_containers = []
for i in reversed(range(self.container_layout.count())):
widget = self.container_layout.itemAt(i).widget()
if widget is not None:
widget.setParent(None)
default_fields = all_default_fields()
for field_group in all_field_groups:
settable_fields = []
for field in field_group['fields']:
if field not in default_fields:
continue
else:
settable_fields.append(field)
default_fields.remove(field)
if not settable_fields:
continue
# Create group box for each field group
group_box = QGroupBox(self)
group_box.setTitle(field_group['name'])
self.container_layout.addWidget(group_box)
parameters = []
for settable_field in settable_fields:
parameter = self.default_field_to_parameter(settable_field)
if parameter:
parameters.append(parameter)
parameter_container = ParameterContainer(
parameters,
description_text=field_group['description'],
extra_parameters=extra_parameter)
parameter_container.setup_ui(must_scroll=False)
group_box_inner_layout = QVBoxLayout()
group_box_inner_layout.addWidget(parameter_container)
group_box.setLayout(group_box_inner_layout)
# Add to attribute
self.default_value_parameter_containers.append(parameter_container)
# Only show non-groups default fields if there is one
if len(default_fields) > 0:
for default_field in default_fields:
parameter = self.default_field_to_parameter(default_field)
if parameter:
self.default_value_parameters.append(parameter)
description_text = tr(
'In this options you can change the global default values for '
'these variables.')
parameter_container = ParameterContainer(
self.default_value_parameters,
description_text=description_text,
extra_parameters=extra_parameter)
parameter_container.setup_ui(must_scroll=False)
self.other_group_box = QGroupBox(tr('Non-group fields'))
other_group_inner_layout = QVBoxLayout()
other_group_inner_layout.addWidget(parameter_container)
self.other_group_box.setLayout(other_group_inner_layout)
self.container_layout.addWidget(self.other_group_box)
# Add to attribute
self.default_value_parameter_containers.append(parameter_container)
def restore_population_parameters(self, global_default=True):
"""Setup UI for population parameter page from setting.
:param global_default: If True, set to original default (from
the value in definitions).
:type global_default: bool
"""
if global_default:
data = generate_default_profile()
else:
data = setting('population_preference', generate_default_profile())
if not isinstance(data, dict):
LOGGER.debug(
'population parameter is not a dictionary. InaSAFE will use '
'the default one.')
data = generate_default_profile()
try:
self.profile_widget.data = data
except KeyError as e:
LOGGER.debug(
'Population parameter is not in correct format. InaSAFE will '
'use the default one.')
LOGGER.debug(e)
data = generate_default_profile()
self.profile_widget.data = data
@staticmethod
def age_ratios():
"""Helper to get list of age ratio from the options dialog.
:returns: List of age ratio.
:rtype: list
"""
# FIXME(IS) set a correct parameter container
parameter_container = None
youth_ratio = parameter_container.get_parameter_by_guid(
youth_ratio_field['key']).value
adult_ratio = parameter_container.get_parameter_by_guid(
adult_ratio_field['key']).value
elderly_ratio = parameter_container.get_parameter_by_guid(
elderly_ratio_field['key']).value
ratios = [youth_ratio, adult_ratio, elderly_ratio]
return ratios
def is_good_age_ratios(self):
"""Method to check the sum of age ratio is 1.
:returns: True if the sum is 1 or the sum less than 1 but there is
None.
:rtype: bool
"""
ratios = self.age_ratios()
if None in ratios:
# If there is None, just check to not exceeding 1
clean_ratios = [x for x in ratios if x is not None]
ratios.remove(None)
if sum(clean_ratios) > 1:
return False
else:
if sum(ratios) != 1:
return False
return True
def save_default_values(self):
"""Save InaSAFE default values."""
for parameter_container in self.default_value_parameter_containers:
parameters = parameter_container.get_parameters()
for parameter in parameters:
set_inasafe_default_value_qsetting(self.settings, GLOBAL,
parameter.guid,
parameter.value)
def restore_defaults_ratio(self):
"""Restore InaSAFE default ratio."""
# Set the flag to true because user ask to.
self.is_restore_default = True
# remove current default ratio
for i in reversed(range(self.container_layout.count())):
widget = self.container_layout.itemAt(i).widget()
if widget is not None:
widget.setParent(None)
# reload default ratio
self.restore_default_values_page()
def default_field_to_parameter(self, default_field):
"""Obtain parameter from default field.
:param default_field: A default field definition.
:type default_field: dict
:returns: A parameter object.
:rtype: FloatParameter, IntegerParameter
"""
if default_field.get('type') == QVariant.Double:
parameter = FloatParameter()
elif default_field.get('type') in qvariant_whole_numbers:
parameter = IntegerParameter()
else:
return
default_value = default_field.get('default_value')
if not default_value:
message = ('InaSAFE default field %s does not have default value' %
default_field.get('name'))
LOGGER.exception(message)
return
parameter.guid = default_field.get('key')
parameter.name = default_value.get('name')
parameter.is_required = True
parameter.precision = default_field.get('precision')
parameter.minimum_allowed_value = default_value.get('min_value', 0)
parameter.maximum_allowed_value = default_value.get(
'max_value', 100000000)
parameter.help_text = default_value.get('help_text')
parameter.description = default_value.get('description')
# Check if user ask to restore to the most default value.
if self.is_restore_default:
parameter._value = default_value.get('default_value')
else:
# Current value
qsetting_default_value = get_inasafe_default_value_qsetting(
self.settings, GLOBAL, default_field['key'])
# To avoid python error
if qsetting_default_value > parameter.maximum_allowed_value:
qsetting_default_value = parameter.maximum_allowed_value
if qsetting_default_value < parameter.minimum_allowed_value:
qsetting_default_value = parameter.minimum_allowed_value
parameter.value = qsetting_default_value
return parameter
def save_population_parameters(self):
"""Helper to save population parameter to QSettings."""
population_parameter = self.profile_widget.data
set_setting('population_preference', population_parameter)
def set_welcome_message(self):
"""Create and insert welcome message."""
string = html_header()
string += welcome_message().to_html()
string += html_footer()
self.welcome_message.setHtml(string)
def show_option_dialog(self):
"""Helper to show usual option dialog (without welcome message tab)."""
self.tabWidget.removeTab(0)
def show_welcome_dialog(self):
"""Setup for showing welcome message dialog.
This method will setup several things:
- Only show welcome, organisation profile, and population parameter
tab. Currently, they are the first 3 tabs.
- Set the title
- Move the check box for always showing welcome message.
"""
self.welcome_layout.addWidget(self.welcome_message_check_box)
while self.tabWidget.count() > 3:
self.tabWidget.removeTab(self.tabWidget.count() - 1)
self.setWindowTitle(self.tr('Welcome to InaSAFE %s' % get_version()))
# Hide the export import button
self.export_button.hide()
self.import_button.hide()
def export_setting(self):
"""Export setting from an existing file."""
LOGGER.debug('Export button clicked')
home_directory = os.path.expanduser('~')
file_name = self.organisation_line_edit.text().replace(' ', '_')
file_path = QFileDialog.getSaveFileName(
self, self.tr('Export InaSAFE settings'),
os.path.join(home_directory, file_name + '.json'),
self.tr('JSON File (*.json)'))
if file_path:
LOGGER.debug('Exporting to %s' % file_path)
export_setting(file_path)
def import_setting(self):
"""Import setting to a file."""
LOGGER.debug('Import button clicked')
home_directory = os.path.expanduser('~')
file_path = QFileDialog.getOpenFileName(
self, self.tr('Import InaSAFE settings'), home_directory,
self.tr('JSON File (*.json)'))
if file_path:
title = tr('Import InaSAFE Settings.')
question = tr(
'This action will replace your current InaSAFE settings with '
'the setting from the file. This action is not reversible. '
'Are you sure to import InaSAFE Setting?')
answer = QMessageBox.question(self, title, question,
QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.Yes:
LOGGER.debug('Import from %s' % file_path)
import_setting(file_path)
class WidgetFFmpeg(QDialog):
def __init__(self, idCodec, cheminVideoEntre, cheminSorti, valeurNum=0, laisserOuvert=1, tailleIm=None, tailleVideo=None, systeme=None, cheminFfmpeg=None, tempsApercu=None, optionSpeciale=None, cheminMPlayer=None):
"""widget ffmpeg"""
super(WidgetFFmpeg, self).__init__()
self.cheminFfmpeg=u"ffmpeg"
self.cheminVideoEntre = unicode(cheminVideoEntre)
self.cheminSorti = unicode(cheminSorti)
# identifiant du codec
self.idCodec = idCodec
# valeur de la boite de spin pour l'encodage
self.valeurNum = valeurNum
# dimension des images (liste de 2 éléments)
self.tailleIm = tailleIm
# dimension de la vidéo (liste de 2 éléments)
self.tailleVideo = tailleVideo
# laisser ouvert la fenêtre après encodage
self.laisserOuvert = laisserOuvert
# Conversion minimale du filtre pour avoir un aperçu.
# Indique le temps où l'aperçu doit être créé
self.tempsApercu = tempsApercu
# drapeau pour ne pas lancer 2 fois l'encodage
self.estLancee = False
# Est-ce que le 1er % de progression a été récupéré (utile pour montage vidéo -> découper)?
self.__recupPourcentDebut = 0
# Pour le son lors de la découpe vidéo pour l'instant
if optionSpeciale!=None:
self.optionSpeciale = optionSpeciale
self.resize(500, 100)
#=== Widgets ===#
self.labelAttente=QLabel()
self.labelAttente.setText(_(u"Attendez la fin du calcul s'il vous plaît, soyez patient !"))
self.zoneTexte = QTextEdit("") # là où s'afficheront les infos
if PYQT_VERSION_STR < "4.1.0":
self.zoneTexte.setText = self.zoneTexte.setPlainText
self.zoneTexte.setReadOnly(True)
self.zoneTexte.setText("#######\n# LOG :\n#######\n")
self.zoneTexte.hide()
self.bout_annuler = QPushButton(_(u"Annuler"))
self.bout_preZoneTexte = QPushButton(_("Voir les informations de l'encodage"))
self.bout_preZoneTexte.hide()
self.pbar = QProgressBar()
self.pbar.setMaximum(100)
vbox = QVBoxLayout()
vbox.addWidget(self.labelAttente)
vbox.addWidget(self.bout_preZoneTexte)
vbox.addWidget(self.zoneTexte)
hbox = QHBoxLayout()
hbox.addWidget(self.pbar)
hbox.addWidget(self.bout_annuler)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.ffmpegProcess = FFmpeg(inputfile = unicode(self.cheminVideoEntre), outputfile = unicode(self.cheminSorti), codec = self.idCodec, imgsize = self.tailleIm, videosize = self.tailleVideo)
#=== connexion des widgets à des fonctions ===#
self.connect(self.ffmpegProcess, SIGNAL('progress(int)'), self.pbar.setValue)
self.connect(self.ffmpegProcess, SIGNAL('log(QString)'), self.zoneTexte.append)
self.connect(self.ffmpegProcess, SIGNAL('finished(int)'), self.finEncodage)
self.connect(self.bout_annuler, SIGNAL('clicked()'), self.close)
self.connect(self.bout_preZoneTexte, SIGNAL('clicked()'), self.afficherLog)
## On sort cette partie qui ne doit pas être lancée dans l'init de l'objet.
# Uniquement FFmpeg
#self.demarrerEncodeur('Ffmpeg')
def setVideoLen(self, videoLen) :
self.ffmpegProcess.setVideoLen(videoLen)
def close(self):
""" Annule le traitement en cours """
self.ffmpegProcess.cancel()
self.ffmpegProcess.wait()
#super(WidgetFFmpeg, self).close() # Python 2.6
QDialog.close(self)
def exec_(self):
""" Surcharge de la fonction exec permettant l'execution hors de l'init"""
self.demarrerEncodeur('Ffmpeg')
#super(WidgetFFmpeg, self).exec_() # Python 2.6
QDialog.exec_(self)
def demarrerEncodeur(self, encodeur):
"""démarrage de mencoder avec les arguments choisis"""
if self.estLancee == False: # pas question de démarrer 2 fois l'encodage
commande = None
has_audio = False
debug('\n')
# Si la conversion d'images en vidéo est sélectionné, aucune
# info Mplayer n'est affichée (problème de récup infos par Mplayer)
if self.idCodec in ['mpeg1video', 'mjpeg', 'h263p', 'mpeg4', 'msmpeg4v2', 'ljpeg', 'dv', 'huffyuv', 'mov', 'flv', 'mp4', 'vob']:
# ICI SI LES FICHIERS CHARGES SONT DES IMAGES
a = "###############################"
b = "# Informations sur les images :"
c = "###############################"
infos = '\n'+a+'\n'+b+'\n'+c+'\n'
debug(infos)
self.zoneTexte.append(infos)
import glob
# Le chemin pour l'affichage des infos sur les images ne fonctionnait
# plus après la nouvelle structure des fichiers temporaires
self.recupTempImgAnim = glob.glob(EkdConfig.getTempDir() + os.sep + "*.*")
self.recupTempImgAnim.sort()
# Affichage du chemin (temp) + le poids de chaque image
# --> Une énumération de parcours a été introduite
for parcNb, parcInfIm in enumerate(self.recupTempImgAnim):
debug('* '+str(parcNb+1)+'. '+parcInfIm+' --> '+str(float(os.path.getsize(parcInfIm)/1000))+' ko'+'\n')
self.zoneTexte.append('* '+str(parcNb+1)+'. '+parcInfIm+' --> '+str(float(os.path.getsize(parcInfIm)/1000))+' ko'+'\n')
# Elimination de la dernière image de la liste car car elle
# s'affiche en double ds la fenêtre information de l'encodage
# et aussi ds la console
#self.log = self.log[:len(self.log)-1]
# On définie la longueur de la futur vidéo en divisant le nombre d'image par le
# nombre d'image par seconde (valeurNum ici)
self.ffmpegProcess.setVideoLen(len(self.recupTempImgAnim) / int(self.valeurNum))
# Pour les traitements autres que la transformation des images en vidéo
if self.idCodec not in ['mpeg1video', 'mjpeg', 'h263p', 'mpeg4', 'msmpeg4v2', 'ljpeg', 'dv', 'huffyuv', 'mov', 'flv', 'mp4', 'vob']:
a = "########################"
b = "# Informations MPlayer :"
c = "########################"
infos = '\n'+a+'\n'+b+'\n'+c+'\n'
debug(infos)
######## Ajouté le 24/07/09 ##################################################################
# Utilisation de la classe infovideo (et en particilier la fonction setVideo)
# présents dans gui_modules_animation/infoVideo.py
info = infovideo(self.cheminVideoEntre)
id_filename = 'ID_FILENAME='+self.cheminVideoEntre+'\n'
debug(id_filename)
id_demuxer = 'ID_DEMUXER='+info.demux+'\n'
debug(id_demuxer)
id_video_format = 'ID_VIDEO_FORMAT='+info.videoFormat+'\n'
debug(id_video_format)
id_video_codec = 'ID_VIDEO_CODEC='+info.video_codec+'\n'
debug(id_video_codec)
id_video_bitrate = 'ID_VIDEO_BITRATE='+str(info.videoBitrate)+'\n'
debug(id_video_bitrate)
id_video_largeur = 'ID_VIDEO_WIDTH='+str(info.videoLargeur)+'\n'
debug(id_video_largeur)
id_video_hauteur = 'ID_VIDEO_HEIGHT='+str(info.videoHauteur)+'\n'
debug(id_video_hauteur)
id_img_par_sec = 'ID_VIDEO_FPS='+str(info.imgParSec)+'\n'
debug(id_img_par_sec)
##### Donnée très importante pour la suite du calcul (pour ffmpeg.py et ffmpeg2theora) ####
self.dureeTotaleVideo = float(info.dureeTotaleVideo)
###########################################################################################
id_duree_totale_video = 'ID_LENGTH='+str(info.dureeTotaleVideo)+'\n'
debug(id_duree_totale_video)
id_audio_codec = 'ID_AUDIO_CODEC='+info.audioCodec+'\n'
debug(id_audio_codec)
id_audio_rate = 'ID_AUDIO_RATE='+str(info.audioRate)+'\n'
debug(id_audio_rate)
id_audio_bitrate = 'ID_AUDIO_BITRATE='+str(info.audioBitrate)+'\n'
debug(id_audio_bitrate)
self.zoneTexte.append(infos+id_filename+id_demuxer+id_video_format+id_video_codec+id_video_bitrate+id_video_largeur+id_video_hauteur+id_img_par_sec+id_duree_totale_video+id_audio_codec+id_audio_rate+id_audio_bitrate)
##############################################################################################
## On définie la longueur de la vidéo pour le process
self.ffmpegProcess.setVideoLen(self.dureeTotaleVideo)
if info.audioCodec :
has_audio = True
debug('\n')
a = "############################"
b = "# Informations %s :" %encodeur
c = "############################"
infos = '\n'+a+'\n'+b+'\n'+c+'\n'
debug(infos)
self.zoneTexte.append(infos)
if self.idCodec=='codec_dv_ffmpeg':
self.ffmpegProcess.commandeFfmpegEncodageDv()
elif self.idCodec=='codec_mov_ffmpeg':
#### Enlevé le 09/04/11 ##############################
#self.ffmpegProcess.commandeFfmpegEncodageMov()
######################################################
#### Ajouté/rectifié le 09/04/11 #####################
self.ffmpegProcess.commandeFfmpegEncodageMov(comp = self.valeurNum[0], size = self.valeurNum[1])
######################################################
elif self.idCodec=='codec_hfyu_ffmpeg':
#### Enlevé le 10/04/11 ##############################
#self.ffmpegProcess.commandeFfmpegEncodageHfyu(audio = has_audio)
######################################################
#### Ajouté/rectifié le 10/04/11 #####################
self.ffmpegProcess.commandeFfmpegEncodageHfyu(size = self.valeurNum, audio = has_audio)
######################################################
elif self.idCodec=='codec_vob_ffmpeg':
self.ffmpegProcess.commandeFfmpegEncodageVob(vquantizer = self.valeurNum)
elif self.idCodec=='codec_3GP_ffmpeg':
#### Enlevé le 30/03/11 ##############################
#self.ffmpegProcess.commandeFfmpegEncodage3gp(audio = has_audio)
#### Ajouté/rectifié le 30/03/11 #####################
self.ffmpegProcess.commandeFfmpegEncodage3gp(size = self.valeurNum)
######################################################
elif self.idCodec=='codec_AMV_ffmpeg':
#### Rectifié le 30/03/11 ## Ajout de size ###########
self.ffmpegProcess.commandeFfmpegEncodageAMV(size = self.valeurNum)
######################################################
elif self.idCodec=='idx':
self.ffmpegProcess.commandeFfmpegNbrImgSec(rate = self.valeurNum)
elif self.idCodec in ['mpeg1video', 'mjpeg', 'h263p', 'mpeg4', 'msmpeg4v2', 'ljpeg', 'dv', 'huffyuv', 'mov', 'flv', 'mp4', 'vob']:
self.ffmpegProcess.commandeFfmpegConvertImg(rate = self.valeurNum, size = "%sx%s" % (self.tailleIm[0], self.tailleIm[1]), vcodec = self.idCodec)
# --------------------------------------------------------------------------------- #
# Traitement pour chaque entrée concernant la HD (classique, en dehors du codec Avid DNxHD)
# --------------------------------------------------------------------------------- #
elif self.idCodec in ['hd_1920x1080_mov__pcm_s16be__16/9', 'hd_1280x720_mov__pcm_s16be__16/9', 'hd_1440x1080_mov__pcm_s16be__4/3']:
## FIXME : La taille est récupérée du nom de idCodec (crade)
self.ffmpegProcess.commandeFfmpegConvHD(size = self.idCodec.split("_")[1])
### Ajouté le 19/08/10 (Gestion du codec Avid DNxHD) ################################
# --------------------------------------------------------------------------------- #
# Traitement pour chaque entrée (24) concernant le codec Avid DNxHD pour la HD
# --------------------------------------------------------------------------------- #
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_220_mbs':
## FIXME : Les éléments utiles sont récupérés du nom de idCodec (crade mais utile)
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 1
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_145_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 2
elif self.idCodec=='hd_dnxhd_1920x1080_25_185_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 3
elif self.idCodec=='hd_dnxhd_1920x1080_25_120_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 4
elif self.idCodec=='hd_dnxhd_1920x1080_25_36_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 5
elif self.idCodec=='hd_dnxhd_1920x1080_24_175_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 6
elif self.idCodec=='hd_dnxhd_1920x1080_24_115_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 7
elif self.idCodec=='hd_dnxhd_1920x1080_24_36_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 8
elif self.idCodec=='hd_dnxhd_1920x1080_23.976_175_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 9
elif self.idCodec=='hd_dnxhd_1920x1080_23.976_115_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 10
elif self.idCodec=='hd_dnxhd_1920x1080_23.976_36_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 11
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_220_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 12
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_145_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 13
elif self.idCodec=='hd_dnxhd_1920x1080_29.97_45_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 14
elif self.idCodec=='hd_dnxhd_1280x720_59.94_220_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 15
elif self.idCodec=='hd_dnxhd_1280x720_59.94_145_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 16
elif self.idCodec=='hd_dnxhd_1280x720_50_175_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 17
elif self.idCodec=='hd_dnxhd_1280x720_50_115_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 18
elif self.idCodec=='hd_dnxhd_1280x720_29.97_110_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 19
elif self.idCodec=='hd_dnxhd_1280x720_29.97_75_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 20
elif self.idCodec=='hd_dnxhd_1280x720_25_90_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 21
elif self.idCodec=='hd_dnxhd_1280x720_25_60_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 22
elif self.idCodec=='hd_dnxhd_1280x720_23.976_90_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 23
elif self.idCodec=='hd_dnxhd_1280x720_23.976_60_mbs':
self.ffmpegProcess.commandeFfmpegConvHD_DNxHD(size=self.idCodec.split("_")[2], vcodec=self.idCodec.split("_")[1], rate=self.idCodec.split("_")[3], vbitrate=self.idCodec.split("_")[4]+'000k') # 24
#################################################################################
elif self.idCodec=='jpeg': # convertir animation en images
self.ffmpegProcess.commandeFfmpegConvAnimImg()
elif self.idCodec=='extractionaudio':
self.ffmpegProcess.commandeFfmpegSeparation()
elif self.idCodec=='encodage_wav': # encodage de fichiers audio en wav
self.ffmpegProcess.commandeFfmpegEncodageWav()
elif self.idCodec=='conv_en_16_9_ou_4_3': # Convertir vidéo en 16/9 ou 4/3
self.ffmpegProcess.commandeFfmpegConv_16_9_ou_4_3(
ext = os.path.splitext(self.cheminVideoEntre)[1],
size = "%sx%s" % (self.tailleVideo[0], self.tailleVideo[1]),
aspect = self.valeurNum,
audio = has_audio)
# Remonté d'un niveau pour simplifier le code et éviter les répetitions
if commande == None:
commande = self.ffmpegProcess.command
else :
self.ffmpegProcess.command = commande
debug(commande)
self.zoneTexte.append(commande+'\n\n')
self.ffmpegProcess.start()
debug(u"Commande lancée")
self.estLancee = True
def finEncodage(self, statutDeSortie):
"""choses à faire à la fin de l'encodage de la vidéo"""
# fermer la fenêtre à la fin de l'encodage
if not self.laisserOuvert:
self.close()
debug("fini!")
self.labelAttente.hide()
self.pbar.setValue(100)
# l'encodage est fini. Il ne peut plus être annulé. La
# seule action possible devient ainsi la fermeture
self.bout_annuler.setText(_(u"Fermer"))
if statutDeSortie != 0 :
self.bout_annuler.setText(_(u"Crash"))
self.bout_preZoneTexte.show()
self.emit(SIGNAL("finEncodage"))
def afficherLog(self):
"""afficher les information de la vidéo de départ et de l'encodage"""
self.zoneTexte.setText(self.ffmpegProcess.log)
self.zoneTexte.show()
self.resize(500, 300)
class RipperWidget(SmoothWidget, ripper.Ripper):
""" One-button multi-track ripper.
"""
def __init__(self, parent=None):
SmoothWidget.__init__(self, parent)
ripper.Ripper.__init__(self)
Layout = QVBoxLayout(self)
self.discLabel = QLabel(self)
Layout.addWidget(self.discLabel)
# ONLY ONE BUTTON!
self.button = QPushButton('Cancel', self)
self.button.setEnabled(True)
self.button.hide()
QObject.connect(self.button, SIGNAL('clicked()'),
self.cancel)
Layout.addWidget(self.button)
self.catFrame = QFrame(self)
self.catFrame.setFrameStyle(QFrame.StyledPanel)
self.catFrame.hide()
QHBoxLayout(self.catFrame)
self.categories = CategoryButtons(self.catFrame)
QObject.connect(self.categories, SIGNAL('selected(QString &)'),
self.start)
self.catFrame.layout().addWidget(self.categories)
Layout.addWidget(self.catFrame)
self.progress = QProgressBar(self)
self.progress.setRange(0, 100)
self.progress.hide()
Layout.addWidget(self.progress)
def start(self, category):
""" Should already have the track info. """
self.genre = str(category)
self._progress_data = {}
self.disc_length = 0.0
for i in range(self.count):
sec = cd_logic.get_track_time_total(i)
self._progress_data[i] = {'rip' : 0,
'enc' : 0,
'length' : sec}
self.disc_length += sec
self.rip_n_encode()
text = '%s - %s' % (self.artist, self.album)
self.discLabel.setText('Copying "'+text+'"...')
self.button.show()
self.progress.show()
self.catFrame.hide()
def cancel(self):
self.stop_request = True
path = os.path.join(ripper.LIBRARY,
self.genre,
self.artist+' - '+self.album)
os.system('rm -rf \"%s\"' % path)
self.discLabel.setText('Canceled')
self.button.hide()
self.progress.hide()
self.progress.setValue(0)
self.emit(SIGNAL('canceled()'))
def read_disc_info(self):
self.discLabel.setText('Getting disc info...')
ripper.Ripper.read_disc_info(self)
def ripper_event(self, e):
""" """
event = QEvent(event_type(e.type))
event.data = e.__dict__
QApplication.instance().postEvent(self, event)
def customEvent(self, e):
if e.type() == event_type(ripper.CDDB_DONE):
self.button.setEnabled(True)
text = '%s - %s' % (self.artist, self.album)
text += ' ( Select a category... )'
self.discLabel.setText(text)
self.catFrame.show()
self.emit(SIGNAL('foundDiscInfo()'))
elif e.type() == event_type(ripper.STATUS_UPDATE):
self.updateProgress(e.data)
self.emit(SIGNAL('status(QEvent *)'), e)
def updateProgress(self, data):
"""
assume rip and enc are equal in time.
"""
state = data['state']
tracknum = data['tracknum']
percent = data['percent']
goal_percents = self.count * 200
item = self._progress_data[tracknum]
if state == 'rip':
item['rip'] = percent
elif state == 'enc':
item['enc'] = percent
else:
# err, etc...
item['rip'] = 0
item['enc'] = 0
total = 0
for i, v in self._progress_data.items():
seconds = v['length']
rip_perc = v['rip']
enc_perc = v['enc']
worth = seconds / self.disc_length
rip_perc *= worth
enc_perc *= worth
total += rip_perc + enc_perc
#print i, worth, rip_perc, enc_perc, total
percent = total / 2
self.progress.setValue(percent)
if percent == 100:
if self.is_ripping:
print 'percent == 100 but still ripping?'
if self.is_encoding:
print 'percent == 100 but still encoding?'
else:
print 'percent == 100 and ripper finished'
self.button.hide()
self.progress.hide()
text = 'Finished copying \"%s - %s\"' % (self.artist, self.album)
self.discLabel.setText(text)
self.emit(SIGNAL('doneRipping()'))
class AdvancedVisualizationForm(QWidget):
def __init__(self, mainwindow, result_manager):
QWidget.__init__(self, mainwindow)
#mainwindow is an OpusGui
self.mainwindow = mainwindow
self.result_manager = result_manager
self.toolboxBase = self.result_manager.mainwindow.toolboxBase
self.inGui = False
self.logFileKey = 0
self.xml_helper = ResultsManagerXMLHelper(toolboxBase = self.toolboxBase)
self.result_generator = OpusResultGenerator(
toolboxBase = self.toolboxBase)
self.result_generator.guiElement = self
self.tabIcon = QIcon(':/Images/Images/cog.png')
self.tabLabel = 'Advanced Visualization'
self.widgetLayout = QVBoxLayout(self)
self.widgetLayout.setAlignment(Qt.AlignTop)
self.resultsGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.resultsGroupBox)
self.dataGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.dataGroupBox)
self.optionsGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.optionsGroupBox)
self._setup_definition_widget()
self._setup_buttons()
self._setup_tabs()
def _setup_buttons(self):
# Add Generate button...
self.pbn_go = QPushButton(self.resultsGroupBox)
self.pbn_go.setObjectName('pbn_go')
self.pbn_go.setText(QString('Go!'))
QObject.connect(self.pbn_go, SIGNAL('released()'),
self.on_pbn_go_released)
self.widgetLayout.addWidget(self.pbn_go)
self.pbn_set_esri_storage_location = QPushButton(self.optionsGroupBox)
self.pbn_set_esri_storage_location.setObjectName('pbn_set_esri_storage_location')
self.pbn_set_esri_storage_location.setText(QString('...'))
self.pbn_set_esri_storage_location.hide()
QObject.connect(self.pbn_set_esri_storage_location, SIGNAL('released()'),
self.on_pbn_set_esri_storage_location_released)
def _setup_tabs(self):
# Add a tab widget and layer in a tree view and log panel
self.tabWidget = QTabWidget(self.resultsGroupBox)
# Log panel
self.logText = QTextEdit(self.resultsGroupBox)
self.logText.setReadOnly(True)
self.logText.setLineWidth(0)
self.tabWidget.addTab(self.logText,'Log')
# Finally add the tab to the model page
self.widgetLayout.addWidget(self.tabWidget)
#
def _setup_definition_widget(self):
#### setup results group box ####
self.gridlayout = QGridLayout(self.resultsGroupBox)
self.gridlayout.setObjectName('gridlayout')
self.lbl_results = QLabel(self.resultsGroupBox)
self.lbl_results.setObjectName('lbl_results')
self.lbl_results.setText(QString('Results'))
self.gridlayout.addWidget(self.lbl_results,0,0,1,3)
self._setup_co_results()
self.gridlayout.addWidget(self.co_results,0,3,1,10)
self.pbn_add = QPushButton(self.resultsGroupBox)
self.pbn_add.setObjectName('pbn_add')
self.pbn_add.setText(QString('+'))
QObject.connect(self.pbn_add, SIGNAL('released()'),
self.on_pbn_add_released)
self.gridlayout.addWidget(self.pbn_add, 0, 14, 1, 1)
self.lw_indicators = QListWidget(self.resultsGroupBox)
self.lw_indicators.setObjectName('lw_indicators')
self.gridlayout.addWidget(self.lw_indicators,1,1,1,13)
self.pbn_remove = QPushButton(self.resultsGroupBox)
self.pbn_remove.setObjectName('pbn_remove')
self.pbn_remove.setText(QString('-'))
QObject.connect(self.pbn_remove, SIGNAL('released()'),
self.on_pbn_remove_released)
self.gridlayout.addWidget(self.pbn_remove, 1, 14, 1, 1)
#### setup data group box ####
self.gridlayout2 = QGridLayout(self.dataGroupBox)
self.gridlayout2.setObjectName('gridlayout2')
self._setup_co_result_style()
self.gridlayout2.addWidget(self.co_result_style,1,0,1,2)
self.lbl_result_style_sep = QLabel(self.resultsGroupBox)
self.lbl_result_style_sep.setObjectName('lbl_result_style_sep')
self.lbl_result_style_sep.setText(QString('<center>as</center>'))
self.gridlayout2.addWidget(self.lbl_result_style_sep,1,2,1,1)
self._setup_co_result_type()
self.gridlayout2.addWidget(self.co_result_type,1,3,1,2)
##### setup options group box ####
self.gridlayout3 = QGridLayout(self.optionsGroupBox)
self.gridlayout3.setObjectName('gridlayout3')
self.le_esri_storage_location = QLineEdit(self.optionsGroupBox)
self.le_esri_storage_location.setObjectName('le_esri_storage_location')
self.le_esri_storage_location.setText('[set path]')
self.le_esri_storage_location.hide()
self.optionsGroupBox.hide()
QObject.connect(self.co_result_style, SIGNAL('currentIndexChanged(int)'),
self.on_co_result_style_changed)
QObject.connect(self.co_result_type, SIGNAL('currentIndexChanged(int)'),
self.on_co_result_type_changed)
def _setup_co_results(self):
self.co_results = QComboBox(self.resultsGroupBox)
self.co_results.setObjectName('co_results')
self.co_results.addItem(QString('[select]'))
results = self.xml_helper.get_available_results()
for result in results:
name = '%i.%s'%(result['run_id'],result['indicator_name'])
self.co_results.addItem(QString(name))
def _setup_co_result_style(self):
available_styles = [
'visualize',
'export',
]
self.co_result_style = QComboBox(self.dataGroupBox)
self.co_result_style.setObjectName('co_result_style')
for dataset in available_styles:
self.co_result_style.addItem(QString(dataset))
def _setup_co_result_type(self):
available_types = [
'Table (per year, spans indicators)',
'Chart (per indicator, spans years)',
'Map (per indicator per year)',
'Chart (per indicator, spans years)',
]
self.co_result_type = QComboBox(self.dataGroupBox)
self.co_result_type.setObjectName('co_result_type')
for dataset in available_types:
self.co_result_type.addItem(QString(dataset))
def on_pbnRemoveModel_released(self):
self.result_manager.removeTab(self)
self.result_manager.updateGuiElements()
def on_pbn_add_released(self):
cur_selected = self.co_results.currentText()
for i in range(self.lw_indicators.count()):
if self.lw_indicators.item(i).text() == cur_selected:
return
self.lw_indicators.addItem(cur_selected)
def on_pbn_remove_released(self):
selected_idxs = self.lw_indicators.selectedIndexes()
for idx in selected_idxs:
self.lw_indicators.takeItem(idx.row())
def on_co_result_style_changed(self, ind):
available_viz_types = [
'Table (per year, spans indicators)',
'Chart (per indicator, spans years)',
'Map (per indicator per year)',
'Chart (per indicator, spans years)',
]
available_export_types = [
'ESRI table (for loading in ArcGIS)'
]
txt = self.co_result_style.currentText()
if txt == 'visualize':
available_types = available_viz_types
else:
available_types = available_export_types
self.co_result_type.clear()
for result_type in available_types:
r_type = QString(result_type)
self.co_result_type.addItem(r_type)
def on_co_result_type_changed(self, ind):
self.gridlayout3.removeWidget(self.le_esri_storage_location)
self.gridlayout3.removeWidget(self.pbn_set_esri_storage_location)
self.optionsGroupBox.hide()
self.pbn_set_esri_storage_location.hide()
self.le_esri_storage_location.hide()
txt = self.co_result_type.currentText()
print txt
if txt == 'ESRI table (for loading in ArcGIS)':
self.pbn_set_esri_storage_location.show()
self.le_esri_storage_location.show()
self.gridlayout3.addWidget(self.le_esri_storage_location,0,1,1,6)
self.gridlayout3.addWidget(self.pbn_set_esri_storage_location,0,7,1,1)
self.optionsGroupBox.show()
def on_pbn_set_esri_storage_location_released(self):
print 'pbn_set_esri_storage_location released'
from opus_core.misc import directory_path_from_opus_path
start_dir = directory_path_from_opus_path('opus_gui.projects')
configDialog = QFileDialog()
filter_str = QString("*.gdb")
fd = configDialog.getExistingDirectory(self,QString("Please select an ESRI geodatabase (*.gdb)..."), #, *.sde, *.mdb)..."),
QString(start_dir), QFileDialog.ShowDirsOnly)
if len(fd) != 0:
fileName = QString(fd)
fileNameInfo = QFileInfo(QString(fd))
fileNameBaseName = fileNameInfo.completeBaseName()
self.le_esri_storage_location.setText(fileName)
def on_pbn_go_released(self):
# Fire up a new thread and run the model
print 'Go button pressed'
# References to the GUI elements for status for this run...
#self.statusLabel = self.runStatusLabel
#self.statusLabel.setText(QString('Model initializing...'))
indicator_names = []
for i in range(self.lw_indicators.count()):
indicator_names.append(str(self.lw_indicators.item(i).text()))
if indicator_names == []:
print 'no indicators selected'
return
indicator_type = str(self.co_result_type.currentText())
indicator_type = {
#'Map (per indicator per year)':'matplotlib_map',
'Map (per indicator per year)':'mapnik_map',
'Chart (per indicator, spans years)':'matplotlib_chart',
'Table (per indicator, spans years)':'table_per_attribute',
'Table (per year, spans indicators)':'table_per_year',
'ESRI table (for loading in ArcGIS)':'table_esri'
}[indicator_type]
kwargs = {}
if indicator_type == 'table_esri':
storage_location = str(self.le_esri_storage_location.text())
if not os.path.exists(storage_location):
print 'Warning: %s does not exist!!'%storage_location
kwargs['storage_location'] = storage_location
self.result_manager.addIndicatorForm(indicator_type = indicator_type,
indicator_names = indicator_names,
kwargs = kwargs)
def runUpdateLog(self):
self.logFileKey = self.result_generator._get_current_log(self.logFileKey)
def runErrorFromThread(self,errorMessage):
QMessageBox.warning(self.mainwindow, 'Warning', errorMessage)
class Main(plugin.Plugin):
" Main Class "
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 run(self):
' run the string replacing '
self.output.clear()
self.button.setEnabled(False)
self.output.append(self.formatInfoMsg('INFO:{}'.format(
datetime.now())))
if self.source.currentText() == 'Local File':
target = 'file://' + str(self.infile.text()).strip()
else:
target = self.inurl.text()
self.output.append(self.formatInfoMsg(' INFO: OK: Parsing Arguments'))
cmd = ' '.join(
('nice --adjustment={}'.format(self.nice.value()), '"{}"'.format(
self.opera.text()),
'-fullscreen' if self.ckcss1.isChecked() is True else '',
'-notouch' if self.ckcss2.isChecked() is True else '',
'-notouchwithtouchevents' if self.ckcss3.isChecked() is True else
'', '-usemouse' if self.ckcss4.isChecked() is True else '',
'-mobileui' if self.ckcss5.isChecked() is True else '',
'-tabletui' if self.ckcss6.isChecked() is True else '',
'-hasmenuandback' if self.ckcss7.isChecked() is True else '',
'-k' if self.ckcss8.isChecked() is True else '',
'-displaysize {}x{}'.format(
self.width.value(),
self.height.value()), '-displayzoom {}'.format(
self.zoom.value()), '-mem {}M'.format(self.ram.value()),
'-lang {}'.format(self.lang.currentText()), '-ppi {}'.format(
self.dpi.value()), '-extra-fonts {}'.format(self.fonts.text())
if str(self.fonts.text()).strip() is not '' else '',
'-user-agent-string {}'.format(
self.agent.currentText()), '-delaycorethread {}'.format(
self.cpulag.value()), '-delayuithread {}'.format(
self.gpulag.value()), '-url "{}"'.format(target)))
self.output.append(self.formatInfoMsg(
'INFO:OK:Command:{}'.format(cmd)))
self.process.start(cmd)
if not self.process.waitForStarted():
self.output.append(self.formatErrorMsg(' ERROR: FAIL: Meh. '))
self.output.append(
self.formatErrorMsg(
'ERROR: FAIL: Failed with Arguments: {} '.format(cmd)))
self.button.setEnabled(True)
return
self.output.setFocus()
self.output.selectAll()
self.button.setEnabled(True)
def on_source_changed(self):
' do something when the desired source has changed '
if self.source.currentText() == 'Local File':
self.open.show()
self.infile.show()
self.inurl.hide()
else:
self.inurl.show()
self.open.hide()
self.infile.hide()
def _process_finished(self):
""" finished sucessfully """
self.output.append(self.formatInfoMsg('INFO:{}'.format(
datetime.now())))
self.output.selectAll()
self.output.setFocus()
def readOutput(self):
"""Read and append output to the logBrowser"""
self.output.append(str(self.process.readAllStandardOutput()).strip())
def readErrors(self):
"""Read and append errors to the logBrowser"""
self.output.append(
self.formatErrorMsg(str(self.process.readAllStandardError())))
def formatErrorMsg(self, msg):
"""Format error messages in red color"""
return self.formatMsg(msg, 'red')
def formatInfoMsg(self, msg):
"""Format informative messages in blue color"""
return self.formatMsg(msg, 'green')
def formatMsg(self, msg, color):
"""Format message with the given color"""
return '<font color="{}">{}</font>'.format(color, msg)
def finish(self):
' save when finish '
with codecs.open(CONFIG_FILE, "w", encoding='utf-8') as fp:
fp.write(self.opera.text())
def create_rows(self, layout):
u"""Build one row of the dialog box"""
play_button_group = QButtonGroup(self)
old_play_button_group = QButtonGroup(self)
for num, (source, dest, text, dl_fname, dl_hash, extras, icon)\
in enumerate(self.list, 3):
tt_text = self.build_text_help_label(text, source, extras)
ico_label = QLabel('', self)
ico_label.setToolTip(tt_text)
if icon:
ico_label.setPixmap(QPixmap.fromImage(icon))
layout.addWidget(ico_label, num, 0)
tt_label = QLabel(text, self)
tt_label.setToolTip(tt_text)
layout.addWidget(tt_label, num, 1)
if self.hide_text:
tt_label.hide()
# Play button.
t_play_button = QPushButton(self)
play_button_group.addButton(t_play_button, num - 3)
t_play_button.setToolTip(self.play_help)
t_play_button.setIcon(QIcon(os.path.join(icons_dir, 'play.png')))
layout.addWidget(t_play_button, num, self.play_column)
if self.note[dest]:
t_play_old_button = QPushButton(self)
old_play_button_group.addButton(t_play_old_button, num - 3)
t_play_old_button.setIcon(
QIcon(os.path.join(icons_dir, 'play.png')))
if not self.hide_text:
t_play_old_button.setToolTip(self.note[dest])
else:
t_play_old_button.setToolTip(self.play_old_help_short)
layout.addWidget(t_play_old_button, num, self.play_old_column)
else:
dummy_label = QLabel('', self)
dummy_label.setToolTip(self.play_old_empty_line_help)
layout.addWidget(dummy_label, num, self.play_old_column)
# The group where we later look what to do:
t_button_group = QButtonGroup(self)
t_button_group.setExclusive(True)
# Now the four buttons
t_add_button = QPushButton(self)
t_add_button.setCheckable(True)
t_add_button.setChecked(True)
t_add_button.setFlat(True)
t_add_button.setToolTip(self.add_help_text_short)
t_add_button.setIcon(QIcon(os.path.join(icons_dir, 'add.png')))
layout.addWidget(t_add_button, num, self.add_column)
t_button_group.addButton(t_add_button, action['add'])
t_keep_button = QPushButton(self)
t_keep_button.setCheckable(True)
t_keep_button.setFlat(True)
t_keep_button.setToolTip(self.keep_help_text_short)
t_keep_button.setIcon(QIcon(os.path.join(icons_dir, 'keep.png')))
layout.addWidget(t_keep_button, num, self.keep_column)
t_button_group.addButton(t_keep_button, action['keep'])
t_delete_button = QPushButton(self)
t_delete_button.setCheckable(True)
t_delete_button.setFlat(True)
t_delete_button.setToolTip(self.delete_help_text_short)
t_delete_button.setIcon(
QIcon(os.path.join(icons_dir, 'delete.png')))
layout.addWidget(t_delete_button, num, self.delete_column)
t_button_group.addButton(t_delete_button, action['delete'])
t_blacklist_button = QPushButton(self)
t_blacklist_button.setCheckable(True)
t_blacklist_button.setFlat(True)
t_blacklist_button.setToolTip(self.blacklist_help_text_short)
t_blacklist_button.setIcon(
QIcon(os.path.join(icons_dir, 'blacklist.png')))
if self.show_skull_and_bones:
layout.addWidget(t_blacklist_button, num,
self.blacklist_column)
else:
t_blacklist_button.hide()
t_button_group.addButton(t_blacklist_button, action['blacklist'])
self.buttons_groups.append(t_button_group)
play_button_group.buttonClicked.connect(
lambda button: play(self.list[play_button_group.id(button)][3]))
old_play_button_group.buttonClicked.connect(
lambda button: playFromText(self.note[self.list[
old_play_button_group.id(button)][1]]))
def process_item(self, data, last_dent_id, username, server, dent_type):
if data["in_reply_to_screen_name"]:
nickname = data["nickname"] + " " + u"\u2794" + " " + data["in_reply_to_screen_name"]
if data["in_reply_to_screen_name"] == username:
dent_type = "mentions"
context_button = QPushButton()
context_button.setFixedHeight(20)
context_button.setText("Context")
context_button.setObjectName("context_button_" + str(data["conversation_id"]))
context_button.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
context_button.hide()
else:
nickname = data["nickname"]
read_state = "not"
#if int(data["id"]) < int(last_dent_id):
if int(data["id"]) < int(last_dent_id) or int(data["id"]) == int(last_dent_id):
read_state = "read"
post_data_info = QLabel()
post_data = QLabel()
post_data.setText(QString.fromUtf8("<b>{0}</b> <span style='font-size:8pt;'>{2}</span><p style='padding:0;'>{1}</p>".format(nickname, data["text"], data["date"])))
post_data.setWordWrap(True)
post_data.setAlignment(Qt.AlignTop)
post_data.setOpenExternalLinks(True)
post_height = post_data.sizeHint().height()
post_data.setMinimumWidth(300)
post_data.setMaximumWidth(6000)
post_data.setMaximumHeight(post_height)
post_data.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
post_data_layout = QVBoxLayout()
post_data_layout.addWidget(post_data)
post_data_layout.setContentsMargins(3, 0, 0, 0)
post_data_layout.setAlignment(Qt.AlignTop)
# Poster avatar and post actions
avatar_data = QLabel()
extension = data["avatar"].split(".")[-1:][0]
avatar = os.path.expanduser("~/.local/share/qtdenter/avatars/") + "%s.%s" % (data["nickname"], extension)
avatar_data.setText("<img src='{0}' height=48 width=48 />".format(avatar))
avatar_data.setMinimumSize(0, 0)
avatar_data.setMaximumSize(48, 48)
avatar_data.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.MinimumExpanding)
#reply_button = QPushButton()
#reply_button.setText("Reply")
destroy_button = QPushButton()
destroy_button.setText("Delete")
destroy_button.setFixedHeight(20)
#destroy_button.setFlat(True)
destroy_button.setObjectName("destroy_button_" + str(data["id"]))
destroy_button.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
spacer = QSpacerItem(0, 1, QSizePolicy.Fixed, QSizePolicy.Expanding)
post_avatar_layout = QVBoxLayout()
post_avatar_layout.addWidget(avatar_data)
#post_avatar_layout.addWidget(reply_button)
post_avatar_layout.addWidget(destroy_button)
post_avatar_layout.addItem(spacer)
post_avatar_widget = QWidget()
post_avatar_widget.setLayout(post_avatar_layout)
# Like button
like_button = QPushButton()
if data["in_favorites"]:
like_button.setText("X")
like_button.setToolTip("De-Favoritize")
else:
like_button.setText(u"\u2665")
like_button.setToolTip("Favoritize")
#like_button.setFlat(True)
like_button.setFixedSize(32, 32)
like_button.setObjectName("like_button_" + str(data["id"]))
redent_button = QPushButton()
redent_button.setText(u"\u267a")
#redent_button.setFlat(True)
redent_button.setFixedSize(32, 32)
redent_button.setObjectName("redent_button_" + str(data["id"]))
buttons_layout = QHBoxLayout()
buttons_layout.addWidget(like_button)
buttons_layout.addWidget(redent_button)
buttons_layout.setContentsMargins(0, 0, 0, 0)
buttons_widget = QWidget()
buttons_widget.setLayout(buttons_layout)
post_data_widget = QWidget()
post_data_widget.setLayout(post_data_layout)
# Some underpost buttons
dentid_button = QPushButton()
dentid_button.setText("#" + str(data["id"]))
dentid_button.setObjectName("dentid_button_" + str(data["id"]))
dentid_button.setFixedHeight(20)
dentid_button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
source = QLabel()
source.setText("<span style='font-size:8pt;'>from {0}".format(data["source"]))
source.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.MinimumExpanding)
source.setWordWrap(True)
spacer2 = QSpacerItem(0, 1, QSizePolicy.Fixed, QSizePolicy.Expanding)
post_info_layout = QVBoxLayout()
post_info_layout.addWidget(dentid_button)
post_info_layout.addWidget(source)
post_info_layout.addWidget(buttons_widget)
if data["in_reply_to_screen_name"]:
post_info_layout.addWidget(context_button)
post_info_layout.addItem(spacer2)
post_info_layout.setAlignment(Qt.AlignTop)
post_info_layout.setContentsMargins(9, 0, 9, 0)
post_info_widget = QWidget()
post_info_widget.setLayout(post_info_layout)
post_info_widget.setFixedWidth(100)
# Final post widget
post_layout = QHBoxLayout()
post_layout.addWidget(post_data_widget)
post_layout.addWidget(post_info_widget)
post_widget = QWidget()
post_widget.setLayout(post_layout)
item = QTreeWidgetItem()
item.setText(2, str(data["id"]) + ":" + data["nickname"] + ":" + str(data["conversation_id"]) + ":" + read_state)
if data["in_favorites"]:
item.setText(3, "favorited")
else:
item.setText(3, "not")
item.setText(4, data["text"])
item.setText(5, server + ":" + dent_type)
return (item, post_avatar_widget, post_widget)
class Form(QDialog):
def __init__(self, parent = None):
super(Form, self).__init__(parent)
self.ql = QLabel("URL:")
self.le = QLineEdit()
self.le.setObjectName("URL")
self.ql1 = QLabel("Name of Anime:")
self.le1 = QLineEdit()
self.le1.setObjectName("Name")
self.ql2 = QLabel("Episodes(From):")
self.le2 = QLineEdit()
self.le2.setObjectName("Episodes")
self.ql6 = QLabel("Episodes(Till):")
self.le6 = QLineEdit()
self.le6.setObjectName("Episodes")
self.ql3 = QLabel("Season:")
self.le3 = QLineEdit()
self.le3.setObjectName("Season")
self.ql4 = QLabel("Quality( 1:-360p 2:-480p 3:-720p 4:-1080p ):")
self.le4 = QLineEdit()
self.le4.setObjectName("Quality")
self.ql5 = QLabel("Category:")
self.le5 = QLineEdit()
self.le5.setObjectName("Category")
self.ql7 = QLabel("--::It requires RapidVideo Server to be available for downloading::--")
self.ql9 = QLabel("--::This project is in development phase, giving absurd values will lead to errors::--")
self.ql10 = QLabel("--::To exit program completely please exit uGet as well as the application window::--")
self.ql11 = QLabel("--::For any issues raise the issue on GitHub (link in README.md)::--")
self.ql8 = QLabel("\n")
self.pb = QPushButton()
self.pb.setObjectName("Download")
self.pb.setText("Download")
layout = QFormLayout()
layout.addWidget(self.ql1)
layout.addWidget(self.le1)
layout.addWidget(self.ql)
layout.addWidget(self.le)
layout.addWidget(self.ql3)
layout.addWidget(self.le3)
layout.addWidget(self.ql2)
layout.addWidget(self.le2)
layout.addWidget(self.ql6)
layout.addWidget(self.le6)
layout.addWidget(self.ql4)
layout.addWidget(self.le4)
layout.addWidget(self.ql5)
layout.addWidget(self.le5)
layout.addWidget(self.ql7)
layout.addWidget(self.ql9)
layout.addWidget(self.ql10)
layout.addWidget(self.ql11)
layout.addWidget(self.ql8)
layout.addWidget(self.pb)
self.setLayout(layout)
self.connect(self.pb, SIGNAL("clicked()"),self.button_click)
self.setWindowTitle("Anime Downloader")
def button_click(self):
url = self.le.text()
anime = self.le1.text()
episodes1 = self.le2.text()
episodes2 = self.le6.text()
season = self.le3.text()
quality = self.le4.text()
category = self.le5.text()
self.le.hide()
self.le1.hide()
self.le2.hide()
self.le3.hide()
self.le4.hide()
self.le5.hide()
self.ql1.hide()
self.ql2.hide()
self.ql3.hide()
self.ql4.hide()
self.ql5.hide()
self.ql6.hide()
self.ql7.hide()
self.ql8.hide()
self.ql9.hide()
self.ql10.hide()
self.ql11.hide()
self.ql.hide()
self.pb.hide()
self.le6.hide()
filepath = os.path.realpath(__file__)
filepath = filepath.replace('/src/anime_downloader.py','/res/')
image_path=filepath
fo = open(filepath + 'config.cfg','w')
fo.write(category + '\n')
fo.close()
fo1 = open(filepath + 'links.txt','w')
fo1.write(anime + '\n' + season + '\n' + episodes1 +'\n')
fo1.close()
fo2 = open(filepath + 'data.txt','w')
fo2.write(url + '\n' + quality + '\n' + episodes1 + '\n' + episodes2 + '\n')
fo2.close()
filepath1 = filepath.replace('/res/','/src/')
subprocess.call(['python','populate_links.py'])
subprocess.call(['python','download_script.py'])
self.setStyleSheet("border-image: url("+image_path+"bg_img.jpg); background-repeat: no-repeat;")
class Search(QWidget, plugin.MainWindowPlugin):
def __init__(self, mainwindow):
super(Search, self).__init__(mainwindow)
self._currentView = None
self._positions = None
self._replace = False # are we in replace mode?
mainwindow.currentViewChanged.connect(self.viewChanged)
mainwindow.actionCollection.edit_find_next.triggered.connect(
self.findNext)
mainwindow.actionCollection.edit_find_previous.triggered.connect(
self.findPrevious)
# don't inherit looks from view
self.setFont(QApplication.font())
self.setPalette(QApplication.palette())
grid = QGridLayout()
grid.setContentsMargins(4, 0, 4, 0)
grid.setVerticalSpacing(0)
self.setLayout(grid)
self.searchEntry = QLineEdit(textChanged=self.slotSearchChanged)
self.searchLabel = QLabel()
self.caseCheck = QCheckBox(checked=True, focusPolicy=Qt.NoFocus)
self.regexCheck = QCheckBox(focusPolicy=Qt.NoFocus)
self.countLabel = QLabel(alignment=Qt.AlignRight | Qt.AlignVCenter)
self.countLabel.setMinimumWidth(
QApplication.fontMetrics().width("9999"))
self.closeButton = QToolButton(autoRaise=True, focusPolicy=Qt.NoFocus)
self.hideAction = QAction(self, triggered=self.slotHide)
self.hideAction.setShortcut(QKeySequence(Qt.Key_Escape))
self.hideAction.setIcon(self.style().standardIcon(
QStyle.SP_DialogCloseButton))
self.closeButton.setDefaultAction(self.hideAction)
grid.addWidget(self.searchLabel, 0, 0)
grid.addWidget(self.searchEntry, 0, 1)
grid.addWidget(self.caseCheck, 0, 2)
grid.addWidget(self.regexCheck, 0, 3)
grid.addWidget(self.countLabel, 0, 4)
grid.addWidget(self.closeButton, 0, 5)
self.caseCheck.toggled.connect(self.slotSearchChanged)
self.regexCheck.toggled.connect(self.slotSearchChanged)
self.replaceEntry = QLineEdit()
self.replaceLabel = QLabel()
self.replaceButton = QPushButton(clicked=self.slotReplace)
self.replaceAllButton = QPushButton(clicked=self.slotReplaceAll)
grid.addWidget(self.replaceLabel, 1, 0)
grid.addWidget(self.replaceEntry, 1, 1)
grid.addWidget(self.replaceButton, 1, 2)
grid.addWidget(self.replaceAllButton, 1, 3)
app.settingsChanged.connect(self.readSettings)
self.readSettings()
app.translateUI(self)
def translateUI(self):
self.searchLabel.setText(_("Search:"))
self.caseCheck.setText(_("&Case"))
self.caseCheck.setToolTip(_("Case Sensitive"))
self.regexCheck.setText(_("&Regex"))
self.regexCheck.setToolTip(_("Regular Expression"))
self.countLabel.setToolTip(_("The total number of matches"))
self.hideAction.setToolTip(_("Close"))
self.replaceLabel.setText(_("Replace:"))
self.replaceButton.setText(_("Re&place"))
self.replaceButton.setToolTip(
_("Replaces the next occurrence of the search term."))
self.replaceAllButton.setText(_("&All"))
self.replaceAllButton.setToolTip(
_("Replaces all occurrences of the search term in the document or selection."
))
def readSettings(self):
data = textformats.formatData('editor')
self.searchEntry.setFont(data.font)
self.replaceEntry.setFont(data.font)
p = data.palette()
self.searchEntry.setPalette(p)
self.replaceEntry.setPalette(p)
def currentView(self):
return self._currentView and self._currentView()
def setCurrentView(self, view):
self._currentView = weakref.ref(view) if view else None
def showWidget(self):
if self.isVisible():
self.hideWidget()
view = self.window().currentView()
self.setCurrentView(view)
layout = widgets.borderlayout.BorderLayout.get(view)
layout.addWidget(self, widgets.borderlayout.BOTTOM)
self.show()
def hideWidget(self):
view = self.currentView()
if view:
self.highlightingOff()
self.hide()
layout = widgets.borderlayout.BorderLayout.get(view)
layout.removeWidget(self)
def viewChanged(self, new):
self.setParent(None)
self.hideWidget()
self.setCurrentView(new)
self.updatePositions()
def slotHide(self):
view = self.currentView()
if view:
self.hideWidget()
view.setFocus()
def find(self):
# hide replace stuff
self.replaceLabel.hide()
self.replaceEntry.hide()
self.replaceButton.hide()
self.replaceAllButton.hide()
self._replace = False # we are not in replace mode
visible = self.isVisible()
if not visible:
self.showWidget()
else:
self.adjustSize()
cursor = self.currentView().textCursor()
#if not visible and self.currentView():
if cursor.hasSelection() or not self.searchEntry.text():
if not cursor.hasSelection():
# pick current word
wordboundary.handler.select(cursor,
QTextCursor.WordUnderCursor)
word = cursor.selection().toPlainText()
if not re.search(r'\w', word):
word = ""
elif self.regexCheck.isChecked():
word = re.escape(word)
with qutil.signalsBlocked(self.searchEntry):
self.searchEntry.setText(word)
self.slotSearchChanged()
else:
self.searchEntry.selectAll()
self.highlightingOn()
self.searchEntry.setFocus()
def replace(self):
# show replace stuff
self.replaceLabel.show()
self.replaceEntry.show()
self.replaceButton.show()
self.replaceAllButton.show()
focus = self.replaceEntry if self.isVisible(
) and self.searchEntry.text() else self.searchEntry
self._replace = True # we are in replace mode
if self.isVisible():
self.adjustSize()
else:
self.showWidget()
self.slotSearchChanged()
focus.setFocus()
def slotSearchChanged(self):
self.updatePositions()
self.highlightingOn()
if not self._replace and self._positions:
positions = [c.position() for c in self._positions]
cursor = self.currentView().textCursor()
index = bisect.bisect_left(positions, cursor.selectionStart())
if index == len(positions):
index -= 1
elif index > 0:
# it might be possible that the text cursor currently already
# is in a search result. This happens when the search is pop up
# with an empty text and the current word is then set as search
# text.
if cursortools.contains(self._positions[index - 1], cursor):
index -= 1
self.currentView().gotoTextCursor(self._positions[index])
def highlightingOn(self, view=None):
if view is None:
view = self.currentView()
if view:
viewhighlighter.highlighter(view).highlight(
"search", self._positions, 1)
def highlightingOff(self, view=None):
if view is None:
view = self.currentView()
if view:
viewhighlighter.highlighter(view).clear("search")
def updatePositions(self):
search = self.searchEntry.text()
view = self.currentView()
document = view.document()
self._positions = []
if search:
text = document.toPlainText()
flags = re.MULTILINE | re.DOTALL
if not self.caseCheck.isChecked():
flags |= re.IGNORECASE
if not self.regexCheck.isChecked():
search = re.escape(search)
try:
matches = re.finditer(search, text, flags)
except re.error:
pass
else:
for m in matches:
c = QTextCursor(document)
c.setPosition(m.end())
c.setPosition(m.start(), QTextCursor.KeepAnchor)
self._positions.append(c)
self.countLabel.setText(format(len(self._positions)))
def findNext(self):
view = self.currentView()
if view and self._positions:
positions = [c.position() for c in self._positions]
index = bisect.bisect_right(positions,
view.textCursor().position())
if index < len(positions):
view.gotoTextCursor(self._positions[index])
else:
view.gotoTextCursor(self._positions[0])
view.ensureCursorVisible()
def findPrevious(self):
view = self.currentView()
positions = [c.position() for c in self._positions]
if view and positions:
index = bisect.bisect_left(positions,
view.textCursor().position()) - 1
view.gotoTextCursor(self._positions[index])
view.ensureCursorVisible()
def event(self, ev):
if ev == QKeySequence.HelpContents:
userguide.show("search_replace")
ev.accept()
return True
elif ev.type() == QEvent.KeyPress:
modifiers = int(ev.modifiers()
& (Qt.SHIFT | Qt.CTRL | Qt.ALT | Qt.META))
if ev.key() == Qt.Key_Tab and modifiers == 0:
# prevent Tab from reaching the View widget
self.window().focusNextChild()
ev.accept()
return True
elif ev.key() == Qt.Key_Backtab and modifiers & ~Qt.SHIFT == 0:
# prevent Tab from reaching the View widget
self.window().focusPreviousChild()
ev.accept()
return True
return super(Search, self).event(ev)
def keyPressEvent(self, ev):
# if in search mode, Up and Down jump between search results
if not self._replace and self._positions and self.searchEntry.text(
) and not ev.modifiers():
if ev.key() == Qt.Key_Up:
self.findPrevious()
return
elif ev.key() == Qt.Key_Down:
self.findNext()
return
# use enter or return for search next
if ev.key() in (Qt.Key_Enter, Qt.Key_Return):
self.findNext()
return
super(Search, self).keyPressEvent(ev)
def doReplace(self, cursor):
text = cursor.selection().toPlainText()
search = self.searchEntry.text()
replace = self.replaceEntry.text()
ok = text == self.searchEntry.text()
if self.regexCheck.isChecked():
m = re.match(search, text)
ok = False
if m:
try:
replace = m.expand(replace)
ok = True
except re.error:
pass
if ok:
pos = cursor.position()
cursor.insertText(replace)
cursor.setPosition(pos, QTextCursor.KeepAnchor)
return ok
def slotReplace(self):
view = self.currentView()
if view and self._positions:
positions = [c.position() for c in self._positions]
index = bisect.bisect_left(positions, view.textCursor().position())
if index >= len(positions):
index = 0
if self.doReplace(self._positions[index]):
self.highlightingOn(view)
if index < len(positions) - 1:
view.gotoTextCursor(self._positions[index + 1])
else:
view.gotoTextCursor(self._positions[0])
del self._positions[index]
view.ensureCursorVisible()
def slotReplaceAll(self):
view = self.currentView()
if view:
replaced = False
cursors = self._positions
if view.textCursor().hasSelection():
cursors = [
cursor for cursor in cursors
if cursortools.contains(view.textCursor(), cursor)
]
with cursortools.compress_undo(view.textCursor()):
for cursor in cursors:
if self.doReplace(cursor):
replaced = True
if replaced:
self.highlightingOn()
class FindDialog(QDialog):
def __init__(self,parent=None):
logging.debug(__name__ +': __init__')
QDialog.__init__(self,parent)
self.setWindowFlags(Qt.Window)
self.setWindowTitle("Find...")
self._findAlgorithm=None
self._properties=[]
self._scripts=[]
self._find=True
self._filter=False
self.fill()
def fill(self):
logging.debug(__name__ +': fill')
self._findLabelLabel = QLabel("Label: ")
self._findLabelLineEdit = QLineEdit()
self._findLabelLineEdit.setToolTip("Example: Particle1")
self._caseSensitiveCheckBox=QCheckBox("Case sensitive")
self._exactMatchCheckBox=QCheckBox("Exact match")
self._helpButton = QPushButton("&Help")
self._findPreviousButton = QPushButton("&Previous")
self._findPreviousButton.hide()
self._findNumberLabel = QLabel("?/?")
self._findNumberLabel.hide()
self._findNextButton = QPushButton("&Find")
self._filterButton = QPushButton("&Filter")
self._resetButton = QPushButton("&Reset")
self._closeButton = QPushButton("&Close")
self.setLayout(QVBoxLayout())
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self._layout1=QHBoxLayout()
self._layout3=QHBoxLayout()
self._layout4=QHBoxLayout()
self._layout1.setSizeConstraint(QLayout.SetDefaultConstraint)
self._layout3.setSizeConstraint(QLayout.SetDefaultConstraint)
self._layout4.setSizeConstraint(QLayout.SetDefaultConstraint)
self.layout().addLayout(self._layout1)
self.layout().addLayout(self._layout3)
self.layout().addStretch()
self.layout().addLayout(self._layout4)
self._layout1.addWidget(self._findLabelLabel)
self._layout1.addWidget(self._findLabelLineEdit)
self._layout3.addWidget(self._helpButton)
self._layout3.addStretch()
self._layout3.addWidget(self._caseSensitiveCheckBox)
self._layout3.addWidget(self._exactMatchCheckBox)
self._layout4.addWidget(self._findPreviousButton)
self._layout4.addWidget(self._findNumberLabel)
self._layout4.addWidget(self._findNextButton)
self._layout4.addWidget(self._filterButton)
self._layout4.addWidget(self._resetButton)
self._layout4.addStretch()
self._layout4.addWidget(self._closeButton)
self.connect(self._findLabelLineEdit, SIGNAL('textChanged(QString)'), self.edited)
self.connect(self._caseSensitiveCheckBox, SIGNAL('stateChanged(int)'), self.edited)
self.connect(self._exactMatchCheckBox, SIGNAL('stateChanged(int)'), self.edited)
self.connect(self._findPreviousButton, SIGNAL('clicked(bool)'), self.findPrevious)
self.connect(self._findNextButton, SIGNAL('clicked(bool)'), self.findNext)
self.connect(self._filterButton, SIGNAL('clicked(bool)'), self.filter)
self.connect(self._resetButton, SIGNAL('clicked(bool)'), self.reset)
self.connect(self._helpButton, SIGNAL('clicked(bool)'), self.help)
self.connect(self._closeButton, SIGNAL('clicked(bool)'), self.reject)
self._addStringProperty(False,False)
self._addScript(False,False)
def _removeProperty(self):
for property in self._properties:
if self.sender() in property:
self._remove(property)
return
def _remove(self,object):
for o in object:
if isinstance(o,QWidget):
o.close()
self.layout().removeItem(object[0])
if object in self._properties:
self._properties.remove(object)
elif object in self._scripts:
self._scripts.remove(object)
def _addStringProperty(self,bool,deletable=True):
layout2=QHBoxLayout()
findPropertyNameLabel = QLabel("Property: ")
findPropertyNameLineEdit = QLineEdit()
findPropertyNameLineEdit.setToolTip("Example: Label = Particle1 ")
findPropertyValueLabel = QLabel(" = ")
findPropertyValueLineEdit = QLineEdit()
findPropertyValueLineEdit.setToolTip("Example: Label = Particle1 ")
propertyAdd = QToolButton()
propertyAdd.setText("+")
propertyDelete = QToolButton()
propertyDelete.setText("-")
if deletable:
propertyAdd.hide()
else:
propertyDelete.hide()
layout2.addWidget(propertyAdd)
layout2.addWidget(propertyDelete)
layout2.addWidget(findPropertyNameLabel)
layout2.addWidget(findPropertyNameLineEdit)
layout2.addWidget(findPropertyValueLabel)
layout2.addWidget(findPropertyValueLineEdit)
self.connect(findPropertyNameLineEdit, SIGNAL('textChanged(QString)'), self.edited)
self.connect(findPropertyValueLineEdit, SIGNAL('textChanged(QString)'), self.edited)
self.connect(propertyAdd, SIGNAL('clicked(bool)'), self._addStringProperty)
self.connect(propertyDelete, SIGNAL('clicked(bool)'), self._removeProperty)
self.layout().insertLayout(len(self._properties)+len(self._scripts)+1,layout2)
self._properties+=[(layout2,findPropertyNameLineEdit,findPropertyValueLineEdit,findPropertyNameLabel,findPropertyValueLabel,propertyAdd,propertyDelete)]
def _removeScript(self):
for script in self._scripts:
if self.sender() in script:
self._remove(script)
return
def _addScript(self,bool,deletable=True):
layout2=QHBoxLayout()
findScriptLabel = QLabel("Filter = ")
findScriptLineEdit = QLineEdit("")
findScriptLineEdit.setToolTip("Example: object.Label == 'Particle1' ")
scriptAdd = QToolButton()
scriptAdd.setText("+")
scriptDelete = QToolButton()
scriptDelete.setText("-")
if deletable:
scriptAdd.hide()
else:
scriptDelete.hide()
layout2.addWidget(scriptAdd)
layout2.addWidget(scriptDelete)
layout2.addWidget(findScriptLabel)
layout2.addWidget(findScriptLineEdit)
self.connect(findScriptLineEdit, SIGNAL('textChanged(QString)'), self.edited)
self.connect(scriptAdd, SIGNAL('clicked(bool)'), self._addScript)
self.connect(scriptDelete, SIGNAL('clicked(bool)'), self._removeScript)
self.layout().insertLayout(len(self._properties)+len(self._scripts)+1,layout2)
self._scripts+=[(layout2,findScriptLineEdit,findScriptLabel,scriptAdd,scriptDelete)]
def onScreen(self, filter=False, find=True):
logging.debug(__name__ +': onScreen')
self._find=find
self._filter=filter
if self._find and self._filter:
self._findNextButton.setDefault(True)
self.setWindowTitle("Find/Filter...")
elif self._find:
self._findNextButton.setDefault(True)
self.setWindowTitle("Find...")
elif self._filter:
self._filterButton.setDefault(True)
self.setWindowTitle("Filter...")
self._findNextButton.setVisible(find)
if not find:
self._findPreviousButton.setVisible(find)
self._filterButton.setVisible(filter)
self.show()
self.raise_()
self.activateWindow()
self._findLabelLineEdit.setFocus()
def keyPressEvent(self, event):
"""
"""
if event.modifiers() == Qt.ControlModifier and event.key() == Qt.Key_W:
self.close()
QDialog.keyPressEvent(self, event)
def setFindAlgorithm(self,findAlgorithm):
logging.debug(__name__ +': setFindAlgorithm')
self._findAlgorithm=findAlgorithm
def findAlgorithm(self):
return self._findAlgorithm
def label(self):
return str(self._findLabelLineEdit.text().toAscii())
def setLabel(self,label):
logging.debug(__name__ +': setLabel '+label)
self._findLabelLineEdit.setText(label)
def properties(self):
return [(str(property[1].text().toAscii()),str(property[2].text().toAscii())) for property in self._properties]
def scripts(self):
return [str(script[1].text().toAscii()) for script in self._scripts]
def caseSensitive(self):
return self._caseSensitiveCheckBox.checkState()==Qt.Checked
def exactMatch(self):
return self._exactMatchCheckBox.checkState()==Qt.Checked
def edited(self):
self._findPreviousButton.hide()
if self._findNextButton.isVisible():
self._findNumberLabel.hide()
self._findNextButton.setText("&Find")
def _updateNumberLabel(self):
current=self._findAlgorithm.currentNumber()
total=self._findAlgorithm.numberOfResults()
message=self._findAlgorithm.message()
text=""
if self._filter:
text=str(total)+" found"
else:
if total>0:
text=str(current)+"/"+str(total)
else:
text="not found"
if message:
text+=" ("+message+")"
self._findNumberLabel.setText(text)
def findPrevious(self):
logging.debug(__name__ +': findPrevious')
object=self._findAlgorithm.previous()
self._updateNumberLabel()
self.emit(SIGNAL("found"),object)
def findNext(self):
logging.debug(__name__ +': findNext')
if not self._findPreviousButton.isVisible():
self._findNextButton.setVisible(False)
self._filterButton.setVisible(False)
self._resetButton.setVisible(False)
self._findNumberLabel.setText("Searching...")
self._findNumberLabel.show()
thread = ThreadChain(self._findAlgorithm.findUsingFindDialog, self)
while thread.isRunning():
if not Application.NO_PROCESS_EVENTS:
QCoreApplication.instance().processEvents()
object=thread.returnValue()
self._findNextButton.setVisible(True)
if self._filter:
self._filterButton.setVisible(True)
self._resetButton.setVisible(True)
self._findPreviousButton.show()
self._findNextButton.setText("&Next")
else:
object=next(self._findAlgorithm)
self._updateNumberLabel()
self.emit(SIGNAL("found"),object)
def filter(self):
logging.debug(__name__ +': filter')
self._findNextButton.setVisible(False)
self._filterButton.setVisible(False)
self._resetButton.setVisible(False)
self._findNumberLabel.setText("Searching...")
self._findNumberLabel.show()
thread = ThreadChain(self._findAlgorithm.findUsingFindDialog, self)
while thread.isRunning():
if not Application.NO_PROCESS_EVENTS:
QCoreApplication.instance().processEvents()
if self._find:
self._findNextButton.setVisible(True)
self._filterButton.setVisible(True)
self._resetButton.setVisible(True)
self._updateNumberLabel()
self.emit(SIGNAL("filtered"),self._findAlgorithm.results())
def reset(self):
self.setLabel("")
for o in self._scripts+self._properties:
self._remove(o)
self._addStringProperty(False,False)
self._addScript(False,False)
self._findAlgorithm.clear()
self._updateNumberLabel()
if self._filter:
self.emit(SIGNAL("filtered"),None)
self.update()
def help(self):
QMessageBox.about(self, 'Info', "You can find objects \n1. using their label shown in the center view, \n2. their properties shown in the property view, or \n3. using a Python script returning a boolean. Empty fields are ignored. Examples are shown as tool tips.")
class NodeParamEditorWidget(QWidget):
def __init__(self, parent=None):
super(NodeParamEditorWidget, self).__init__(parent)
self._tokenWidgets = []
self._showTokenWidgetIndex = 0
vbox = QVBoxLayout()
hboxTitle = QHBoxLayout()
self._lb1 = QLabel('Node index : ', self)
self._lb2 = QLabel('', self)
self._lb2.setMinimumWidth(50)
self._lb2.setMaximumWidth(50)
hboxTitle.addWidget(self._lb1)
hboxTitle.addWidget(self._lb2)
self._labelTE = QLineEdit(self)
hboxTitle.addWidget(self._labelTE)
vbox.addLayout(hboxTitle)
self._vboxToken = QVBoxLayout()
self._upToken = QPushButton('Up')
self._upToken.setMaximumHeight(20)
# self._upToken.setMaximumWidth(150)
self._upToken.setEnabled(False)
self._plusToken = QPushButton('+')
# self._plusToken.setMaximumWidth(150)
self._downToken = QPushButton('Down')
self._downToken.setMaximumHeight(20)
# self._downToken.setMaximumWidth(150)
self._downToken.setEnabled(False)
self._vboxToken.addWidget(self._upToken)
self._vboxToken.addWidget(self._plusToken)
self._vboxToken.addWidget(self._downToken)
vbox.addLayout(self._vboxToken)
self._upToken.clicked.connect(self.upToken)
self._downToken.clicked.connect(self.downToken)
self._plusToken.clicked.connect(self.addToken)
self.init()
self._selectedNode = None
self._labelTE.textChanged.connect(self.labelChanged)
self._labelTE.textChanged.connect(self.window().setModified)
self.setLayout(vbox)
def addToken(self):
self._selectedNode.addToken()
token = TokenWidget(len(self._tokenWidgets), parent=self)
self._tokenWidgets.append(token)
self._vboxToken.insertWidget(self._vboxToken.count() - 2, token)
if len(self._tokenWidgets) >= 3:
self._tokenWidgets[-3].hide()
self._upToken.setEnabled(True)
self._showTokenWidgetIndex += 1
def removeToken(self, tokenWidget):
tokenWidget.hide()
self._tokenWidgets.remove(tokenWidget)
self._selectedNode.removeToken(tokenWidget.index)
for tW in self._tokenWidgets[tokenWidget.index:]:
tW.index -= 1
self._vboxToken.removeWidget(tokenWidget)
self.updateTokenWidgetIndex()
def updateTokenWidgetIndex(self):
if len(self._tokenWidgets) <= 2:
self._upToken.setEnabled(False)
self._downToken.setEnabled(False)
for tokW in self._tokenWidgets:
tokW.show()
self._plusToken.show()
self._showTokenWidgetIndex = 0
return
maxIndex = len(self._tokenWidgets) - 1
if maxIndex == self._showTokenWidgetIndex:
self._showTokenWidgetIndex -= 1
self._tokenWidgets[self._showTokenWidgetIndex].show()
self._tokenWidgets[self._showTokenWidgetIndex + 1].show()
if maxIndex - self._showTokenWidgetIndex == 1:
self._plusToken.show()
else:
self._tokenWidgets[self._showTokenWidgetIndex + 2].show()
def upToken(self):
self._downToken.setEnabled(True)
maxIndex = len(self._tokenWidgets) - 1
if self._showTokenWidgetIndex == maxIndex - 1:
self._plusToken.hide()
else:
self._tokenWidgets[self._showTokenWidgetIndex + 2].hide()
self._showTokenWidgetIndex -= 1
self._tokenWidgets[self._showTokenWidgetIndex].show()
if self._showTokenWidgetIndex == 0:
self._upToken.setEnabled(False)
def downToken(self):
self._upToken.setEnabled(True)
maxIndex = len(self._tokenWidgets) - 1
if self._showTokenWidgetIndex == maxIndex - 2:
self._plusToken.show()
else:
self._tokenWidgets[self._showTokenWidgetIndex + 3].show()
self._tokenWidgets[self._showTokenWidgetIndex].hide()
self._showTokenWidgetIndex += 1
if self._showTokenWidgetIndex == maxIndex - 1:
self._downToken.setEnabled(False)
def init(self):
self.setLabel('Node label.')
def setIndex(self, num):
self._lb2.setText(str(num))
def setLabel(self, label):
self._labelTE.setText(label)
def setTokens(self, tokens):
for tokenWidget in self._tokenWidgets:
tokenWidget.hide()
self._upToken.setEnabled(False)
self._downToken.setEnabled(False)
del self._tokenWidgets[:]
for token in tokens:
tokenWidget = TokenWidget(len(self._tokenWidgets), parent=self)
tokenWidget.setText(token)
self._tokenWidgets.append(tokenWidget)
self._vboxToken.insertWidget(self._vboxToken.count() - 2, tokenWidget)
tokenWidget.hide()
self._plusToken.show()
if len(self._tokenWidgets) >= 3:
self._upToken.setEnabled(True)
self._tokenWidgets[-2].show()
self._tokenWidgets[-1].show()
self._showTokenWidgetIndex = len(tokens) - 2
else:
for tokenWidget in self._tokenWidgets:
tokenWidget.show()
self._showTokenWidgetIndex = 0
def labelChanged(self):
try:
self._selectedNode.setLabel(str(self._labelTE.text()))
except AttributeError:
pass
def tokenChanged(self, token):
index = token.index
text = token.text
self._selectedNode.setToken(index, text)
def setSelectedNode(self, n):
self._selectedNode = n
try:
self.setIndex(n.num)
self.setLabel(n.getLabel())
self.setTokens(n.getTokens())
except AttributeError:
self.init()
class AdvancedVisualizationForm(QWidget):
def __init__(self, mainwindow, result_manager):
QWidget.__init__(self, mainwindow)
#mainwindow is an OpusGui
self.mainwindow = mainwindow
self.result_manager = result_manager
self.toolboxBase = self.result_manager.mainwindow.toolboxBase
self.inGui = False
self.logFileKey = 0
self.xml_helper = ResultsManagerXMLHelper(toolboxBase=self.toolboxBase)
self.result_generator = OpusResultGenerator(
toolboxBase=self.toolboxBase)
self.result_generator.guiElement = self
self.tabIcon = QIcon(':/Images/Images/cog.png')
self.tabLabel = 'Advanced Visualization'
self.widgetLayout = QVBoxLayout(self)
self.widgetLayout.setAlignment(Qt.AlignTop)
self.resultsGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.resultsGroupBox)
self.dataGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.dataGroupBox)
self.optionsGroupBox = QGroupBox(self)
self.widgetLayout.addWidget(self.optionsGroupBox)
self._setup_definition_widget()
self._setup_buttons()
self._setup_tabs()
def _setup_buttons(self):
# Add Generate button...
self.pbn_go = QPushButton(self.resultsGroupBox)
self.pbn_go.setObjectName('pbn_go')
self.pbn_go.setText(QString('Go!'))
QObject.connect(self.pbn_go, SIGNAL('released()'),
self.on_pbn_go_released)
self.widgetLayout.addWidget(self.pbn_go)
self.pbn_set_esri_storage_location = QPushButton(self.optionsGroupBox)
self.pbn_set_esri_storage_location.setObjectName(
'pbn_set_esri_storage_location')
self.pbn_set_esri_storage_location.setText(QString('...'))
self.pbn_set_esri_storage_location.hide()
QObject.connect(self.pbn_set_esri_storage_location,
SIGNAL('released()'),
self.on_pbn_set_esri_storage_location_released)
def _setup_tabs(self):
# Add a tab widget and layer in a tree view and log panel
self.tabWidget = QTabWidget(self.resultsGroupBox)
# Log panel
self.logText = QTextEdit(self.resultsGroupBox)
self.logText.setReadOnly(True)
self.logText.setLineWidth(0)
self.tabWidget.addTab(self.logText, 'Log')
# Finally add the tab to the model page
self.widgetLayout.addWidget(self.tabWidget)
#
def _setup_definition_widget(self):
#### setup results group box ####
self.gridlayout = QGridLayout(self.resultsGroupBox)
self.gridlayout.setObjectName('gridlayout')
self.lbl_results = QLabel(self.resultsGroupBox)
self.lbl_results.setObjectName('lbl_results')
self.lbl_results.setText(QString('Results'))
self.gridlayout.addWidget(self.lbl_results, 0, 0, 1, 3)
self._setup_co_results()
self.gridlayout.addWidget(self.co_results, 0, 3, 1, 10)
self.pbn_add = QPushButton(self.resultsGroupBox)
self.pbn_add.setObjectName('pbn_add')
self.pbn_add.setText(QString('+'))
QObject.connect(self.pbn_add, SIGNAL('released()'),
self.on_pbn_add_released)
self.gridlayout.addWidget(self.pbn_add, 0, 14, 1, 1)
self.lw_indicators = QListWidget(self.resultsGroupBox)
self.lw_indicators.setObjectName('lw_indicators')
self.gridlayout.addWidget(self.lw_indicators, 1, 1, 1, 13)
self.pbn_remove = QPushButton(self.resultsGroupBox)
self.pbn_remove.setObjectName('pbn_remove')
self.pbn_remove.setText(QString('-'))
QObject.connect(self.pbn_remove, SIGNAL('released()'),
self.on_pbn_remove_released)
self.gridlayout.addWidget(self.pbn_remove, 1, 14, 1, 1)
#### setup data group box ####
self.gridlayout2 = QGridLayout(self.dataGroupBox)
self.gridlayout2.setObjectName('gridlayout2')
self._setup_co_result_style()
self.gridlayout2.addWidget(self.co_result_style, 1, 0, 1, 2)
self.lbl_result_style_sep = QLabel(self.resultsGroupBox)
self.lbl_result_style_sep.setObjectName('lbl_result_style_sep')
self.lbl_result_style_sep.setText(QString('<center>as</center>'))
self.gridlayout2.addWidget(self.lbl_result_style_sep, 1, 2, 1, 1)
self._setup_co_result_type()
self.gridlayout2.addWidget(self.co_result_type, 1, 3, 1, 2)
##### setup options group box ####
self.gridlayout3 = QGridLayout(self.optionsGroupBox)
self.gridlayout3.setObjectName('gridlayout3')
self.le_esri_storage_location = QLineEdit(self.optionsGroupBox)
self.le_esri_storage_location.setObjectName('le_esri_storage_location')
self.le_esri_storage_location.setText('[set path]')
self.le_esri_storage_location.hide()
self.optionsGroupBox.hide()
QObject.connect(self.co_result_style,
SIGNAL('currentIndexChanged(int)'),
self.on_co_result_style_changed)
QObject.connect(self.co_result_type,
SIGNAL('currentIndexChanged(int)'),
self.on_co_result_type_changed)
def _setup_co_results(self):
self.co_results = QComboBox(self.resultsGroupBox)
self.co_results.setObjectName('co_results')
self.co_results.addItem(QString('[select]'))
results = self.xml_helper.get_available_results()
for result in results:
name = '%i.%s' % (result['run_id'], result['indicator_name'])
self.co_results.addItem(QString(name))
def _setup_co_result_style(self):
available_styles = [
'visualize',
'export',
]
self.co_result_style = QComboBox(self.dataGroupBox)
self.co_result_style.setObjectName('co_result_style')
for dataset in available_styles:
self.co_result_style.addItem(QString(dataset))
def _setup_co_result_type(self):
available_types = [
'Table (per year, spans indicators)',
'Chart (per indicator, spans years)',
'Map (per indicator per year)',
'Chart (per indicator, spans years)',
]
self.co_result_type = QComboBox(self.dataGroupBox)
self.co_result_type.setObjectName('co_result_type')
for dataset in available_types:
self.co_result_type.addItem(QString(dataset))
def on_pbnRemoveModel_released(self):
self.result_manager.removeTab(self)
self.result_manager.updateGuiElements()
def on_pbn_add_released(self):
cur_selected = self.co_results.currentText()
for i in range(self.lw_indicators.count()):
if self.lw_indicators.item(i).text() == cur_selected:
return
self.lw_indicators.addItem(cur_selected)
def on_pbn_remove_released(self):
selected_idxs = self.lw_indicators.selectedIndexes()
for idx in selected_idxs:
self.lw_indicators.takeItem(idx.row())
def on_co_result_style_changed(self, ind):
available_viz_types = [
'Table (per year, spans indicators)',
'Chart (per indicator, spans years)',
'Map (per indicator per year)',
'Chart (per indicator, spans years)',
]
available_export_types = ['ESRI table (for loading in ArcGIS)']
txt = self.co_result_style.currentText()
if txt == 'visualize':
available_types = available_viz_types
else:
available_types = available_export_types
self.co_result_type.clear()
for result_type in available_types:
r_type = QString(result_type)
self.co_result_type.addItem(r_type)
def on_co_result_type_changed(self, ind):
self.gridlayout3.removeWidget(self.le_esri_storage_location)
self.gridlayout3.removeWidget(self.pbn_set_esri_storage_location)
self.optionsGroupBox.hide()
self.pbn_set_esri_storage_location.hide()
self.le_esri_storage_location.hide()
txt = self.co_result_type.currentText()
print txt
if txt == 'ESRI table (for loading in ArcGIS)':
self.pbn_set_esri_storage_location.show()
self.le_esri_storage_location.show()
self.gridlayout3.addWidget(self.le_esri_storage_location, 0, 1, 1,
6)
self.gridlayout3.addWidget(self.pbn_set_esri_storage_location, 0,
7, 1, 1)
self.optionsGroupBox.show()
def on_pbn_set_esri_storage_location_released(self):
print 'pbn_set_esri_storage_location released'
from opus_core.misc import directory_path_from_opus_path
start_dir = directory_path_from_opus_path('opus_gui.projects')
configDialog = QFileDialog()
filter_str = QString("*.gdb")
fd = configDialog.getExistingDirectory(
self,
QString("Please select an ESRI geodatabase (*.gdb)..."
), #, *.sde, *.mdb)..."),
QString(start_dir),
QFileDialog.ShowDirsOnly)
if len(fd) != 0:
fileName = QString(fd)
fileNameInfo = QFileInfo(QString(fd))
fileNameBaseName = fileNameInfo.completeBaseName()
self.le_esri_storage_location.setText(fileName)
def on_pbn_go_released(self):
# Fire up a new thread and run the model
print 'Go button pressed'
# References to the GUI elements for status for this run...
#self.statusLabel = self.runStatusLabel
#self.statusLabel.setText(QString('Model initializing...'))
indicator_names = []
for i in range(self.lw_indicators.count()):
indicator_names.append(str(self.lw_indicators.item(i).text()))
if indicator_names == []:
print 'no indicators selected'
return
indicator_type = str(self.co_result_type.currentText())
indicator_type = {
#'Map (per indicator per year)':'matplotlib_map',
'Map (per indicator per year)': 'mapnik_map',
'Chart (per indicator, spans years)': 'matplotlib_chart',
'Table (per indicator, spans years)': 'table_per_attribute',
'Table (per year, spans indicators)': 'table_per_year',
'ESRI table (for loading in ArcGIS)': 'table_esri'
}[indicator_type]
kwargs = {}
if indicator_type == 'table_esri':
storage_location = str(self.le_esri_storage_location.text())
if not os.path.exists(storage_location):
print 'Warning: %s does not exist!!' % storage_location
kwargs['storage_location'] = storage_location
self.result_manager.addIndicatorForm(indicator_type=indicator_type,
indicator_names=indicator_names,
kwargs=kwargs)
def runUpdateLog(self):
self.logFileKey = self.result_generator._get_current_log(
self.logFileKey)
def runErrorFromThread(self, errorMessage):
QMessageBox.warning(self.mainwindow, 'Warning', errorMessage)
class UserDialog(QDialog):
holdc = {}
def __init__(self, parent=None):
super(UserDialog, self).__init__(parent)
self.pagetitle = self.sessionname
self.tableFont = QFont('Century Gothic', 8)
self.table = QTableWidget()
self.cols = [
'SN', 'ITEM', 'QUANTITY', 'UNIT AMOUNT', 'TOTAL AMOUNT', 'DATE'
]
self.h1_pull_box = QVBoxLayout()
#self.tableFont.setFamily('Century Gothic')
self.tableHeaderStyle = "::section {" "background-color: teal; color:white}"
#pull all CA
self.editID = 0
self.hold_unit = {}
self.hold_store = {}
self.hold_storeGroup = {}
self.hold_borrowed = {}
from_label = QLabel('From:')
to_label = QLabel('To:')
self.fromData = QDateEdit()
self.toData = QDateEdit()
currentDate = QDate()
self.fromData.setDate(currentDate.currentDate())
self.fromData.setCalendarPopup(True)
self.toData.setDate(currentDate.currentDate())
self.toData.setCalendarPopup(True)
menu = QMenu()
menu.addAction('All', lambda: self.reloadTable(0))
menu.addAction('In-Stock', lambda: self.reloadTable(1))
menu.addAction('Out-Stock', lambda: self.reloadTable(2))
menu.addAction('Damaged', lambda: self.reloadTable(3))
menu.addAction('Borrowed', lambda: self.reloadTable(4))
self.pull_btn = QPushButton()
self.pull_btn.setText("Load")
self.pull_btn.setMenu(menu)
h_pull_box = QHBoxLayout()
h_pull_box.addWidget(from_label)
h_pull_box.addWidget(self.fromData)
h_pull_box.addWidget(to_label)
h_pull_box.addWidget(self.toData)
h_pull_box.addWidget(self.pull_btn)
storeGroup = self.pullGroupStore()
unit = self.pullUnit()
self.storeGroupText = QLabel('Category')
self.storeGroupData = QComboBox()
self.storeGroupData.currentIndexChanged.connect(self.reloadStore)
self.storeText = QLabel('Items')
self.storeData = QComboBox()
self.amountText = QLabel('Total Cost')
self.amountData = QLineEdit()
self.amountData.setPlaceholderText('0000.00')
self.tellerText = QLabel('Reciept No.')
self.tellerData = QLineEdit()
self.tellerData.setPlaceholderText('xxxxxxxxx')
self.quantityText = QLabel('Quantity.')
self.quantityData = QLineEdit()
self.quantityData.setPlaceholderText('00.0')
self.periodText = QLabel('Period (days)')
self.periodData = QLineEdit()
self.periodData.setPlaceholderText('00.0')
self.personText = QLabel('Recieved By:')
self.personData = QLineEdit()
self.personData.setPlaceholderText('00.0')
self.unitText = QLabel('Unit')
self.unitData = QComboBox()
self.borrowedText = QLabel('Borrowed')
self.borrowedData = QComboBox()
self.dateText = QLabel('Date')
self.dateData = QDateEdit()
self.dateData.setDate(currentDate.currentDate())
self.dateData.setCalendarPopup(True)
self.descriptionText = QLabel('Description')
self.descriptionData = QPlainTextEdit()
self.descriptionData.move(200, 100)
self.borrowedText.hide()
self.borrowedData.hide()
mboz = QVBoxLayout()
hboz = QHBoxLayout()
self.state = QLabel('')
self.r1 = QRadioButton('In-stock')
self.r1.setChecked(True)
self.r1.toggled.connect(lambda: self.changeStates())
self.r2 = QRadioButton('Out-stock')
self.r2.toggled.connect(lambda: self.changeStates())
self.r3 = QRadioButton('Damaged')
self.r3.toggled.connect(lambda: self.changeStates())
self.r4 = QRadioButton('Borrowed')
self.r4.toggled.connect(lambda: self.changeStates())
self.r5 = QRadioButton('Returned')
self.r5.toggled.connect(lambda: self.changeStates())
hboz.addWidget(self.r1)
hboz.addWidget(self.r2)
hboz.addWidget(self.r3)
hboz.addWidget(self.r4)
hboz.addWidget(self.r5)
i = 0
for a in storeGroup:
self.hold_storeGroup[i] = a['id']
tex = str(a['name']).upper()
self.storeGroupData.addItem(tex)
i += 1
i = 0
str_key = self.hold_storeGroup[self.storeGroupData.currentIndex()]
store = self.pullStore(str_key)
for a in store:
self.hold_store[i] = a['id']
tex = str(a['name']).upper()
self.storeData.addItem(tex)
i += 1
i = 0
for a in unit:
self.hold_unit[i] = a['id']
tex = str(a['name']).upper()
self.unitData.addItem(tex)
i += 1
self.reloadBorrowed()
self.FormLayout = QFormLayout()
self.FormLayout.addRow(self.storeGroupText, self.storeGroupData)
self.FormLayout.addRow(self.storeText, self.storeData)
self.FormLayout.addRow(self.tellerText, self.tellerData)
self.FormLayout.addRow(self.quantityText, self.quantityData)
self.FormLayout.addRow(self.amountText, self.amountData)
self.FormLayout.addRow(self.dateText, self.dateData)
self.FormLayout.addRow(self.periodText, self.periodData)
self.FormLayout.addRow(self.borrowedText, self.borrowedData)
self.FormLayout.addRow(self.personText, self.personData)
self.FormLayout.addRow(self.descriptionText, self.descriptionData)
self.periodText.hide()
self.periodData.hide()
mboz.addLayout(hboz)
mboz.addLayout(self.FormLayout)
mboz.addWidget(self.state)
groupBox1 = QGroupBox('Add Store Item')
groupBox1.setLayout(mboz)
self.pb = QPushButton()
self.pb.setObjectName("Add")
self.pb.setText("Add Store Item")
self.pb1 = QPushButton()
self.pb1.setObjectName("Edit")
self.pb1.setText("Edit Row")
self.pb1.setEnabled(False)
self.pb2 = QPushButton()
self.pb2.setObjectName("Close")
self.pb2.setText("Close")
self.pb3 = QPushButton()
self.pb3.setObjectName("Delete")
self.pb3.setText("Delete Row")
self.pb3.setEnabled(False)
self.pb4 = QPushButton()
self.pb4.setObjectName("Reset")
self.pb4.setText("Reset")
self.pb4.hide()
self.pb5 = QPushButton()
self.pb5.setObjectName("Change")
self.pb5.setText("Change Store")
self.pb5.hide()
self.pb6 = QPushButton()
self.pb6.setObjectName("Clear")
self.pb6.setText("Clear Selection")
self.pb6.setEnabled(False)
hbo = QHBoxLayout()
hbo.addWidget(self.pb)
hbo.addWidget(self.pb5)
hbo.addWidget(self.pb4)
hbo.addWidget(self.pb2)
groupBox2 = QGroupBox('Store Data')
groupBox2.setLayout(hbo)
al = self.pullStoreData(0)
if al and len(al) > 0:
al = al
else:
al = {}
self.storeData.currentIndexChanged.connect(
lambda: self.reloadBorrowed())
header = self.table.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
header.setStyleSheet(self.tableHeaderStyle)
vheader = self.table.verticalHeader()
vheader.setStyleSheet(self.tableHeaderStyle)
# Body
self.table.setWindowTitle("Store")
self.table.setStyleSheet("color:white")
self.table.resize(300, 250)
self.table.setFont(self.tableFont)
self.table.setSortingEnabled(2)
#self.table.resizeColumnsToContents()
self.table.setRowCount(len(al))
self.table.setColumnCount(len(self.cols))
self.table.setHorizontalHeaderLabels(self.cols)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.handleHeaderMenu)
self.table.hideColumn(0)
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
i = 0
for q in al:
#row id
if q['state'] == 1:
color = QColor(100, 0, 0)
elif q['state'] == 2:
color = QColor(100, 100, 0)
elif q['state'] == 3:
color = QColor(100, 0, 100)
elif q['state'] == 4:
color = QColor(0, 100, 100)
else:
color = QColor(0, 50, 150)
self.table.setItem(i, 0, QTableWidgetItem(str(q['id'])))
self.table.item(i, 0).setBackground(color)
self.table.setItem(i, 1,
QTableWidgetItem(str(q['itemname']).upper()))
self.table.item(i, 1).setBackground(color)
self.table.setItem(i, 2,
QTableWidgetItem(str(q['quantity']).upper()))
self.table.item(i, 2).setBackground(color)
try:
zamt = str("{:,}".format(float(q['amount'])))
except:
zamt = ''
self.table.setItem(i, 3, QTableWidgetItem(zamt))
self.table.item(i, 3).setBackground(color)
try:
if len(q['amount']) > 0 and float(q['amount']) > 0:
tot = float(q['amount']) * float(q['quantity'])
else:
tot = 0
except:
tot = 0
self.table.setItem(i, 4, QTableWidgetItem(str(tot).upper()))
self.table.item(i, 4).setBackground(color)
damz = float(q['datepaid'])
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
self.table.setItem(i, 5, QTableWidgetItem(str(damt)))
self.table.item(i, 5).setBackground(color)
i += 1
self.table.itemSelectionChanged.connect(self.confirmSelection)
self.table.resizeRowsToContents()
v_pull_box = QVBoxLayout()
self.h1_pull_box.addWidget(self.table)
v_pull_box.addLayout(h_pull_box)
v_pull_box.addLayout(self.h1_pull_box)
h2_pull_box = QHBoxLayout()
h2_pull_box.addWidget(self.pb1)
h2_pull_box.addWidget(self.pb3)
h2_pull_box.addWidget(self.pb6)
v_pull_box.addLayout(h2_pull_box)
groupBox3 = QGroupBox()
groupBox3.setLayout(hbo)
groupBox2.setLayout(v_pull_box)
grid = QGridLayout()
grid.addWidget(groupBox1, 0, 0)
grid.addWidget(groupBox2, 0, 1, 2, 1)
grid.addWidget(groupBox3, 1, 0)
self.setLayout(grid)
self.connect(self.pb, SIGNAL("clicked()"), lambda: self.button_click())
self.connect(self.pb1, SIGNAL("clicked()"),
lambda: self.button_editshow())
self.connect(self.pb2, SIGNAL("clicked()"),
lambda: self.button_close(self))
self.connect(self.pb3, SIGNAL("clicked()"),
lambda: self.button_delete())
self.connect(self.pb4, SIGNAL("clicked()"),
lambda: self.button_reset())
self.connect(self.pb5, SIGNAL("clicked()"), lambda: self.button_edit())
self.connect(self.pb6, SIGNAL("clicked()"),
lambda: self.button_clear())
#self.connect(self.pull_btn, SIGNAL("clicked()"), lambda x =1: self.reloadTable(x))
self.setWindowTitle(self.pagetitle)
def stateReciept(self):
self.amountText.show()
self.amountData.show()
self.tellerText.show()
self.tellerData.show()
self.tellerText.setText('Reciept No.')
self.periodText.hide()
self.periodData.hide()
self.personText.setText('Recieved By:')
self.personData.setPlaceholderText('Fullname or department')
self.borrowedText.hide()
self.borrowedData.hide()
self.reloadTable(1)
def stateIssue(self):
self.amountText.hide()
self.amountData.hide()
self.tellerText.show()
self.tellerData.show()
self.tellerText.setText('Issue No.')
self.periodText.hide()
self.periodData.hide()
self.personText.setText('Issued to:')
self.personData.setPlaceholderText('Fullname or department issued to')
self.borrowedText.hide()
self.borrowedData.hide()
self.reloadTable(2)
def stateDamage(self):
self.amountText.hide()
self.amountData.hide()
self.tellerText.hide()
self.tellerData.hide()
self.periodText.hide()
self.periodData.hide()
self.personText.setText('Reported By:')
self.personData.setPlaceholderText('Fullname or department')
self.borrowedText.hide()
self.borrowedData.hide()
self.reloadTable(3)
def stateBorrowed(self):
self.amountText.hide()
self.amountData.hide()
self.tellerText.hide()
self.tellerData.hide()
self.periodText.show()
self.periodData.show()
self.personText.setText('Given to:')
self.personData.setPlaceholderText(
'Fullname or department borrowed to')
self.borrowedText.hide()
self.borrowedData.hide()
self.reloadTable(4)
def stateReturned(self):
self.amountText.hide()
self.amountData.hide()
self.tellerText.hide()
self.tellerData.hide()
self.periodText.hide()
self.periodData.hide()
self.personText.setText('Returned By:')
self.personData.setPlaceholderText(
'Fullname or department borrowed to')
self.borrowedText.show()
self.borrowedData.show()
self.reloadBorrowed()
self.reloadTable(5)
def changeStates(self):
self.getQuantity()
if self.r1.isChecked():
self.stateReciept()
elif self.r2.isChecked():
self.stateIssue()
elif self.r3.isChecked():
self.stateDamage()
elif self.r4.isChecked():
self.stateBorrowed()
elif self.r5.isChecked():
self.stateReturned()
def handleHeaderMenu(self, pos):
print('column(%d)' % self.table.horizontalHeader().logicalIndexAt(pos))
menu = QMenu()
menu.addAction('Add')
menu.addAction('Delete')
menu.exec_(QCursor.pos())
def pullGroupStore(self):
cn = Db()
arr = cn.selectn('datas', '', '', {"pubID": 23, "active": 0})
return arr
def pullStore(self, a):
cn = Db()
arr = cn.selectn('datas', '', '', {"subID": a})
return arr
def pullUnit(self):
cn = Db()
arr = cn.selectn('datas', '', '', {"pubID": 20, "active": 0})
return arr
def pullStoreData(self, a=None):
st_date = self.fromData.date().toPyDate()
en_date = self.toData.date().toPyDate()
st_date = time.mktime(st_date.timetuple())
en_date = time.mktime(en_date.timetuple())
db = 'school_stores' + str(self.session)
cn = Db()
arr = cn.selectStoreDate(db, st_date, en_date, a)
return arr
def mySelectTable(self):
'''
get the selected rpws in a table
returns list or row ids
'''
sels = self.table.selectedIndexes()
sels = self.table.selectionModel().selectedRows()
park = []
park1 = []
for j in sels:
park.append(j.row())
for i in set(park):
selected = self.table.item(i, 0).text()
park1.append(selected)
return park1
def editRow(self, a):
_session = self.session
g = Db()
db = 'school_stores' + str(_session)
data = g.selectn(db, '', 1, {'id': a})
if len(data) > 0:
try:
amt = float(data['amount'])
qty = float(data['quantity'])
if amt > 0 and qty > 0:
cost = amt * qty
else:
cost = 0
except:
cost = 0
amt = 0
qty = 0
if data['state'] == 1:
self.r1.setChecked(True)
elif data['state'] == 2:
self.r2.setChecked(True)
elif data['state'] == 3:
self.r3.setChecked(True)
elif data['state'] == 4:
self.r4.setChecked(True)
elif data['state'] == 5:
self.r5.setChecked(True)
self.amountData.setText(str(cost))
self.descriptionData.clear()
self.descriptionData.insertPlainText(str(data['description']))
self.tellerData.setText(str(data['teller']))
self.periodData.setText(str(data['period']))
self.personData.setText(str(data['person']))
self.quantityData.setText(str(qty))
stID = self.hold_store.keys()[self.hold_store.values().index(
data['itemID'])]
self.storeData.setCurrentIndex(stID)
def reloadBorrowed(self):
self.getQuantity()
_store = self.hold_store[self.storeData.currentIndex()]
_session = self.session
g = Db()
db = 'school_stores' + str(_session)
data = g.selectn(db, '', '', {'itemID': _store, 'state': 4})
fig = 0
self.borrowedData.clear()
self.hold_borrowed = {}
i = 0
for a in data:
ret = g.selectStoreReturned(db, a['id'])
if ret:
retu = ret['qty']
else:
retu = 0
fig = float(a['quantity']) - float(retu)
damz = float(a['datepaid'])
if float(fig) > 0:
self.hold_borrowed[i] = a['id']
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
tex = str(damt) + " " + str(
a['person']).upper() + " (" + str(fig).upper() + ")"
self.borrowedData.addItem(tex)
i += 1
def reloadStore(self):
self.getQuantity()
cat = self.hold_storeGroup[self.storeGroupData.currentIndex()]
store = self.pullStore(cat)
self.storeData.clear()
self.hold_store = {}
i = 0
for a in store:
self.hold_store[i] = a['id']
tex = str(a['name']).upper()
self.storeData.addItem(tex)
i += 1
def getQuantity(self):
if self.storeData.currentIndex() > -1:
s = self.hold_store[self.storeData.currentIndex()]
_session = self.session
g = Db()
db = 'school_stores' + str(_session)
fi = g.selectStoreQuantity(db, s)
remain = 0
arr = {}
for a in fi:
arr[a['state']] = a['qty']
if 1 in arr:
re = arr[1]
else:
re = 0
if 2 in arr:
isu = arr[2]
else:
isu = 0
if 3 in arr:
dam = arr[3]
else:
dam = 0
if 4 in arr:
bor = arr[4]
else:
bor = 0
if 5 in arr:
ret = arr[5]
else:
ret = 0
borrowed = float(bor) - float(ret)
issued = float(isu) + float(borrowed) + float(dam)
remain = float(re) - float(issued)
self.quantityText.setText('QTY: ' + str(remain))
if remain == 0 and (self.r2.isChecked() or self.r3.isChecked()
or self.r4.isChecked()):
self.quantityData.setEnabled(False)
else:
self.quantityData.setEnabled(True)
return remain
def reloadTable(self, a):
self.getQuantity()
if not a == 0:
data = self.pullStoreData(a)
else:
data = self.pullStoreData()
self.table.close()
self.table = QTableWidget()
header = self.table.horizontalHeader()
header.setResizeMode(QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
header.setStyleSheet(self.tableHeaderStyle)
vheader = self.table.verticalHeader()
vheader.setStyleSheet(self.tableHeaderStyle)
# Body
self.table.setWindowTitle("Stores")
self.table.setStyleSheet("color:white")
self.table.resize(300, 250)
self.table.setFont(self.tableFont)
self.table.setSortingEnabled(2)
self.table.resizeColumnsToContents()
self.table.setRowCount(len(data))
self.table.setColumnCount(len(self.cols))
self.table.setHorizontalHeaderLabels(self.cols)
self.table.setContextMenuPolicy(Qt.CustomContextMenu)
self.table.customContextMenuRequested.connect(self.handleHeaderMenu)
self.table.hideColumn(0)
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
i = 0
for q in data:
#row id
if q['state'] == 1:
color = QColor(100, 0, 0)
elif q['state'] == 2:
color = QColor(100, 100, 0)
elif q['state'] == 3:
color = QColor(100, 0, 100)
elif q['state'] == 4:
color = QColor(0, 100, 100)
else:
color = QColor(0, 50, 150)
self.table.setItem(i, 0, QTableWidgetItem(str(q['id'])))
self.table.item(i, 0).setBackground(color)
self.table.setItem(i, 1,
QTableWidgetItem(str(q['itemname']).upper()))
self.table.item(i, 1).setBackground(color)
self.table.setItem(i, 2,
QTableWidgetItem(str(q['quantity']).upper()))
self.table.item(i, 2).setBackground(color)
try:
zamt = str("{:,}".format(float(q['amount'])))
except:
zamt = ''
self.table.setItem(i, 3, QTableWidgetItem(zamt))
self.table.item(i, 3).setBackground(color)
try:
if len(q['amount']) > 0 and float(q['amount']) > 0:
tot = float(q['amount']) * float(q['quantity'])
else:
tot = 0
except:
tot = 0
self.table.setItem(i, 4, QTableWidgetItem(str(tot).upper()))
self.table.item(i, 4).setBackground(color)
damz = float(q['datepaid'])
damt = datetime.utcfromtimestamp(damz).strftime('%d-%m-%Y')
self.table.setItem(i, 5, QTableWidgetItem(str(damt)))
self.table.item(i, 5).setBackground(color)
i += 1
self.table.itemSelectionChanged.connect(self.confirmSelection)
self.table.resizeRowsToContents()
self.h1_pull_box.addWidget(self.table)
self.table.show()
def pullOnes(self, a, b):
cn = Db()
arr = cn.selectn(a, '', 1, {'id': b})
return arr
def confirmSelection(self):
item = self.mySelectTable()
if len(item) == 1:
self.pb1.setEnabled(True)
self.pb3.setEnabled(True)
self.pb6.setEnabled(True)
elif len(item) > 1:
self.pb1.setEnabled(False)
self.pb3.setEnabled(True)
self.pb6.setEnabled(True)
else:
self.pb1.setEnabled(False)
self.pb3.setEnabled(False)
self.pb6.setEnabled(False)
def button_close(self, b):
b.close()
def button_editshow(self):
item = self.mySelectTable()
self.editRow(item[0])
self.pb.hide()
self.pb4.show()
self.pb5.show()
def button_delete(self):
item = self.mySelectTable()
_session = self.session
g = Db()
db = 'school_stores' + str(_session)
for j in item:
g.delete(db, {'id': j})
self.reloadTable(1)
def button_edit(self):
_session = self.session
_amounts = self.amountData.text()
_teller = self.tellerData.text()
_quantity = self.quantityData.text()
_person = self.personData.text()
_period = self.periodData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
_description = self.descriptionData.toPlainText()
_store = self.hold_store[self.storeData.currentIndex()]
_borrowed = self.hold_borrowed[self.borrowedData.currentIndex()]
arr = {}
#recieved
if self.r1.isChecked() and _amounts and not (
_amounts == 0) and int(_store) > 0 and int(_quantity) > 0:
_amount = float(_amounts) / float(_quantity)
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 1
#issued
elif self.r2.isChecked() and int(_store) > 0 and int(_quantity) > 0:
_amount = float(_amounts) / float(_quantity)
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 2
#damaged
elif self.r3.isChecked() and int(_store) > 0 and int(_quantity) > 0:
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 3
elif self.r4.isChecked() and int(_store) > 0 and int(_quantity) > 0:
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['quantity'] = _quantity
arr['person'] = _person
arr['period'] = _period
arr['state'] = 4
elif self.r5.isChecked() and int(_store) > 0 and int(_quantity) > 0:
_borrowed = self.hold_borrowed[self.borrowedData.currentIndex()]
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['quantity'] = _quantity
arr['person'] = _person
arr['period'] = _period
arr['active'] = _borrowed
arr['state'] = 5
ups = {}
ups['id'] = self.editID
if int(self.editID) > 0 and len(arr) > 0:
db = 'school_stores' + str(_session)
g = Db()
g.update(db, arr, ups)
if int(self.editID) > 0:
self.button_reset()
def button_reset(self):
self.getQuantity()
self.reloadTable(1)
self.amountData.setText('')
self.descriptionData.clear()
self.tellerData.setText('')
self.personData.setText('')
self.periodData.setText('')
self.quantityData.setText('')
self.pb4.hide()
self.pb5.hide()
self.pb.show()
self.editID = 0
self.button_clear()
self.confirmSelection()
self.reloadBorrowed()
def button_clear(self):
self.table.selectionModel().clearSelection()
def button_click(self):
_session = self.session
_amounts = self.amountData.text()
_teller = self.tellerData.text()
_quantity = self.quantityData.text()
_person = self.personData.text()
_period = self.periodData.text()
_date = self.dateData.date().toPyDate()
_date = time.mktime(_date.timetuple())
_description = self.descriptionData.toPlainText()
_store = self.hold_store[self.storeData.currentIndex()]
arr = {}
#recieved
if self.r1.isChecked() and _amounts and not (
_amounts == 0) and int(_store) > 0 and int(_quantity) > 0:
_amount = float(_amounts) / float(_quantity)
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 1
#issued
elif self.r2.isChecked() and _amounts and not (
_amounts == 0) and int(_store) > 0 and int(_quantity) > 0:
_amount = float(_amounts) / float(_quantity)
arr['amount'] = _amount
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 2
#damaged
elif self.r3.isChecked() and int(_store) > 0 and int(
float(_quantity)) > 0:
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['teller'] = _teller
arr['quantity'] = _quantity
arr['person'] = _person
arr['state'] = 3
elif self.r4.isChecked() and int(_store) > 0 and int(
float(_quantity)) > 0:
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['quantity'] = _quantity
arr['person'] = _person
arr['period'] = _period
arr['state'] = 4
elif self.r5.isChecked() and int(_store) > 0 and int(
float(_quantity)) > 0 and self.borrowedData.currentIndex() > 0:
_borrowed = self.hold_borrowed[self.borrowedData.currentIndex()]
arr['datepaid'] = _date
arr['description'] = _description
arr['itemID'] = _store
arr['quantity'] = _quantity
arr['person'] = _person
arr['period'] = _period
arr['active'] = _borrowed
arr['state'] = 5
if len(arr) > 0:
db = 'school_stores' + str(_session)
g = Db()
ins = g.insert(db, arr)
if int(ins) > 0:
self.button_reset()
class Search(QWidget, plugin.MainWindowPlugin):
def __init__(self, mainwindow):
super(Search, self).__init__(mainwindow)
self._currentView = None
self._positions = None
self._replace = False # are we in replace mode?
mainwindow.currentViewChanged.connect(self.viewChanged)
mainwindow.actionCollection.edit_find_next.triggered.connect(self.findNext)
mainwindow.actionCollection.edit_find_previous.triggered.connect(self.findPrevious)
# dont inherit looks from view
self.setFont(QApplication.font())
self.setPalette(QApplication.palette())
grid = QGridLayout()
grid.setContentsMargins(4, 0, 4, 0)
grid.setVerticalSpacing(0)
self.setLayout(grid)
self.searchEntry = QLineEdit(textChanged=self.slotSearchChanged)
self.searchLabel = QLabel()
self.caseCheck = QCheckBox(checked=True, focusPolicy=Qt.NoFocus)
self.regexCheck = QCheckBox(focusPolicy=Qt.NoFocus)
self.countLabel = QLabel(alignment=Qt.AlignRight | Qt.AlignVCenter)
self.countLabel.setMinimumWidth(QApplication.fontMetrics().width("9999"))
self.closeButton = QToolButton(autoRaise=True, focusPolicy=Qt.NoFocus)
self.hideAction = QAction(self, triggered=self.slotHide)
self.hideAction.setShortcut(QKeySequence(Qt.Key_Escape))
self.hideAction.setIcon(self.style().standardIcon(QStyle.SP_DialogCloseButton))
self.closeButton.setDefaultAction(self.hideAction)
grid.addWidget(self.searchLabel, 0, 0)
grid.addWidget(self.searchEntry, 0, 1)
grid.addWidget(self.caseCheck, 0, 2)
grid.addWidget(self.regexCheck, 0, 3)
grid.addWidget(self.countLabel, 0, 4)
grid.addWidget(self.closeButton, 0, 5)
self.caseCheck.toggled.connect(self.slotSearchChanged)
self.regexCheck.toggled.connect(self.slotSearchChanged)
self.replaceEntry = QLineEdit()
self.replaceLabel = QLabel()
self.replaceButton = QPushButton(clicked=self.slotReplace)
self.replaceAllButton = QPushButton(clicked=self.slotReplaceAll)
grid.addWidget(self.replaceLabel, 1, 0)
grid.addWidget(self.replaceEntry, 1, 1)
grid.addWidget(self.replaceButton, 1, 2)
grid.addWidget(self.replaceAllButton, 1, 3)
app.settingsChanged.connect(self.readSettings)
self.readSettings()
app.translateUI(self)
def translateUI(self):
self.searchLabel.setText(_("Search:"))
self.caseCheck.setText(_("&Case"))
self.caseCheck.setToolTip(_("Case Sensitive"))
self.regexCheck.setText(_("&Regex"))
self.regexCheck.setToolTip(_("Regular Expression"))
self.countLabel.setToolTip(_("The total number of matches"))
self.hideAction.setToolTip(_("Close"))
self.replaceLabel.setText(_("Replace:"))
self.replaceButton.setText(_("Re&place"))
self.replaceButton.setToolTip(_("Replaces the next occurrence of the search term."))
self.replaceAllButton.setText(_("&All"))
self.replaceAllButton.setToolTip(_("Replaces all occurrences of the search term in the document or selection."))
def readSettings(self):
data = textformats.formatData('editor')
self.searchEntry.setFont(data.font)
self.replaceEntry.setFont(data.font)
p = data.palette()
self.searchEntry.setPalette(p)
self.replaceEntry.setPalette(p)
def currentView(self):
return self._currentView and self._currentView()
def setCurrentView(self, view):
self._currentView = weakref.ref(view) if view else None
def showWidget(self):
if self.isVisible():
self.hideWidget()
view = self.window().currentView()
self.setCurrentView(view)
layout = widgets.borderlayout.BorderLayout.get(view)
layout.addWidget(self, widgets.borderlayout.BOTTOM)
self.show()
def hideWidget(self):
view = self.currentView()
if view:
viewhighlighter.highlighter(view).clear("search")
self.hide()
layout = widgets.borderlayout.BorderLayout.get(view)
layout.removeWidget(self)
def viewChanged(self, new):
self.setParent(None)
self.hideWidget()
self.setCurrentView(new)
self.updatePositions()
def slotHide(self):
view = self.currentView()
if view:
self.hideWidget()
view.setFocus()
def find(self):
# hide replace stuff
self.replaceLabel.hide()
self.replaceEntry.hide()
self.replaceButton.hide()
self.replaceAllButton.hide()
self._replace = False # we are not in replace mode
visible = self.isVisible()
if not visible:
with qutil.signalsBlocked(self.searchEntry):
self.searchEntry.clear()
self.showWidget()
if not visible and self.currentView():
# pick current word
cursor = self.currentView().textCursor()
cursor.movePosition(QTextCursor.StartOfWord)
cursor.movePosition(QTextCursor.EndOfWord, QTextCursor.KeepAnchor)
word = cursor.selection().toPlainText()
if not re.search(r'\w', word):
word = ""
self.searchEntry.setText(word)
self.searchEntry.selectAll()
else:
self.slotSearchChanged()
self.searchEntry.setFocus()
def replace(self):
# show replace stuff
self.replaceLabel.show()
self.replaceEntry.show()
self.replaceButton.show()
self.replaceAllButton.show()
focus = self.replaceEntry if self.isVisible() and self.searchEntry.text() else self.searchEntry
self._replace = True # we are in replace mode
self.showWidget()
self.slotSearchChanged()
focus.setFocus()
def slotSearchChanged(self):
self.updatePositions()
viewhighlighter.highlighter(self.currentView()).highlight("search", self._positions, 1)
def updatePositions(self):
search = self.searchEntry.text()
view = self.currentView()
document = view.document()
self._positions = []
if search:
text = document.toPlainText()
flags = re.MULTILINE | re.DOTALL
if not self.caseCheck.isChecked():
flags |= re.IGNORECASE
if not self.regexCheck.isChecked():
search = re.escape(search)
try:
matches = re.finditer(search, text, flags)
except re.error:
pass
else:
for m in matches:
c = QTextCursor(document)
c.setPosition(m.end())
c.setPosition(m.start(), QTextCursor.KeepAnchor)
self._positions.append(c)
self.countLabel.setText(unicode(len(self._positions)))
def findNext(self):
view = self.currentView()
if view and self._positions:
positions = [c.position() for c in self._positions]
index = bisect.bisect_right(positions, view.textCursor().position())
if index < len(positions):
view.setTextCursor(self._positions[index])
else:
view.setTextCursor(self._positions[0])
view.ensureCursorVisible()
def findPrevious(self):
view = self.currentView()
positions = [c.position() for c in self._positions]
if view and positions:
index = bisect.bisect_left(positions, view.textCursor().position()) - 1
view.setTextCursor(self._positions[index])
view.ensureCursorVisible()
def keyPressEvent(self, ev):
if ev.key() == Qt.Key_Tab:
# prevent Tab from reaching the View widget
self.window().focusNextChild()
return
# if in search mode, Up and Down jump between search results
if not self._replace and self._positions and self.searchEntry.text() and not ev.modifiers():
if ev.key() == Qt.Key_Up:
self.findPrevious()
return
elif ev.key() == Qt.Key_Down:
self.findNext()
return
# use enter or return for search next
if ev.key() in (Qt.Key_Enter, Qt.Key_Return):
self.findNext()
return
super(Search, self).keyPressEvent(ev)
def doReplace(self, cursor):
text = cursor.selection().toPlainText()
search = self.searchEntry.text()
replace = self.replaceEntry.text()
ok = text == self.searchEntry.text()
if self.regexCheck.isChecked():
m = re.match(search, text)
ok = False
if m:
try:
replace = m.expand(replace)
ok = True
except re.error:
pass
if ok:
pos = cursor.position()
cursor.insertText(replace)
cursor.setPosition(pos, QTextCursor.KeepAnchor)
return ok
def slotReplace(self):
view = self.currentView()
if view and self._positions:
positions = [c.position() for c in self._positions]
index = bisect.bisect_left(positions, view.textCursor().position())
if index >= len(positions):
index = 0
if self.doReplace(self._positions[index]):
viewhighlighter.highlighter(view).highlight("search", self._positions, 1)
if index < len(positions) - 1:
view.setTextCursor(self._positions[index+1])
else:
view.setTextCursor(self._positions[0])
view.ensureCursorVisible()
def slotReplaceAll(self):
view = self.currentView()
if view:
replaced = False
cursors = self._positions
if view.textCursor().hasSelection():
cursors = [cursor for cursor in cursors if cursortools.contains(view.textCursor(), cursor)]
view.textCursor().beginEditBlock()
for cursor in cursors:
if self.doReplace(cursor):
replaced = True
view.textCursor().endEditBlock()
if replaced:
viewhighlighter.highlighter(view).highlight("search", self._positions, 1)
class ComponentSearchForm():
data_source = None
related_mashups = None
widget = None
table = None
add_btn = None
graph_form = None
highlighted_api = None
highlighted_mashup = None
categoryWindow = None
dataSetListWdiget = None
climateData = None
def show_main_window(self):
# Get datasets from server
data = json.load(urllib2.urlopen(RECO_API_SERVER_ADDR + "/getAllDataSets/"))
# self.climateData = self.loadClimateDataSet(data)
self.climateData = self.parseServerData(data)
self.graph_form = matplotlibWidget()
if self.widget:
self.widget.destroy()
self.widget = None;
self.widget = QWidget()
self.widget.setMinimumSize(1000, 900)
self.widget.setWindowTitle("Recommendation PlugIn")
margin = 30
# Search Feature
self.textboxLabel = QLabel(self.widget)
self.textboxLabel.setText("Describe your goals:")
self.textboxLabel.move(30, 20)
self.textboxLabel.show
self.textbox = QTextEdit(self.widget)
self.textbox.move(30, 45)
self.textbox.setFixedWidth(300)
self.textbox.setFixedHeight(28)
btn_api = QtGui.QPushButton("Recommend Services", self.widget)
btn_api.move(30, 80)
btn_mashup = QtGui.QPushButton("Recommend Workflows", self.widget)
btn_mashup.move(230, 80)
btn_api.clicked.connect(self.api_button_clicked)
btn_mashup.clicked.connect(self.mashups_button_clicked)
self.table = QTableView(self.widget)
self.table.clicked.connect(self.table_clicked)
self.table.setMinimumSize(600, 300)
self.table.resizeColumnsToContents()
self.table.move(30, 120)
# Top Service
self.textboxLabel = QLabel("Top Datasets (Usage)", self.widget)
self.textboxLabel.move(650, 20)
self.textboxLabel.show
self.listWidget = QListWidget(self.widget)
topDatasets = json.load(urllib2.urlopen(RECO_API_SERVER_ADDR + "/getTop10UsedDataset/"))
for topDataset in topDatasets:
id = int(topDataset["datasetID"])
item = QListWidgetItem("{} ({})".format(self.climateData[id]["name"], topDataset["usage"]))
item.setData(Qt.UserRole,self.climateData[id])
self.listWidget.addItem(item)
self.listWidget.move(650, 45)
self.listWidget.resize(280, 380)
self.listWidget.show()
self.listWidget.clicked.connect(lambda: self.dataset_clicked(\
self.listWidget.currentItem().data(Qt.UserRole)))
# Username input box and button for generating recommendations
userTopOffset = 430
self.textboxLabel = QLabel("Enter username for dataset recommendations:", self.widget)
self.textboxLabel.move(30, userTopOffset)
self.textboxLabel.show()
self.userTextbox = QTextEdit(self.widget)
self.userTextbox.move(30, userTopOffset + 30)
self.userTextbox.setFixedWidth(200)
self.userTextbox.setFixedHeight(28)
userBtn = QPushButton("Recommend Datasets", self.widget)
userBtn.move(30 + self.userTextbox.width() + 10, userTopOffset + 30)
#print RECO_API_SERVER_ADDR + "/getTop5RecommendationByUserName/"
## Jan.20 2016
## Change the API names here by shenggu
## According to github.com/cmusv-sc/RecommendationAPIs
##
userBtn.clicked.connect(lambda: self.getRecommendations(RECO_API_SERVER_ADDR + "/getTopKContentBasedCFRecommendedDatasetByUsername",
self.recListFeature))
userBtn.clicked.connect(lambda: self.getRecommendations(RECO_API_SERVER_ADDR + "/getTopKItemBasedCFRecommendedDatasetByUsername",
self.recListItem))
userBtn.clicked.connect(lambda: self.getRecommendations(RECO_API_SERVER_ADDR + "/getTopKUserBasedCFRecommendedDatasetByUsername",
self.recListUser))
userBtn.show()
# Test QlineEdit
# self.userTextbox2 = QLineEdit(self.widget)
# self.userTextbox.move(200, userTopOffset + 30)
# self.userTextbox.setFixedWidth(200)
# self.userTextbox.setFixedHeight(28)
# Feature Recommendations
recTopOffset = 500
self.textboxLabel = QLabel("Feature Recommendations", self.widget)
self.textboxLabel.move(30, recTopOffset)
self.textboxLabel.show()
self.recListFeature = QListWidget(self.widget)
self.recListFeature.move(30, recTopOffset + 30)
self.recListFeature.resize(280, 250)
self.recListFeature.show()
# Item-based Recommendations
self.textboxLabel = QLabel("Item-based Recommendations", self.widget)
self.textboxLabel.move(340, recTopOffset)
self.textboxLabel.show
self.recListItem = QListWidget(self.widget)
self.recListItem.move(340, recTopOffset + 30)
self.recListItem.resize(280, 250)
self.recListItem.show()
# User-based Recommendations
self.textboxLabel = QLabel("User-based Recommendations", self.widget)
self.textboxLabel.move(650, recTopOffset)
self.textboxLabel.show
self.recListUser = QListWidget(self.widget)
self.recListUser.move(650, recTopOffset + 30)
self.recListUser.resize(280, 250)
self.recListUser.show()
# Categories
categoryTopOffset = 300
self.textboxLabel = QLabel("Categories", self.widget)
self.textboxLabel.move(30, recTopOffset + categoryTopOffset)
self.textboxLabel.show
button1 = QPushButton("By Agency", self.widget)
button1.clicked.connect(lambda: self.listCategory_clicked("agency"))
button1.move(30, recTopOffset + categoryTopOffset + 30)
button1.show()
button2 = QPushButton("By Instrument", self.widget)
button2.clicked.connect(lambda: self.listCategory_clicked("instrument"))
button2.move(margin + button1.width() + 20, recTopOffset + categoryTopOffset + 30)
button2.show()
button3 = QPushButton("By Data Source Input", self.widget)
button3.clicked.connect(lambda: self.listCategory_clicked("input"))
button3.move(margin + button1.width() + button2.width() + 40, recTopOffset + categoryTopOffset + 30)
button3.show()
# Show and move widget
self.widget.move(QtGui.QApplication.desktop().screen().rect().center() - \
self.widget.rect().center())
self.widget.show()
# Service and workflow recommendation
self.add_btn = QPushButton("Add to Palette", self.widget)
self.add_btn.clicked.connect(self.add_new_api)
self.add_btn.hide()
self.add_btn.setFixedWidth(160)
self.add_btn.move(470, 20)
self.recommendLabel = QLabel("Also Used", self.widget)
self.recommendLabel.hide()
self.recommendLabel.setFixedWidth(160)
self.recommendLabel.move(470, 50)
self.switch_btn_apis = QPushButton("Related Workflows", self.widget)
self.switch_btn_apis.clicked.connect(self._show_related_apis)
self.switch_btn_apis.hide()
self.switch_btn_apis.setFixedWidth(160)
self.switch_btn_apis.move(470, 80)
self.switch_btn_mashups = QPushButton("Related Modules", self.widget)
self.switch_btn_mashups.clicked.connect(self._show_related_mashups)
self.switch_btn_mashups.hide()
self.switch_btn_mashups.setFixedWidth(160)
self.switch_btn_mashups.move(470, 80)
def printMessage(self):
print "testing"
def __init__(self, parent=None):
self.data_source = DataSource()
def getRecommendations(self, url, listWidget):
# http GET request
username = str(self.userTextbox.toPlainText())
url = url + "?username=kzhang&top_num=5" # + username
print url
results = json.load(urllib2.urlopen(url))
# Update recommendation list
listWidget.clear()
for result in results:
dataset = self.climateData[int(result["datasetID"])]
item = QListWidgetItem(dataset["name"])
item.setData(Qt.UserRole, dataset)
listWidget.addItem(item)
listWidget.clicked.connect(lambda: self.dataset_clicked(\
listWidget.currentItem().data(Qt.UserRole)))
def listCategory_clicked(self, category):
self.categoryWindow = QWidget()
c = self.categoryWindow
c.setWindowTitle("Search dataset by category")
c.setMinimumSize(600, 500)
# Category list showing all posible options
label1 = QLabel("Options by {0}:".format(category), c)
label1.move(50, 20)
label1.show()
categoryListWidget = QListWidget(c)
optionSet = set()
for key in self.climateData:
optionSet.add(self.climateData[key][category])
for option in sorted(list(optionSet)):
item = QListWidgetItem(option)
item.setData(Qt.UserRole, option)
categoryListWidget.addItem(item)
categoryListWidget.move(50, 50)
categoryListWidget.resize(200, 400)
categoryListWidget.show()
categoryListWidget.clicked.connect(lambda: self.categoryItem_clicked(\
category, categoryListWidget.currentItem().data(Qt.UserRole)))
# List showing all datasets associated with the selected option
label2 = QLabel("Available Datasets:", c)
label2.move(250, 20)
label2.show()
self.datasetListWidget = QListWidget(c)
self.datasetListWidget.move(250, 50)
self.datasetListWidget.resize(400, 400)
self.datasetListWidget.show()
c.move(QtGui.QApplication.desktop().screen().rect().center() - \
c.rect().center())
c.show()
def categoryItem_clicked(self, category, option):
self.datasetListWidget.clear()
results = []
for key in self.climateData:
if self.climateData[key][category] == option:
results.append(self.climateData[key])
for result in sorted(results):
item = QListWidgetItem(result["name"])
item.setData(Qt.UserRole,result)
self.datasetListWidget.addItem(item)
self.datasetListWidget.clicked.connect(lambda: self.dataset_clicked(\
self.datasetListWidget.currentItem().data(Qt.UserRole)));
def dataset_clicked(self, data):
# Initiate Table
keyOrder = ["name", "agency", "instrument", "pvar", "var", "units", "grid", \
"webvar", "input", "start", "end"]
sortedData = sorted(data.items(), key=lambda dataPair:keyOrder.index(dataPair[0]))
self.topServiceTable = QTableWidget()
t = self.topServiceTable
t.setWindowTitle(data["name"])
t.resize(550, 400)
t.setRowCount(len(data.keys()))
t.setColumnCount(2)
t.setColumnWidth(0, 100);
t.setColumnWidth(1, 400);
# Set label
t.setHorizontalHeaderLabels(("Variable;Value").split(";"))
# Set data
for row, pair in enumerate(sortedData):
t.setItem(row, 0, QTableWidgetItem(pair[0]))
t.setItem(row, 1, QTableWidgetItem(pair[1]))
t.move(QtGui.QApplication.desktop().screen().rect().topRight() - t.rect().topRight())
t.show()
def table_clicked(self):
"""
Click the table, the graph form may change according to the selection.
"""
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
row = index.row()
# data = index.model().headerData(0,Qt.Horizontal).toString()
data = index.model().headerData(0,Qt.Horizontal)
newIndex = index.model().index(row, 0)
if data == "API":
api_id = get_api_full_name(newIndex.model().data(newIndex))
api = self.data_source.api_by_id(api_id)
print api
mashups = self.data_source.mashups_by_api(api)
apis = []
for mashup in mashups:
apis.extend(self.data_source.apis_by_mashup(mashup))
self.graph_form.draw_apis(apis, api, self.highlighted_api)
else:
mashup_id = get_mashup_full_name(newIndex.model().data(newIndex))
mashup = self.data_source.mashup_by_id(mashup_id)
if not mashup:
return
apis = self.data_source.apis_by_mashup(mashup)
mashups = []
if len(apis) > 0:
mashups.extend(self.data_source.mashups_by_api(apis[0]))
self.graph_form.draw_mashups(mashups, mashup, self.highlighted_mashup)
return
def _show_apis(self, apis, recommend=False):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(apis), 4)
model.setColumnCount(4)
#QVariant(...) -> ...
for api in apis:
model.setData(model.index(row, 0), get_api_name(api))
model.setData(model.index(row, 1), api['protocols'])
model.setData(model.index(row, 2), api['provider'])
model.setData(model.index(row, 3), api['version'])
row += 1
model.setHeaderData(0, Qt.Horizontal, "Service") # Replaced "Module" with "Service"
model.setHeaderData(1, Qt.Horizontal, "Protocol")
model.setHeaderData(2, Qt.Horizontal, "Provider")
model.setHeaderData(3, Qt.Horizontal, "Version")
self.table.setModel(model)
self.table.resizeColumnsToContents()
if recommend:
self.recommendLabel.show()
self.add_btn.show()
def _show_mashups(self, mashups):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(mashups), 4)
model.setColumnCount(4)
for mashup in mashups:
model.setData(model.index(row, 0), get_mashup_name(mashup))
model.setData(model.index(row, 1), mashup['title'])
model.setData(model.index(row, 2), mashup['self'])
model.setData(model.index(row, 3), mashup['description'])
row += 1
model.setHeaderData(0, Qt.Horizontal, "Workflow")
model.setHeaderData(1, Qt.Horizontal, "Short Description")
model.setHeaderData(2, Qt.Horizontal, "Provider")
model.setHeaderData(3, Qt.Horizontal, "Detailed Info")
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.add_btn.show()
def api_button_clicked(self):
"""
Trigger to search APIs
"""
self.graph_form.draw_api()
self.graph_form.show()
# Get user input from textbox
apis = self.data_source.apis()
key = str(self.textbox.toPlainText())
if key:
self.api_search_button_clicked()
else:
self._show_apis(apis)
def mashups_button_clicked(self):
"""
Trigger to search mashups
"""
self.graph_form.draw_mashup()
self.graph_form.show()
key = str(self.textbox.toPlainText())
print key
print "button clicked"
if key:
self.mashup_search_button_clicked()
else:
self._show_mashups(self.data_source.mashups())
#Should probably refactor this into one method.
def api_search_button_clicked(self):
"""
Search when keyword is present
"""
self.highlighted_api = None
self.highlighted_mashup = None
key = str(self.textbox.toPlainText())
if key != "":
apis = self.data_source.search_api(key)
self._show_apis(apis)
def mashup_search_button_clicked(self):
"""
Search when keyword is present
"""
self.highlighted_api = None
self.highlighted_mashup = None
key = str(self.textbox.toPlainText())
if key != "":
mashups = self.data_source.search_mashup(key)
self._show_mashups(mashups)
def add_new_api(self):
"""
Add new api to the modules package.
"""
apis = self.data_source.apis()
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
api = apis[index.row()]
self._add_new_api(api)
return
def add_related_api(self):
objs = []
for mashup in self.related_mashups:
objs.append(mashup)
for api in mashup["related_mashups"]:
objs.append(api)
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
api = objs[index.row()]
if api.get("protocols"):
self._add_new_api(api)
return
def _show_related_mashups(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
apis = []
objs = []
for mashup in self.related_mashups:
apis.extend(mashup["related_mashups"])
for api in apis:
objs.append(api)
mashups = self.data_source.mashups_by_api(api)
objs.extend(mashups)
row = 0
model = QStandardItemModel(len(objs), 4)
model.setColumnCount(4)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 0), get_api_name(obj))
model.setData(model.index(row, 1), obj['protocols'])
model.setData(model.index(row, 2), obj['provider'])
else:
model.setData(model.index(row, 3), get_mashup_name(obj))
row += 1
model.setHeaderData(0, Qt.Horizontal, "API")
model.setHeaderData(1, Qt.Horizontal, "Protocols")
model.setHeaderData(2, Qt.Horizontal, "Provider")
model.setHeaderData(3, Qt.Horizontal, "Mashup")
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.switch_btn_apis.show()
def _show_related_apis(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
objs = []
for mashup in self.related_mashups:
objs.append(mashup)
for api in mashup["related_mashups"]:
objs.append(api)
#Combining similarity and related.
similar_apis = self.data_source.search_api_similarity(self.highlighted_api)
#return str(mashup['id'])[(len("http://www.programmableweb.com/mashup/")):]
objs.append({'id': "http://www.programmableweb.com/mashup/Using-Similarity-Metric"})
objs.extend(similar_apis)
#Combining similarity and related.
#http://localhost:9000/getReputation/John%20Lions
model = QStandardItemModel(len(objs), 6)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 1), get_api_name(obj))
model.setData(model.index(row, 2), obj['protocols'])
model.setData(model.index(row, 3), obj['provider'])
model.setData(model.index(row, 4), obj['version'])
#trust = requests.get('http://localhost:9000/getReputation/Luis Ramos').content
model.setData(model.index(row, 5), str(random.random()))
#model.setData(model.index(row, 5), QVariant(trust))
else:
model.setData(model.index(row, 0), get_mashup_name(obj))
row += 1
model.setHeaderData(0, Qt.Horizontal, "Mashup")
model.setHeaderData(1, Qt.Horizontal, "API")
model.setHeaderData(2, Qt.Horizontal, "Protocols")
model.setHeaderData(3, Qt.Horizontal, "Provider")
model.setHeaderData(4, Qt.Horizontal, "Version")
model.setHeaderData(5, Qt.Horizontal, "Trust")
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.switch_btn_mashups.show()
def _add_new_api(self, api):
self.highlighted_api = api
mashups = self.data_source.mashups_by_api(api)
for mashup in mashups:
mashup['related_mashups'] = (self.data_source.apis_by_mashup(mashup))
if len(mashups) > 0:
self.related_mashups = mashups
self._show_related_apis()
manager = core.packagemanager.get_package_manager()
reg = core.modules.module_registry.get_module_registry()
package = manager.get_package("edu.cmu.sv.components", "1.0.0")
core.modules.module_registry.set_current_package(package)
if (api["protocols"] == "SOAP" and api["wsdl"] != ""):
s = Service(api["wsdl"])
# add_new_service(s, api["wsdl"])
else:
new_module = vistrails_module.new_module(Module, get_api_name(api))
reg.add_module(new_module)
reg.add_input_port(new_module, "value1",
(core.modules.basic_modules.String, 'the first argument'))
reg.add_input_port(new_module, "value2",
(core.modules.basic_modules.String, 'the second argument'))
reg.add_output_port(new_module, "value",
(core.modules.basic_modules.String, 'the result'))
# def loadClimateDataSet(self):
# filename = '/home/hywel/Documents/VisTrailsRecommendation/vistrails_current/vistrails/packages/componentSearch/Climate_Datasets.csv'
# with open(filename, mode='r') as infile:
# reader = csv.reader(infile)
# next(reader, None)
# with open('coors_new.csv', mode='w') as outfile:
# writer = csv.writer(outfile)
# climateData = {}
# for row in reader:
# id = int(row[0])
# climateData[id] = {}
# climateData[id]["dataset"] = row[1]
# climateData[id]["agency"] = row[2]
# climateData[id]["instrument"] = row[3]
# climateData[id]["pvar"] = row[4]
# climateData[id]["var"] = row[5]
# climateData[id]["units"] = row[6]
# climateData[id]["grid"] = row[7]
# climateData[id]["webvar"] = row[8]
# climateData[id]["input"] = row[9]
# climateData[id]["start"] = row[10]
# climateData[id]["end"] = row[11]
# return climateData
def parseServerData(self, data):
climateData = {}
for dataset in data:
id = int(dataset["datasetID"])
climateData[id] = {}
climateData[id]["name"] = dataset["dataset"]
climateData[id]["agency"] = dataset["agency"]
climateData[id]["instrument"] = dataset["instrument"]
climateData[id]["pvar"] = dataset["pvar"]
climateData[id]["var"] = dataset["var"]
climateData[id]["units"] = dataset["units"]
climateData[id]["grid"] = dataset["grid"]
climateData[id]["webvar"] = dataset["webvar"]
climateData[id]["input"] = dataset["input"]
climateData[id]["start"] = dataset["start"]
climateData[id]["end"] = dataset["end"]
return climateData
class ComponentSearchForm():
data_source = None
related_mashups = None
widget = None
table = None
add_btn = None
graph_form = None
highlighted_api = None
highlighted_mashup = None
def show_main_window(self):
self.graph_form = matplotlibWidget()
if self.widget:
self.widget.destroy()
self.widget = None;
self.widget = QWidget()
self.widget.setMinimumSize(800, 600)
btn_api = QtGui.QPushButton("Recommend Modules", self.widget)
btn_api.move(30, 20)
btn_mashup = QtGui.QPushButton("Recommend Workflows", self.widget)
btn_mashup.move(200, 20)
self.textboxLabel = QLabel(self.widget)
self.textboxLabel.setText("Describe your goals:")
self.textboxLabel.move(35, 60)
self.textboxLabel.show
self.textbox = QTextEdit(self.widget)
self.textbox.move(30, 80)
self.textbox.setFixedWidth(300)
self.textbox.setFixedHeight(28)
btn_api.clicked.connect(self.api_button_clicked)
btn_mashup.clicked.connect(self.mashups_button_clicked)
self.table = QTableView(self.widget)
self.table.clicked.connect(self.table_clicked)
self.table.setMinimumSize(740, 500)
self.table.resizeColumnsToContents()
self.table.move(30, 120)
self.widget.show()
self.add_btn = QPushButton(self.widget)
self.add_btn.clicked.connect(self.add_new_api)
self.add_btn.setText("Add to Palette")
self.add_btn.hide()
self.add_btn.move(650, 20)
self.recommendLabel = QLabel(self.widget)
self.recommendLabel.setText("Also Used")
self.recommendLabel.move(30, 95)
self.recommendLabel.hide()
self.switch_btn_apis = QPushButton(self.widget)
self.switch_btn_apis.clicked.connect(self._show_related_apis)
self.switch_btn_apis.setText("Related Mashup")
self.switch_btn_apis.move(500, 20)
self.switch_btn_apis.hide()
self.switch_btn_mashups = QPushButton(self.widget)
self.switch_btn_mashups.clicked.connect(self._show_related_mashups)
self.switch_btn_mashups.setText("Related API")
self.switch_btn_mashups.move(500, 20)
self.switch_btn_mashups.hide()
def __init__(self, parent=None):
self.data_source = DataSource()
def table_clicked(self):
"""
Click the table, the graph form may change according to the selection.
"""
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
row = index.row()
data = index.model().headerData(0,Qt.Horizontal).toString()
newIndex = index.model().index(row, 0)
if data == "API":
api_id = get_api_full_name(newIndex.model().data(newIndex).toString())
api = self.data_source.api_by_id(api_id)
print api
mashups = self.data_source.mashups_by_api(api)
apis = []
for mashup in mashups:
apis.extend(self.data_source.apis_by_mashup(mashup))
self.graph_form.draw_apis(apis, api, self.highlighted_api)
else:
mashup_id = get_mashup_full_name(newIndex.model().data(newIndex).toString())
mashup = self.data_source.mashup_by_id(mashup_id)
if not mashup:
return
apis = self.data_source.apis_by_mashup(mashup)
mashups = []
if len(apis) > 0:
mashups.extend(self.data_source.mashups_by_api(apis[0]))
self.graph_form.draw_mashups(mashups, mashup, self.highlighted_mashup)
return
def _show_apis(self, apis, recommend=False):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(apis), 4)
model.setColumnCount(4)
for api in apis:
model.setData(model.index(row, 0), QVariant(get_api_name(api)))
model.setData(model.index(row, 1), QVariant(api['protocols']))
model.setData(model.index(row, 2), QVariant(api['provider']))
model.setData(model.index(row, 3), QVariant(api['version']))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("Module"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Protocol"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Version"))
# model.setHeaderData(0, Qt.Horizontal, QVariant("API"))
# model.setHeaderData(1, Qt.Horizontal, QVariant("Protocols"))
# model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
# model.setHeaderData(3, Qt.Horizontal, QVariant("Version"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
if recommend:
self.recommendLabel.show()
self.add_btn.show()
def _show_mashups(self, mashups):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
model = QStandardItemModel(len(mashups), 4)
model.setColumnCount(4)
for mashup in mashups:
model.setData(model.index(row, 0), QVariant(get_mashup_name(mashup)))
model.setData(model.index(row, 1), QVariant(mashup['title']))
model.setData(model.index(row, 2), QVariant(mashup['self']))
model.setData(model.index(row, 3), QVariant(mashup['description']))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("Workflow"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Short Description"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Detailed Info"))
# model.setHeaderData(0, Qt.Horizontal, QVariant("Info"))
# model.setHeaderData(1, Qt.Horizontal, QVariant("Title"))
# model.setHeaderData(2, Qt.Horizontal, QVariant("self"))
# model.setHeaderData(3, Qt.Horizontal, QVariant("Description"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.add_btn.show()
def api_button_clicked(self):
"""
Trigger to search APIs
"""
self.graph_form.draw_api()
self.graph_form.show()
apis = self.data_source.apis()
key = str(self.textbox.toPlainText())
#Has key or not has key, it is different.
if key:
self.api_search_button_clicked()
else:
self._show_apis(apis)
def mashups_button_clicked(self):
"""
Trigger to search mashups
"""
self.graph_form.draw_mashup()
self.graph_form.show()
key = str(self.textbox.toPlainText())
if key:
self.mashup_search_button_clicked()
else:
self._show_mashups(self.data_source.mashups())
#Should probably refactor this into one method.
def api_search_button_clicked(self):
"""
Search when no keyword
"""
self.highlighted_api = None
self.highlighted_mashup = None
key = str(self.textbox.toPlainText())
if key != "":
apis = self.data_source.search_api(key)
self._show_apis(apis)
def mashup_search_button_clicked(self):
"""
Search when no keyword
"""
self.highlighted_api = None
self.highlighted_mashup = None
key = str(self.textbox.toPlainText())
if key != "":
mashups = self.data_source.search_mashup(key)
self._show_mashups(mashups)
def add_new_api(self):
"""
Add new api to the modules package.
"""
apis = self.data_source.apis()
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
api = apis[index.row()]
self._add_new_api(api)
return
def add_related_api(self):
objs = []
for mashup in self.related_mashups:
objs.append(mashup)
for api in mashup["related_mashups"]:
objs.append(api)
model = self.table.selectionModel()
indexes = model.selectedIndexes()
for index in indexes:
api = objs[index.row()]
if api.get("protocols"):
self._add_new_api(api)
return
def _show_related_mashups(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
apis = []
objs = []
for mashup in self.related_mashups:
apis.extend(mashup["related_mashups"])
for api in apis:
objs.append(api)
mashups = self.data_source.mashups_by_api(api)
objs.extend(mashups)
row = 0
model = QStandardItemModel(len(objs), 4)
model.setColumnCount(4)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 0), QVariant(get_api_name(obj)))
model.setData(model.index(row, 1), QVariant(obj['protocols']))
model.setData(model.index(row, 2), QVariant(obj['provider']))
else:
model.setData(model.index(row, 3), QVariant(get_mashup_name(obj)))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("API"))
model.setHeaderData(1, Qt.Horizontal, QVariant("Protocols"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Mashup"))
self.table.setModel(model)
self.table.resizeColumnsToContents()
self.switch_btn_apis.show()
def _show_related_apis(self):
self.switch_btn_apis.hide()
self.switch_btn_mashups.hide()
self.recommendLabel.hide()
row = 0
objs = []
for mashup in self.related_mashups:
objs.append(mashup)
for api in mashup["related_mashups"]:
objs.append(api)
#Combining similarity and related.
similar_apis = self.data_source.search_api_similarity(self.highlighted_api)
#return str(mashup['id'])[(len("http://www.programmableweb.com/mashup/")):]
objs.append({'id': "http://www.programmableweb.com/mashup/Using-Similarity-Metric"})
objs.extend(similar_apis)
#Combining similarity and related.
model = QStandardItemModel(len(objs), 5)
for obj in objs:
if obj.get('protocols'):
model.setData(model.index(row, 1), QVariant(get_api_name(obj)))
model.setData(model.index(row, 2), QVariant(obj['protocols']))
model.setData(model.index(row, 3), QVariant(obj['provider']))
model.setData(model.index(row, 4), QVariant(obj['version']))
else:
model.setData(model.index(row, 0), QVariant(get_mashup_name(obj)))
row += 1
model.setHeaderData(0, Qt.Horizontal, QVariant("Mashup"))
model.setHeaderData(1, Qt.Horizontal, QVariant("API"))
model.setHeaderData(2, Qt.Horizontal, QVariant("Protocols"))
model.setHeaderData(3, Qt.Horizontal, QVariant("Provider"))
model.setHeaderData(4, Qt.Horizontal, QVariant("Version"))
self.table.setModel(model)
self.switch_btn_mashups.show()
def _add_new_api(self, api):
self.highlighted_api = api
mashups = self.data_source.mashups_by_api(api)
for mashup in mashups:
mashup['related_mashups'] = (self.data_source.apis_by_mashup(mashup))
if len(mashups) > 0:
self.related_mashups = mashups
self._show_related_apis()
manager = core.packagemanager.get_package_manager()
reg = core.modules.module_registry.get_module_registry()
package = manager.get_package("edu.cmu.sv.components", "1.0.0")
core.modules.module_registry.set_current_package(package)
if (api["protocols"] == "SOAP" and api["wsdl"] != ""):
s = Service(api["wsdl"])
add_new_service(s, api["wsdl"])
else:
new_module = vistrails_module.new_module(Module, get_api_name(api))
reg.add_module(new_module)
reg.add_input_port(new_module, "value1",
(core.modules.basic_modules.String, 'the first argument'))
reg.add_input_port(new_module, "value2",
(core.modules.basic_modules.String, 'the second argument'))
reg.add_output_port(new_module, "value",
(core.modules.basic_modules.String, 'the result'))
class AssociatedPair(QWidget):
""" Gui for a simple vocabulary trainer
"""
def __init__(self, use_wasabi=False):
super(AssociatedPair, self).__init__()
# Speech recognition:
grammar = Grammar("example grammar")
# rules = [NumberNullRule, NumberOneRule, NumberTwoRule, NumberThreeRule,
# NumberFourRule, NumberFiveRule, NumberSixRule,
# NumberSevenRule, NumberEightRule, NumberNineRule]
# for rule in rules:
# grammar.add_rule(rule(self.answer_given))
# grammar.load()
grammar.add_rule(NumberNullRule(self.answer_given))
grammar.add_rule(NumberOneRule(self.answer_given))
grammar.add_rule(NumberTwoRule(self.answer_given))
grammar.add_rule(NumberThreeRule(self.answer_given))
grammar.add_rule(NumberFourRule(self.answer_given))
grammar.add_rule(NumberFiveRule(self.answer_given))
grammar.add_rule(NumberSixRule(self.answer_given))
grammar.add_rule(NumberSevenRule(self.answer_given))
grammar.add_rule(NumberEightRule(self.answer_given))
grammar.add_rule(NumberNineRule(self.answer_given))
grammar.load()
self.training = True
if DEBUG:
self.emo_output = QLabel("")
self.cog_output = QLabel("")
self.speech_output = QLabel("")
agent_layout = QGridLayout()
agent_layout.addWidget(QLabel("Emotional Output:"), 0, 0)
agent_layout.addWidget(self.emo_output, 0, 1)
agent_layout.addWidget(QLabel("Cognition Output:"), 1, 0)
agent_layout.addWidget(self.cog_output, 1, 1)
agent_layout.addWidget(QLabel("Speech Output:"), 2, 0)
agent_layout.addWidget(self.speech_output, 2, 1)
agent_layout.setColumnMinimumWidth(0, 100)
agent_layout.setColumnMinimumWidth(1, 500)
agent = QWidget()
agent.setLayout(agent_layout)
self.start_button = QPushButton("&Start")
self.start_button.clicked.connect(self.start_button_clicked)
main_layout = QBoxLayout(2)
main_layout.addWidget(agent)
main_layout.addWidget(self.start_button)
self.input_widget = self.get_input_widget()
self.input_widget.hide()
main_layout.addWidget(self.input_widget)
self.setLayout(main_layout)
self.resize(600, 400)
# 192.168.0.46
self.exp = Environment(use_wasabi)
self.waiting_for_answer = False
# emotion, cog, speech = self.exp.start()
# self.update_output(emotion, cog, speech)
self.phase = 0
else:
self.speech_output = QLabel("")
self.start_button = QPushButton("&Start")
self.start_button.clicked.connect(self.start_button_clicked)
main_layout = QBoxLayout(2)
main_layout.addWidget(self.start_button)
self.input_widget = self.get_input_widget()
self.input_widget.hide()
main_layout.addWidget(self.input_widget)
self.setLayout(main_layout)
self.resize(300, 300)
self.width = 300
self.height = 300
# 192.168.0.46
self.exp = Environment(use_wasabi)
self.waiting_for_answer = False
# emotion, cog, speech = self.exp.start()
# self.update_output(emotion, cog, speech)
self.phase = 0
QTimer.singleShot(4000, self.second_introduction)
def second_introduction(self):
self.exp.agent.say("Bitte sprechen Sie die folgenden Zahlen nach.")
QTimer.singleShot(6000, self.train_number)
def train_number(self):
if self.exp.test_nr_index < len(self.exp.test_nr) - 1:
self.exp.train_number()
QTimer.singleShot(3000, self.train_number)
else:
print "training finished"
if self.exp.test_correct >= 9:
self.exp.agent.say("Alles richtig. Starten Sie den Test.")
print "Alles ok"
else:
print "Nochmal"
self.exp.test_correct = 0
self.exp.test_nr_index = -1
self.exp.agent.say("Mehr als ein Wort falsch. Noch ein Durchgang.")
QTimer.singleShot(6000, self.train_number)
def get_input_widget(self):
# Nr layout:
button0 = QPushButton("&0")
button1 = QPushButton("&1")
button2 = QPushButton("&2")
button3 = QPushButton("&3")
button4 = QPushButton("&4")
button5 = QPushButton("&5")
button6 = QPushButton("&6")
button7 = QPushButton("&7")
button8 = QPushButton("&8")
button9 = QPushButton("&9")
button0.clicked.connect(self.bu0_clicked)
button1.clicked.connect(self.bu1_clicked)
button2.clicked.connect(self.bu2_clicked)
button3.clicked.connect(self.bu3_clicked)
button4.clicked.connect(self.bu4_clicked)
button5.clicked.connect(self.bu5_clicked)
button6.clicked.connect(self.bu6_clicked)
button7.clicked.connect(self.bu7_clicked)
button8.clicked.connect(self.bu8_clicked)
button9.clicked.connect(self.bu9_clicked)
nr_layout = QGridLayout()
nr_layout.addWidget(button7, 0, 0)
nr_layout.addWidget(button8, 0, 1)
nr_layout.addWidget(button9, 0, 2)
nr_layout.addWidget(button4, 1, 0)
nr_layout.addWidget(button5, 1, 1)
nr_layout.addWidget(button6, 1, 2)
nr_layout.addWidget(button1, 2, 0)
nr_layout.addWidget(button2, 2, 1)
nr_layout.addWidget(button3, 2, 2)
nr_layout.addWidget(button0, 3, 0)
nr_widget = QWidget()
nr_widget.setLayout(nr_layout)
return nr_widget
def start_button_clicked(self):
self.start_button.hide()
self.input_widget.show()
self.training = False
self.exp.save_start_time()
self.exp.start()
QTimer.singleShot(6000, self.present_word)
def bu0_clicked(self):
self.answer_given(0)
def bu1_clicked(self):
self.answer_given(1)
def bu2_clicked(self):
self.answer_given(2)
def bu3_clicked(self):
self.answer_given(3)
def bu4_clicked(self):
self.answer_given(4)
def bu5_clicked(self):
self.answer_given(5)
def bu6_clicked(self):
self.answer_given(6)
def bu7_clicked(self):
self.answer_given(7)
def bu8_clicked(self):
self.answer_given(8)
def bu9_clicked(self):
self.answer_given(9)
def answer_given(self, nr):
if self.training:
self.exp.check_nr(str(nr))
else:
if self.waiting_for_answer:
# print ' @', now - self.exp.start_time, 'answer received: Took', now - self.exp.start_time_answer
self.exp.evaluate(str(nr), datetime.datetime.now())
self.waiting_for_answer = False
def update_output(self, emotion, cog, speech):
""" Updates the text output of the agent.
"""
self.speech_output.setText(speech)
if DEBUG:
self.emo_output.setText(emotion)
self.cog_output.setText(cog)
def present_word(self):
if self.exp.has_next():
# print '@', now - self.exp.start_time, 'present word called'
emotion, cog, speech = self.exp.present_word(datetime.datetime.now())
self.update_output(emotion, cog, speech)
self.waiting_for_answer = True
QTimer.singleShot(5000, self.present_number)
else:
if self.exp.current_run < self.exp.total_runs - 1:
self.exp.reset()
QTimer.singleShot(10000, self.present_word)
else:
self.end()
def present_number(self):
# print '@', now-self.exp.start_time, 'present number called'
self.waiting_for_answer = False
emotion, cog, speech = self.exp.present_number(datetime.datetime.now())
self.update_output(emotion, cog, speech)
QTimer.singleShot(5000, self.present_word)
def end(self):
""" End vocabulary test
"""
emotion, speech = self.exp.end()
if DEBUG:
self.emo_output.setText(emotion)
self.speech_output.setText(speech)
self.input_widget.hide()
