def __init__(self, *args, **kwargs):
# Initialize the base class...
super(DvidDataSelectionBrowser, self).__init__(*args, **kwargs)
self._subvol_widget = SubregionRoiWidget(parent=self)
subvol_layout = QVBoxLayout()
subvol_layout.addWidget(self._subvol_widget)
group_title = (
"Restrict to subvolume (Right-click a volume name above to auto-initialize these subvolume parameters.)"
)
subvol_groupbox = QGroupBox(group_title, parent=self)
subvol_groupbox.setCheckable(True)
subvol_groupbox.setChecked(False)
subvol_groupbox.setEnabled(False)
subvol_groupbox.toggled.connect(self._update_status)
subvol_groupbox.setLayout(subvol_layout)
subvol_groupbox.setFixedHeight(200)
subvol_groupbox.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
self._subvol_groupbox = subvol_groupbox
# Add to the layout
layout = self.layout()
layout.insertWidget(3, subvol_groupbox)
# Special right-click behavior.
self._repo_treewidget.viewport().installEventFilter(self)
def __init__(self, *args, **kwargs):
# Initialize the base class...
super( DvidDataSelectionBrowser, self ).__init__(*args, **kwargs)
self._subvol_widget = SubregionRoiWidget( parent=self )
subvol_layout = QVBoxLayout()
subvol_layout.addWidget( self._subvol_widget )
group_title = "Restrict to subvolume (Right-click a volume name above to auto-initialize these subvolume parameters.)"
subvol_groupbox = QGroupBox(group_title, parent=self)
subvol_groupbox.setCheckable(True)
subvol_groupbox.setChecked(False)
subvol_groupbox.setEnabled(False)
subvol_groupbox.toggled.connect( self._update_status )
subvol_groupbox.setLayout( subvol_layout )
subvol_groupbox.setFixedHeight( 200 )
subvol_groupbox.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Minimum )
self._subvol_groupbox = subvol_groupbox
# Add to the layout
layout = self.layout()
layout.insertWidget( 3, subvol_groupbox )
# Special right-click behavior.
self._repo_treewidget.viewport().installEventFilter(self)
def __init__(self, *args, **kwargs):
# Initialize the base class...
super( DvidDataSelectionBrowser, self ).__init__(*args, **kwargs)
self._roi_widget = SubregionRoiWidget( parent=self )
roi_layout = QVBoxLayout()
roi_layout.addWidget( self._roi_widget )
roi_groupbox = QGroupBox("Specify Region of Interest", parent=self)
roi_groupbox.setCheckable(True)
roi_groupbox.setChecked(False)
roi_groupbox.setEnabled(False)
roi_groupbox.toggled.connect( self._update_display )
roi_groupbox.setLayout( roi_layout )
roi_groupbox.setFixedHeight( 200 )
roi_groupbox.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Minimum )
self._roi_groupbox = roi_groupbox
# Add to the layout
layout = self.layout()
layout.insertWidget( 3, roi_groupbox )
def __init__(self, *args, **kwargs):
# Initialize the base class...
super( DvidDataSelectionBrowser, self ).__init__(*args, **kwargs)
self._roi_widget = SubregionRoiWidget( parent=self )
roi_layout = QVBoxLayout()
roi_layout.addWidget( self._roi_widget )
roi_groupbox = QGroupBox("Specify Region of Interest", parent=self)
roi_groupbox.setCheckable(True)
roi_groupbox.setChecked(False)
roi_groupbox.setEnabled(False)
roi_groupbox.toggled.connect( self._update_display )
roi_groupbox.setLayout( roi_layout )
roi_groupbox.setFixedHeight( 200 )
roi_groupbox.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Minimum )
self._roi_groupbox = roi_groupbox
# Add to the layout
layout = self.layout()
layout.insertWidget( 3, roi_groupbox )
class WProbes(QWidget, Logger.ClassLogger):
"""
Widget for probes
"""
def __init__(self, parent):
"""
Constructs WProbes widget
@param parent:
@type parent:
"""
QWidget.__init__(self, parent)
self.parent = parent
self.name = self.tr("Probes")
self.itemCurrentRunning = None
self.itemCurrentInstalled = None
self.itemCurrentDefault = None
self.probes = {}
self.nbPrbs = 0
# self.prbsInstalled = None
self.createWidgets()
self.createConnections()
self.createActions()
self.createToolbar()
self.deactivate()
def createWidgets (self):
"""
QtWidgets creation
QTreeWidget (Name, Running on address, Type, Sched at, Version, Description)
_______________
| |
|---------------|
| |
| |
|_______________|
"""
layout = QHBoxLayout()
self.deployBox = QGroupBox("Default probes")
self.probesAvailable = QTreeWidget(self)
self.probesAvailable.setIndentation(10)
self.labelsAvail = [ self.tr("Installed") ]
self.probesAvailable.setHeaderLabels(self.labelsAvail)
self.runningBox = QGroupBox("Running")
self.probesRegistered = QTreeWidget(self)
self.probesRegistered.setIndentation(10)
self.runningDockToolbar = QToolBar(self)
self.runningDockToolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.availDockToolbar = QToolBar(self)
self.availDockToolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.labels = [ self.tr("Name"), self.tr("Running on address"), self.tr("Started at"),
self.tr("Type"), self.tr("Auto Startup"), self.tr("Description") ]
self.probesRegistered.setHeaderLabels(self.labels)
self.probesRegistered.setColumnWidth(0, 180)
self.probesRegistered.setColumnWidth(1, 120)
self.probesRegistered.setColumnWidth(2, 150)
self.probesRegistered.setColumnWidth(3, 70)
self.probesRegistered.setContextMenuPolicy(Qt.CustomContextMenu)
self.probesDefault = QTreeWidget(self)
self.probesDefault.setIndentation(10)
self.labelsDefault = [ self.tr("Enabled"), self.tr("Name"), self.tr("Type"), self.tr("Description") ]
self.probesDefault.setHeaderLabels(self.labelsDefault)
self.probesDefault.setContextMenuPolicy(Qt.CustomContextMenu)
self.probesDefault.setColumnWidth(1, 180)
layoutRunning = QVBoxLayout()
layoutRunning.addWidget(self.runningDockToolbar)
layoutRunning.addWidget(self.probesRegistered)
self.runningBox.setLayout(layoutRunning)
self.probeNameEdit = QLineEdit('')
self.probeNameEdit.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Fixed )
self.probeDescEdit = QLineEdit('')
self.probeDescEdit.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Fixed )
self.probeTypeEdit = QLineEdit('')
self.probeTypeEdit.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Fixed )
self.probeTypeEdit.setEnabled(False)
self.probeDescrInstalledEdit = QTextEdit('')
self.probeDescrInstalledEdit.setEnabled(False)
self.checkAutoStartOption = QCheckBox()
self.checkStartNowOption = QCheckBox()
paramLayout = QGridLayout()
paramLayout.addWidget(QLabel("Type:"), 0, 0, Qt.AlignRight)
paramLayout.addWidget(self.probeTypeEdit, 0, 1)
paramLayout.addWidget(QLabel("Name:"), 1, 0, Qt.AlignRight)
paramLayout.addWidget(self.probeNameEdit, 1, 1)
paramLayout.addWidget(QLabel("Description:"), 2, 0, Qt.AlignRight)
paramLayout.addWidget(self.probeDescEdit, 2, 1)
paramLayout.addWidget(QLabel("Startup on boot:"), 3, 0, Qt.AlignRight)
paramLayout.addWidget(self.checkAutoStartOption, 3, 1)
paramLayout.addWidget(QLabel("Start now:"), 4, 0, Qt.AlignRight)
paramLayout.addWidget(self.checkStartNowOption, 4, 1)
layoutLeft = QVBoxLayout()
layoutAvail = QHBoxLayout()
layoutAvail.addWidget(self.probesAvailable)
layoutAvail.addWidget(self.probeDescrInstalledEdit)
layoutLeft.addLayout(layoutAvail)
layoutLeft.addWidget(self.runningBox)
layoutDeploy = QVBoxLayout()
layoutDeploy.addWidget(self.availDockToolbar)
layoutDeploy.addLayout(paramLayout)
layoutDeploy.addWidget(self.probesDefault)
self.deployBox.setLayout(layoutDeploy)
layoutRight = QVBoxLayout()
layoutRight.addWidget(self.deployBox)
layout.addLayout(layoutLeft)
layout.addLayout(layoutRight)
self.setLayout(layout)
def createConnections (self):
"""
Create Qt Connections
"""
self.probesRegistered.customContextMenuRequested.connect(self.onPopupMenu)
self.probesRegistered.currentItemChanged.connect(self.currentItemChanged)
self.probesRegistered.itemClicked.connect(self.itemClicked)
self.probesAvailable.currentItemChanged.connect(self.currentItemChanged)
self.probesDefault.currentItemChanged.connect(self.currentItemChanged)
self.probesDefault.customContextMenuRequested.connect(self.onPopupMenuDefault)
def createActions (self):
"""
Actions defined:
* stop probe
* start probe
* delete one probe
* clear fields
* refresh running probes
* refresh default probes
"""
self.stopAction = QtHelper.createAction(self, "&Stop", self.stopProbe, tip = 'Stop probe',
icon = QIcon(":/act-stop.png"))
self.startAction = QtHelper.createAction(self, "&Add / Start", self.startProbe, tip = 'Add default probe',
icon = QIcon(":/probe-add.png"))
self.delProbeAction = QtHelper.createAction(self, "&Delete", self.delProbe, tip = 'Delete default probe',
icon = QIcon(":/probe-del.png"))
self.cancelAction = QtHelper.createAction(self, "&Clear", self.resetProbe, tip = 'Clear fields',
icon = QIcon(":/clear.png") )
self.refreshRunningAction = QtHelper.createAction(self, "&Refresh",
self.refreshRunningProbe, tip = 'Refresh running probes',
icon = QIcon(":/act-refresh.png") )
self.refreshDefaultAction = QtHelper.createAction(self, "&Refresh",
self.refreshDefaultProbe, tip = 'Refresh default probes',
icon = QIcon(":/act-refresh.png") )
def createToolbar(self):
"""
Toolbar creation
||-------||
|| Empty ||
||-------||
"""
self.runningDockToolbar.setObjectName("Registered Probe toolbar")
self.runningDockToolbar.addAction(self.refreshRunningAction)
self.runningDockToolbar.addSeparator()
self.runningDockToolbar.addAction(self.stopAction)
self.runningDockToolbar.addSeparator()
self.runningDockToolbar.setIconSize(QSize(16, 16))
self.availDockToolbar.setObjectName("Installed Probe toolbar")
self.availDockToolbar.addAction(self.refreshDefaultAction)
self.availDockToolbar.addSeparator()
self.availDockToolbar.addAction(self.startAction)
self.availDockToolbar.addAction(self.delProbeAction)
self.availDockToolbar.addSeparator()
self.availDockToolbar.addAction(self.cancelAction)
self.availDockToolbar.addSeparator()
self.availDockToolbar.setIconSize(QSize(16, 16))
def itemClicked(self, currentItem):
"""
On item clicked
@param currentItem:
@type currentItem:
"""
if currentItem is not None:
if isinstance( currentItem, ProbeItem ):
self.itemCurrentRunning = currentItem
self.stopAction.setEnabled(True)
def currentItemChanged(self, currentItem, previousItem):
"""
On current item changed
@param currentItem:
@type currentItem:
@param previousItem:
@type previousItem:
"""
if currentItem is not None:
if isinstance( currentItem, ProbeInstalledItem ):
self.itemCurrentInstalled = currentItem
if 'description' in currentItem.dataProbe:
self.probeDescrInstalledEdit.setText( currentItem.dataProbe['description'] )
self.probeTypeEdit.setText( currentItem.dataProbe['type'] )
else:
self.probeDescrInstalledEdit.setText( '' )
elif isinstance( currentItem, ProbeItem ):
self.itemCurrentRunning = currentItem
self.stopAction.setEnabled(True)
elif isinstance( currentItem, ProbeDefaultItem ):
self.itemCurrentDefault = currentItem
self.delProbeAction.setEnabled(True)
else:
self.stopAction.setEnabled(False)
self.delProbeAction.setEnabled(False)
self.probeDescrInstalledEdit.setText( '' )
def onPopupMenu(self, pos):
"""
Display menu on right click
@param pos:
@type pos:
"""
self.menu = QMenu()
item = self.probesRegistered.itemAt(pos)
if item:
self.itemCurrentRunning = item
self.menu.addAction( "Stop...", self.stopProbe)
self.menu.popup(self.probesRegistered.mapToGlobal(pos))
def onPopupMenuDefault(self, pos):
"""
Display menu on right click
@param pos:
@type pos:
"""
self.menu = QMenu()
item = self.probesDefault.itemAt(pos)
if item:
self.itemCurrentDefault = item
self.menu.addAction( "Delete...", self.delProbe)
self.menu.popup(self.probesDefault.mapToGlobal(pos))
def refreshDefaultProbe(self):
"""
Refresh the default list of probes
"""
RCI.instance().defaultProbes()
def refreshRunningProbe(self):
"""
Refresh the running list of probes
"""
RCI.instance().runningProbes()
def delProbe(self):
"""
Delete probe
"""
if self.itemCurrentDefault is not None:
reply = QMessageBox.question(self, "Stop probe", "Are you sure ?",
QMessageBox.Yes | QMessageBox.No )
if reply == QMessageBox.Yes:
probeName = self.itemCurrentDefault.dataProbe['name']
self.delProbeAction.setEnabled(False)
# rest call
RCI.instance().removeProbe(probeName=probeName)
def stopProbe(self):
"""
Stop the selected probe
"""
if self.itemCurrentRunning is not None:
reply = QMessageBox.question(self, "Stop probe", "Are you sure ?",
QMessageBox.Yes | QMessageBox.No )
if reply == QMessageBox.Yes:
probeName = self.itemCurrentRunning.dataProbe['id']
self.itemCurrentRunning = None
self.stopAction.setEnabled(False)
# rest call
RCI.instance().disconnectProbe(probeName=probeName)
def startProbe(self):
"""
Start a new probe
"""
# some checks before
if self.probeTypeEdit.text() == '':
QMessageBox.information(self, "Add Default Probe" , "Please select the probe type.")
return
if self.probeNameEdit.text() == '':
QMessageBox.information(self, "Add Default Probe" , "Probe name is mandatory.")
return
if not self.checkAutoStartOption.isChecked() and not self.checkStartNowOption.isChecked():
QMessageBox.information(self, "Add Default Probe" , "Select startup option.")
return
# call web services
probeType = str( self.probeTypeEdit.text() )
probeName = str( self.probeNameEdit.text() )
probeDescription = str( self.probeDescEdit.text() )
probeAutoStart = self.checkAutoStartOption.isChecked()
if not self.checkStartNowOption.isChecked():
RCI.instance().addProbe(probeName=probeName, probeType=probeType,
probeDescription=probeDescription)
else:
RCI.instance().connectProbe(probeName=probeName, probeType=probeType,
probeDescription=probeDescription,
probeBoot=probeAutoStart)
def resetProbe(self):
"""
Clear probe field
"""
self.probeDescrInstalledEdit.setText( '' )
self.probeDescEdit.setText( '' )
self.probeNameEdit.setText( '' )
self.probeTypeEdit.setText( '' )
# clear selection
itms = self.probesAvailable.selectedItems()
for i in itms:
if i.isSelected():
i.setSelected(False)
self.itemCurrentInstalled = None
def active (self):
"""
Enables QTreeWidget
"""
self.probesRegistered.setEnabled(True)
self.probesAvailable.setEnabled(True)
self.deployBox.setEnabled(True)
self.runningBox.setEnabled(True)
self.refreshRunningAction.setEnabled(True)
def deactivate (self):
"""
Clears QTreeWidget and disables it
"""
self.checkAutoStartOption.setCheckState(Qt.Unchecked)
self.checkStartNowOption.setCheckState(Qt.Unchecked)
self.probesAvailable.clear()
self.probeDescrInstalledEdit.setText('')
self.probesRegistered.clear()
self.probesDefault.clear()
self.probes = {}
self.probesRegistered.setEnabled(False)
self.probesAvailable.setEnabled(False)
self.deployBox.setEnabled(False)
self.runningBox.setEnabled(False)
# actions
self.stopAction.setEnabled(False)
self.delProbeAction.setEnabled(False)
self.itemCurrentRunning = None
self.itemCurrentInstalled = None
self.probeDescEdit.setText( '' )
self.probeTypeEdit.setText( '' )
self.probeNameEdit.setText( '' )
self.resetNbProbes()
self.refreshRunningAction.setEnabled(False)
def getRunningProbes(self):
"""
Get running probes
"""
if sys.version_info > (3,): # python3 support
return list(self.probes.keys())
else:
return self.probes.keys()
def getProbeTypeByName(self, name):
"""
Get probe type by name
@param name:
@type name:
"""
if name in self.probes:
return self.probes[name].getProbeType()
else:
return ''
def loadDefault (self, data):
"""
Loads default probes
@param data:
@type data: dict
"""
self.probesDefault.clear()
for defProbe in data:
defProbeItem = ProbeDefaultItem( probe = defProbe, parent= self.probesDefault)
def loadData (self, data, dataInstalled=None):
"""
Loads probes
@param data:
@type data: dict
@param dataInstalled:
@type dataInstalled:
"""
if isinstance(data, dict):
data = [ data ]
self.probesRegistered.clear()
for probe in data:
probeItem = ProbeItem( probe = probe, parent= self.probesRegistered)
self.probes[probe['id']] = probeItem
# load tests stats
if dataInstalled is not None:
if len(dataInstalled) == 0:
self.deployBox.setEnabled(False)
self.probesAvailable.setEnabled(False)
def resetNbProbes(self, data=None):
"""
Reset the number of probes
"""
pass
def refreshData (self, data, action):
"""
Refresh probes
@param data:
@type data: dict
@param action: expected values in 'del' and 'add'
@type action: string
"""
if action == 'del':
self.probesRegistered.clear()
self.probes = {}
self.resetNbProbes(data=data)
self.loadData( data = data )
elif action == 'add':
self.resetNbProbes(data=data)
self.loadData( data = data )
else:
self.error( 'action unknown: %s' % str(action) )
def refreshDataDefault(self, data, action):
"""
Refresh probes
@param data:
@type data: dict
@param action: expected values in 'del' and 'add'
@type action: string
"""
if action == 'del':
self.probesDefault.clear()
self.loadDefault( data = data )
elif action == 'add':
self.probesDefault.clear()
self.loadDefault( data = data )
else:
self.error( 'action unknown: %s' % str(action) )
class OutputAnalyserDialog(QDialog):
def __init__(self, iface, parent, params):
QDialog.__init__(self, parent)
self.iface = iface
self.parent = parent
self.params = params
self.output_reader = None
self.tool = None
self.element_ids_nodes = None
self.element_ids_links = None
self.nodes_lay = None
self.links_lay = None
self.setWindowTitle(Parameters.plug_in_name)
# Selection changed listeners
self.params.junctions_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.reservoirs_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.tanks_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.pipes_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.pumps_vlay.selectionChanged.connect(
self.feature_sel_changed)
self.params.valves_vlay.selectionChanged.connect(
self.feature_sel_changed)
# self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
fra_main_lay = QVBoxLayout(self)
self.fra_out_file = QFrame(self)
fra_out_file_lay = QHBoxLayout(self.fra_out_file)
self.lbl_out_file = QLabel('Simulation output file:')
self.txt_out_file = QLineEdit('')
self.txt_out_file.setReadOnly(True)
self.btn_out_file = QToolButton()
self.btn_out_file.setText('...')
self.btn_out_file.clicked.connect(self.btn_out_file_clicked)
fra_out_file_lay.addWidget(self.lbl_out_file)
fra_out_file_lay.addWidget(self.txt_out_file)
fra_out_file_lay.addWidget(self.btn_out_file)
self.tab_widget = QTabWidget(self)
# Graphs tab ---------------------------------------------------------------------------------------------------
self.tab_graphs = QWidget()
tab_graphs_lay = QHBoxLayout(self.tab_graphs)
# Left frame
self.fra_graphs_left = QFrame()
self.fra_graphs_left.setMaximumWidth(100)
fra_graphs_left_lay = QVBoxLayout(self.fra_graphs_left)
self.btn_sel_element = QPushButton('Pick')
self.btn_sel_element.clicked.connect(self.btn_sel_element_clicked)
fra_graphs_left_lay.addWidget(self.btn_sel_element)
# Nodes
self.grb_nodes = QGroupBox(u'Nodes')
lay_grb_nodes = QVBoxLayout(self.grb_nodes)
self.chk_node_demand = QCheckBox('Demand')
lay_grb_nodes.addWidget(self.chk_node_demand)
self.chk_node_head = QCheckBox('Head')
lay_grb_nodes.addWidget(self.chk_node_head)
self.chk_node_pressure = QCheckBox('Pressure')
lay_grb_nodes.addWidget(self.chk_node_pressure)
self.chk_node_quality = QCheckBox('Quality')
lay_grb_nodes.addWidget(self.chk_node_quality)
fra_graphs_left_lay.addWidget(self.grb_nodes)
# Links
self.grb_links = QGroupBox(u'Links')
lay_grb_links = QVBoxLayout(self.grb_links)
self.chk_link_flow = QCheckBox('Flow')
lay_grb_links.addWidget(self.chk_link_flow)
self.chk_link_velocity = QCheckBox('Velocity')
lay_grb_links.addWidget(self.chk_link_velocity)
self.chk_link_headloss = QCheckBox('Headloss')
lay_grb_links.addWidget(self.chk_link_headloss)
self.chk_link_quality = QCheckBox('Quality')
lay_grb_links.addWidget(self.chk_link_quality)
fra_graphs_left_lay.addWidget(self.grb_links)
self.btn_draw_graph = QPushButton('Draw')
self.btn_draw_graph.clicked.connect(self.draw_graphs)
fra_graphs_left_lay.addWidget(self.btn_draw_graph)
self.spacer = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
fra_graphs_left_lay.addItem(self.spacer)
tab_graphs_lay.addWidget(self.fra_graphs_left)
# Right frame
self.fra_graphs_right = QFrame()
fra_graphs_right_lay = QVBoxLayout(self.fra_graphs_right)
fra_graphs_right_lay.setContentsMargins(0, 0, 0, 0)
self.static_canvas = StaticMplCanvas(self.fra_graphs_right,
width=5,
height=4,
dpi=100)
fra_graphs_right_lay.addWidget(self.static_canvas)
tab_graphs_lay.addWidget(self.fra_graphs_right)
# lay.addWidget(self.button)
self.tab_widget.addTab(self.tab_graphs, 'Graphs')
# Maps tab -----------------------------------------------------------------------------------------------------
self.tab_maps = QWidget()
tab_maps_lay = QHBoxLayout(self.tab_maps)
# Left frame
self.fra_maps_left = QFrame()
self.fra_maps_left.setMaximumWidth(200)
fra_maps_left_lay = QVBoxLayout(self.fra_maps_left)
self.grb_maps = QGroupBox(u'Variable')
grb_maps_lay = QVBoxLayout(self.grb_maps)
self.rad_maps_node_demand = QRadioButton(u'Node demand')
grb_maps_lay.addWidget(self.rad_maps_node_demand)
self.rad_maps_node_head = QRadioButton(u'Node head')
grb_maps_lay.addWidget(self.rad_maps_node_head)
self.rad_maps_node_pressure = QRadioButton(u'Node pressure')
grb_maps_lay.addWidget(self.rad_maps_node_pressure)
self.rad_maps_node_quality = QRadioButton(u'Node quality')
grb_maps_lay.addWidget(self.rad_maps_node_quality)
self.rad_maps_link_flow = QRadioButton(u'Link flow')
grb_maps_lay.addWidget(self.rad_maps_link_flow)
self.rad_maps_link_velocity = QRadioButton(u'Link velocity')
grb_maps_lay.addWidget(self.rad_maps_link_velocity)
self.rad_maps_link_headloss = QRadioButton(u'Link headloss')
grb_maps_lay.addWidget(self.rad_maps_link_headloss)
self.rad_maps_link_quality = QRadioButton(u'Link quality')
grb_maps_lay.addWidget(self.rad_maps_link_quality)
fra_maps_left_lay.addWidget(self.grb_maps)
fra_maps_left_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_left)
# Right maps frame
self.fra_maps_right = QFrame()
fra_maps_right_lay = QVBoxLayout(self.fra_maps_right)
self.fra_maps_right_time = QFrame()
fra_maps_right_time_lay = QFormLayout(self.fra_maps_right_time)
self.lbl_map_times = QLabel(u'Period [h]:')
self.cbo_map_times = QComboBox()
fra_maps_right_time_lay.addRow(self.lbl_map_times, self.cbo_map_times)
fra_maps_right_lay.addWidget(self.fra_maps_right_time)
self.btn_draw_map = QPushButton(u'Draw map')
self.btn_draw_map.clicked.connect(self.draw_maps)
fra_maps_right_lay.addWidget(self.btn_draw_map)
fra_maps_right_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_right)
self.tab_widget.addTab(self.tab_maps, 'Maps')
# # Add to main
fra_main_lay.addWidget(self.fra_out_file)
fra_main_lay.addWidget(self.tab_widget)
self.setup()
self.initialize()
# self.read_outputs()
# Set size
self.setMinimumWidth(self.tab_graphs.width())
self.setMinimumHeight(self.tab_graphs.height())
def setup(self):
pass
def btn_out_file_clicked(self):
config_file = ConfigFile(Parameters.config_file_path)
out_file = QFileDialog.getOpenFileName(self, 'Select out file',
config_file.get_last_out_file(),
'Out files (*.out)')
if out_file is None or out_file == '':
return
config_file.set_last_out_file(out_file)
self.txt_out_file.setText(out_file)
self.read_outputs()
if self.output_reader is None:
return
# Fill times combo
self.cbo_map_times.clear()
for period_s in self.output_reader.period_results.iterkeys():
text = self.seconds_to_string(
period_s, self.output_reader.sim_duration_secs,
self.output_reader.report_time_step_secs)
self.cbo_map_times.addItem(text, period_s)
def initialize(self):
# Graphs
self.grb_nodes.setEnabled(False)
self.grb_links.setEnabled(False)
# Maps
self.rad_maps_node_demand.setChecked(True)
def feature_sel_changed(self):
is_nodes = False
sel_junctions = self.params.junctions_vlay.selectedFeatureCount()
sel_reservoirs = self.params.reservoirs_vlay.selectedFeatureCount()
sel_tanks = self.params.tanks_vlay.selectedFeatureCount()
if sel_junctions > 0 or sel_reservoirs > 0 or sel_tanks > 0:
is_nodes = True
self.grb_nodes.setEnabled(is_nodes)
is_links = False
sel_pipes = self.params.pipes_vlay.selectedFeatureCount()
sel_pumps = self.params.pumps_vlay.selectedFeatureCount()
sel_valves = self.params.valves_vlay.selectedFeatureCount()
if sel_pipes > 0 or sel_pumps > 0 or sel_valves > 0:
is_links = True
self.grb_links.setEnabled(is_links)
def read_outputs(self):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
self.output_reader = BinaryOutputReader()
self.output_reader.read(self.txt_out_file.text())
QApplication.restoreOverrideCursor()
# Check if output compatible with loaded project
compatible = True
out_nodes_nr = self.output_reader.nodes_nr
out_tanks_reservs_nr = self.output_reader.tanks_reservs_nr
out_juncts_nr = out_nodes_nr - out_tanks_reservs_nr
out_links_nr = self.output_reader.links_nr
out_pumps_nr = self.output_reader.pumps_nr
out_valves_nr = self.output_reader.valves_nr
out_pipes_nr = out_links_nr - out_pumps_nr - out_valves_nr
if out_juncts_nr != self.params.junctions_vlay.featureCount():
compatible = False
if out_tanks_reservs_nr != (
self.params.reservoirs_vlay.featureCount() +
self.params.tanks_vlay.featureCount()):
compatible = False
if out_pipes_nr != self.params.pipes_vlay.featureCount():
compatible = False
if out_valves_nr != self.params.valves_vlay.featureCount():
compatible = False
if out_pumps_nr != self.params.pumps_vlay.featureCount():
compatible = False
if not compatible:
message = 'The out file appears to incompatible with the actual project layers.'
QMessageBox.warning(self, Parameters.plug_in_name, message,
QMessageBox.Ok)
self.output_reader = None
self.txt_out_file.setText('')
else:
# Message after reading completed
message = 'Out file loaded: ' + str(
out_nodes_nr) + ' nodes, ' + str(
out_links_nr) + ' links found.'
# Clear refs to output layer
self.params.out_lay_node_demand = None
self.params.out_lay_node_head = None
self.params.out_lay_node_pressure = None
self.params.out_lay_node_quality = None
self.params.out_lay_link_flow = None
self.params.out_lay_link_velocity = None
self.params.out_lay_link_headloss = None
self.params.out_lay_link_quality = None
QMessageBox.information(self, Parameters.plug_in_name, message,
QMessageBox.Ok)
finally:
# self.iface.messageBar().pushWarning(
# Parameters.plug_in_name,
# 'Error while reading output file.') # TODO: softcode
# self.output_reader = None
# self.txt_out_file.setText('')
QApplication.restoreOverrideCursor()
def btn_sel_element_clicked(self):
if self.output_reader is None:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Please select the simulation out file.',
QgsMessageBar.WARNING, 5) # TODO: softcode
return
self.tool = SelectTool(self, self.params)
self.iface.mapCanvas().setMapTool(self.tool)
cursor = QCursor()
cursor.setShape(Qt.ArrowCursor)
self.iface.mapCanvas().setCursor(cursor)
def draw_graphs(self):
# Get selected features
self.element_ids_nodes = []
for junction_feat in self.params.junctions_vlay.selectedFeatures():
self.element_ids_nodes.append(
junction_feat.attribute(Junction.field_name_eid))
for reservoir_feat in self.params.reservoirs_vlay.selectedFeatures():
self.element_ids_nodes.append(
reservoir_feat.attribute(Reservoir.field_name_eid))
for tank_feat in self.params.tanks_vlay.selectedFeatures():
self.element_ids_nodes.append(
tank_feat.attribute(Tank.field_name_eid))
self.element_ids_links = []
for pipe_feat in self.params.pipes_vlay.selectedFeatures():
self.element_ids_links.append(
pipe_feat.attribute(Pipe.field_name_eid))
for pump_feat in self.params.pumps_vlay.selectedFeatures():
self.element_ids_links.append(
pump_feat.attribute(Pump.field_name_eid))
for valve_feat in self.params.valves_vlay.selectedFeatures():
self.element_ids_links.append(
valve_feat.attribute(Valve.field_name_eid))
# Build values dictionaries
xs = self.output_reader.report_times
ys_d_d = {}
params_count = 0
# Nodes
if self.grb_nodes.isEnabled():
if self.chk_node_demand.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_demands_d[element_id],
self.params.options.flow_units
]
ys_d_d[OutputParamCodes.NODE_DEMAND] = ys_d
if self.chk_node_head.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_heads_d[element_id],
Options.units_diameter_tanks[self.params.options.units]
]
ys_d_d[OutputParamCodes.NODE_HEAD] = ys_d
if self.chk_node_pressure.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_pressures_d[element_id],
Options.units_pressure[self.params.options.units]
]
ys_d_d[OutputParamCodes.NODE_PRESSURE] = ys_d
if self.chk_node_quality.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_qualities_d[element_id],
Quality.quality_units_text[
self.params.options.quality.mass_units]
]
ys_d_d[OutputParamCodes.NODE_QUALITY] = ys_d
# Links
if self.grb_links.isEnabled():
if self.chk_link_flow.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_flows_d[element_id],
self.params.options.flow_units
]
ys_d_d[OutputParamCodes.LINK_FLOW] = ys_d
if self.chk_link_velocity.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_velocities_d[element_id],
Options.units_velocity[self.params.options.units]
]
ys_d_d[OutputParamCodes.LINK_VELOCITY] = ys_d
if self.chk_link_headloss.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_headlosses_d[element_id],
Options.units_diameter_tanks[self.params.options.units]
]
ys_d_d[OutputParamCodes.LINK_HEADLOSS] = ys_d
if self.chk_link_quality.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_qualities_d[element_id],
Quality.quality_units_text[
self.params.options.quality.mass_units]
]
ys_d_d[OutputParamCodes.LINK_QUALITY] = ys_d
if ys_d_d:
self.static_canvas.draw_output_line(xs, ys_d_d, params_count)
def draw_maps(self):
"""
Draws layers with all the attributes
:return:
"""
report_time = self.cbo_map_times.itemText(
self.cbo_map_times.currentIndex())
if self.rad_maps_node_demand.isChecked(
): # -------------------------------------------------------------------
lay_name = u'Node demand'
lay_id = self.draw_map(LayerType.NODE,
self.params.out_lay_node_demand_id,
lay_name, self.output_reader.node_demands_d,
report_time)
self.params.out_lay_node_demand_id = lay_id
elif self.rad_maps_node_head.isChecked():
lay_name = u'Node head'
lay_id = self.draw_map(LayerType.NODE,
self.params.out_lay_node_head_id, lay_name,
self.output_reader.node_heads_d,
report_time)
self.params.out_lay_node_head_id = lay_id
elif self.rad_maps_node_pressure.isChecked():
lay_name = u'Node pressure'
lay_id = self.draw_map(LayerType.NODE,
self.params.out_lay_node_pressure_id,
lay_name,
self.output_reader.node_pressures_d,
report_time)
self.params.out_lay_node_pressure_id = lay_id
elif self.rad_maps_node_quality.isChecked():
lay_name = u'Node quality'
lay_id = self.draw_map(LayerType.NODE,
self.params.out_lay_node_quality_id,
lay_name,
self.output_reader.node_qualities_d,
report_time)
self.params.out_lay_node_quality_id = lay_id
elif self.rad_maps_link_flow.isChecked(
): # -------------------------------------------------------------------
lay_name = u'Link flow'
lay_id = self.draw_map(LayerType.LINK,
self.params.out_lay_link_flow_id, lay_name,
self.output_reader.link_flows_d,
report_time)
self.params.out_lay_link_flow_id = lay_id
elif self.rad_maps_link_velocity.isChecked():
lay_name = u'Link velocity'
lay_id = self.draw_map(LayerType.LINK,
self.params.out_lay_link_velocity_id,
lay_name,
self.output_reader.link_velocities_d,
report_time)
self.params.out_lay_link_velocity_id = lay_id
elif self.rad_maps_link_headloss.isChecked():
lay_name = u'Link headloss'
lay_id = self.draw_map(LayerType.LINK,
self.params.out_lay_link_headloss_id,
lay_name,
self.output_reader.link_headlosses_d,
report_time)
self.params.out_lay_link_headloss_id = lay_id
elif self.rad_maps_link_quality.isChecked():
lay_name = u'Link quality'
lay_id = self.draw_map(LayerType.LINK,
self.params.out_lay_link_quality_id,
lay_name,
self.output_reader.link_qualities_d,
report_time)
self.params.out_lay_link_quality_id = lay_id
def draw_map(self, lay_type, lay_id, lay_name, dataset, report_time):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
lay_name += ' ' + report_time
lay = LayerUtils.get_lay_from_id(lay_id)
if lay is None:
if lay_type == LayerType.NODE:
lay = self.create_out_node_layer(lay_name, dataset)
ns = NodeSymbology()
lay.setRendererV2(
ns.make_graduated_sym_renderer(lay, report_time))
elif lay_type == LayerType.LINK:
lay = self.create_out_link_layer(lay_name, dataset)
ls = LinkSymbology()
lay.setRendererV2(
ls.make_flow_sym_renderer(lay, report_time))
lay_id = lay.id()
QgsMapLayerRegistry.instance().addMapLayer(lay)
self.params.out_layers.append(lay)
else:
lay.setLayerName(lay_name)
lay.triggerRepaint()
QApplication.restoreOverrideCursor()
finally:
QApplication.restoreOverrideCursor()
return lay_id
def btn_cancel_clicked(self):
self.setVisible(False)
def btn_ok_clicked(self):
pass
def create_out_node_layer(self, lay_name, values_d):
return self.create_out_layer(lay_name, values_d, LayerType.NODE)
def create_out_link_layer(self, lay_name, values_d):
return self.create_out_layer(lay_name, values_d, LayerType.LINK)
def create_out_layer(self, lay_name, values_d, lay_type):
field_name_vars = []
periods = self.output_reader.period_results.keys()
for period_s in periods:
text = self.seconds_to_string(
period_s, self.output_reader.sim_duration_secs,
self.output_reader.report_time_step_secs)
field_name_vars.append(text)
if lay_type == LayerType.NODE:
new_lay = MemoryDS.create_nodes_lay(self.params, field_name_vars,
lay_name, self.params.crs)
elif lay_type == LayerType.LINK:
new_lay = MemoryDS.create_links_lay(self.params, field_name_vars,
lay_name, self.params.crs)
with edit(new_lay):
# Update attributes
for feat in new_lay.getFeatures():
fid = feat.id()
eid = feat.attribute(Node.field_name_eid)
values = values_d[eid]
for p in range(len(periods)):
new_lay.changeAttributeValue(fid, p + 1, values[p])
return new_lay
def seconds_to_string(self, period_s, duration_s, interval_s):
day = int(math.floor(period_s / 86400))
hour = period_s / 3600 - day * 24
minute = period_s / 60 - day * 24 * 60 - hour * 60
second = period_s - day * 86400 - hour * 3600 - minute * 60
text = ''
if duration_s >= 86400:
# We need days
text += str(day) + 'd'
if duration_s >= 3600:
# We need hours
text += '{:02}'.format(hour) + 'H'
text += '{:02}'.format(minute) + 'm'
if second > 0:
text += '{:02}'.format(second) + 's'
return text
def _init_layout(self):
"""
Create the GUI widgets (but leave them empty).
"""
hostname_combobox = QComboBox(parent=self)
self._hostname_combobox = hostname_combobox
hostname_combobox.setEditable(True)
hostname_combobox.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Maximum )
hostname_combobox.installEventFilter(self)
for hostname in self._suggested_hostnames:
hostname_combobox.addItem( hostname )
self._connect_button = QPushButton("Connect", parent=self, clicked=self._handle_new_hostname)
hostname_layout = QHBoxLayout()
hostname_layout.addWidget( hostname_combobox )
hostname_layout.addWidget( self._connect_button )
hostname_groupbox = QGroupBox("DVID Host", parent=self)
hostname_groupbox.setLayout( hostname_layout )
hostname_groupbox.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Maximum )
data_treewidget = QTreeWidget(parent=self)
data_treewidget.setHeaderLabels( ["Data"] ) # TODO: Add type, shape, axes, etc.
data_treewidget.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Preferred )
data_treewidget.itemSelectionChanged.connect( self._handle_data_selection )
data_layout = QVBoxLayout()
data_layout.addWidget( data_treewidget )
data_groupbox = QGroupBox("Data Volumes", parent=self)
data_groupbox.setLayout( data_layout )
node_listwidget = QListWidget(parent=self)
node_listwidget.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Preferred )
node_listwidget.itemSelectionChanged.connect( self._update_display )
node_layout = QVBoxLayout()
node_layout.addWidget( node_listwidget )
node_groupbox = QGroupBox("Nodes", parent=self)
node_groupbox.setLayout( node_layout )
new_data_edit = QLineEdit(parent=self)
new_data_edit.textEdited.connect( self._update_display )
full_url_label = QLabel(parent=self)
full_url_label.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Maximum )
text_flags = full_url_label.textInteractionFlags()
full_url_label.setTextInteractionFlags( text_flags | Qt.TextSelectableByMouse )
new_data_layout = QVBoxLayout()
new_data_layout.addWidget( new_data_edit )
new_data_groupbox = QGroupBox("New Data Volume", parent=self)
new_data_groupbox.setLayout( new_data_layout )
new_data_groupbox.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Maximum )
buttonbox = QDialogButtonBox( Qt.Horizontal, parent=self )
buttonbox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel )
buttonbox.accepted.connect( self.accept )
buttonbox.rejected.connect( self.reject )
buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
layout = QVBoxLayout()
layout.addWidget( hostname_groupbox )
layout.addWidget( data_groupbox )
layout.addWidget( node_groupbox )
if self._mode == "specify_new":
layout.addWidget( new_data_groupbox )
else:
new_data_groupbox.hide()
layout.addWidget( full_url_label )
layout.addWidget( buttonbox )
# Stretch factors
layout.setStretchFactor(data_groupbox, 3)
layout.setStretchFactor(node_groupbox, 1)
self.setLayout(layout)
self.setWindowTitle( "Select DVID Volume" )
# Initially disabled
data_groupbox.setEnabled(False)
node_groupbox.setEnabled(False)
new_data_groupbox.setEnabled(False)
# Save instance members
self._data_groupbox = data_groupbox
self._node_groupbox = node_groupbox
self._new_data_groupbox = new_data_groupbox
self._data_treewidget = data_treewidget
self._node_listwidget = node_listwidget
self._new_data_edit = new_data_edit
self._full_url_label = full_url_label
self._buttonbox = buttonbox
def _init_layout(self):
"""
Create the GUI widgets (but leave them empty).
"""
hostname_combobox = QComboBox(parent=self)
self._hostname_combobox = hostname_combobox
hostname_combobox.setEditable(True)
hostname_combobox.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Maximum)
for hostname in self._suggested_hostnames:
hostname_combobox.addItem(hostname)
# EventFilter is installed after everything else is initialized. (See below.)
#hostname_combobox.installEventFilter(self)
self._connect_button = QPushButton("Connect",
parent=self,
clicked=self._handle_new_hostname)
hostname_layout = QHBoxLayout()
hostname_layout.addWidget(hostname_combobox)
hostname_layout.addWidget(self._connect_button)
hostinfo_table = QTableWidget()
hostinfo_table.setColumnCount(len(SERVER_INFO_FIELDS))
hostinfo_table.setHorizontalHeaderLabels(SERVER_INFO_FIELDS)
hostinfo_table.horizontalHeader().setVisible(True)
hostinfo_table.verticalHeader().setVisible(False)
hostinfo_table.setRowCount(1)
hostinfo_table.setItem(0, 0, QTableWidgetItem("Placeholder"))
hostinfo_table.setVisible(False)
hostinfo_table.resizeRowsToContents()
hostinfo_table.horizontalHeader().setStretchLastSection(True)
table_height = hostinfo_table.verticalHeader().sectionSize(
0) + hostinfo_table.rowHeight(0)
hostinfo_table.resize(QSize(hostinfo_table.width(), table_height))
hostinfo_table.setMaximumSize(QSize(1000, table_height))
hostinfo_table.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
host_layout = QVBoxLayout()
host_layout.addLayout(hostname_layout)
host_layout.addWidget(hostinfo_table)
host_groupbox = QGroupBox("DVID Host", parent=self)
host_groupbox.setLayout(host_layout)
host_groupbox.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
repo_treewidget = QTreeWidget(parent=self)
repo_treewidget.setHeaderLabels(
TREEVIEW_COLUMNS) # TODO: Add type, shape, axes, etc.
repo_treewidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
repo_treewidget.itemSelectionChanged.connect(
self._handle_data_selection)
data_layout = QVBoxLayout()
data_layout.addWidget(repo_treewidget)
data_groupbox = QGroupBox("Data Volumes", parent=self)
data_groupbox.setLayout(data_layout)
node_listwidget = QListWidget(parent=self)
node_listwidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
node_listwidget.itemSelectionChanged.connect(self._update_status)
node_layout = QVBoxLayout()
node_layout.addWidget(node_listwidget)
node_groupbox = QGroupBox("Nodes", parent=self)
node_groupbox.setLayout(node_layout)
new_data_edit = QLineEdit(parent=self)
new_data_edit.textEdited.connect(self._update_status)
full_url_label = QLabel(parent=self)
full_url_label.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
text_flags = full_url_label.textInteractionFlags()
full_url_label.setTextInteractionFlags(text_flags
| Qt.TextSelectableByMouse)
new_data_layout = QVBoxLayout()
new_data_layout.addWidget(new_data_edit)
new_data_groupbox = QGroupBox("New Data Volume", parent=self)
new_data_groupbox.setLayout(new_data_layout)
new_data_groupbox.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
buttonbox = QDialogButtonBox(Qt.Horizontal, parent=self)
buttonbox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.accept)
buttonbox.rejected.connect(self.reject)
buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
layout = QVBoxLayout()
layout.addWidget(host_groupbox)
layout.addWidget(data_groupbox)
layout.addWidget(node_groupbox)
if self._mode == "specify_new":
layout.addWidget(new_data_groupbox)
else:
new_data_groupbox.hide()
layout.addWidget(full_url_label)
layout.addWidget(buttonbox)
# Stretch factors
layout.setStretchFactor(data_groupbox, 3)
layout.setStretchFactor(node_groupbox, 1)
self.setLayout(layout)
self.setWindowTitle("Select DVID Volume")
self.resize(1000, 1000)
# Initially disabled
data_groupbox.setEnabled(False)
node_groupbox.setEnabled(False)
new_data_groupbox.setEnabled(False)
# Set tab order
self.setTabOrder(hostname_combobox, repo_treewidget)
self.setTabOrder(repo_treewidget, node_listwidget)
self.setTabOrder(node_listwidget, buttonbox)
# Save instance members
self._hostinfo_table = hostinfo_table
self._data_groupbox = data_groupbox
self._node_groupbox = node_groupbox
self._new_data_groupbox = new_data_groupbox
self._repo_treewidget = repo_treewidget
self._node_listwidget = node_listwidget
self._new_data_edit = new_data_edit
self._full_url_label = full_url_label
self._buttonbox = buttonbox
# Finally install eventfilter (after everything is initialized)
hostname_combobox.installEventFilter(self)
class Main(plugin.Plugin):
" Main Class "
def initialize(self, *args, **kwargs):
" Init Main Class "
super(Main, self).initialize(*args, **kwargs)
self.chooser, self.process = QComboBox(), QProcess()
self.chooser.addItems([' Ubuntu Unity QuickList .desktop ',
' KDE Plasma MetaData .desktop ',
' FreeDesktop Standard .desktop '])
self.chooser.currentIndexChanged.connect(self.on_index_changed)
self.chooser.setToolTip('Select a target .desktop file format')
# Standard FreeDesktop
self.group1 = QGroupBox()
self.group1.setTitle(' Standard ')
self.ledVersion, self.ledCategories = QDoubleSpinBox(), QComboBox()
self.ledVersion.setMinimum(0.1)
self.ledVersion.setMaximum(999.9)
self.ledVersion.setValue(1.0)
self.ledVersion.setDecimals(1)
self.ledType, self.ledName = QLineEdit('Application'), QLineEdit('App')
self.ledGenericName = QLineEdit('Generic App')
self.ledComment, self.ledIcon = QLineEdit('App'), QLineEdit('icon.svg')
self.ledCategories.addItems(['Python Programming Language',
'Development', 'Ruby', 'C++', 'Amateur Radio', 'Communication',
'Cross Platform', 'Databases', 'Debug', 'Documentation', 'Editors',
'Education', 'Electronics', 'Email', 'Embebed Devices', 'Fonts',
'GNOME Desktop Environment', 'GNU R Statistical System',
'GObject Introspection Data', 'Games and Amusement',
'Gnustep Desktop Environtment', 'Graphics',
'Haskell Programming Language',
'Internationalization and Localization', 'Internet',
'Interpreted Computer Languages', 'KDE Software Compilation',
'Kernel and Modules', 'Libraries', 'Libraries - Development',
'Libraries - Old', 'Lisp Programming Language', 'Localization',
'Mathematics', 'Meta Packages', 'Miscelaneous - Graphical',
'Miscelaneous - Text Based', 'Mono/CLI Infraestructure',
'Multimedia', 'Networking', 'Newsgroups',
'OCaml Programming Language', 'PHP Programming Language',
'Perl Programming Language', 'Ruby Programming Language',
'Science', 'Shells', 'System Administration', 'TeX Authoring',
'Utilities', 'Version Control Systems', 'Video Software',
'Web Servers', 'Word Processing', 'Xfce Desktop Environment',
'Zope/Plone Environment'])
self.ledExec, self.ledTryExec = QLineEdit('myapp'), QLineEdit('myapp')
self.ledMymeType = QLineEdit('application/x-desktop')
self.ledTerminal = QComboBox()
self.ledTerminal.addItems(['False', 'True'])
self.ledActions = QLineEdit('Next;Previous')
self.ledOnlyShowIn = QLineEdit('Unity;KDE')
self.ledNotShowIn = QLineEdit('Gnome2')
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (QLabel('Version'), self.ledVersion, QLabel('Type'),
self.ledType, QLabel('Name'), self.ledName, QLabel('GenericName'),
self.ledGenericName, QLabel('Comment'), self.ledComment,
QLabel('Icon'), self.ledIcon, QLabel('Categories'),
self.ledCategories, QLabel('Exec'), self.ledExec, QLabel('TryExec'),
self.ledTryExec, QLabel('MymeType'), self.ledMymeType,
QLabel('Terminal'), self.ledTerminal, QLabel('Actions'),
self.ledActions, QLabel('OnlyShowIn'), self.ledOnlyShowIn,
QLabel('NotShowIn'), self.ledNotShowIn):
vboxg1.addWidget(each_widget)
# KDE Plasma
self.group2 = QGroupBox()
self.group2.setTitle(' KDE Plasma ')
self.group2.setGraphicsEffect(QGraphicsBlurEffect(self))
self.ledEncoding, self.ledXPlasmaAPI = QComboBox(), QComboBox()
self.ledEncoding.addItems(['UTF-8', 'ISO-8859-1'])
self.ledServiceType = QLineEdit('Plasma/Applet')
self.ledXPlasmaAPI.addItems([
'Python', 'Javascript', 'Ruby', 'C++', 'HTML5', 'QML'])
self.ledXPlasmaMainScript = QLineEdit('path/to/your/code.py')
self.ledXKDEPluginInfoAuthor = QLineEdit(getuser())
self.ledXKDEPluginInfoEmail = QLineEdit(getuser() + '@gmail.com')
self.ledXKDEPluginInfoName = QLineEdit('Hello-World')
self.ledXKDEPluginInfoVersion = QLineEdit('1.0')
self.ledXKDEPluginInfoWebsite = QLineEdit('http:plasma.kde.org')
self.ledXKDEPluginInfoCategory = QComboBox()
self.ledXKDEPluginInfoCategory.addItems(['Application Launchers',
'Accessibility', 'Astronomy', 'Date and Time',
'Development Tools', 'Education', 'Environment', 'Examples',
'File System', 'Fun and Games', 'Graphics', 'Language', 'Mapping',
'Multimedia', 'Online Services', 'System Information', 'Utilities',
'Windows and Tasks', 'Miscelaneous'])
self.ledXKDEPluginInfoDepends = QLineEdit()
self.ledXKDEPluginInfoLicense = QLineEdit('GPL')
self.ledXKDEPluginInfoEnabledByDefault = QComboBox()
self.ledXKDEPluginInfoEnabledByDefault.addItems(['True', 'False'])
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (
QLabel('Encoding'), self.ledEncoding,
QLabel('ServiceType'), self.ledServiceType,
QLabel('X-Plasma-API'), self.ledXPlasmaAPI,
QLabel('X-Plasma-MainScript'), self.ledXPlasmaMainScript,
QLabel('X-KDE-PluginInfo-Author'), self.ledXKDEPluginInfoAuthor,
QLabel('X-KDE-PluginInfo-Email'), self.ledXKDEPluginInfoEmail,
QLabel('X-KDE-PluginInfo-Name'), self.ledXKDEPluginInfoName,
QLabel('X-KDE-PluginInfo-Version'), self.ledXKDEPluginInfoVersion,
QLabel('X-KDE-PluginInfo-Website'), self.ledXKDEPluginInfoWebsite,
QLabel('X-KDE-PluginInfo-Category'), self.ledXKDEPluginInfoCategory,
QLabel('X-KDE-PluginInfo-Depends'), self.ledXKDEPluginInfoDepends,
QLabel('X-KDE-PluginInfo-License'), self.ledXKDEPluginInfoLicense,
QLabel('X-KDE-PluginInfo-EnabledByDefault'),
self.ledXKDEPluginInfoEnabledByDefault):
vboxg2.addWidget(each_widget)
# Ubuntu Unity
self.ledXAyatanaDesktopShortcuts = QLineEdit('Next;Previous')
self.checkbox1 = QCheckBox('Open .desktop file when done')
self.checkbox2 = QCheckBox('Make .desktop file Executable')
[a.setChecked(True) for a in (self.checkbox1, self.checkbox2)]
self.button = QPushButton(' Make .Desktop File ! ')
self.button.setMinimumSize(100, 50)
self.button.clicked.connect(self.writeFile)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
glow.setEnabled(True)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((self.chooser, self.group1, self.group2,
QLabel('X-Ayatana-Desktop-Shortcuts'),
self.ledXAyatanaDesktopShortcuts, QLabel(''),
self.checkbox1, self.checkbox2, self.button))
self.dock, self.scrollable = QDockWidget(), QScrollArea()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "DotDesktop")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda: QMessageBox.information(self.dock, __doc__,
''.join((__doc__, __version__, __license__, 'by', __author__))))
def writeFile(self):
' write the .desktop file to disk '
UNITY = ''.join(a for a in iter((
'OnlyShowIn=', str(self.ledOnlyShowIn.text()), linesep,
'NotShowIn=', str(self.ledNotShowIn.text()), linesep,
'X-Ayatana-Desktop-Shortcuts=',
str(self.ledXAyatanaDesktopShortcuts.text()), linesep)))
PLASMA = ''.join(a for a in iter((
'OnlyShowIn=', str(self.ledOnlyShowIn.text()), linesep,
'NotShowIn=', str(self.ledNotShowIn.text()), linesep,
'Encoding=', str(self.ledEncoding.currentText()), linesep,
'ServiceTypes=', str(self.ledServiceType.text()), linesep,
'X-Plasma-API=', str(self.ledXPlasmaAPI.currentText()), linesep,
'X-Plasma-MainScript=', str(self.ledXPlasmaMainScript.text()), linesep,
'X-KDE-PluginInfo-Author=', str(self.ledXKDEPluginInfoAuthor.text()),
linesep,
'X-KDE-PluginInfo-Email=', str(self.ledXKDEPluginInfoEmail.text()),
linesep,
'X-KDE-PluginInfo-Name=', str(self.ledXKDEPluginInfoName.text()),
linesep,
'X-KDE-PluginInfo-Version=', str(self.ledXKDEPluginInfoVersion.text()),
linesep,
'X-KDE-PluginInfo-Website=', str(self.ledXKDEPluginInfoWebsite.text()),
linesep,
'X-KDE-PluginInfo-Category=',
str(self.ledXKDEPluginInfoCategory.currentText()), linesep,
'X-KDE-PluginInfo-Depends=', str(self.ledXKDEPluginInfoDepends.text()),
linesep,
'X-KDE-PluginInfo-License=', str(self.ledXKDEPluginInfoLicense.text()),
linesep,
'X-KDE-PluginInfo-EnabledByDefault=',
str(self.ledXKDEPluginInfoEnabledByDefault.currentText()), linesep)))
BASE = ''.join(a for a in iter((
'[Desktop Entry]', linesep,
'Version=', str(self.ledVersion.value()), linesep,
'Type=', str(self.ledType.text()), linesep,
'Name=', str(self.ledName.text()), linesep,
'Comment=', str(self.ledComment.text()), linesep,
'TryExec=', str(self.ledTryExec.text()), linesep,
'Exec=', str(self.ledExec.text()), linesep,
'Icon=', str(self.ledIcon.text()), linesep,
'MimeType=', str(self.ledMymeType.text()), linesep,
'Actions=', str(self.ledActions.text()), linesep,
'Terminal=', str(self.ledTerminal.currentText()), linesep)))
ACTIONS * len(str(self.ledActions.text()).lower().strip().split(';'))
fnm = str(QFileDialog.getSaveFileName(self.dock, '', '', "(*.desktop)"))
with open(fnm, 'w') as f:
if self.chooser.currentIndex() is 0 and fnm is not '':
f.write(''.join(a for a in iter((BASE, UNITY, ACTIONS))))
elif self.chooser.currentIndex() is 1 and fnm is not '':
f.write(''.join(a for a in iter((BASE, PLASMA))))
elif fnm is not '':
f.write(BASE)
if self.checkbox2.isChecked() and fnm is not '':
try:
chmod(fnm, 0775) # Py2
except:
chmod(fnm, 0o775) # Py3
if self.checkbox1.isChecked() and fnm is not '':
self.process.start('ninja-ide ' + fnm)
if not self.process.waitForStarted():
print((" ERROR: FAIL: {} failed!".format(fnm)))
return
def on_index_changed(self):
' enable disable the qgroupbox if needed '
if self.chooser.currentIndex() is 1:
self.group2.graphicsEffect().setEnabled(False)
self.group2.setEnabled(True)
else:
self.group2.graphicsEffect().setEnabled(True)
self.group2.setEnabled(False)
if self.chooser.currentIndex() is 0:
self.ledXAyatanaDesktopShortcuts.setEnabled(True)
else:
self.ledXAyatanaDesktopShortcuts.setEnabled(False)
def _init_layout(self):
"""
Create the GUI widgets (but leave them empty).
"""
hostname_combobox = QComboBox(parent=self)
self._hostname_combobox = hostname_combobox
hostname_combobox.setEditable(True)
hostname_combobox.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Maximum )
for hostname in self._suggested_hostnames:
hostname_combobox.addItem( hostname )
# EventFilter is installed after everything else is initialized. (See below.)
#hostname_combobox.installEventFilter(self)
self._connect_button = QPushButton("Connect", parent=self, clicked=self._handle_new_hostname)
hostname_layout = QHBoxLayout()
hostname_layout.addWidget( hostname_combobox )
hostname_layout.addWidget( self._connect_button )
hostinfo_table = QTableWidget()
hostinfo_table.setColumnCount(len(SERVER_INFO_FIELDS))
hostinfo_table.setHorizontalHeaderLabels(SERVER_INFO_FIELDS)
hostinfo_table.horizontalHeader().setVisible(True)
hostinfo_table.verticalHeader().setVisible(False)
hostinfo_table.setRowCount(1)
hostinfo_table.setItem(0,0, QTableWidgetItem("Placeholder"))
hostinfo_table.setVisible(False)
hostinfo_table.resizeRowsToContents()
hostinfo_table.horizontalHeader().setStretchLastSection(True)
table_height = hostinfo_table.verticalHeader().sectionSize(0) + hostinfo_table.rowHeight(0)
hostinfo_table.resize( QSize( hostinfo_table.width(), table_height ) )
hostinfo_table.setMaximumSize( QSize( 1000, table_height ) )
hostinfo_table.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
host_layout = QVBoxLayout()
host_layout.addLayout(hostname_layout)
host_layout.addWidget(hostinfo_table)
host_groupbox = QGroupBox("DVID Host", parent=self)
host_groupbox.setLayout( host_layout )
host_groupbox.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Preferred )
repo_treewidget = QTreeWidget(parent=self)
repo_treewidget.setHeaderLabels( TREEVIEW_COLUMNS ) # TODO: Add type, shape, axes, etc.
repo_treewidget.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Preferred )
repo_treewidget.itemSelectionChanged.connect( self._handle_data_selection )
data_layout = QVBoxLayout()
data_layout.addWidget( repo_treewidget )
data_groupbox = QGroupBox("Data Volumes", parent=self)
data_groupbox.setLayout( data_layout )
node_listwidget = QListWidget(parent=self)
node_listwidget.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Preferred )
node_listwidget.itemSelectionChanged.connect( self._update_status )
node_layout = QVBoxLayout()
node_layout.addWidget( node_listwidget )
node_groupbox = QGroupBox("Nodes", parent=self)
node_groupbox.setLayout( node_layout )
new_data_edit = QLineEdit(parent=self)
new_data_edit.textEdited.connect( self._update_status )
full_url_label = QLabel(parent=self)
full_url_label.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Maximum )
text_flags = full_url_label.textInteractionFlags()
full_url_label.setTextInteractionFlags( text_flags | Qt.TextSelectableByMouse )
new_data_layout = QVBoxLayout()
new_data_layout.addWidget( new_data_edit )
new_data_groupbox = QGroupBox("New Data Volume", parent=self)
new_data_groupbox.setLayout( new_data_layout )
new_data_groupbox.setSizePolicy( QSizePolicy.Preferred, QSizePolicy.Maximum )
buttonbox = QDialogButtonBox( Qt.Horizontal, parent=self )
buttonbox.setStandardButtons( QDialogButtonBox.Ok | QDialogButtonBox.Cancel )
buttonbox.accepted.connect( self.accept )
buttonbox.rejected.connect( self.reject )
buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
layout = QVBoxLayout()
layout.addWidget( host_groupbox )
layout.addWidget( data_groupbox )
layout.addWidget( node_groupbox )
if self._mode == "specify_new":
layout.addWidget( new_data_groupbox )
else:
new_data_groupbox.hide()
layout.addWidget( full_url_label )
layout.addWidget( buttonbox )
# Stretch factors
layout.setStretchFactor(data_groupbox, 3)
layout.setStretchFactor(node_groupbox, 1)
self.setLayout(layout)
self.setWindowTitle( "Select DVID Volume" )
self.resize(1000, 1000)
# Initially disabled
data_groupbox.setEnabled(False)
node_groupbox.setEnabled(False)
new_data_groupbox.setEnabled(False)
# Set tab order
self.setTabOrder(hostname_combobox, repo_treewidget)
self.setTabOrder(repo_treewidget, node_listwidget)
self.setTabOrder(node_listwidget, buttonbox)
# Save instance members
self._hostinfo_table = hostinfo_table
self._data_groupbox = data_groupbox
self._node_groupbox = node_groupbox
self._new_data_groupbox = new_data_groupbox
self._repo_treewidget = repo_treewidget
self._node_listwidget = node_listwidget
self._new_data_edit = new_data_edit
self._full_url_label = full_url_label
self._buttonbox = buttonbox
# Finally install eventfilter (after everything is initialized)
hostname_combobox.installEventFilter(self)
class mainwindow(QtGui.QMainWindow):
'''主窗体'''
def __init__(self):
super(mainwindow, self).__init__()
self.setWindowTitle('组件设计工具')
self.setWindowIcon(QIcon(':/image/组件设计工具.png'))
self.setMinimumWidth(1024)
self.setMinimumHeight(800)
self.showMaximized()
self.menuBar().show()
self.createMenus()
#self.setWindowFlags(QtCore.Qt.WindowMinimizeButtonHint)
labelSizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
editSizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
cwVLayout = QVBoxLayout()
cwHLayout = QHBoxLayout()
lLayout = QVBoxLayout()
rLayout = QVBoxLayout()
self.lw = QListWidget()
self.lw.setSelectionMode(QAbstractItemView.SingleSelection)
lLayout.addWidget(self.lw)
self.lw.itemSelectionChanged.connect(self.on_select)
lGroup = QGroupBox('项目列表')
lGroup.setLayout(lLayout)
cwHLayout.addWidget(lGroup, 2)
lGroup.setContentsMargins(0, 12, 0, 22)
tLayout = QVBoxLayout()
bLayout = QHBoxLayout()
self.tGroup = QGroupBox('配置信息')
self.bGroup = QGroupBox('生成代码')
self.tGroup.setLayout(tLayout)
self.tGroup.setEnabled(False)
self.bGroup.setLayout(bLayout)
self.bGroup.setEnabled(False)
cwHLayout.addWidget(self.tGroup, 8)
cwVLayout.addLayout(cwHLayout)
cwVLayout.addWidget(self.bGroup)
self.tw_config = QTreeWidget()
headerLabels = QStringList()
headerLabels.append(' 项目')
headerLabels.append(' 值')
self.tw_config.setHeaderLabels(headerLabels)
self.tw_config.setColumnWidth(0, 312)
self.tw_config.setColumnWidth(1, 660)
thLayout = QHBoxLayout()
thLayout.setContentsMargins(0, 6, 0, 0)
thLayout.addSpacing(10)
modify_btn = QPushButton('') #修改
modify_btn.setObjectName('modify_btn')
modify_btn.clicked.connect(self.on_modify)
del_btn = QPushButton('') #删除
del_btn.setObjectName('del_btn')
del_btn.clicked.connect(self.on_del)
thLayout.addWidget(modify_btn)
thLayout.addWidget(del_btn)
thLayout.addStretch(0)
tLayout.addLayout(thLayout)
tLayout.addWidget(self.tw_config)
bhLayout = QHBoxLayout()
lable1 = QLabel('工程名称：')
lable1.setSizePolicy(labelSizePolicy)
self.et_project_name = QLineEdit()
self.et_project_name.setSizePolicy(editSizePolicy)
bhLayout.addWidget(lable1)
bhLayout.addWidget(self.et_project_name)
bhLayout.addSpacing(16)
lable2 = QLabel('工程位置：')
lable2.setSizePolicy(labelSizePolicy)
self.et_project_location = QLineEdit()
self.et_project_location.setReadOnly(True)
self.et_project_location.setSizePolicy(editSizePolicy)
btn_location = QPushButton('') #打开
btn_location.setObjectName('btn_location')
btn_location.setSizePolicy(labelSizePolicy)
btn_location.clicked.connect(self.getProjectLocation)
bhLayout.addWidget(lable2)
bhLayout.addWidget(self.et_project_location)
bhLayout.addSpacing(10)
bhLayout.addWidget(btn_location)
#bhLayout.addStretch(0)
gen_btn = QPushButton('') # 生成
gen_btn.setObjectName('gen_btn')
gen_btn.setSizePolicy(labelSizePolicy)
gen_btn.clicked.connect(self.on_gen)
bhLayout.addSpacing(45)
bhLayout.addWidget(gen_btn)
bLayout.addLayout(bhLayout)
bLayout.setContentsMargins(10, 24, 22, 34)
statusBar = self.statusBar()
sBH = QHBoxLayout()
copyright = QLabel('')
copyright.setAlignment(QtCore.Qt.AlignCenter)
copyright.setStyleSheet("color:#acacac")
statusBar.setMinimumHeight(30)
statusBar.addWidget(copyright, 10)
cw = QWidget()
cw.setLayout(cwVLayout)
self.setCentralWidget(cw)
self._initByConfig()
self.setMinimumSize(400, 200)
def _initByConfig(self):
'''初始化'''
pass
def createMenus(self):
'''创建菜单'''
self.ToolBar = self.addToolBar('')
self.ToolBar.setMinimumHeight(54)
newBtn = QToolButton()
newBtn.setText('创建项目')
newBtn.setIcon(QIcon(':/image/创建项目.png'))
newBtn.setToolButtonStyle(3)
newBtn.setFixedWidth(99)
OpenBtn = QToolButton()
OpenBtn.setText('打开项目')
OpenBtn.setIcon(QIcon(':/image/打开.png'))
OpenBtn.setToolButtonStyle(3)
OpenBtn.setFixedWidth(99)
AboutBtn = QToolButton()
AboutBtn.setText('关于')
AboutBtn.setIcon(QIcon(':/image/关于.png'))
AboutBtn.setToolButtonStyle(3)
AboutBtn.setFixedWidth(99)
HelpBtn = QToolButton()
HelpBtn.setText('帮助')
HelpBtn.setIcon(QIcon(':/image/帮助.png'))
HelpBtn.setToolButtonStyle(3)
HelpBtn.setFixedWidth(99)
newBtn.clicked.connect(self.on_new)
OpenBtn.clicked.connect(self.on_open)
AboutBtn.clicked.connect(self.on_about)
HelpBtn.clicked.connect(self.on_help)
self.ToolBar.addWidget(newBtn)
self.ToolBar.addWidget(OpenBtn)
self.ToolBar.addWidget(AboutBtn)
self.ToolBar.addWidget(HelpBtn)
self.ToolBar.setMovable(False)
self.ToolBar.setVisible(True)
def on_help(self):
app.g_pwd = os.getcwd()
if not (QtGui.QDesktopServices.openUrl(
QUrl.fromLocalFile(app.g_pwd + os.sep + 'image' + os.sep +
'help.pdf'))):
print app.g_pwd + os.sep + '/image/help.pdf'
QMessageBox.critical(None, "Failure", "Cannot open help manual")
def on_about(self):
abt = AboutDlg()
abt.exec_()
def on_new(self):
'''新建向导'''
app.g_configurations = Configuration() # 用来渲染的配置数据
dlg = wizard.MyWizard()
if dlg.exec_():
app.g_configurations.initialized = True
app.g_projects.append(app.g_configurations)
content = app.g_configurations.toJson()
self.path = QFileDialog.getSaveFileName(
self, "选择模板保存的路径",
app.g_pwd + os.sep + "configurations" + os.sep +
app.g_configurations.project_name.encode('utf-8') + ".json",
"Config (*.json)")
fileInfo = QFileInfo(self.path)
if not self.path.isEmpty():
path = app.QString2str(self.path)
with open(path, 'w+') as f:
f.write(content)
self.addConfig(fileInfo.baseName(), fileInfo.filePath(),
content)
#self.lw.addItem(app.g_configurations.project_name)
def getProjectLocation(self):
'''获取项目路径'''
path = QFileDialog.getExistingDirectory()
path = QDir.fromNativeSeparators(path)
self.et_project_location.setText(path)
def on_open(self):
'''打开现有配置'''
fileName = QFileDialog.getOpenFileName(
self, "选择现有模板", app.g_pwd + os.sep + "configurations",
"Config (*.json)")
if fileName.isEmpty():
return
self.path = fileName
with open(app.QString2str(fileName), 'r') as f:
content = f.read()
fileInfo = QFileInfo(fileName)
if not fileInfo.exists():
return
config = Configuration()
config.fromJson(content)
config.allone_dir = os.getenv('ALLONEDIR', '../..').replace('\\', '/')
self.addConfig(fileInfo.baseName(), fileInfo.filePath(), content)
self.on_select()
def on_del(self):
self.tw_config.clear()
self.bGroup.setEnabled(False)
self.tGroup.setEnabled(False)
index = self.lw.currentRow()
self.lw.takeItem(index)
def on_select(self):
'''选取配置'''
item = self.lw.currentItem()
if item != None:
content = item.data(QtCore.Qt.UserRole).toString()
config = Configuration()
config.fromJson(app.QString2str(content))
self.currentConfig = config
self.showConfigInfo(self.currentConfig)
self.bGroup.setEnabled(True)
self.path = item.data(QtCore.Qt.UserRole + 1).toString()
# index = self.lw.currentRow()
# if index < len(app.g_projects):
# self.currentConfig = app.g_projects[index]
# self.showConfigInfo(self.currentConfig)
# self.bGroup.setEnabled(True)
def addConfig(self, fileName, filePath, config):
item = QListWidgetItem(fileName)
item.setData(QtCore.Qt.UserRole, config)
item.setData(QtCore.Qt.UserRole + 1, filePath)
self.lw.addItem(item)
self.lw.setCurrentRow(0)
def showConfigInfo(self, cf):
'''显示配置信息'''
self.tw_config.clear()
self.et_project_name.setText(cf.project_name)
self.et_project_location.setText(cf.project_location)
sr = QStringList()
sr.append('信息')
root1 = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('Qt库')
root2 = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('模块')
root3a = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('第三方库')
root3b = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('接口')
root4 = QTreeWidgetItem(sr)
self.tw_config.addTopLevelItem(root1)
self.tw_config.addTopLevelItem(root2)
self.tw_config.addTopLevelItem(root3a)
self.tw_config.addTopLevelItem(root3b)
self.tw_config.addTopLevelItem(root4)
sr1c00 = QStringList()
sr1c00.append("项目名称")
sr1c00.append(cf.project_name)
r1c00 = QTreeWidgetItem(sr1c00)
root1.addChild(r1c00)
# sr1c0 = QStringList()
# sr1c0.append("项目位置")
# sr1c0.append(cf.project_location)
# r1c0 = QTreeWidgetItem(sr1c0)
# root1.addChild(r1c0)
sr1c1 = QStringList()
sr1c1.append("组件类型")
sr1c1.append(cf.component_type)
r1c1 = QTreeWidgetItem(sr1c1)
root1.addChild(r1c1)
sr1c2 = QStringList()
sr1c2.append("源模板")
sr1c2.append(cf.template_source)
r1c2 = QTreeWidgetItem(sr1c2)
root1.addChild(r1c2)
sr1c3 = QStringList()
sr1c3.append("平台类型")
tmp_pt = ""
if cf.platform_type & configuration.PT_WIN32:
tmp_pt += "win32;"
if cf.platform_type & configuration.PT_LINUX:
tmp_pt += "linux"
sr1c3.append(tmp_pt)
r1c3 = QTreeWidgetItem(sr1c3)
root1.addChild(r1c3)
sr1c4 = QStringList()
sr1c4.append("平台级别")
sr1c4.append(cf.platform_version)
r1c4 = QTreeWidgetItem(sr1c4)
root1.addChild(r1c4)
sr1c5 = QStringList()
sr1c5.append("资源文件")
if cf.resourcesFile == "True":
sr1c5.append("添加")
else:
sr1c5.append("未添加")
r1c5 = QTreeWidgetItem(sr1c5)
root1.addChild(r1c5)
sr1c6 = QStringList()
sr1c6.append("翻译文件")
if cf.translateFile == "True":
sr1c6.append("添加")
else:
sr1c6.append("未添加")
r1c6 = QTreeWidgetItem(sr1c6)
root1.addChild(r1c6)
for qt in cf.qt_libs:
sr2 = QStringList()
sr2.append(qt['name'])
sr2.append(qt['qt'])
r2 = QTreeWidgetItem(sr2)
root2.addChild(r2)
for module in cf.modules:
sr3a = QStringList()
sr3a.append(module['name'])
sr3a.append(module['description'])
r3a = QTreeWidgetItem(sr3a)
root3a.addChild(r3a)
# sr3b = QStringList()
# sr3b.append('ALLONE_DIR')
# sr3b.append(os.getenv('ALLONEDIR','../..')) # 第二个参数是默认值
# r3b = QTreeWidgetItem(sr3b)
# root3b.addChild(r3b)
for info in cf.thirdpart_lib:
sr3b = QStringList()
sr3b.append(info['libname'])
sr3b.append(info['libpath'])
r3b = QTreeWidgetItem(sr3b)
root3b.addChild(r3b)
for key in cf.interfaces.keys():
sr4 = QStringList()
sr4.append(key)
if cf.interfaces[key]:
sr4.append('实现')
else:
sr4.append('未实现')
r4 = QTreeWidgetItem(sr4)
root4.addChild(r4)
self.tw_config.expandAll()
self.tw_config.header().resizeSection(0, 300)
self.tGroup.setEnabled(True)
def on_modify(self):
'''修改配置'''
if self.currentConfig:
app.g_configurations = copy.copy(self.currentConfig)
dlg = wizard.MyWizard()
if dlg.exec_():
item = self.lw.currentItem()
if item != None:
content = app.g_configurations.toJson()
item.setData(QtCore.Qt.UserRole, content)
path = item.data(QtCore.Qt.UserRole + 1).toString()
if not path.isEmpty():
path = app.QString2str(path)
with open(path, 'w+') as f:
f.write(content)
self.on_select()
def on_gen(self):
'''生成工程'''
if not self.currentConfig:
return
#获取工程名及有效路径
project_name = self.et_project_name.text()
project_location = self.et_project_location.text()
qdir = QDir(project_location)
if not qdir.exists():
if not qdir.mkpath(project_location):
QMessageBox.warning(self, '警告', '路径无效！')
return
project_location = qdir.absolutePath()
if not project_location.endsWith(
'/') and not project_location.endsWith('\\'):
project_location += os.sep
project_location.replace('\\', '/')
if project_name.isEmpty() or project_location.isEmpty():
QMessageBox.warning(self, '警告', '项目名称或路径不能为空！')
return
self.currentConfig.project_name = app.QString2str(project_name)
self.currentConfig.project_location = app.QString2str(project_location)
content = self.currentConfig.toJson()
fileInfo = QFileInfo(self.path)
if not self.path.isEmpty():
path = app.QString2str(self.path)
with open(path, 'w+') as f:
f.write(content)
item = self.lw.currentItem()
item.setData(QtCore.Qt.UserRole, content)
template_name = self.currentConfig.template_source
template_dir = app.g_pwd + os.sep + 'templates' + os.sep + template_name.encode(
'utf-8')
with open(template_dir + os.sep + 'config.json', 'r') as f:
self.currentConfig.config_content = f.read()
ret_json = app.render(self.currentConfig.config_content,
config=self.currentConfig)
self.currentConfig.config = json.loads(ret_json)
for file in self.currentConfig.config['files']:
sourcepath = template_dir + os.sep + file['source'].encode('utf-8')
targetdir = self.currentConfig.project_location + self.currentConfig.project_name
targetpath = targetdir + os.sep + file['target']
fi = QFileInfo(targetpath)
qdir = fi.absoluteDir()
if not qdir.exists():
qdir.mkpath(fi.absolutePath())
with open(sourcepath, 'r') as f:
content = f.read()
content = app.render(content, config=self.currentConfig) #渲染文件
with open(targetpath, 'w+') as f:
f.write(content.encode('utf-8'))
QMessageBox.information(self, '提示', '生成成功！')
class EncryptDialog(QDialog):
def __init__(self):
self.techniquesClass = {
'caesar cipher': caesarCipher,
'mono alphabetic cipher': monoAlphabeticCipher,
'vigenere cipher': vigenereCipher,
'vernan cipher': vernanCipher,
'one time pad': oneTimePad
}
self.rowsview = []
self.filesview = []
self.techniques = []
QDialog.__init__(self)
self.setWindowTitle("CryptoSystems")
self.resize(1024, 600)
self.setMinimumSize(QSize(1024, 600))
self.setMaximumSize(QSize(1024, 600))
self.checkBox_2 = QCheckBox(self)
self.checkBox_2.setGeometry(QRect(620, 10, 130, 20))
self.checkBox_2.setText('Select All')
self.checkBox_2.clicked.connect(self.__selectAllFiles)
self.treeView = QTreeView(self)
self.treeView.setGeometry(QRect(10, 10, 230, 580))
self.treeView.setObjectName("treeView")
self.fileSystemModel = QFileSystemModel(self.treeView)
self.fileSystemModel.setReadOnly(False)
self.fileSystemModel.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
root = self.fileSystemModel.setRootPath("/")
self.treeView.setModel(self.fileSystemModel)
self.treeView.setRootIndex(root)
self.treeView.hideColumn(1)
self.treeView.hideColumn(2)
self.treeView.hideColumn(3)
self.treeView.clicked.connect(self.__eventDirectoryChanged)
self.mygroupbox = QGroupBox(self)
self.mygroupbox.setGeometry(QRect(0, 0, 1000, 1000))
self.myform = QFormLayout()
for j in list(range(100)):
horizontalLayout = QHBoxLayout()
self.myform.addRow(horizontalLayout)
self.rowsview.append(horizontalLayout)
self.mygroupbox.setLayout(self.myform)
scroll = QScrollArea(self)
scroll.setWidget(self.mygroupbox)
scroll.setWidgetResizable(True)
scroll.setGeometry(QRect(250, 30, 500, 580))
scroll.setWidgetResizable(True)
self.label_4 = QLabel(self)
self.label_4.setGeometry(QRect(780, 30, 31, 16))
self.label_4.setPixmap(QPixmap("images/key.png"))
self.label_4.setScaledContents(True)
self.lineEdit = QLineEdit(self)
self.lineEdit.setGeometry(QRect(820, 30, 180, 20))
self.lineEdit.setObjectName("lineEdit")
self.lineEdit.setPlaceholderText(_fromUtf8('write your password'))
self.lineEdit.setEchoMode(QLineEdit.Password)
self.techniquesGroup = QGroupBox(self)
self.tecniquesform = QFormLayout()
self.techniquesGroup.setLayout(self.tecniquesform)
self.techniquesScroll = QScrollArea(self)
self.techniquesScroll.setGeometry(QRect(770, 100, 230, 300))
self.techniquesScroll.setWidget(self.techniquesGroup)
self.techniquesScroll.setWidgetResizable(True)
self.rowsTechiques = []
for i in list(range(8)):
horizontalLayout = QHBoxLayout()
self.tecniquesform.addRow(horizontalLayout)
self.rowsTechiques.append(horizontalLayout)
techniquesCombo = QComboBox()
techniquesCombo.setGeometry(QRect(10, 50, 171, 22))
techniquesCombo.addItems(self.techniquesClass.keys())
self.techniques.append(techniquesCombo)
self.rowsTechiques[0].addWidget(techniquesCombo)
self.techniquesNumber = 1
self.addTechnique = QPushButton()
self.addTechnique.setGeometry(QRect(90, 90, 31, 21))
self.addTechnique.setFixedSize(31, 21)
self.addTechnique.setText('+')
self.connect(self.addTechnique, SIGNAL("clicked()"),
self.__eventAddTechnique)
self.rowsTechiques[len(self.rowsTechiques) - 1].addWidget(
self.addTechnique)
self.okButton = QPushButton(self)
self.okButton.setGeometry(QRect(920, 560, 80, 20))
self.okButton.setText('Start...')
self.connect(self.okButton, SIGNAL("clicked()"),
self.__eventInitEncryption)
def __eventAddTechnique(self):
techniquesCombo = QComboBox()
techniquesCombo.setGeometry(QRect(10, 50, 171, 22))
techniquesCombo.addItems(self.techniquesClass.keys())
self.techniques.append(techniquesCombo)
self.rowsTechiques[self.techniquesNumber].addWidget(techniquesCombo)
self.techniquesNumber = self.techniquesNumber + 1
if ((len(self.rowsTechiques) - 1) == self.techniquesNumber):
self.addTechnique.setEnabled(False)
def __eventDirectoryChanged(self):
index = self.treeView.currentIndex()
self.__changeDirectory(self.fileSystemModel.filePath(index))
def __changeDirectory(self, path):
for c in self.filesview:
c.setParent(None)
c.deleteLater()
self.filesview = []
self.checkBox_2.setChecked(False)
self.progressBars = {}
for f in self.__getFiles(path):
try:
group = QGroupBox(f, self)
group.setGeometry(QRect(20, 20, 100, 150))
group.setCheckable(True)
group.setChecked(False)
group.setFixedSize(100, 150)
group.setFlat(True)
group.setToolTip(f)
label = QLabel(group)
label.setScaledContents(True)
label.setGeometry(QRect(5, 25, 90, 90))
label.setToolTip(f)
progressBar = QProgressBar(group)
progressBar.setGeometry(QRect(0, 70, 111, 10))
progressBar.setProperty("value", 0)
progressBar.setTextVisible(False)
progressBar.setToolTip('0%')
progressBar.setVisible(False)
self.progressBars[f] = progressBar
self.filesview.append(group)
from os.path import isfile
if isfile(path + '/' + f):
ext = f.split('.')[-1]
if isfile('icons/' + ext.lower() + '.png'):
label.setPixmap(
QPixmap('icons/' + ext.lower() + '.png'))
else:
label.setPixmap(QPixmap('icons/default.png'))
else:
label.setPixmap(QPixmap('icons/folder.png'))
self.connect(group, SIGNAL("clicked()"), self.__deselectFile)
except ValueError:
pass
i = 0
for x in list(range(len(self.filesview))):
if (x % 4) == 0:
i = i + 1
self.rowsview[i].addWidget(self.filesview[x])
def __selectAllFiles(self):
for o in self.filesview:
o.setChecked(self.checkBox_2.isChecked())
def __deselectFile(self):
#print 'deselect'
self.checkBox_2.setChecked(False)
def __arrozconpollo(self):
self.__obtainSelectedFIles()
def __obtainSelectedFIles(self):
files = []
for o in self.filesview:
if o.isChecked():
files.append(str(o.title()))
self.progressBars[str(o.title())].setVisible(True)
return files
def __getFiles(self, path):
from os import listdir
from os.path import isfile
f = []
for base in listdir(path):
try:
if isfile(path + '/' + base):
f.append(base)
except ValueError:
pass
f.sort()
return f
def __eventInitEncryption(self):
if len(self.__obtainSelectedFIles()) == 0:
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("You must specify the files you want to encrypt")
msg.setWindowTitle("CryptoSystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
return
if str(self.lineEdit.text()).strip() == '':
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("You must specify a key")
msg.setWindowTitle("CryptoSystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
return
self.okButton.setEnabled(False)
self.techniquesGroup.setEnabled(False)
self.lineEdit.setEnabled(False)
index = self.treeView.currentIndex()
path = self.fileSystemModel.filePath(index)
selectedFiles = self.__obtainSelectedFIles()
from os.path import getsize
blockSize = 4096
from hashlib import md5
Hash = md5()
Hash.update(str(self.lineEdit.text()))
key = Hash.hexdigest()
for f in selectedFiles:
f_in = open(path + '/' + f, 'rb')
f_out = open(
path + '/' + reduceMd5(checksum(path + '/' + f)) + '.cry',
'wb')
f_out.write('CRYOGENESIS' + unhexlify('00') + 'ARCHIVE' +
unhexlify('01'))
header_list = ''
techniquesObjects = []
for t in self.techniques:
header_list = header_list + t.currentText() + ':'
techniquesObjects.append(self.techniquesClass[str(
t.currentText())](key))
file_header = str('header|' + str(f_in.name.split('/')[-1]) + '|' +
str(header_list) + '|' +
str(checksum(path + '/' + f)))
aes = AES(key)
f_out.write(aes.encrypt(file_header))
f_out.write(unhexlify('02'))
in_size = getsize(path + '/' + f)
in_progress = 0.0
block = f_in.read(blockSize)
while (block):
block_c = block
for t in techniquesObjects:
block_c = t.encrypt(block_c)
f_out.write(block_c)
in_progress = in_progress + blockSize
progress = (in_progress / in_size) * 100
#print progress
self.progressBars[str(f)].setProperty("value", int(progress))
self.progressBars[str(f)].setToolTip(str(progress) + '%')
block = f_in.read(blockSize)
f_in.close()
f_out.close()
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("Encryption has successfully concluded")
msg.setWindowTitle("CryptoSystems")
msg.setStandardButtons(QMessageBox.Ok)
msg.exec_()
self.hide()
class mainwindow(QtGui.QMainWindow):
'''主窗体'''
def __init__(self):
super(mainwindow,self).__init__()
self.setWindowTitle('组件设计工具')
self.showMaximized()
self.menuBar().show()
self.createMenus()
cwHLayout = QHBoxLayout()
lLayout = QVBoxLayout()
rLayout = QVBoxLayout()
self.lw = QListWidget()
self.lw.setSelectionMode(QAbstractItemView.SingleSelection )
lLayout.addWidget(self.lw)
self.lw.itemSelectionChanged.connect(self.on_select)
lGroup = QGroupBox('项目列表')
lGroup.setLayout(lLayout)
cwHLayout.addWidget(lGroup,2)
cwHLayout.addLayout(rLayout,8)
tLayout = QVBoxLayout()
bLayout = QVBoxLayout()
tGroup = QGroupBox('配置信息')
self.bGroup = QGroupBox('生成代码')
tGroup.setLayout(tLayout)
self.bGroup.setLayout(bLayout)
self.bGroup.setEnabled(False)
rLayout.addWidget(tGroup)
rLayout.addWidget(self.bGroup)
self.tw_config = QTreeWidget()
headerLabels = QStringList()
headerLabels.append('项目')
headerLabels.append('值')
self.tw_config.setHeaderLabels(headerLabels)
thLayout = QHBoxLayout()
thLayout.addStretch(0)
modify_btn = QPushButton('修改')
modify_btn.clicked.connect(self.on_modify)
del_btn = QPushButton('删除')
del_btn.clicked.connect(self.on_del)
thLayout.addWidget(modify_btn)
thLayout.addWidget(del_btn)
tLayout.addWidget(self.tw_config)
tLayout.addLayout(thLayout)
bhLayout = QHBoxLayout()
bhLayout.addStretch(0)
gen_btn = QPushButton('生成')
gen_btn.clicked.connect(self.on_gen)
bhLayout.addWidget(gen_btn)
row1 = QHBoxLayout()
lable1 = QLabel('工程名称：')
self.et_project_name = QLineEdit()
row1.addSpacing(10)
row1.addWidget(lable1)
row1.addWidget(self.et_project_name)
row1.addStretch(0)
row2 = QHBoxLayout()
lable2 = QLabel('工程位置：')
self.et_project_location = QLineEdit()
self.et_project_location.setReadOnly(True)
btn_location = QPushButton('...')
btn_location.setFixedWidth(50)
btn_location.clicked.connect(self.getProjectLocation)
row2.addSpacing(10)
row2.addWidget(lable2)
row2.addWidget(self.et_project_location)
row2.addWidget(btn_location)
row2.addStretch(0)
bLayout.addLayout(row1)
bLayout.addLayout(row2)
bLayout.addLayout(bhLayout)
cw = QWidget()
cw.setLayout(cwHLayout)
self.setCentralWidget(cw)
self._initByConfig()
self.setMinimumSize(400,200)
def _initByConfig(self):
'''初始化'''
pass
def createMenus(self):
'''创建菜单'''
menueBar = self.menuBar()
menuSys = menueBar.addMenu('系统')
actNew = menuSys.addAction('新建工程')
actOpen = menuSys.addAction('打开工程')
actNew.triggered.connect(self.on_new)
actOpen.triggered.connect(self.on_open)
menueBar.addMenu(menuSys)
def on_new(self):
'''新建向导'''
app.g_configurations = Configuration() # 用来渲染的配置数据
dlg = wizard.MyWizard()
if dlg.exec_():
app.g_configurations.initialized = True
app.g_projects.append(app.g_configurations)
content = app.g_configurations.toJson()
path = QFileDialog.getSaveFileName(self,"选择模板保存的路径",
app.g_pwd + os.sep + "configurations" + os.sep + app.g_configurations.project_name + ".json"
,"Config (*.json)")
if not path.isEmpty():
path = app.QString2str(path)
with open(path,'w+') as f:
f.write(content)
self.lw.addItem(app.g_configurations.project_name)
def getProjectLocation(self):
'''获取项目路径'''
path = QFileDialog.getExistingDirectory()
path = QDir.fromNativeSeparators(path)
self.et_project_location.setText(path)
def on_open(self):
'''打开现有配置'''
fileName = QFileDialog.getOpenFileName(self,"选择现有模板",app.g_pwd + os.sep + "configurations","Config (*.json)")
if fileName.isEmpty():
return
with open(app.QString2str(fileName), 'r') as f:
content = f.read()
config = Configuration()
config.fromJson(content)
app.g_projects.append(config)
self.lw.addItem(config.project_name)
def on_del(self):
index = self.lw.currentRow()
if index < app.g_projects:
self.bGroup.setEnabled(False)
self.lw.takeItem(index)
config = app.g_projects[index]
app.g_projects.remove(config)
self.tw_config.clear()
return
def on_select(self):
'''选取配置'''
index = self.lw.currentRow()
if index < app.g_projects:
self.bGroup.setEnabled(True)
self.currentConfig = app.g_projects[index]
self.showConfigInfo(self.currentConfig)
def showConfigInfo(self,cf):
'''显示配置信息'''
self.tw_config.clear()
self.et_project_name.setText(cf.project_name)
self.et_project_location.setText(cf.project_location)
sr = QStringList()
sr.append('信息')
root1 = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('Qt库')
root2 = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('模块')
root3 = QTreeWidgetItem(sr)
sr = QStringList()
sr.append('接口')
root4 = QTreeWidgetItem(sr)
self.tw_config.addTopLevelItem(root1)
self.tw_config.addTopLevelItem(root2)
self.tw_config.addTopLevelItem(root3)
self.tw_config.addTopLevelItem(root4)
sr1c00 = QStringList()
sr1c00.append("项目名称")
sr1c00.append(cf.project_name)
r1c00 = QTreeWidgetItem(sr1c00)
root1.addChild(r1c00)
# sr1c0 = QStringList()
# sr1c0.append("项目位置")
# sr1c0.append(cf.project_location)
# r1c0 = QTreeWidgetItem(sr1c0)
# root1.addChild(r1c0)
sr1c1 = QStringList()
sr1c1.append("组件类型")
sr1c1.append(cf.component_type)
r1c1 = QTreeWidgetItem(sr1c1)
root1.addChild(r1c1)
sr1c2 = QStringList()
sr1c2.append("源模板")
sr1c2.append(cf.template_source)
r1c2 = QTreeWidgetItem(sr1c2)
root1.addChild(r1c2)
sr1c3 = QStringList()
sr1c3.append("平台类型")
tmp_pt = ""
if cf.platform_type & configuration.PT_WIN32:
tmp_pt += "win32;"
if cf.platform_type & configuration.PT_LINUX:
tmp_pt += "linux"
sr1c3.append(tmp_pt)
r1c3 = QTreeWidgetItem(sr1c3)
root1.addChild(r1c3)
sr1c4 = QStringList()
sr1c4.append("平台级别")
sr1c4.append(cf.platform_version)
r1c4 = QTreeWidgetItem(sr1c4)
root1.addChild(r1c4)
for qt in cf.qt_libs:
sr2 = QStringList()
sr2.append(qt['name'])
sr2.append(qt['qt'])
r2 = QTreeWidgetItem(sr2)
root2.addChild(r2)
for module in cf.modules:
sr3 = QStringList()
sr3.append(module['name'])
sr3.append(module['description'])
r3 = QTreeWidgetItem(sr3)
root3.addChild(r3)
for key in cf.interfaces.keys():
sr4 = QStringList()
sr4.append(key)
if cf.interfaces[key]:
sr4.append('实现')
else:
sr4.append('未实现')
r4 = QTreeWidgetItem(sr4)
root4.addChild(r4)
self.tw_config.expandAll()
self.tw_config.header().resizeSection(0,300)
def on_modify(self):
'''修改配置'''
if self.currentConfig:
app.g_configurations = copy.copy(self.currentConfig)
dlg = wizard.MyWizard()
if dlg.exec_():
index = self.lw.currentRow()
if index < app.g_projects:
self.currentConfig = app.g_configurations
app.g_projects[index] = self.currentConfig
self.showConfigInfo(self.currentConfig)
def on_gen(self):
'''生成工程'''
if not self.currentConfig:
return
#获取工程名及有效路径
project_name = self.et_project_name.text()
project_location = self.et_project_location.text()
qdir = QDir(project_location)
if not qdir.exists():
if not qdir.mkpath(project_location):
QMessageBox.warning(self, '警告', '路径无效！')
return
project_location = qdir.absolutePath()
if not project_location.endsWith('/') and not project_location.endsWith('\\'):
project_location += os.sep
if project_name.isEmpty() or project_location.isEmpty():
QMessageBox.warning(self, '警告', '项目名称或路径不能为空！')
return
self.currentConfig.project_name = app.QString2str(project_name)
self.currentConfig.project_location = app.QString2str(project_location)
template_name = self.currentConfig.template_source
template_dir = app.g_pwd + os.sep + 'templates' + os.sep + template_name
with open(template_dir + os.sep + 'config.json', 'r') as f:
self.currentConfig.config_content = f.read()
ret_json = app.render(self.currentConfig.config_content, config=self.currentConfig)
self.currentConfig.config = json.loads(ret_json)
for file in self.currentConfig.config['files']:
sourcepath = template_dir + os.sep + file['source']
targetdir = self.currentConfig.project_location + self.currentConfig.project_name
targetpath = targetdir + os.sep + file['target']
fi = QFileInfo(targetpath)
qdir = fi.absoluteDir()
if not qdir.exists():
qdir.mkpath(fi.absolutePath())
with open(sourcepath, 'r') as f:
content = f.read()
content = app.render(content, config=self.currentConfig) #渲染文件
with open(targetpath, 'w+') as f:
f.write(content.encode('utf-8'))
QMessageBox.information(self,'提示','生成成功！')
class AuthenticationFrontend(ScrollArea):
COMPONENT = 'auth_cert'
LABEL = tr('Authentication server')
REQUIREMENTS = ('auth_cert',)
ICON = ':/icons/auth_protocol.png'
def __init__(self, client, parent):
self.__loading = True
ScrollArea.__init__(self)
self.mainwindow = parent
self.client = client
self.modified = False
self.qauthcertobject = QAuthCertObject.getInstance()
frame = QFrame(self)
layout = QVBoxLayout(frame)
layout.addWidget(QLabel('<H1>%s</H1>' % tr('Authentication server') ))
head_box = QGroupBox(tr("How the authentication server handles certificates"))
head = QFormLayout(head_box)
self.strictCheckBox = QCheckBox()
head.addRow(QLabel(tr("Strict mode (check the client's certificate against the installed CA)")), self.strictCheckBox)
self.connect(self.strictCheckBox, SIGNAL('toggled(bool)'),
self.setStrict)
self.cl_auth_box = QGroupBox(tr("Client authentication with a certificate is"))
cl_auth = QVBoxLayout(self.cl_auth_box)
self.auth_by_cert = QButtonGroup()
self.auth_by_cert.setExclusive(True)
self.mainwindow.writeAccessNeeded(self.strictCheckBox)
labels = [tr('forbidden'), tr('allowed'), tr('mandatory')]
for index, label_button in enumerate(labels):
button = QRadioButton(label_button)
self.auth_by_cert.addButton(button, index)
cl_auth.addWidget(button)
self.mainwindow.writeAccessNeeded(button)
self.auth_by_cert.button(0).setChecked(Qt.Checked)
self.connect(self.auth_by_cert, SIGNAL('buttonClicked(int)'),
self.auth_by_cert_modified)
# Captive portal
# --------------
self.portal_groupbox = QGroupBox(tr("Captive portal"))
self.portal_groupbox.setLayout(QVBoxLayout())
# Enabled checkbox:
self.portal_checkbox = QCheckBox(tr("Enable captive portal"))
self.connect(self.portal_checkbox, SIGNAL('toggled(bool)'),
self.setPortalEnabled)
# List of networks redirected to the captive portal:
self.portal_nets_groupbox = QGroupBox(
tr("Networks handled by the captive portal"))
self.portal_nets_groupbox.setLayout(QVBoxLayout())
self.portal_nets_edit = NetworkListEdit()
self.connect(self.portal_nets_edit, SIGNAL('textChanged()'), self.setPortalNets)
self.portal_nets_groupbox.layout().addWidget(self.portal_nets_edit)
# Pack the widgets:
for widget in (self.portal_checkbox, self.portal_nets_groupbox):
self.portal_groupbox.layout().addWidget(widget)
self.mainwindow.writeAccessNeeded(self.portal_checkbox)
self.mainwindow.writeAccessNeeded(self.portal_nets_edit)
if not EDENWALL:
self.portal_groupbox.setVisible(False)
# authentication server
self.pki_widget = PkiEmbedWidget(self.client, self, 'auth_cert', PkiEmbedWidget.SHOW_ALL|PkiEmbedWidget.CRL_OPTIONAL, self.setModified)
self.mainwindow.writeAccessNeeded(self.pki_widget)
layout.addWidget(head_box)
layout.addWidget(self.cl_auth_box)
layout.addWidget(self.portal_groupbox)
layout.addWidget(self.pki_widget)
layout.addStretch()
self.setWidget(frame)
self.setWidgetResizable(True)
self.resetConf()
self.__loading = False
def setModified(self, isModified=True, message=""):
if self.__loading:
return
if isModified:
self.modified = True
self.mainwindow.setModified(self, True)
if message:
self.mainwindow.addToInfoArea(message)
else:
self.modified = False
def setModifiedCallback(self, *unused):
self.setModified()
def isModified(self):
return self.modified
def saveConf(self, message):
self.qauthcertobject.auth_cert.auth_by_cert = self.auth_by_cert.checkedId()
conf = self.pki_widget.getConfig()
self.qauthcertobject.auth_cert.setSSLDict(conf)
serialized = self.qauthcertobject.auth_cert.serialize(downgrade=True)
self.client.call('auth_cert', 'setAuthCertConfig', serialized, message)
def resetConf(self):
auth_cert_loaded = self._reset_helper(
'auth_cert',
'getAuthCertConfig',
self.qauthcertobject,
tr("Authentication interface enabled"),
tr("Authentication disabled: backend not loaded")
)
self.setModified(False)
remote = self.qauthcertobject.auth_cert.getReceivedSerialVersion()
if remote < 3:
self.mainwindow.addWarningMessage(tr('Captive portal configuration disabled: this frontend and your appliance software versions are not compatible.'))
enable_portal = (
auth_cert_loaded
and EDENWALL
and remote >= 3
)
self.portal_groupbox.setVisible(enable_portal)
if not auth_cert_loaded:
return
self.strictCheckBox.setChecked(self.qauthcertobject.auth_cert.strict)
if not self.qauthcertobject.auth_cert.auth_by_cert:
self.qauthcertobject.auth_cert.auth_by_cert = 0
self.auth_by_cert.button(
self.qauthcertobject.auth_cert.auth_by_cert).setChecked(True)
# Captive portal:
self.portal_checkbox.setChecked(
self.qauthcertobject.auth_cert.portal_enabled)
self.portal_nets_edit.setIpAddrs(
self.qauthcertobject.auth_cert.portal_nets)
# Certificate (PKI):
pki_conf = self.qauthcertobject.auth_cert.getSSLDict()
self.pki_widget.setConfig(pki_conf)
def error(self, message):
self.mainwindow.addToInfoArea(message, category=COLOR_ERROR)
def auth_by_cert_modified(self, idbox):
button_name = self.auth_by_cert.button(idbox).text()
info = tr("Certificates - Authentication with client certificate : '%s'") % button_name
self.setModified(message=info)
def setPortalEnabled(self, value):
if value != self.qauthcertobject.auth_cert.portal_enabled:
self.qauthcertobject.auth_cert.setPortalEnabled(value)
self.setModified()
def setPortalNets(self):
if self.portal_nets_edit.isValid():
self.qauthcertobject.auth_cert.setPortalNets(
self.portal_nets_edit.value())
self.setModified()
def setStrict(self, value):
if value != self.qauthcertobject.auth_cert.strict:
self.qauthcertobject.auth_cert.setStrict(value)
self.setModified()
self.cl_auth_box.setEnabled(value)
def isValid(self):
cert_validity = self.pki_widget.validate()
if cert_validity is not None:
self.error_message = '<br/>' + cert_validity + '<br/>'
self.mainwindow.addToInfoArea(cert_validity, category=COLOR_ERROR)
return False
return True
def onApplyFinished(self):
self.pki_widget.feed()
class RawView(QWidget, Logger.ClassLogger):
"""
Raw view widget
"""
def __init__(self,
parent,
data,
toCsv=False,
toHtml=False,
toXml=False,
toPrinter=False,
toTxt=False,
toPdf=False):
"""
Raw view widget
@param parent:
@type parent:
"""
QWidget.__init__(self, parent)
self.parent = parent
self.__data = data
self.toCsv = toCsv
self.toXml = toXml
self.toCsv = toCsv
self.toHtml = toHtml
self.toPrinter = toPrinter
self.toTxt = toTxt
self.toPdf = toPdf
self.createActions()
self.createWidgets()
self.createToolbars()
self.createConnections()
def createWidgets(self):
"""
Create qt widgets
"""
# prepare menu
self.toolbar = QToolBar(self)
self.toolbar.setStyleSheet(
"QToolBar { border: 0px }") # remove 3D border
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.toolbarPlugins = QToolBar(self)
self.toolbarPlugins.setStyleSheet(
"QToolBar { border: 0px }") # remove 3D border
self.toolbarPlugins.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.pluginsBox = QGroupBox("Plugins")
self.pluginsBox.setStyleSheet("""
QGroupBox { font: normal; border: 1px solid silver; border-radius: 2px; }
QGroupBox { padding-bottom: 10px; background-color: #FAFAFA; }
QGroupBox::title { subcontrol-position: bottom center;}
""")
layoutPlugins = QHBoxLayout()
layoutPlugins.addWidget(self.toolbarPlugins)
layoutPlugins.setContentsMargins(0, 0, 0, 0)
self.pluginsBox.setLayout(layoutPlugins)
self.pluginsBox.hide()
self.exportBox = QGroupBox("Exports")
self.exportBox.setStyleSheet("""
QGroupBox { font: normal; border: 1px solid silver; border-radius: 2px; }
QGroupBox { padding-bottom: 10px; background-color: #FAFAFA; }
QGroupBox::title { subcontrol-position: bottom center;}
""")
layoutExports = QHBoxLayout()
layoutExports.addWidget(self.toolbar)
layoutExports.setContentsMargins(0, 0, 0, 0)
self.exportBox.setLayout(layoutExports)
layout = QVBoxLayout()
if self.toXml:
self.txtEdit = QtHelper.RawXmlEditor(parent=self)
self.txtEdit.setText(self.__data)
# self.txtEdit.setUtf8(True)
self.txtEdit.setFont(QFont("Courier", 9))
else:
self.txtEdit = QtHelper.RawEditor(parent=self)
self.txtEdit.setTabStopWidth(10)
self.txtEdit.setText(self.__data)
self.txtEdit.setFont(QFont("Courier", 9))
self.txtEdit.setMinimumWidth(650)
self.txtEdit.setMinimumHeight(400)
self.delGroup = QGroupBox("Remove line")
self.delTG = QCheckBox("TESTGLOBAL")
self.delTP = QCheckBox("TESTPLAN")
self.delTS = QCheckBox("TESTSUITE")
self.delTU = QCheckBox("TESTUNIT")
self.delTA = QCheckBox("TESTABSTRACT")
self.delTC = QCheckBox("TESTCASE")
self.delSTP = QCheckBox("STEP")
layoutDel = QHBoxLayout()
layoutDel.addWidget(self.delTG)
layoutDel.addWidget(self.delTP)
layoutDel.addWidget(self.delTS)
layoutDel.addWidget(self.delTU)
layoutDel.addWidget(self.delTA)
layoutDel.addWidget(self.delTC)
layoutDel.addWidget(self.delSTP)
self.delGroup.setLayout(layoutDel)
if self.toXml: self.delGroup.setEnabled(False)
layoutToolbars = QHBoxLayout()
layoutToolbars.addWidget(self.exportBox)
layoutToolbars.addWidget(self.pluginsBox)
layoutToolbars.addStretch(1)
layoutToolbars.setContentsMargins(5, 0, 0, 0)
layout.addLayout(layoutToolbars)
layout.addWidget(self.delGroup)
layout.addWidget(self.txtEdit)
if not self.toXml:
self.rawFind = QtHelper.RawFind(parent=self,
editor=self.txtEdit,
buttonNext=True)
layout.addWidget(self.rawFind)
self.setLayout(layout)
def createConnections(self):
"""
All qt connections
"""
self.delTG.stateChanged.connect(self.onRemoveLines)
self.delTP.stateChanged.connect(self.onRemoveLines)
self.delTS.stateChanged.connect(self.onRemoveLines)
self.delTU.stateChanged.connect(self.onRemoveLines)
self.delTA.stateChanged.connect(self.onRemoveLines)
self.delTC.stateChanged.connect(self.onRemoveLines)
self.delSTP.stateChanged.connect(self.onRemoveLines)
def createActions(self):
"""
Qt Actions
"""
self.saveCsvAction = QtHelper.createAction(self,
"&To CSV",
self.saveCsv,
tip='Save to CSV file',
icon=QIcon(":/csv.png"))
self.saveTxtAction = QtHelper.createAction(
self,
"&To TXT",
self.saveTxt,
tip='Save to TXT file',
icon=QIcon(":/file-txt.png"))
self.saveHtmlAction = QtHelper.createAction(self,
"&To HTML",
self.saveHtml,
tip='Save to HTML file',
icon=QIcon(":/web.png"))
self.savePdfAction = QtHelper.createAction(self,
"&To PDF",
self.savePdf,
tip='Save to PDF file',
icon=QIcon(":/to_pdf.png"))
self.saveXmlAction = QtHelper.createAction(self,
"&To XML",
self.saveXml,
tip='Save to XML file',
icon=QIcon(":/xml.png"))
self.toPrinterAction = QtHelper.createAction(
self,
"&To Printer",
self.savePrinter,
tip='Print',
icon=QIcon(":/printer.png"))
def createToolbars(self):
"""
Toolbar creation
"""
self.toolbar.setObjectName("Export toolbar")
if self.toCsv: self.toolbar.addAction(self.saveCsvAction)
if self.toTxt: self.toolbar.addAction(self.saveTxtAction)
if self.toHtml: self.toolbar.addAction(self.saveHtmlAction)
if self.toPdf: self.toolbar.addAction(self.savePdfAction)
if self.toXml: self.toolbar.addAction(self.saveXmlAction)
if self.toPrinter: self.toolbar.addAction(self.toPrinterAction)
self.toolbar.setIconSize(QSize(16, 16))
def registerPlugin(self, pluginAction):
"""
Register plugin
"""
self.toolbarPlugins.addAction(pluginAction)
self.toolbarPlugins.setIconSize(QSize(16, 16))
self.pluginsBox.show()
def onRemoveLines(self):
"""
Called to remove lines
"""
ret = []
for l in self.__data.splitlines():
if self.delTG.checkState() and l.startswith("TESTGLOBAL"):
continue
elif self.delTP.checkState() and l.startswith("TESTPLAN"):
continue
elif self.delTS.checkState() and l.startswith("TESTSUITE"):
continue
elif self.delTU.checkState() and l.startswith("TESTUNIT"):
continue
elif self.delTA.checkState() and l.startswith("TESTABSTRACT"):
continue
elif self.delTC.checkState() and l.startswith("TESTCASE"):
continue
elif self.delSTP.checkState() and l.startswith("STEP"):
continue
else:
ret.append(l)
self.txtEdit.setText("\n".join(ret))
del ret
def savePrinter(self):
"""
Save to printer
"""
printer = QPrinter()
dialog = QPrintDialog(printer, self)
dialog.setWindowTitle("Print")
if dialog.exec_() != QDialog.Accepted:
return
if QtHelper.IS_QT5: # new in v18
self.fileName = printer
self.txtEdit.page().toHtml(self.__toPrinter)
else:
doc = QTextDocument()
doc.setPlainText(self.txtEdit.text())
doc.print_(printer)
def __toPrinter(self, html):
"""
New in v18
Callback from QWebpage
"""
textEdit = QTextEdit(self)
textEdit.setHtml(html)
textEdit.print(self.fileName)
textEdit.deleteLater()
self.fileName = None
def saveCsv(self):
"""
Save to csv file
"""
fileName = QFileDialog.getSaveFileName(
self, "Save CSV file", "", "CSV file (*.csv);;All Files (*.*)")
# new in v17.1
if QtHelper.IS_QT5:
_filename, _type = fileName
else:
_filename = fileName
# end of new
if _filename:
try:
f = open(_filename, 'w')
f.write(self.txtEdit.toPlainText())
f.close()
except Exception as e:
self.error('unable to save report file as txt: %s' % str(e))
def saveTxt(self):
"""
Save to txt file
"""
fileName = QFileDialog.getSaveFileName(
self, "Save TXT file", "", "TXT file (*.txt);;All Files (*.*)")
# new in v17.1
if QtHelper.IS_QT5:
_filename, _type = fileName
else:
_filename = fileName
# end of new
if _filename:
try:
f = open(_filename, 'w')
f.write(self.txtEdit.toPlainText())
f.close()
except Exception as e:
self.error('unable to save report file as txt: %s' % str(e))
def saveXml(self):
"""
Save to xml file
"""
fileName = QFileDialog.getSaveFileName(
self, "Save XML file", "", "XML file (*.xml);;All Files (*.*)")
# new in v17.1
if QtHelper.IS_QT5:
_filename, _type = fileName
else:
_filename = fileName
# end of new
if _filename:
try:
with codecs.open(_filename, "w", "utf-8") as f:
f.write(self.txtEdit.text())
except Exception as e:
self.error('unable to save design file as xml: %s' % str(e))
def saveHtml(self):
"""
Save to html file
"""
fileName = QFileDialog.getSaveFileName(
self, "Save HTML file", "", "HTML file (*.html);;All Files (*.*)")
# new in v17.1
if QtHelper.IS_QT5:
_filename, _type = fileName
else:
_filename = fileName
# end of new
if _filename:
try:
f = open(_filename, 'w')
f.write(self.txtEdit.toHtml())
f.close()
except Exception as e:
self.error('unable to save report file as html: %s' % str(e))
def savePdf(self):
"""
Save pdf file
"""
fileName = QFileDialog.getSaveFileName(
self, 'Save to PDF', "", "PDF file (*.pdf);;All Files (*.*)")
# new in v17.1
if QtHelper.IS_QT5:
_filename, _type = fileName
else:
_filename = fileName
# end of new
if _filename:
printer = QPrinter(QPrinter.HighResolution)
printer.setPageSize(QPrinter.A4)
printer.setColorMode(QPrinter.Color)
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(_filename)
doc = QTextDocument()
if self.toXml:
doc.setPlainText(self.txtEdit.text())
else:
doc.setHtml(self.txtEdit.toHtml())
doc.print_(printer)
class WServerInformation(QWidget, Logger.ClassLogger):
"""
Widget for the global server information
"""
def __init__(self, parent=None):
"""
Constructs WServerInformation widget
@param parent:
@type parent:
"""
QWidget.__init__(self, parent)
self.parent = parent
self.name = self.tr("Miscellaneous")
self.createWidgets()
self.createActions()
self.createToolbar()
self.deactivate()
def createWidgets(self):
"""
QtWidgets creation
"""
self.dockToolbar = QToolBar(self)
self.dockToolbar.setStyleSheet(
"QToolBar { border: 0px }") # remove 3D border
self.dockToolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.dockToolbarReset = QToolBar(self)
self.dockToolbarReset.setStyleSheet(
"QToolBar { border: 0px }") # remove 3D border
self.dockToolbarReset.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.dockToolbarGen = QToolBar(self)
self.dockToolbarGen.setStyleSheet(
"QToolBar { border: 0px }") # remove 3D border
self.dockToolbarGen.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.refreshBox = QGroupBox("Refresh")
self.refreshBox.setStyleSheet("""
QGroupBox { font: normal; border: 1px solid silver; border-radius: 2px; }
QGroupBox { padding-bottom: 10px; background-color: #FAFAFA; }
QGroupBox::title { subcontrol-position: bottom center;}
""")
layoutRefreshBox = QHBoxLayout()
layoutRefreshBox.addWidget(self.dockToolbar)
layoutRefreshBox.setContentsMargins(0, 0, 0, 0)
self.refreshBox.setLayout(layoutRefreshBox)
self.resetBox = QGroupBox("Reset")
self.resetBox.setStyleSheet("""
QGroupBox { font: normal; border: 1px solid silver; border-radius: 2px; }
QGroupBox { padding-bottom: 10px; background-color: #FAFAFA; }
QGroupBox::title { subcontrol-position: bottom center;}
""")
layoutResetBox = QHBoxLayout()
layoutResetBox.addWidget(self.dockToolbarReset)
layoutResetBox.setContentsMargins(0, 0, 0, 0)
self.resetBox.setLayout(layoutResetBox)
self.genBox = QGroupBox("Prepare")
self.genBox.setStyleSheet("""
QGroupBox { font: normal; border: 1px solid silver; border-radius: 2px; }
QGroupBox { padding-bottom: 10px; background-color: #FAFAFA; }
QGroupBox::title { subcontrol-position: bottom center;}
""")
layoutGenBox = QHBoxLayout()
layoutGenBox.addWidget(self.dockToolbarGen)
layoutGenBox.setContentsMargins(0, 0, 0, 0)
self.genBox.setLayout(layoutGenBox)
layoutToolbars = QHBoxLayout()
layoutToolbars.addWidget(self.refreshBox)
layoutToolbars.addWidget(self.genBox)
layoutToolbars.addWidget(self.resetBox)
layoutToolbars.addStretch(1)
layoutFinal = QHBoxLayout()
layoutLeft = QVBoxLayout()
layoutRight = QVBoxLayout()
layoutRight.addLayout(layoutToolbars)
self.diskUsageBox = QGroupBox("Disk Usage")
self.nbSizeLogsOnDiskLabel = QLabel("0")
self.nbSizeTmpOnDiskLabel = QLabel("0")
self.nbSizeArchivesOnDiskLabel = QLabel("0")
self.nbSizeAdpOnDiskLabel = QLabel("0")
self.nbSizeLibOnDiskLabel = QLabel("0")
self.nbSizeBakOnDiskLabel = QLabel("0")
self.nbSizeTestsOnDiskLabel = QLabel("0")
layout2 = QFormLayout()
layout2.addRow(QLabel("Logs"), self.nbSizeLogsOnDiskLabel)
layout2.addRow(QLabel("Tmp"), self.nbSizeTmpOnDiskLabel)
layout2.addRow(QLabel("Archives"), self.nbSizeArchivesOnDiskLabel)
layout2.addRow(QLabel("Tests"), self.nbSizeTestsOnDiskLabel)
layout2.addRow(QLabel("Adapters"), self.nbSizeAdpOnDiskLabel)
layout2.addRow(QLabel("Libraries"), self.nbSizeLibOnDiskLabel)
layout2.addRow(QLabel("Backups"), self.nbSizeBakOnDiskLabel)
self.diskUsageBox.setLayout(layout2)
layoutGrid = QGridLayout()
layoutGrid.addWidget(self.diskUsageBox, 0, 0)
layoutRight.addLayout(layoutGrid)
layoutRight.addStretch(1)
self.informations = QTreeWidget(self)
self.informations.setVerticalScrollMode(
QAbstractItemView.ScrollPerPixel)
self.informations.setIndentation(10)
self.labels = [self.tr("Key"), self.tr("Value")]
self.informations.setHeaderLabels(self.labels)
layoutLeft.addWidget(self.informations)
layoutFinal.addLayout(layoutLeft)
layoutFinal.addLayout(layoutRight)
self.setLayout(layoutFinal)
def createActions(self):
"""
Actions defined:
* generate the cache for the documentation
* generate all packages
* refresh statistics
* refresh the context of the server
* check the syntax of adapters
* reset statistics
"""
self.genCacheHelpAction = QtHelper.createAction(
self,
"&Generate\nDocumentations",
self.genCacheHelp,
tip='Generate the cache for the documentation',
icon=QIcon(":/generate-doc.png"))
self.genTarAdaptersAction = QtHelper.createAction(
self,
"&Package\nAdapters",
self.genPackageAdapters,
tip='Generate adapters packages',
icon=QIcon(":/generate-tar.png"))
self.genTarLibrariesAction = QtHelper.createAction(
self,
"&Package\nLibraries",
self.genPackageLibraries,
tip='Generate libraries packages',
icon=QIcon(":/generate-tar.png"))
self.genTarSamplesAction = QtHelper.createAction(
self,
"&Package\nSamples",
self.genPackageSamples,
tip='Generate samples packages',
icon=QIcon(":/generate-tar.png"))
self.refreshAction = QtHelper.createAction(
self,
"&Usages",
self.refreshUsages,
tip='Refresh Usages',
tooltip='Refresh usages',
icon=QIcon(":/refresh-statistics.png"))
self.refreshCtxAction = QtHelper.createAction(
self,
"&Session",
self.refreshCtx,
tip='Refresh server context',
tooltip='Refresh server context',
icon=QIcon(":/act-refresh.png"))
self.resetAction = QtHelper.createAction(
self,
"&Reset\nStatistics",
self.resetStats,
tip='Reset all statistics',
icon=QIcon(":/reset-counter.png"))
self.unlockAllTestsAction = QtHelper.createAction(
self,
"&Unlock\nTests",
self.unlockTests,
tip='Unlock all files',
icon=QIcon(":/unlock.png"))
self.unlockAllAdaptersAction = QtHelper.createAction(
self,
"&Unlock\nAdapters",
self.unlockAdapters,
tip='Unlock all files',
icon=QIcon(":/unlock.png"))
self.unlockAllLibrariesAction = QtHelper.createAction(
self,
"&Unlock\nLibraries",
self.unlockLibraries,
tip='Unlock all files',
icon=QIcon(":/unlock.png"))
def createToolbar(self):
"""
Toolbar creation
"""
self.dockToolbar.setObjectName("Misc toolbar")
self.dockToolbar.addAction(self.refreshCtxAction)
self.dockToolbar.addAction(self.refreshAction)
self.dockToolbar.setIconSize(QSize(16, 16))
self.dockToolbarGen.setObjectName("Generate toolbar")
self.dockToolbarGen.addAction(self.genCacheHelpAction)
self.dockToolbarGen.addAction(self.genTarAdaptersAction)
self.dockToolbarGen.addAction(self.genTarLibrariesAction)
self.dockToolbarGen.addAction(self.genTarSamplesAction)
self.dockToolbarGen.setIconSize(QSize(16, 16))
self.dockToolbarReset.setObjectName("Reset toolbar")
self.dockToolbarReset.addAction(self.resetAction)
self.dockToolbarReset.addAction(self.unlockAllTestsAction)
self.dockToolbarReset.addAction(self.unlockAllAdaptersAction)
self.dockToolbarReset.addAction(self.unlockAllLibrariesAction)
self.dockToolbarReset.setIconSize(QSize(16, 16))
def unlockTests(self):
"""
Unlock all files
"""
RCI.instance().unlockTests()
def unlockAdapters(self):
"""
Unlock all files
"""
RCI.instance().unlockAdapters()
def unlockLibraries(self):
"""
Unlock all files
"""
RCI.instance().unlockLibraries()
def genPackageAdapters(self):
"""
Generate all tar packages
"""
RCI.instance().buildAdapters()
def genPackageLibraries(self):
"""
Generate all tar packages
"""
RCI.instance().buildLibraries()
def genPackageSamples(self):
"""
Generate all tar packages
"""
RCI.instance().buildSamples()
def resetStats(self):
"""
Reset statistic manually
"""
reply = QMessageBox.question(self, "Reset statistics",
"Are you sure ?",
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
RCI.instance().resetTestsMetrics()
def refreshCtx(self):
"""
Call the server to refresh context of the server
"""
RCI.instance().sessionContext()
def refreshUsages(self):
"""
Call the server to refresh statistics of the server
"""
RCI.instance().systemUsages()
def genCacheHelp(self):
"""
Call the server to generate the cache documentation
"""
reply = QMessageBox.question(self, "Generate cache", "Are you sure ?",
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
RCI.instance().buildDocumentations()
def active(self):
"""
Enables QTreeWidget
"""
self.diskUsageBox.setEnabled(True)
self.informations.setEnabled(True)
self.genCacheHelpAction.setEnabled(True)
self.resetAction.setEnabled(True)
self.unlockAllTestsAction.setEnabled(True)
self.unlockAllAdaptersAction.setEnabled(True)
self.unlockAllLibrariesAction.setEnabled(True)
def deactivate(self):
"""
Clears QTreeWidget and disables it
"""
self.diskUsageBox.setEnabled(False)
self.informations.clear()
self.informations.setEnabled(False)
self.genCacheHelpAction.setEnabled(False)
self.resetAction.setEnabled(False)
self.unlockAllTestsAction.setEnabled(False)
self.unlockAllAdaptersAction.setEnabled(False)
self.unlockAllLibrariesAction.setEnabled(False)
self.nbSizeLogsOnDiskLabel.setText("0")
self.nbSizeTmpOnDiskLabel.setText("0")
self.nbSizeArchivesOnDiskLabel.setText("0")
self.nbSizeAdpOnDiskLabel.setText("0")
self.nbSizeLibOnDiskLabel.setText("0")
self.nbSizeBakOnDiskLabel.setText("0")
self.nbSizeTestsOnDiskLabel.setText("0")
def cleanContext(self):
"""
Clear the context
Removes all items
"""
self.informations.clear()
def loadStats(self, data):
"""
Load statistics
"""
self.nbSizeLogsOnDiskLabel.setText(
str(QtHelper.bytes2human(data['disk-usage-logs'])))
self.nbSizeTmpOnDiskLabel.setText(
str(QtHelper.bytes2human(data['disk-usage-tmp'])))
self.nbSizeArchivesOnDiskLabel.setText(
str(QtHelper.bytes2human(data['disk-usage-testresults'])))
self.nbSizeAdpOnDiskLabel.setText(
str(QtHelper.bytes2human(data['disk-usage-adapters'])))
self.nbSizeLibOnDiskLabel.setText(
str(QtHelper.bytes2human(data['disk-usage-libraries'])))
self.nbSizeBakOnDiskLabel.setText(
str(QtHelper.bytes2human(data['disk-usage-backups'])))
self.nbSizeTestsOnDiskLabel.setText(
str(QtHelper.bytes2human(data['disk-usage-tests'])))
def loadData(self, data):
"""
Load all config keys
@param data:
@type data:
"""
if isinstance(data, dict):
data = [data]
for param in data:
probeItem = ParamItem(param=param, parent=self.informations)
# resize columns
for i in xrange(len(self.labels) - 1):
self.informations.resizeColumnToContents(i)
class WTestManager(QWidget, Logger.ClassLogger):
"""
Widget to display all tests in the scheduler
"""
def __init__(self, parent):
"""
Constructs WTestManager widget
@param parent:
@type parent:
"""
QWidget.__init__(self, parent)
self.parent = parent
self.name = self.tr("Task Manager")
self.ascendingOrder = False
self.ascendingOrderHistory = False
self.ascendingOrderWaiting = False
self.itemCurrent = None
self.projects = []
self.createWidgets()
self.createActions()
self.createConnections()
self.createActions()
self.createToolbar()
self.deactivate()
def createWidgets (self):
"""
QtWidgets creation
QTreeWidget (Id, Name, Init at, Sched at, Start at, Stop at, User, Duration)
_______________
| QToolBar |
|---------------|
_______________
| |
|---------------|
| |
| |
|_______________|
"""
#self.mainTab = QTabWidget()
layout = QVBoxLayout()
topLayout = QHBoxLayout()
# waiting tree widget
self.tabWaiting = QTabWidget()
#self.waitingBox = QGroupBox("Waiting")
self.waitingBox = QFrame(self)
self.testWaiting = QTreeWidget(self)
self.testWaiting.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.waitingToolbar = QToolBar(self)
self.labelsWaiting = [ self.tr("No.") , self.tr("Group"), self.tr("Schedulation Type"),
self.tr("Project"), self.tr("Name") , self.tr("Next run"),
self.tr("Repeat"), self.tr("Probes"), self.tr("Notifications") ,
self.tr("Tests result"), self.tr("Author") ]
self.testWaiting.setHeaderLabels(self.labelsWaiting)
self.testWaiting.setIndentation(10)
self.testWaiting.setContextMenuPolicy(Qt.CustomContextMenu)
layoutWaiting = QVBoxLayout()
layoutWaiting.addWidget(self.waitingToolbar)
layoutWaiting.addWidget(self.testWaiting)
self.waitingBox.setLayout(layoutWaiting)
self.tabWaiting.addTab( self.waitingBox, "Scheduled" )
self.enqueuedBox = QFrame(self)
layoutEnqueued = QVBoxLayout()
self.testEnqueued = QTreeWidget(self)
self.labelsEnqueued = [ self.tr("Group of tests") ]
self.testEnqueued.setHeaderLabels(self.labelsEnqueued)
self.testEnqueued.setIndentation(10)
layoutEnqueued.addWidget(self.testEnqueued)
self.enqueuedBox.setLayout(layoutEnqueued)
self.tabWaiting.addTab( self.enqueuedBox, "Waiting" )
# current tree widget
self.currentBox = QGroupBox("Running")
self.testManager = QTreeWidget(self)
self.testManager.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.dockToolbar = QToolBar(self)
self.labels = [ self.tr("No."), self.tr("Project"), self.tr("Name"), self.tr("Started at"),
self.tr("Author"), self.tr("Recursive") ]
self.testManager.setHeaderLabels(self.labels)
self.testManager.setIndentation(10)
self.testManager.setContextMenuPolicy(Qt.CustomContextMenu)
layoutCurrent = QVBoxLayout()
layoutCurrent.addWidget(self.dockToolbar)
layoutCurrent.addWidget(self.testManager)
self.currentBox.setLayout(layoutCurrent)
v_splitter = QSplitter(self)
v_splitter.addWidget( self.tabWaiting )
v_splitter.addWidget( self.currentBox )
topLayout.addWidget(v_splitter)
# history tree widget
self.historyBox = QGroupBox("History")
self.testHistory = QTreeWidget(self)
self.historyToolbar = QToolBar(self)
self.labels2 = [ self.tr("Id"), self.tr("Schedulation Type"), self.tr("Project") , self.tr("Name"),
self.tr("Sched at"), self.tr("Run start"), self.tr("Run end"), self.tr("Author"),
self.tr("Duration (in sec.)"), self.tr("Run Result") ]
self.testHistory.setHeaderLabels(self.labels2)
self.statsBox = QGroupBox("Summary")
self.nbRunningLabel = QLabel("0")
self.nbWaitingLabel = QLabel("0")
self.nbHistoryLabel = QLabel("0")
self.nbCompleteHistoryLabel = QLabel("0")
self.nbErrorHistoryLabel = QLabel("0")
self.nbKilledHistoryLabel = QLabel("0")
self.nbCancelledHistoryLabel = QLabel("0")
layout2 = QFormLayout()
layout2.addRow(QLabel("Running"), self.nbRunningLabel )
layout2.addRow(QLabel("Waiting"), self.nbWaitingLabel )
layout2.addRow( QLabel(""), QLabel("") )
layout2.addRow(QLabel("History"), self.nbHistoryLabel )
layout2.addRow(QLabel(" - COMPLETE"), self.nbCompleteHistoryLabel )
layout2.addRow(QLabel(" - ERROR"), self.nbErrorHistoryLabel )
layout2.addRow(QLabel(" - KILLED"), self.nbKilledHistoryLabel )
layout2.addRow(QLabel(" - CANCELLED"), self.nbCancelledHistoryLabel )
self.statsBox.setLayout(layout2)
layoutHistory = QVBoxLayout()
layoutHistory.addWidget(self.historyToolbar)
layoutHistory.addWidget(self.testHistory)
self.historyBox.setLayout(layoutHistory)
subLayout = QHBoxLayout()
subLayout.addWidget(self.historyBox)
subLayout.addWidget(self.statsBox)
frame_left = QFrame(self)
frame_left.setFrameShape(QFrame.NoFrame)
frame_left.setLayout(topLayout)
frame_right = QFrame(self)
frame_right.setFrameShape(QFrame.NoFrame)
frame_right.setLayout(subLayout)
topLayout.setContentsMargins(0,0,0,0)
subLayout.setContentsMargins(0,0,0,0)
splitter1 = QSplitter(Qt.Vertical)
splitter1.addWidget(frame_left)
splitter1.addWidget(frame_right)
layout.addWidget(splitter1)
self.setLayout(layout)
def createConnections(self):
"""
Create Qt Connections
"""
self.testWaiting.customContextMenuRequested.connect(self.onPopupMenuWaiting)
self.testWaiting.currentItemChanged.connect(self.onCurrentWaitingItemChanged)
self.testManager.customContextMenuRequested.connect(self.onPopupMenu)
self.testManager.currentItemChanged.connect(self.onCurrentItemChanged)
self.testWaiting.itemDoubleClicked.connect(self.onItemDoubleClicked)
def createActions (self):
"""
Actions defined:
* sort running task
* sort waiting task
* sort history task
* kill one task
* kill all tasks
* cancel one task
* cancel all task
* clear the history
* edit a waiting task
* refresh waiting tasks
* refresh running tasks
* partial refresh of the history
* complete refresh of the history
* disable a waiting task
* enable a waiting task
"""
self.sortAction = QtHelper.createAction(self, "Ascending Order", self.toggleSort, toggled = True,
icon = QIcon(":/ascending.png") )
self.sortHistoryAction = QtHelper.createAction(self, "Ascending Order", self.toggleSortHistory, toggled = True,
icon = QIcon(":/ascending.png") )
self.sortWaitingAction = QtHelper.createAction(self, "Ascending Order", self.toggleSortWaiting, toggled = True,
icon = QIcon(":/ascending.png") )
self.killAction = QtHelper.createAction(self, "&Kill", self.killTask, tip = 'Kill selected test',
icon = QIcon(":/process-kill.png") )
self.killAllAction = QtHelper.createAction(self, "&Kill All", self.killAllTasks, tip = 'Kill all running tests',
icon = QIcon(":/process-killall.png") )
self.cancelAction = QtHelper.createAction(self, "&Cancel", self.cancelTask, tip = 'Cancel selected test',
icon = QIcon(":/process-cancel.png") )
self.cancelAllAction = QtHelper.createAction(self, "&Cancel All", self.cancelAllTasks, tip = 'Cancel all waiting tests',
icon = QIcon(":/processes-cancelall.png") )
self.clearHistoryAction = QtHelper.createAction(self, "&Clear history", self.clearHistory, tip = 'Clear history',
icon = QIcon(":/trash.png"))
self.editWaitingAction = QtHelper.createAction(self, "&Edit", self.editWaiting, tip = 'Edit the selected task',
icon = QIcon(":/reschedule.png"))
self.refreshWaitingAction = QtHelper.createAction(self, "Waiting tasks", self.refreshWaitingList,
icon = QIcon(":/act-refresh.png"), tip="Refresh waiting tasks" )
self.refreshRunningAction = QtHelper.createAction(self, "Running tasks", self.refreshRunningList,
icon = QIcon(":/act-refresh.png"), tip="Refresh running tasks" )
self.partialRefreshHistoryAction = QtHelper.createAction(self, "Partial history", self.partialRefreshHistoryList,
icon = QIcon(":/act-half-refresh.png"), tip="Refresh partial history" )
self.refreshHistoryAction = QtHelper.createAction(self, "Full history", self.refreshHistoryList,
icon = QIcon(":/act-refresh.png"), tip="Refresh full history" )
self.disableAction = QtHelper.createAction(self, "&Disable", self.disableTask, tip = 'Disable task',
icon = QIcon(":/process-pause-icon.png") )
self.enableAction = QtHelper.createAction(self, "&Enable", self.enableTask, tip = 'Enable task',
icon = None)
def createToolbar(self):
"""
Toolbar creation
||----------||
|| Kill all ||
||----------||
"""
self.dockToolbar.setObjectName("Test Manager toolbar")
self.dockToolbar.addAction(self.sortAction)
self.dockToolbar.addAction(self.refreshRunningAction)
self.dockToolbar.addSeparator()
self.dockToolbar.addAction(self.killAction)
self.dockToolbar.addAction(self.killAllAction)
self.dockToolbar.addSeparator()
self.dockToolbar.setIconSize(QSize(16, 16))
#
self.historyToolbar.setObjectName("Test Manager History toolbar")
self.historyToolbar.addAction(self.sortHistoryAction)
self.historyToolbar.addAction(self.partialRefreshHistoryAction)
self.historyToolbar.addAction(self.refreshHistoryAction)
self.historyToolbar.addSeparator()
self.historyToolbar.addAction(self.clearHistoryAction)
self.historyToolbar.setIconSize(QSize(16, 16))
#
self.waitingToolbar.setObjectName("Test Manager Waiting toolbar")
self.waitingToolbar.addAction(self.sortWaitingAction)
self.waitingToolbar.addAction(self.refreshWaitingAction)
self.waitingToolbar.addSeparator()
self.waitingToolbar.addAction(self.editWaitingAction)
self.waitingToolbar.addAction(self.disableAction)
self.waitingToolbar.addAction(self.cancelAction)
self.waitingToolbar.addAction(self.cancelAllAction)
self.waitingToolbar.addSeparator()
self.waitingToolbar.setIconSize(QSize(16, 16))
def onItemDoubleClicked(self, item):
"""
On item double clicked in waiting task
"""
if item.taskEventType in [ UCI.SCHED_QUEUE_AT, UCI.SCHED_QUEUE ]:
pass
else:
self.editWaiting()
def getProjectName(self, prjId):
"""
Return the project name
"""
pname = "UNKNOWN"
if prjId == 0:
return "UNDEFINED"
for p in self.projects:
if int(p['project_id']) == int(prjId):
pname = p['name']
break
return pname
def refreshWaitingList(self):
"""
Refresh the waiting task list
"""
RCI.instance().waitingTasks()
def refreshRunningList(self):
"""
Refresh the running task list
"""
RCI.instance().runningTasks()
def partialRefreshHistoryList(self):
"""
Partial refresh of the history task list
"""
RCI.instance().historyTasks()
def refreshHistoryList(self):
"""
Refresh the history task list
"""
RCI.instance().historyTasksAll()
def onCurrentItemChanged(self, witem1, witem2):
"""
On current item changed
@param witem1:
@type witem1:
@param witem2:
@type witem2:
"""
# kill task available just for admin and tester
if UCI.RIGHTS_ADMIN in RCI.instance().userRights or UCI.RIGHTS_TESTER in RCI.instance().userRights :
if witem1 is not None:
if witem1.taskState == STATE_RUNNING :
self.itemCurrent = witem1
self.killAction.setEnabled(True)
else:
self.killAction.setEnabled(False)
def onCurrentWaitingItemChanged(self, witem1, witem2):
"""
On current waiting task item changed
@param witem1:
@type witem1:
@param witem2:
@type witem2:
"""
# kill task available just for admin and tester
if UCI.RIGHTS_ADMIN in RCI.instance().userRights or UCI.RIGHTS_TESTER in RCI.instance().userRights :
if witem1 is not None:
self.itemCurrent = witem1
self.cancelAction.setEnabled(True)
self.editWaitingAction.setEnabled(True)
self.disableAction.setEnabled(True)
else:
self.cancelAction.setEnabled(False)
self.editWaitingAction.setEnabled(False)
self.disableAction.setEnabled(False)
def disableTask(self):
"""
Disable a waiting task
"""
# if self.itemCurrent is not None:
for currentItem in self.testWaiting.selectedItems():
RCI.instance().rescheduleTask(taskId=currentItem.taskId, taskEnabled=False,
scheduleType=currentItem.taskEventType,
scheduleAt=currentItem.taskEventArgs,
scheduleRepeat=currentItem.taskEventNb,
probesEnabled=currentItem.taskWithoutProbes,
notificationsEnabled=currentItem.taskWithoutNotif,
debugEnabled=False, logsEnabled=currentItem.taskNoKeepTr,
fromTime=currentItem.taskEventFrom, toTime=currentItem.taskEventTo )
def enableTask(self):
"""
Enable a waiting task
"""
# if self.itemCurrent is not None:
for currentItem in self.testWaiting.selectedItems():
RCI.instance().rescheduleTask(taskId=currentItem.taskId, taskEnabled=True,
scheduleType=currentItem.taskEventType,
scheduleAt=currentItem.taskEventArgs,
scheduleRepeat=currentItem.taskEventNb,
probesEnabled=currentItem.taskWithoutProbes,
notificationsEnabled=currentItem.taskWithoutNotif,
debugEnabled=False, logsEnabled=currentItem.taskNoKeepTr,
fromTime=currentItem.taskEventFrom, toTime=currentItem.taskEventTo )
def editWaiting(self):
"""
Edit a waiting task
"""
if self.itemCurrent is not None:
if self.itemCurrent.taskEventType in [ UCI.SCHED_QUEUE_AT, UCI.SCHED_QUEUE ]:
pass
else:
dSched = ScheduleDialog.SchedDialog( self )
dSched.fillFields( schedType=self.itemCurrent.taskEventType, schedArgs=self.itemCurrent.taskEventArgs,
taskName=self.itemCurrent.taskEventName, taskId=self.itemCurrent.taskId,
schedNb=self.itemCurrent.taskEventNb, withoutProbes=self.itemCurrent.taskWithoutProbes,
enabled=self.itemCurrent.taskEventEnabled,
withoutNotifs=self.itemCurrent.taskWithoutNotif, noKeepTr=self.itemCurrent.taskNoKeepTr,
schedFrom=self.itemCurrent.taskEventFrom, schedTo=self.itemCurrent.taskEventTo )
if dSched.exec_() == QDialog.Accepted:
runAt, runType, runNb, withoutProbes, runEnabled, noTr, withoutNotifs, runFrom, runTo = dSched.getSchedtime()
RCI.instance().rescheduleTask(taskId=self.itemCurrent.taskId, taskEnabled=runEnabled, scheduleType=runType,
scheduleAt=runAt, scheduleRepeat=runNb,
probesEnabled=withoutProbes, notificationsEnabled=withoutNotifs,
debugEnabled=False, logsEnabled=noTr,
fromTime=runFrom, toTime=runTo )
def clearHistory(self):
"""
Call the server to clear the history
"""
reply = QMessageBox.question(self, "Clear tasks history", "Are you sure ?",
QMessageBox.Yes | QMessageBox.No )
if reply == QMessageBox.Yes:
RCI.instance().clearHistory()
def testKilled(self):
"""
Test kiled
"""
self.itemCurrent = None
self.killAction.setEnabled(False)
def testCancelled(self):
"""
Test cancelled
"""
self.itemCurrent = None
self.cancelAction.setEnabled(False)
def active (self):
"""
Enables QTreeWidget
"""
self.waitingBox.setEnabled(True)
self.currentBox.setEnabled(True)
self.historyBox.setEnabled(True)
self.statsBox.setEnabled(True)
#
self.testManager.setEnabled(True)
self.testHistory.setEnabled(True)
self.testWaiting.setEnabled(True)
#
self.sortAction.setEnabled(True)
self.sortHistoryAction.setEnabled(True)
self.sortWaitingAction.setEnabled(True)
self.refreshWaitingAction.setEnabled(True)
self.refreshRunningAction.setEnabled(True)
self.refreshHistoryAction.setEnabled(True)
self.partialRefreshHistoryAction.setEnabled(True)
self.killAction.setEnabled(False)
self.cancelAction.setEnabled(False)
self.editWaitingAction.setEnabled(False)
if UCI.RIGHTS_ADMIN in RCI.instance().userRights:
self.killAllAction.setEnabled(True)
self.cancelAllAction.setEnabled(True)
self.clearHistoryAction.setEnabled(True)
self.disableAction.setEnabled(False)
self.enableAction.setEnabled(True)
def deactivate (self):
"""
Clears QTreeWidget and disables it
"""
self.waitingBox.setEnabled(False)
self.currentBox.setEnabled(False)
self.historyBox.setEnabled(False)
self.statsBox.setEnabled(False)
self.testWaiting.clear()
self.testWaiting.setEnabled(False)
self.testManager.clear()
self.testManager.setEnabled(False)
self.testHistory.clear()
self.testHistory.setEnabled(False)
self.testEnqueued.clear()
self.testHistory.setEnabled(False)
self.nbRunningLabel.setText("0")
self.nbWaitingLabel.setText("0")
self.nbHistoryLabel.setText("0")
self.nbCompleteHistoryLabel.setText("0")
self.nbErrorHistoryLabel.setText("0")
self.nbKilledHistoryLabel.setText("0")
self.nbCancelledHistoryLabel.setText("0")
self.itemCurrent = None
self.setDefaultActionsValues()
def setDefaultActionsValues (self):
"""
Set default values for qt actions
"""
self.sortAction.setEnabled(False)
self.sortHistoryAction.setEnabled(False)
self.sortWaitingAction.setEnabled(False)
self.killAction.setEnabled(False)
self.killAllAction.setEnabled(False)
self.cancelAction.setEnabled(False)
self.cancelAllAction.setEnabled(False)
self.editWaitingAction.setEnabled(False)
self.clearHistoryAction.setEnabled(False)
self.refreshWaitingAction.setEnabled(False)
self.refreshRunningAction.setEnabled(False)
self.refreshHistoryAction.setEnabled(False)
self.partialRefreshHistoryAction.setEnabled(False)
self.disableAction.setEnabled(False)
self.enableAction.setEnabled(False)
def loadProjects(self, data):
"""
Load all projects
"""
self.projects = data
def loadRunning (self, data):
"""
Loads running tasks
@param data:
@type data: dict
"""
self.nbRunningLabel.setText( str( len(data) ) )
for task in data:
if self.getProjectName(task['project-id']) == "UNKNOWN":
continue
taskItem = TaskRunningItem( task = task, parent= self.testManager )
# resize cols
for i in xrange(len(self.labels2) - 1):
self.testManager.resizeColumnToContents(i)
# change sort order
if self.ascendingOrder:
self.testWaiting.sortItems(2, Qt.AscendingOrder) # sort by sched time
self.testManager.sortItems(2, Qt.DescendingOrder)
def updateRunning(self, data):
"""
Update running tasks
@param data:
@type data:
"""
self.testManager.clear()
self.loadRunning( data=data )
def loadWaiting (self, data):
"""
Loads waiting tasks
@param data:
@type data: dict
"""
self.nbWaitingLabel.setText( str(len(data)) )
for task in data:
eventid, eventtype, eventargs, eventtime, eventname, author, realruntime, duration, result, eventnb, \
eventnbcur, eventenabled, withoutprobes, withoutnotif, nokeeptr, userid, projectid, eventfrom, eventto, groupid = task
if self.getProjectName(projectid) == "UNKNOWN":
continue
taskItem = TaskWaitingItem( task = task, parent= self.testWaiting )
# resize cols
for i in xrange(len(self.labels2) - 1):
self.testWaiting.resizeColumnToContents(i)
# change sort order
if self.ascendingOrderHistory:
self.testWaiting.sortItems(3, Qt.AscendingOrder)
self.testWaiting.sortItems(3, Qt.DescendingOrder)
def updateWaiting(self, data):
"""
Update waiting tasks
@param data:
@type data:
"""
self.testWaiting.clear()
self.loadWaiting( data=data )
def loadEnqueued (self, data):
"""
Loads enqueued tasks
@param data:
@type data: dict
"""
for (groupId, groupData) in data.items():
groupName, groupsTests = groupData
pluriel = ''
if len(groupsTests) > 1:
pluriel = ''
groupTask = TaskEnqueuedItem( parent=self.testEnqueued, text="%s - %s - (%s test%s)" % (groupId, groupName, len(groupsTests), pluriel) )
groupTask.setExpanded(True)
for gTest in groupsTests:
tDict = eval(gTest)
tst = "%s:%s.%s" % ( self.getProjectName(tDict['prj-id']), tDict['test-path'], tDict['test-extension'])
# set the icon according to the type of test
if tDict['test-extension'] == 'tux':
testIcon = QIcon(":/tux.png")
if tDict['test-extension'] == 'tax':
testIcon = QIcon(":/tax.png")
if tDict['test-extension'] == 'tsx':
testIcon = QIcon(":/tsx.png")
if tDict['test-extension'] == 'tpx':
testIcon = QIcon(":/tpx.png")
if tDict['test-extension'] == 'tgx':
testIcon = QIcon(":/tgx.png")
subTask = TaskEnqueuedItem(parent=groupTask, text=tst, icon=testIcon)
def updateEnqueued(self, data):
"""
Update enqueued tasks
@param data:
@type data:
"""
self.testEnqueued.clear()
self.loadEnqueued( data=data )
def loadHistory (self, data):
"""
Loads history tasks
@param data:
@type data: dict
"""
# Init counters
nbComplete = int(self.nbCompleteHistoryLabel.text())
nbError = int(self.nbErrorHistoryLabel.text())
nbKilled = int(self.nbKilledHistoryLabel.text())
nbCancelled = int(self.nbCancelledHistoryLabel.text())
for task in data:
dbid, eventtype, eventargs, eventtime, eventname, author, realruntime, duration, result, projectid = task
if self.getProjectName(projectid) == "UNKNOWN":
continue
taskItem = TaskHistoryItem( task = task, parent= self.testHistory )
if taskItem.taskEventResult == STATE_COMPLETE:
nbComplete += 1
if taskItem.taskEventResult == STATE_ERROR:
nbError += 1
if taskItem.taskEventResult == STATE_KILLED:
nbKilled += 1
if taskItem.taskEventResult == STATE_CANCELLED:
nbCancelled += 1
# resize cols
for i in xrange(len(self.labels2) - 1):
self.testHistory.resizeColumnToContents(i)
# change sort order by sched at
if self.ascendingOrderHistory:
self.testHistory.sortItems(0, Qt.AscendingOrder)
self.testHistory.sortItems(0, Qt.DescendingOrder)
# Update summary
nbHistory = int(self.nbHistoryLabel.text())
self.nbHistoryLabel.setText( str( len(data) + nbHistory ) )
self.nbCompleteHistoryLabel.setText( str(nbComplete) )
self.nbErrorHistoryLabel.setText( str(nbError) )
self.nbKilledHistoryLabel.setText( str(nbKilled) )
self.nbCancelledHistoryLabel.setText( str(nbCancelled) )
def updateHistory(self, data):
"""
Update history tasks
@param data:
@type data:
"""
# reset counters
self.nbHistoryLabel.setText("0")
self.nbCompleteHistoryLabel.setText("0")
self.nbErrorHistoryLabel.setText("0")
self.nbKilledHistoryLabel.setText("0")
self.nbCancelledHistoryLabel.setText("0")
#
self.testHistory.clear()
self.loadHistory( data=data )
def refreshRunningTask(self, data, action):
"""
Refresh running task
@param data:
@type data:
@param action:
@type action:
"""
if action == "add":
self.loadRunning(data=data)
elif action == "update":
self.updateRunning(data=data)
else:
pass # error
def refreshWaitingTask(self, data, action):
"""
Refresh waiting task
@param data:
@type data:
@param action:
@type action:
"""
if action == "update":
self.updateWaiting(data=data)
else:
pass # error
def refreshEnqueuedTask(self, data, action):
"""
Refresh enqueued task
@param data:
@type data:
@param action:
@type action:
"""
if action == "update":
self.updateEnqueued(data=data)
else:
pass # error
def refreshHistoryTask(self, data, action):
"""
Refresh history task
@param data:
@type data:
@param action:
@type action:
"""
if action == "add":
self.loadHistory(data=data)
elif action == "update":
self.updateHistory(data=data)
else:
pass # error
def onPopupMenu(self, pos):
"""
Display menu on right click
@param pos:
@type pos:
"""
self.menu = QMenu()
item = self.testManager.itemAt(pos)
if item:
self.itemCurrent = item
# kill task available just for admin and tester
if UCI.RIGHTS_ADMIN in RCI.instance().userRights or UCI.RIGHTS_TESTER in RCI.instance().userRights :
if item.taskState == STATE_RUNNING :
self.menu.addAction( self.killAction )
self.menu.popup(self.testManager.mapToGlobal(pos))
def onPopupMenuWaiting(self, pos):
"""
Display menu on right click
@param pos:
@type pos:
"""
self.menu = QMenu()
item = self.testWaiting.itemAt(pos)
if item:
self.itemCurrent = item
# kill task available just for admin and tester
if UCI.RIGHTS_ADMIN in RCI.instance().userRights or UCI.RIGHTS_TESTER in RCI.instance().userRights :
self.menu.addAction( self.editWaitingAction )
self.menu.addAction( self.cancelAction )
self.menu.addSeparator()
self.menu.addAction( self.disableAction )
self.menu.addAction( self.enableAction )
self.menu.popup(self.testWaiting.mapToGlobal(pos))
def cancelTask(self):
"""
Cancel the selected task
"""
items = self.testWaiting.selectedItems()
taskIds = []
for itm in items:
taskIds.append( itm.taskId )
reply = QMessageBox.question(self, "Cancel test(s)", "Are you sure ?",
QMessageBox.Yes | QMessageBox.No )
if reply == QMessageBox.Yes:
RCI.instance().cancelTasks(taskIds=taskIds)
def cancelAllTasks(self):
"""
Cancel all tasks
"""
reply = QMessageBox.question(self, "Cancel all tests", "Are you sure ?",
QMessageBox.Yes | QMessageBox.No )
if reply == QMessageBox.Yes:
RCI.instance().cancelTasksAll()
def killTask(self):
"""
Kill the selected task
"""
items = self.testManager.selectedItems()
taskIds = []
for itm in items:
taskIds.append( itm.taskId )
reply = QMessageBox.question(self, "Kill test", "Are you sure ?",
QMessageBox.Yes | QMessageBox.No )
if reply == QMessageBox.Yes:
RCI.instance().killTasks(taskIds=taskIds)
def killAllTasks(self):
"""
Kill all tasks
"""
reply = QMessageBox.question(self, "Kill all tests", "Are you sure ?",
QMessageBox.Yes | QMessageBox.No )
if reply == QMessageBox.Yes:
RCI.instance().killTasksAll()
def toggleSort(self):
"""
Toggle sort of running task
"""
if not self.ascendingOrder:
self.testManager.sortItems(2, Qt.AscendingOrder)
self.ascendingOrder = True
else:
self.testManager.sortItems(2, Qt.DescendingOrder)
self.ascendingOrder = False
def toggleSortHistory(self):
"""
Toggle sort of the history
"""
if not self.ascendingOrderHistory:
self.testHistory.sortItems(0, Qt.AscendingOrder)
self.ascendingOrderHistory = True
else:
self.testHistory.sortItems(0, Qt.DescendingOrder)
self.ascendingOrderHistory = False
def toggleSortWaiting(self):
"""
Toggle sort of the waiting
"""
if not self.ascendingOrderWaiting:
self.testWaiting.sortItems(3, Qt.AscendingOrder)
self.ascendingOrderWaiting = True
else:
self.testWaiting.sortItems(3, Qt.DescendingOrder)
self.ascendingOrderWaiting = False
class ProxyConfigPage(QWizardPage):
def __init__(self, parent=None,key=None):
super(ProxyConfigPage, self).__init__(parent)
self.parent = parent
self.key = key
try:
(pxytype,pxyhost,pxyport,pxyauth,pxyusr,pxypwd) = self.parent.mfr.readProxyConfig()
except:
(pxytype,pxyhost,pxyport,pxyauth,pxyusr,pxypwd) = (None,)*6
#if we use enums for pxy types
#pxytype = [a[0] for a in WFSDataStore.PROXY_TYPE.reverse.items() if a[1]==pxytype][0]
self.setTitle(self.parent.plist.get(self.key)[1]+' Configuration Options')
self.setSubTitle('Enter the hostname/ip-address, port number and authentication details of your HTTP proxy')
QToolTip.setFont(QFont('SansSerif', 10))
#labels
directlabel = QLabel('Direct Connection')
systemlabel = QLabel('Use System Proxy settings')
proxylabel = QLabel('Configure Proxy')
hostLabel = QLabel('Proxy Host')
portLabel = QLabel('Proxy Port')
authLabel = QLabel('Authentication')
usrLabel = QLabel('Username')
pwdLabel = QLabel('Password')
#radio buttons
self.directradio = QRadioButton()
self.systemradio = QRadioButton()
self.usrdefradio = QRadioButton()
#edit boxes
self.hostEdit = QLineEdit(pxyhost)
self.hostEdit.setToolTip('Enter Proxy host (IP Address or hostname)')
self.portEdit = QLineEdit(pxyport)
self.portEdit.setToolTip('Enter Proxy port')
#dropdown
self.authSelect = QComboBox()
self.authSelect.addItem('')
self.authSelect.setToolTip('Select appropriate proxy authentication mechanism')
self.authSelect.addItems(WFSDataStore.PROXY_AUTH)
self.authSelect.setCurrentIndex(0 if LU.assessNone(pxyauth) is None else WFSDataStore.PROXY_AUTH.index(pxyauth))
self.usrEdit = QLineEdit(pxyusr)
self.usrEdit.setToolTip('Enter your proxy username (if required)')
self.pwdEdit = QLineEdit('')#pxypwd
self.usrEdit.setToolTip('Enter your proxy password (if required)')
self.pwdEdit.setEchoMode(QLineEdit.Password)
self.portEdit.setValidator(QRegExpValidator(QRegExp("\d{1,5}"), self))
self.registerField(self.key+"host",self.hostEdit)
self.registerField(self.key+"port",self.portEdit)
self.registerField(self.key+"auth",self.authSelect,"currentIndex")
self.registerField(self.key+"usr",self.usrEdit)
self.registerField(self.key+"pwd",self.pwdEdit)
self.registerField(self.key+WFSDataStore.PROXY_TYPE[0],self.directradio)
self.registerField(self.key+WFSDataStore.PROXY_TYPE[1],self.systemradio)
self.registerField(self.key+WFSDataStore.PROXY_TYPE[2],self.usrdefradio)
#grid
grid1 = QGridLayout()
grid1.setSpacing(10)
grid2 = QGridLayout()
grid2.setSpacing(10)
#layout
hbox = QHBoxLayout()
grid1.addWidget(self.directradio,1,0)
grid1.addWidget(directlabel,1,1)
grid1.addWidget(self.systemradio,2,0)
grid1.addWidget(systemlabel,2,1)
grid1.addWidget(self.usrdefradio,3,0)
grid1.addWidget(proxylabel,3,1)
hbox.addLayout(grid1)
hbox.addStretch(1)
self.gbox = QGroupBox('Proxy Configuration')
#dsu
subs = False
if pxytype == WFSDataStore.PROXY_TYPE[1]:
#system
self.systemradio.setChecked(True)
elif pxytype == WFSDataStore.PROXY_TYPE[2]:
#user_defined
self.usrdefradio.setChecked(True)
subs = True
else:
#direct (default)
self.directradio.setChecked(True)
self.setUserDefined(subs)
self.directradio.clicked.connect(self.disableUserDefined)
self.systemradio.clicked.connect(self.disableUserDefined)
self.usrdefradio.clicked.connect(self.enableUserDefined)
grid2.addWidget(hostLabel, 1, 0)
grid2.addWidget(self.hostEdit, 1, 2)
grid2.addWidget(portLabel, 2, 0)
grid2.addWidget(self.portEdit, 2, 2)
grid2.addWidget(authLabel, 3, 0)
grid2.addWidget(self.authSelect, 3, 2)
grid2.addWidget(usrLabel, 4, 0)
grid2.addWidget(self.usrEdit, 4, 2)
grid2.addWidget(pwdLabel, 5, 0)
grid2.addWidget(self.pwdEdit, 5, 2)
self.gbox.setLayout(grid2)
#layout
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.insertWidget(1,self.gbox)
self.setLayout(vbox)
def selectConfFile(self):
self.fileEdit.setText(QFileDialog.getOpenFileName())
def nextId(self):
#now go to selected dest configger
#return int(self.field("ldsdest").toString())
if self.testConnection():
return self.field("ldsdest")
return self.parent.plist.get('proxy')[0]
def disableUserDefined(self):
self.setUserDefined(False)
def enableUserDefined(self):
self.setUserDefined(True)
def setUserDefined(self,udval):
self.gbox.setEnabled(udval)
self.hostEdit.setEnabled(udval)
self.portEdit.setEnabled(udval)
self.authSelect.setEnabled(udval)
self.usrEdit.setEnabled(udval)
self.pwdEdit.setEnabled(udval)
def testConnection(self):
if not self.usrdefradio.isChecked():
return True
if not any(f for f in (self.hostEdit.isModified(),self.portEdit.isModified(),
self.usrEdit.isModified(),self.pwdEdit.isModified())):
return False
proxydata = {'type':'USER','host':str(self.hostEdit.text()),'port':str(self.portEdit.text()),
'auth':str(WFSDataStore.PROXY_AUTH[self.authSelect.currentIndex()-1]),
'user':str(self.usrEdit.text()),'pass':str(self.pwdEdit.text())}
wfsdata = {'key':'00112233445566778899aabbccddeeff'}#key not necessary but config tester checks format
lds = LDSDataStore(None,{'Proxy':proxydata,'WFS':wfsdata})
lds.applyConfigOptions()
try:
#use website likely to be up (that isn't LDS so error is distinct)
lds.initDS('http://www.google.com/',False)
except DatasourceConnectException as dce:
QMessageBox.warning(self, 'Connection Error', 'Cannot connect to network using proxy parameters provided {}'.format(dce), 'OK')
return False
except DatasourceOpenException as dse:
QMessageBox.info(self, 'Connection Warning', 'Connection parameters confirmed, Datasource initialisation untested. Continuing.\n{}'.format(dse), 'OK')
return True
except RuntimeError as rte:
QMessageBox.warning(self, 'RuntimeError', 'Error connecting to network: '+str(rte), 'OK')
return False
return True
class NetWorkSettingWidget(QWidget):
def __init__(self, app, parent = None):
super(NetWorkSettingWidget,self).__init__(parent)
self.setStyleSheet("font-size : 16px;")
self.app = app
CDLL("../lib/libjson-c.so", mode=RTLD_GLOBAL)
self.jytcapi = cdll.LoadLibrary('../lib/libjytcapi.so')
self.jytcapi.jyinittcapi()
self.initLayout()
self.initCheckBoxStatus()
self.restartNetworkTD = RestartNetworkThread()
self.waitingDlg = InfoHintDialog(None)
#绑定信号
self.connect(self.autoGetIpCheckbox, SIGNAL("stateChanged(int)"),self.slotSettingDHCPType)
self.connect(self.staticIpGroupbox, SIGNAL("clicked(bool)"),self.slotSettingStaticType)
self.connect(self.autoGetDNSCheckBox, SIGNAL("stateChanged(int)"),self.slotSettingDNSType)
self.connect(self.dnsServerAddressGroupbox, SIGNAL("clicked(bool)"),self.slotSettingCustomDNSType)
self.connect(self.saveBtn, SIGNAL("clicked()"),self.slotSave)
self.connect(self.restartNetworkTD, SIGNAL("restartNetwork"),self.slotShowRestartNetworkInfo)
def initLayout(self):
#IP设置
self.autoGetIpCheckbox = QCheckBox(self.tr("Auto get IP"))
self.staticIpGroupbox = QGroupBox(self.tr("Use this IP"))
self.staticIpGroupbox.setCheckable(True)
self.ipLabel = QLabel(self.tr("IP address"))
self.netmastLabel = QLabel(self.tr("Net mask"))
self.defaultGatewayLabel = QLabel(self.tr("Default gateway"))
topSpaceWidget = QLabel()
topSpaceWidget.setFixedHeight(1)
self.ip = QLineEdit()
self.ip.setContextMenuPolicy(Qt.NoContextMenu)
self.ip.setFixedSize(400, 30)
self.netmast = QLineEdit()
self.netmast.setContextMenuPolicy(Qt.NoContextMenu)
self.defaultGateway = QLineEdit()
self.defaultGateway.setContextMenuPolicy(Qt.NoContextMenu)
topGridLayout = QGridLayout()
topGridLayout.setSpacing(15)
topGridLayout.setMargin(20)
topGridLayout.addWidget(self.ipLabel, 0, 0, 1, 1)
topGridLayout.addWidget(self.ip, 0, 1, 1, 1)
topGridLayout.addWidget(self.netmastLabel, 1, 0, 1, 1)
topGridLayout.addWidget(self.netmast, 1, 1, 1, 1)
topGridLayout.addWidget(self.defaultGatewayLabel, 2, 0, 1, 1)
topGridLayout.addWidget(self.defaultGateway, 2, 1, 1, 1)
topGridLayout.addWidget(topSpaceWidget, 3, 0, 1, 1)
self.staticIpGroupbox.setLayout(topGridLayout)
#DNS设置
self.autoGetDNSCheckBox = QCheckBox(self.tr("Auto Get DNS"))
self.dnsServerAddressGroupbox = QGroupBox(self.tr("Use This DNS"))
self.dnsServerAddressGroupbox.setCheckable(True)
self.dnsLabel = QLabel(self.tr("DNS"))
self.backupDnsLabel = QLabel(self.tr("Backup DNS"))
bottomSpaceWidget = QLabel()
bottomSpaceWidget.setFixedHeight(1)
self.dns = QLineEdit()
self.dns.setContextMenuPolicy(Qt.NoContextMenu)
self.backupDns = QLineEdit()
self.backupDns.setContextMenuPolicy(Qt.NoContextMenu)
self.saveBtn = QPushButton(self.tr("Save"))
self.saveBtn.setStyleSheet("background: rgb(7,87,198); color: white; width: 90px; height: 30px;font-size : 16px;")
bottomGridLayout = QGridLayout()
bottomGridLayout.setSpacing(15)
bottomGridLayout.setMargin(20)
bottomGridLayout.addWidget(self.dnsLabel, 0, 0, 1, 1)
bottomGridLayout.addWidget(self.dns, 0, 1, 1, 1)
bottomGridLayout.addWidget(self.backupDnsLabel, 1, 0, 1, 1)
bottomGridLayout.addWidget(self.backupDns, 1, 1, 1, 1)
bottomGridLayout.addWidget(bottomSpaceWidget, 2, 0, 1, 1)
self.dnsServerAddressGroupbox.setLayout(bottomGridLayout)
#布局调整
vLayout = QVBoxLayout()
vLayout.setSpacing(10)
vLayout.setMargin(10)
vLayout.addWidget(self.autoGetIpCheckbox)
vLayout.addWidget(self.staticIpGroupbox)
vLayout.addSpacing(15)
vLayout.addWidget(self.autoGetDNSCheckBox)
vLayout.addWidget(self.dnsServerAddressGroupbox)
vLayout.addStretch()
topMainLayout = QHBoxLayout()
topMainLayout.addStretch()
topMainLayout.addSpacing(50)
topMainLayout.addLayout(vLayout)
topMainLayout.addStretch(2)
bottomHLayout = QHBoxLayout()
bottomHLayout.addStretch()
bottomHLayout.addWidget(self.saveBtn)
bottomHLayout.addStretch()
mainVLayout = QVBoxLayout()
mainVLayout.addLayout(topMainLayout)
mainVLayout.addSpacing(10)
mainVLayout.addLayout(bottomHLayout)
self.setLayout(mainVLayout)
def updateWindow(self):
self.autoGetDNSCheckBox.setText(self.tr("Auto Get DNS"))
self.autoGetIpCheckbox.setText(self.tr("Auto get IP"))
self.dnsServerAddressGroupbox.setTitle(self.tr("Use This DNS"))
self.staticIpGroupbox.setTitle(self.tr("Use this IP"))
self.ipLabel.setText(self.tr("IP address"))
self.netmastLabel.setText(self.tr("Net mask"))
self.defaultGatewayLabel.setText(self.tr("Gate way"))
self.dnsLabel.setText(self.tr("DNS"))
self.backupDnsLabel.setText(self.tr("Backup DNS"))
self.saveBtn.setText(self.tr("Save"))
def slotShowRestartNetworkInfo(self, status):
"""显示重启网络的状态信息"""
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)
"""显示重启网络的状态信息"""
if status == "Start":
self.waitingDlg.setHintInfo(self.tr("network is restarting, waiting..."))
elif status == "Success":
self.waitingDlg.setHintInfo(self.tr("network start success!"))
vmtype = StoreInfoParser.instance().getVmType()
if vmtype == "offline":
pass
elif status == "Failed":
self.waitingDlg.setHintInfo(self.tr("network restart failed!"))
else:
return
if self.waitingDlg.isHidden():
self.waitingDlg.exec_()
def slotSave(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)
if not self.checkInputValid():
return
if self.autoGetIpCheckbox.isChecked():
netconf = self.setDynamicNetwork()
elif self.staticIpGroupbox.isChecked():
netconf = self.setStaticNetwork()
#重新启动网络
self.restartNetworkTD.setNetConf(netconf)
self.restartNetworkTD.start()
return
def getCmdExecValueT(self, cmd):
"""得到命令执行的结果"""
statusOutput = commands.getstatusoutput(cmd)
monitorList = statusOutput[1].split("\n")
return monitorList
def getNetDnsType(self):
typeList = ["dhcp","dhcp"]
networkInfo = self.getCmdExecValueT("../lib/ccr_jytcapi network")
for item in networkInfo:
if len(item.split(":")) == 2:
if item.split(":")[0] == "conf":
if item.split(":")[1] == "0":
typeList[0] = "dhcp"
else:
typeList[0] = "static"
else:
pass
DNSStatus = StoreInfoParser.instance().getDNSStatus()
if DNSStatus == None:
pass
else:
typeList[1] = DNSStatus
return typeList
def getNetStatic(self):
netList = ["0.0.0.0","255.255.255.0","1.1.1.1"]
networkInfo = self.getCmdExecValueT("../lib/ccr_jytcapi network")
for item in networkInfo:
if len(item.split(":")) == 2:
if item.split(":")[0] == "ip":
netList[0] = item.split(":")[1]
elif item.split(":")[0] == "mask":
netList[1] = item.split(":")[1]
elif item.split(":")[0] == "gateway":
netList[2] = item.split(":")[1]
return netList
def getDnsStatic(self):
dnsList = ["0.0.0.0","2.5.5.0"]
networkInfo = self.getCmdExecValueT("../lib/ccr_jytcapi network")
for item in networkInfo:
if len(item.split(":")) == 2:
if item.split(":")[0] == "dns1":
dnsList[0] = item.split(":")[1]
elif item.split(":")[0] == "dns2":
dnsList[1] = item.split(":")[1]
return dnsList
def initCheckBoxStatus(self):
"""读取网络配置文件，初始化相应的checkbox的状态"""
[netType, DNSType] = self.getNetDnsType()
if netType == "dhcp":
self.autoGetIpCheckbox.setChecked(True)
self.staticIpGroupbox.setChecked(False)
self.autoGetDNSCheckBox.setEnabled(False)
self.dnsServerAddressGroupbox.setEnabled(False)
else:
self.autoGetIpCheckbox.setChecked(False)
self.staticIpGroupbox.setChecked(True)
self.autoGetDNSCheckBox.setEnabled(True)
self.dnsServerAddressGroupbox.setEnabled(True)
[ip, netmask, gateway] = self.getNetStatic()
if ip:
self.ip.setText(ip)
if netmask:
self.netmast.setText(netmask)
if gateway:
self.defaultGateway.setText(gateway)
if DNSType == "dhcp":
self.autoGetDNSCheckBox.setChecked(True)
self.dnsServerAddressGroupbox.setChecked(False)
else:
self.autoGetDNSCheckBox.setChecked(False)
self.dnsServerAddressGroupbox.setChecked(True)
[DNS_first, DNS_second] = self.getDnsStatic()
if DNS_first:
self.dns.setText(DNS_first)
if DNS_second:
self.backupDns.setText(DNS_second)
def getCustomDNSInfo(self):
"""得到自定义DNS的内容"""
DNS_first = None
DNS_second = None
statusOutput = commands.getstatusoutput("cat %s" % common.NETWORK_CONFIG_UBUNTU)
if statusOutput[0] == 0:
outputList = QString(statusOutput[1]).split("\n")
for value in outputList:
if value.split(" ")[0] == "dns-nameservers":
DNS_first = value.split(" ")[1]
if len(value.split(" ")) > 2:
DNS_second = value.split(" ")[2]
return [DNS_first, DNS_second]
def getStaticNetworkInfo(self):
"""得到静态网络的信息"""
ip = netmask = gateway = None
statusOutput = commands.getstatusoutput("cat %s" % common.NETWORK_CONFIG_UBUNTU)
if statusOutput[0] == 0:
outputList = QString(statusOutput[1]).split("\n")
for value in outputList:
if value.split(" ")[0] == "address":
ip = value.split(" ")[1]
elif value.split(" ")[0] == "netmask":
netmask = value.split(" ")[1]
elif value.split(" ")[0] == "gateway":
gateway = value.split(" ")[1]
return [ip, netmask, gateway]
def getNetworkType(self):
"""得到网络是静态还是动态类型"""
netType = None
DNSType = None
statusOutput = commands.getstatusoutput("cat %s" % common.NETWORK_CONFIG_UBUNTU)
if statusOutput[0] == 0:
output = QString(statusOutput[1])
if output.contains("dhcp"):
netType = "dhcp"
else:
netType = "static"
if output.contains("dns-nameservers"):
DNSType = "customDNS"
else:
DNSType = "AUTODNS"
return [netType, DNSType]
def checkInputValid(self):
"""检测输入的有效性"""
if self.checkStaticIPInputValid() and self.checkDnsInputValid():
return True
return False
def checkStaticIPInputValid(self):
"""检查静态IP输入内容的有效性"""
ip = self.ip.text().trimmed()
netmask = self.netmast.text().trimmed()
gateway = self.defaultGateway.text().trimmed()
if not self.autoGetIpCheckbox.isChecked():
if ip.isEmpty() or ip.isNull() or netmask.isEmpty() or netmask.isNull():
InfoHintDialog(u'IP地址或子网掩码不能为空').exec_()
return False
pattern = '^([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])$'
matchObj = re.match(pattern, ip)
if matchObj is None:
InfoHintDialog(u'IP地址格式有误，请重新填入').exec_()
self.ip.setFocus()
return False
matchObj = re.match(pattern, str(netmask))
if matchObj is None:
InfoHintDialog(u'子网掩码地址格式有误，请重新填入').exec_()
self.netmast.setFocus()
return False
if gateway:
matchObj = re.match(pattern, str(gateway))
if matchObj is None:
InfoHintDialog(u'网关地址格式有误，请重新填入').exec_()
self.netmast.setFocus()
return False
return True
def checkDnsInputValid(self):
"""检查DNS输入的内容的有效性"""
if not self.autoGetDNSCheckBox.isChecked():
dns = self.dns.text().trimmed()
backupDns = self.backupDns.text().trimmed()
if dns.isEmpty() or dns.isNull():
InfoHintDialog(u'DNS不能为空').exec_()
return False
pattern = '^([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])\.([01]?\d\d?|2[0-4]\d|25[0-5])$'
matchObj = re.match(pattern, str(dns))
if matchObj is None:
InfoHintDialog(u'DNS地址格式有误，请重新填入').exec_()
self.dns.setFocus()
return False
if backupDns:
matchObj = re.match(pattern, str(backupDns))
if matchObj is None:
InfoHintDialog(u'备用DNS地址格式有误，请重新填入').exec_()
self.backupDns.setFocus()
return False
return True
else:
return True
def slotSettingDNSType(self, status):
if status == Qt.Checked:
self.dnsServerAddressGroupbox.setChecked(False)
elif status == Qt.Unchecked:
self.dnsServerAddressGroupbox.setChecked(True)
def slotSettingCustomDNSType(self, status):
if status:
self.autoGetDNSCheckBox.setChecked(False)
else:
self.autoGetDNSCheckBox.setChecked(True)
def slotSettingDHCPType(self, status):
if status == Qt.Checked:
self.staticIpGroupbox.setChecked(False)
self.dnsServerAddressGroupbox.setChecked(False)
self.autoGetDNSCheckBox.setChecked(True)
self.autoGetDNSCheckBox.setEnabled(False)
self.dnsServerAddressGroupbox.setEnabled(False)
elif status == Qt.Unchecked:
self.staticIpGroupbox.setChecked(True)
self.dnsServerAddressGroupbox.setChecked(True)
self.autoGetDNSCheckBox.setEnabled(True)
self.autoGetDNSCheckBox.setChecked(False)
self.dnsServerAddressGroupbox.setEnabled(True)
def slotSettingStaticType(self, status):
if status:
self.autoGetIpCheckbox.setChecked(False)
self.dnsServerAddressGroupbox.setChecked(True)
self.autoGetDNSCheckBox.setEnabled(True)
self.autoGetDNSCheckBox.setChecked(False)
self.dnsServerAddressGroupbox.setEnabled(True)
else:
self.autoGetIpCheckbox.setChecked(True)
self.dnsServerAddressGroupbox.setChecked(False)
self.autoGetDNSCheckBox.setEnabled(False)
self.autoGetDNSCheckBox.setChecked(True)
self.dnsServerAddressGroupbox.setEnabled(False)
def setDynamicNetwork(self):
"""设置动态网络的信息到配置文件"""
netconf="conf=0&ip=&mask=&gateway="
#如果是指定DNS地址
if self.dnsServerAddressGroupbox.isChecked():
dns = str(self.dns.text().trimmed())
backupDns = str(self.backupDns.text().trimmed())
if not backupDns:
netconf = netconf + "&dns1=" + dns
else:
netconf = netconf + "&dns1=" + dns + "&dns2=" + backupDns
StoreInfoParser.instance().setDNSStatus("static")
else:
netconf = netconf + "&dns1=&dns2="
StoreInfoParser.instance().setDNSStatus("dhcp")
return netconf
def setStaticNetwork(self):
"""设置静态网络的信息到配置文件"""
IPADDR = str(self.ip.text().trimmed())
NETMASK = str(self.netmast.text().trimmed())
GATEWAY = str(self.defaultGateway.text().trimmed())
content = None
if not GATEWAY:
content = "conf=1&ip=%s&mask=%s&gateway=" % (IPADDR, NETMASK)
else:
content = "conf=1&ip=%s&mask=%s&gateway=%s" % (IPADDR, NETMASK, GATEWAY)
#如果是指定DNS地址
if self.dnsServerAddressGroupbox.isChecked():
dns = str(self.dns.text().trimmed())
backupDns = str(self.backupDns.text().trimmed())
if not backupDns:
content = content + "&dns1=" + dns
else:
content = content + "&dns1=" + dns + "&dns2=" + backupDns
StoreInfoParser.instance().setDNSStatus("static")
else:
content = content + "&dns1=&dns2="
StoreInfoParser.instance().setDNSStatus("dhcp")
return content
def initUploadTab(self):
###Upload Tab###
upload_tab = QWidget()
upload_tab_layout = QVBoxLayout()
self.tabWidget.addTab(upload_tab, "Upload HITs")
# Frames Box
frames_box = QGroupBox()
frames_box.setTitle("Frame selection")
frames_layout = QVBoxLayout()
frames_label = QLabel("Select which frames to upload:")
frames_layout.addWidget(frames_label)
# Init list view
self.view = QListView()
frames_layout.addWidget(self.view)
upload_button = QPushButton("Upload HITs")
upload_button.clicked.connect(self.upload)
frames_layout.addWidget(upload_button)
frames_box.setLayout(frames_layout)
# MotionOptions Box
motionOptionsBox = QGroupBox()
motionOptionsBox.setTitle("Motion Annotation Options")
patchLabel = QLabel("Patch size: 50x50 Pixels")
motionOptionsBoxLayout = QHBoxLayout()
overlapping = QCheckBox("Overlapping Patches")
overlapping.clicked.connect(self.getBalance)
motionOptionsBoxLayout.addWidget(overlapping)
motionOptionsBoxLayout.addWidget(patchLabel)
motionOptionsBox.setLayout(motionOptionsBoxLayout)
# LayerOptions Box
options_box = QGroupBox()
options_box.setTitle('Layer Annotation Options')
blurLabel = QLabel("Amount: 4 Pixels")
options_box_layout = QHBoxLayout()
blur = QCheckBox("Blur Outlines")
options_box_layout.addWidget(blur)
options_box_layout.addWidget(blurLabel)
options_box.setLayout(options_box_layout)
# Disable not needed options
if self.segmentation_mode:
motionOptionsBox.setEnabled(False)
else:
options_box.setEnabled(False)
# Costs
costs_box = QGroupBox()
costs_box.setTitle('Costs')
costs_box_layout = QVBoxLayout()
self.credit_label = QLabel("Your current account balance is:")
self.costLabel = QLabel("Costs per frame:")
costs_box_layout.addWidget(self.credit_label)
costs_box_layout.addWidget(self.costLabel)
costs_box.setLayout(costs_box_layout)
# Upload Box
upload_tab_layout.addWidget(frames_box)
upload_tab_layout.addWidget(motionOptionsBox)
upload_tab_layout.addWidget(options_box)
upload_tab_layout.addWidget(costs_box)
upload_tab.setLayout(upload_tab_layout)
def _init_layout(self):
"""
Create the GUI widgets (but leave them empty).
"""
hostname_combobox = QComboBox(parent=self)
self._hostname_combobox = hostname_combobox
hostname_combobox.setEditable(True)
hostname_combobox.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Maximum)
hostname_combobox.installEventFilter(self)
for hostname in self._suggested_hostnames:
hostname_combobox.addItem(hostname)
self._connect_button = QPushButton("Connect",
parent=self,
clicked=self._handle_new_hostname)
hostname_layout = QHBoxLayout()
hostname_layout.addWidget(hostname_combobox)
hostname_layout.addWidget(self._connect_button)
hostname_groupbox = QGroupBox("DVID Host", parent=self)
hostname_groupbox.setLayout(hostname_layout)
hostname_groupbox.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
data_treewidget = QTreeWidget(parent=self)
data_treewidget.setHeaderLabels(
["Data"]) # TODO: Add type, shape, axes, etc.
data_treewidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
data_treewidget.itemSelectionChanged.connect(
self._handle_data_selection)
data_layout = QVBoxLayout()
data_layout.addWidget(data_treewidget)
data_groupbox = QGroupBox("Data Volumes", parent=self)
data_groupbox.setLayout(data_layout)
node_listwidget = QListWidget(parent=self)
node_listwidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
node_listwidget.itemSelectionChanged.connect(self._update_display)
node_layout = QVBoxLayout()
node_layout.addWidget(node_listwidget)
node_groupbox = QGroupBox("Nodes", parent=self)
node_groupbox.setLayout(node_layout)
new_data_edit = QLineEdit(parent=self)
new_data_edit.textEdited.connect(self._update_display)
full_url_label = QLabel(parent=self)
full_url_label.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
text_flags = full_url_label.textInteractionFlags()
full_url_label.setTextInteractionFlags(text_flags
| Qt.TextSelectableByMouse)
new_data_layout = QVBoxLayout()
new_data_layout.addWidget(new_data_edit)
new_data_groupbox = QGroupBox("New Data Volume", parent=self)
new_data_groupbox.setLayout(new_data_layout)
new_data_groupbox.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
buttonbox = QDialogButtonBox(Qt.Horizontal, parent=self)
buttonbox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonbox.accepted.connect(self.accept)
buttonbox.rejected.connect(self.reject)
buttonbox.button(QDialogButtonBox.Ok).setEnabled(False)
layout = QVBoxLayout()
layout.addWidget(hostname_groupbox)
layout.addWidget(data_groupbox)
layout.addWidget(node_groupbox)
if self._mode == "specify_new":
layout.addWidget(new_data_groupbox)
else:
new_data_groupbox.hide()
layout.addWidget(full_url_label)
layout.addWidget(buttonbox)
# Stretch factors
layout.setStretchFactor(data_groupbox, 3)
layout.setStretchFactor(node_groupbox, 1)
self.setLayout(layout)
self.setWindowTitle("Select DVID Volume")
# Initially disabled
data_groupbox.setEnabled(False)
node_groupbox.setEnabled(False)
new_data_groupbox.setEnabled(False)
# Save instance members
self._data_groupbox = data_groupbox
self._node_groupbox = node_groupbox
self._new_data_groupbox = new_data_groupbox
self._data_treewidget = data_treewidget
self._node_listwidget = node_listwidget
self._new_data_edit = new_data_edit
self._full_url_label = full_url_label
self._buttonbox = buttonbox
class previewDlg(QMainWindow):
'''
classdocs
'''
def __init__(self, parent, comp, basePMCheck, model):
'''
Constructor
'''
QMainWindow.__init__(self, parent)
self.basePMCheck = basePMCheck
# self.ui = Ui_Previewself.grbPageProperty()
# self.ui.setupUi(self)
self.resize(1000, 700)
self.setWindowTitle("Preview Dialog")
self.view = QgsComposerView(self)
viewLayout = QGridLayout()
viewLayout.setSpacing(0)
viewLayout.setMargin(0)
mHorizontalRuler = QgsComposerRuler(QgsComposerRuler.Horizontal)
mVerticalRuler = QgsComposerRuler(QgsComposerRuler.Vertical)
mRulerLayoutFix = QWidget()
mRulerLayoutFix.setAttribute(Qt.WA_NoMousePropagation)
mRulerLayoutFix.setBackgroundRole(QPalette.Window)
mRulerLayoutFix.setFixedSize(mVerticalRuler.rulerSize(),
mHorizontalRuler.rulerSize())
viewLayout.addWidget(mRulerLayoutFix, 0, 0)
viewLayout.addWidget(mHorizontalRuler, 0, 1)
viewLayout.addWidget(mVerticalRuler, 1, 0)
self.view.setContentsMargins(0, 0, 0, 0)
self.view.setHorizontalRuler(mHorizontalRuler)
self.view.setVerticalRuler(mVerticalRuler)
viewLayout.addWidget(self.view, 1, 1)
# self.scene = comp
self.view.setZoomLevel(1.0)
self.view.setComposition(comp)
self.scene = self.view.composition()
layout = QVBoxLayout()
hLayout = QHBoxLayout()
hLayout.addLayout(viewLayout)
self.mapItem = self.scene.getComposerMapById(0)
self.view.scale(2.8, 2.8)
self.view.setPreviewModeEnabled(True)
self.toolBarAction = self.addToolBar("composer action")
self.actionMapRefresh = QAction(self)
self.actionMapRefresh.setObjectName("actionMapRefresh")
icon3 = QIcon("Resource/Refresh.png")
self.actionMapRefresh.setIcon(icon3)
self.actionMapRefresh.setToolTip("Refresh")
# self.textItemAction.setCheckable(True)
self.connect(self.actionMapRefresh, SIGNAL("triggered()"),
self.actionMapRefresh_triggered)
self.toolBarAction.addAction(self.actionMapRefresh)
# # self.templeteCreateAction = QAction(self)
# # self.templeteCreateAction.setObjectName("createTempleteAction")
# # icon4 = QIcon("Resource\\templetepointer.png")
# # self.templeteCreateAction.setIcon(icon4)
# # self.templeteCreateAction.setToolTip("Create Templete")
# # self.templeteCreateAction.setCheckable(True)
# # self.connect(self.templeteCreateAction, SIGNAL("triggered()"), self.createTempleteAction)
# # self.toolBar.addAction(self.templeteCreateAction)
# layout.insertWidget(0, self.toolBar)
# self.scene.selectedItemChanged.connect(self.selectedItemDisplay)
self.view.selectedItemChanged.connect(self.selectedItemDisplay)
self.view.cursorPosChanged.connect(self.cursorPosChangedEvent)
# self.connect(self.view, SIGNAL("selectedItemChanged(QgsComposerItem)"),self, SLOT("selectedItemDisplay(QgsComposerItem)"))
# self.scene.composerLabelAdded.connect(self.composerLabelAddedEvent)
self.view.itemRemoved.connect(self.deleteItem)
# self.connect( self.view, SIGNAL( "actionFinished()" ), self.setSelectionTool)
#listen out for position updates from the QgsComposerView
self.propertyWidget = QWidget(self)
hLayout.addWidget(self.propertyWidget)
self.propertyWidget.setObjectName("propertyWidget")
self.propertyWidget.resize(222, 302)
self.vLayout_3 = QVBoxLayout(self.propertyWidget)
self.vLayout_3.setObjectName("vLayout_3")
self.groupBox = QGroupBox(self.propertyWidget)
self.groupBox.setObjectName("groupBox")
self.horizontalLayout_2 = QHBoxLayout(self.groupBox)
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.frame = QFrame(self.groupBox)
self.frame.setFrameShape(QFrame.StyledPanel)
self.frame.setFrameShadow(QFrame.Raised)
self.frame.setObjectName("frame")
self.verticalLayout = QVBoxLayout(self.frame)
self.verticalLayout.setObjectName("verticalLayout")
self.label = QLabel(self.frame)
self.label.setObjectName("label")
self.verticalLayout.addWidget(self.label)
self.labelText = QPlainTextEdit(self.frame)
self.labelText.setObjectName("labelText")
self.verticalLayout.addWidget(self.labelText)
self.btnLabelFont = QPushButton(self.frame)
self.btnLabelFont.setObjectName("btnLabelFont")
self.verticalLayout.addWidget(self.btnLabelFont)
self.btnLabelColor = QPushButton(self.frame)
self.btnLabelColor.setObjectName("btnLabelColor")
self.verticalLayout.addWidget(self.btnLabelColor)
self.frame_2 = QFrame(self.frame)
self.frame_2.setFrameShape(QFrame.StyledPanel)
self.frame_2.setFrameShadow(QFrame.Raised)
self.frame_2.setObjectName("frame_2")
self.horizontalLayout = QHBoxLayout(self.frame_2)
self.horizontalLayout.setObjectName("horizontalLayout")
self.label_2 = QLabel(self.frame_2)
self.label_2.setObjectName("label_2")
self.horizontalLayout.addWidget(self.label_2)
self.spinLabelRotation = QSpinBox(self.frame_2)
self.spinLabelRotation.setObjectName("spinLabelRotation")
self.spinLabelRotation.setMinimum(-360)
self.spinLabelRotation.setMaximum(360)
self.horizontalLayout.addWidget(self.spinLabelRotation)
self.verticalLayout.addWidget(self.frame_2)
self.chbBackgroundEnable = QCheckBox(self.frame)
self.chbBackgroundEnable.setChecked(True)
self.chbBackgroundEnable.setObjectName("chbBackgroundEnable")
self.verticalLayout.addWidget(self.chbBackgroundEnable)
self.horizontalLayout_2.addWidget(self.frame)
self.vLayout_3.addWidget(self.groupBox)
self.resolutionFrame = QFrame(self.frame)
self.resolutionFrame.setFrameShape(QFrame.StyledPanel)
self.resolutionFrame.setFrameShadow(QFrame.Raised)
self.resolutionFrame.setObjectName("resolutionFrame")
self.horizontalLayout4 = QHBoxLayout(self.resolutionFrame)
self.horizontalLayout4.setObjectName("horizontalLayout4")
self.label_resolution = QLabel(self.resolutionFrame)
self.label_resolution.setObjectName("label_resolution")
self.label_resolution.setText("Print Resolution (dpi):")
self.horizontalLayout4.addWidget(self.label_resolution)
self.spinResolution = QSpinBox(self.resolutionFrame)
self.spinResolution.setObjectName("spinResolution")
self.spinResolution.setMinimum(0)
self.spinResolution.setMaximum(1000)
self.spinResolution.setValue(300)
self.horizontalLayout4.addWidget(self.spinResolution)
# self.verticalLayout.addWidget(self.frame_2)
self.vLayout_3.addWidget(self.resolutionFrame)
self.gbTable = GroupBox(self.propertyWidget)
self.gbTable.Caption = "Table"
self.vLayout_3.addWidget(self.gbTable)
self.mTableView = QTableView(self.gbTable)
self.gbTable.Add = self.mTableView
hHeder = self.mTableView.horizontalHeader()
hHeder.setVisible(False)
vHeder = self.mTableView.verticalHeader()
vHeder.setVisible(False)
# self.mTableView.setFixedHeight(70)
# self.mTableView.setFixedWidth(comp.paperWidth() - 40)
# self.stdItemModel = QStandardItemModel()
# self.
self.spaceItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.vLayout_3.addItem(self.spaceItem)
self.groupBox.setTitle("Label Property")
self.label.setText("Label Text:")
self.btnLabelFont.setText("Label Font")
self.btnLabelColor.setText("Label Color")
self.label_2.setText("Label Rotation:")
self.chbBackgroundEnable.setText("Background Enable")
self.groupBox.setEnabled(False)
self.connect(self.btnLabelFont, SIGNAL("clicked()"),
self.btnLabelFontClick)
self.connect(self.btnLabelColor, SIGNAL("clicked()"),
self.btnLabelColorClick)
self.connect(self.chbBackgroundEnable, SIGNAL("clicked()"),
self.chbBackgroundEnableClick)
self.labelText.textChanged.connect(self.labelTextChanged)
self.spinLabelRotation.valueChanged.connect(
self.spinLabelRotationValueChanged)
layout.addLayout(hLayout)
#
self.btnBack = QPushButton()
self.btnBack.setText("back")
footerLayout = QHBoxLayout()
footerLayout.addWidget(self.btnBack)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName("buttonBox")
footerLayout.addWidget(self.buttonBox)
layout.addLayout(footerLayout)
self.setLayout(layout)
deleteItemKey = QShortcut(QKeySequence(Qt.Key_Delete), self)
deleteItemKey.activated.connect(self.deleteItem)
# self.btnBack.clicked.connect(self.back)
self.connect(self.buttonBox, SIGNAL("accepted()"), self.acceptMethod)
self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
self.btnCancel = self.buttonBox.button(QDialogButtonBox.Cancel)
self.view.setCurrentTool(QgsComposerView.Select)
self.btnLabelColor.setVisible(False)
# self.btnBack.setVisible(False)
self.chbBackgroundEnable.setVisible(False)
# self.view.emit(SIGNAL("actionFinished"))
# if self.scene.plotStyle() != QgsComposition.Preview:
# self.scene.setPlotStyle(QgsComposition.Preview)
# self.mapItem.setPreviewMode(QgsComposerMap.Render)
# self.mapItem.updateCachedImage()
# self.mapItem.setSelected(True)
self.mComposition = comp
self.composerMapItem = self.mComposition.composerMapItems()[0]
self.composerMapItem.setUpdatesEnabled(True)
self.mStdModel = model
self.mTableView.setModel(self.mStdModel)
self.mTableView.setSpan(0, 0, 1, 6)
self.mTableView.setSpan(1, 0, 1, 2)
self.mTableView.setSpan(2, 0, 2, 1)
self.mTableView.setSpan(4, 0, 1, 2)
self.mTableView.setSpan(5, 0, 1, 2)
self.mTableView.setSpan(6, 0, 1, 2)
self.mTableView.setSpan(0, 6, 1, 8)
self.mTableView.setSpan(1, 7, 1, 4)
self.mTableView.setSpan(1, 11, 1, 3)
self.mTableView.setSpan(2, 7, 1, 4)
self.mTableView.setSpan(2, 11, 1, 3)
def acceptMethod(self):
# self.mStdModel.setItem(0, QStandardItem("nnnnnnnn"))
filePath = QFileDialog.getSaveFileName(
self, "Save PDF File", QCoreApplication.applicationDirPath(),
"pdf files(*.pdf )")
if filePath == "":
return
self.mComposition.clearSelection()
self.mComposition.setPrintResolution(self.spinResolution.value())
resultPdf = self.mComposition.exportAsPDF(filePath)
if resultPdf:
message = QMessageBox.information(self, "Result",
"Successful export PDF")
else:
message = QMessageBox.information(self, "Result",
"Don't export PDF")
def rePresent(self, comp, model):
self.mComposition = comp
self.mStdModel = model
self.view.setComposition(comp)
self.scene = self.view.composition()
def back(self):
self.done(2)
def spinLabelRotationValueChanged(self, rotationValue):
self.selectedLabelItem.setItemRotation(rotationValue)
def cursorPosChangedEvent(self, scenePointF):
self.scenePoint = scenePointF
# i = 100
def labelTextChanged(self):
self.selectedLabelItem.beginCommand(
"Label text changed", QgsComposerMergeCommand.ComposerLabelSetText)
self.selectedLabelItem.blockSignals(True)
self.selectedLabelItem.setText(self.labelText.toPlainText())
self.selectedLabelItem.update()
self.selectedLabelItem.blockSignals(False)
self.selectedLabelItem.endCommand()
def chbBackgroundEnableClick(self):
if self.chbBackgroundEnable.isChecked():
self.selectedLabelItem.setBackgroundEnabled(True)
self.mapItem.updateCachedImage()
else:
self.selectedLabelItem.setBackgroundEnabled(False)
self.mapItem.updateCachedImage()
def btnLabelFontClick(self):
dlgFont = QFontDialog(self)
dlgFont.setCurrentFont(self.selectedLabelItem.font())
result = dlgFont.exec_()
if result == 1:
self.labelFont = dlgFont.selectedFont()
else:
self.labelFont = QFont()
self.selectedLabelItem.setFont(self.labelFont)
def btnLabelColorClick(self):
dlgColor = QColorDialog(self)
dlgColor.setCurrentColor(self.selectedLabelItem.fontColor())
result = dlgColor.exec_()
if result == 1:
self.labelColor = dlgColor.selectedColor()
self.selectedLabelItem.setFontColor(self.labelColor)
def createTempleteAction(self):
if self.templeteCreateAction.isChecked() and self.basePMCheck:
font = QFont("Arial", 13)
font.setItalic(True)
self.compLabel1 = QgsComposerLabel(self.scene)
self.compLabel1.setFont(font)
self.compLabel1.setText("South China Sea")
self.compLabel1.setBackgroundEnabled(False)
self.compLabel1.setItemPosition(156, 100)
self.compLabel1.adjustSizeToText()
self.compLabel1.setItemRotation(60)
# mapitem = self.scene.composerMapItems()
# mapitem[0].addItem(self.compLabel1)
self.scene.addItem(self.compLabel1)
self.compLabel2 = QgsComposerLabel(self.scene)
self.compLabel2.setFont(font)
self.compLabel2.setText("Straits Of Malacca")
self.compLabel2.setBackgroundEnabled(False)
self.compLabel2.setItemPosition(35, 100)
self.compLabel2.adjustSizeToText()
self.compLabel2.setItemRotation(60)
self.scene.addItem(self.compLabel2)
font.setItalic(False)
self.compLabel3 = QgsComposerLabel(self.scene)
self.compLabel3.setFont(font)
self.compLabel3.setBackgroundEnabled(False)
self.compLabel3.setText("THAILAND")
self.compLabel3.setItemPosition(68, 60)
self.compLabel3.adjustSizeToText()
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel3)
# self.templeteCreateAction.setChecked(False)
self.compLabel4 = QgsComposerLabel(self.scene)
self.compLabel4.setFont(font)
self.compLabel4.setBackgroundEnabled(False)
self.compLabel4.setText("SINGAPORE")
self.compLabel4.setItemPosition(141, 218)
self.compLabel4.adjustSizeToText()
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel4)
self.templeteCreateAction.setChecked(False)
self.compLabel4.setSelected(True)
elif self.templeteCreateAction.isChecked(
) and self.basePMCheck == False:
font = QFont("Arial", 14)
font.setItalic(True)
self.compLabel5 = QgsComposerLabel(self.scene)
self.compLabel5.setFont(font)
self.compLabel5.setText("South China Sea")
self.compLabel5.setBackgroundEnabled(False)
self.compLabel5.setItemPosition(108, 86)
self.compLabel5.adjustSizeToText()
self.compLabel5.setItemRotation(-45)
# mapitem = self.scene.composerMapItems()
# mapitem[0].addItem(self.compLabel1)
self.scene.addItem(self.compLabel5)
self.compLabel6 = QgsComposerLabel(self.scene)
self.compLabel6.setFont(font)
self.compLabel6.setText("Sulu Sea")
self.compLabel6.setBackgroundEnabled(False)
self.compLabel6.setItemPosition(236, 38)
self.compLabel6.adjustSizeToText()
self.compLabel6.setItemRotation(45)
self.scene.addItem(self.compLabel6)
font.setItalic(False)
self.compLabel7 = QgsComposerLabel(self.scene)
self.compLabel7.setFont(font)
self.compLabel7.setBackgroundEnabled(False)
self.compLabel7.setText("Celebes Sea")
self.compLabel7.setItemPosition(242, 112)
self.compLabel7.adjustSizeToText()
self.compLabel7.setItemRotation(-45)
# self.compLabel3.setItemRotation(0.5)
self.scene.addItem(self.compLabel7)
# self.templeteCreateAction.setChecked(False)
self.compLabel8 = QgsComposerLabel(self.scene)
self.compLabel8.setFont(font)
self.compLabel8.setBackgroundEnabled(False)
self.compLabel8.setText("INDONESIA\n(Kalimantan)")
self.compLabel8.setItemPosition(172, 148, 32, 16)
# self.compLabel8.setHAlign(Qt.AlignHCenter)
# self.compLabel8.setVAlign(Qt.AlignVCenter)
# self.compLabel8.setFrameEnabled(False)
# self.compLabel8.setItemPosition()
# self.compLabel8.adjustSizeToText()
# self.compLabl3.setItemRotation(0.5)
self.scene.addItem(self.compLabel8)
self.compLabel9 = QgsComposerLabel(self.scene)
self.compLabel9.setFont(font)
self.compLabel9.setBackgroundEnabled(False)
self.compLabel9.setText("BRUNEI")
self.compLabel9.setItemPosition(136, 83)
self.compLabel9.adjustSizeToText()
# self.compLabl3.setItemRotation(0.5)
self.scene.addItem(self.compLabel9)
self.templeteCreateAction.setChecked(False)
pass
def actionMapRefresh_triggered(self):
self.view.setCurrentTool(QgsComposerView.AddRectangle)
def setSelectionTool(self):
self.view.deleteSelectedItems()
font = QFont("Arial", 14)
newLabelItem = QgsComposerLabel(self.scene)
newLabelItem.setText("QGIS")
newLabelItem.setFont(font)
newLabelItem.setItemPosition(self.scenePoint.x(), self.scenePoint.y())
newLabelItem.adjustSizeToText()
self.scene.addItem(newLabelItem)
# selectItemPoint = self.scene.composerItemAt(self.scenePoint)
newLabelItem.setSelected(True)
self.groupBox.setEnabled(True)
self.selectedLabelItem = newLabelItem
# txt = self.selectedLabelItem.text()
# textDoc = QTextDocument(txt)
self.labelText.setPlainText(self.selectedLabelItem.text())
# self.scene.setSelectedItem(self.newLabelItem)
self.view.setCurrentTool(QgsComposerView.Select)
# self.selectedLabelItem = self.view.currentTool()
self.textItemAction.setChecked(False)
def selectedItemDisplay(self, item):
if self.scene.plotStyle() != QgsComposition.Preview:
self.scene.setPlotStyle(QgsComposition.Preview)
self.mapItem.setPreviewMode(QgsComposerMap.Render)
self.mapItem.updateCachedImage()
item._class_ = QgsComposerLabel
# selectedItems = self.scene.selectedComposerItems(True)
# if isinstance(item, QgsComposerItem):
# self.selectedLabelItem = item
# if isinstance(item, QGraphicsRectItem):
# self.selectedLabelItem = item
if isinstance(item, QgsComposerLabel):
self.selectedLabelItem = item
self.groupBox.setEnabled(True)
self.labelText.setPlainText(self.selectedLabelItem.text())
self.spinLabelRotation.setValue(self.selectedLabelItem.rotation())
else:
self.groupBox.setEnabled(False)
# print "debug"
itemName = self.view.currentTool()
if itemName == 5:
item.setText("label")
pass
def deleteItem(self):
self.view.deleteSelectedItems()
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_error)
self.sourceDirectory, self.outputDirectory = None, None
self.group2 = QGroupBox()
self.group2.setTitle(' Paths ')
self.inf = QLineEdit(path.expanduser("~"))
self.inf.setPlaceholderText(' /full/path/to/directory ')
self.out, self.fle = QLineEdit(path.expanduser("~")), QLineEdit()
self.out.setPlaceholderText(' /full/path/to/directory ')
self.fle.setPlaceholderText(' /full/path/to/single/file ')
self.completer, self.dirs = QCompleter(self), QDirModel(self)
self.dirs.setFilter(QDir.AllEntries | QDir.NoDotAndDotDot)
self.completer.setModel(self.dirs)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(QCompleter.PopupCompletion)
self.inf.setCompleter(self.completer)
self.out.setCompleter(self.completer)
self.fle.setCompleter(self.completer)
self.open1 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open1.setCursor(QCursor(Qt.PointingHandCursor))
self.open1.clicked.connect(lambda: self.inf.setText(str(
QFileDialog.getExistingDirectory(self.dock, "Open Source Directory",
path.expanduser("~")))))
self.open2 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open2.setCursor(QCursor(Qt.PointingHandCursor))
self.open2.clicked.connect(lambda: self.out.setText(str(
QFileDialog.getExistingDirectory(self.dock, "Open Target Directory",
path.expanduser("~")))))
self.open3 = QPushButton(QIcon.fromTheme("folder-open"), 'Open')
self.open3.setCursor(QCursor(Qt.PointingHandCursor))
self.open3.clicked.connect(lambda: self.fle.setText(str(
QFileDialog.getOpenFileName(self.dock, "Open a Target File...",
path.expanduser("~"), ';;'.join(['{}(*.{})'.format(e.upper(), e)
for e in ['py', 'pyw', '*']])))))
vboxg2 = QVBoxLayout(self.group2)
for each_widget in (
QLabel('Source Directory Project:'), self.inf, self.open1,
QLabel(' Target Directory Outputs: '), self.out, self.open2,
QLabel(' Source Single File (Optional):'), self.fle, self.open3, ):
vboxg2.addWidget(each_widget)
self.group1 = QGroupBox()
self.group1.setTitle(' Options ')
self.chckbx1 = QCheckBox(' Inject Twitter Bootstrap CSS3 ')
self.chckbx1.toggled.connect(self.toggle_styles_group)
self.chckbx2 = QCheckBox(' Warn all missing references ')
self.chckbx3 = QCheckBox(' Open Docs when done building ')
self.chckbx4 = QCheckBox('Save Bash script to reproduce Sphinx Builds')
vboxg1 = QVBoxLayout(self.group1)
for each_widget in (self.chckbx1, self.chckbx2,
self.chckbx3, self.chckbx4):
vboxg1.addWidget(each_widget)
each_widget.setChecked(True)
self.group3 = QGroupBox()
self.group3.setTitle(' Styles ')
self.group3.setGraphicsEffect(QGraphicsBlurEffect(self))
self.group3.graphicsEffect().setEnabled(False)
self.basecss, self.fontcss = QComboBox(), QComboBox()
self.basecss.addItems(['slate', 'united', 'spacelab', 'superhero',
'simplex', 'journal', 'flatly', 'cyborg', 'cosmo', 'cerulean'])
self.fontcss.addItems(['Ubuntu Light', 'Oxygen', 'Roboto', 'Droid Sans',
'Open Sans', 'Pacifico', 'Rancho', 'Arvo', 'Fresca', 'Graduate'])
self.backcss = QComboBox()
self.backcss.addItems(['shattered', 'retina_wood', 'ricepaper',
'brickwall', 'sneaker_mesh_fabric', 'diagonales_decalees',
'noisy_grid', 'pw_pattern', 'escheresque', 'diamond_upholstery'])
vboxg3 = QVBoxLayout(self.group3)
for each_widget in (QLabel('<b>Twitter Bootstrap Theme'), self.basecss,
QLabel('<b>Fonts Family'), self.fontcss,
QLabel('<b>Background Seamless Tiled Pattern'), self.backcss):
vboxg3.addWidget(each_widget)
self.output = QTextEdit('''
My brain is something more than merely mortal; As time will show.
- Ada Lovelace ''')
self.output.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.button = QPushButton('Document My Code')
self.button.setCursor(QCursor(Qt.PointingHandCursor))
self.button.setMinimumSize(75, 50)
self.button.clicked.connect(self.build)
glow = QGraphicsDropShadowEffect(self)
glow.setOffset(0)
glow.setBlurRadius(99)
glow.setColor(QColor(99, 255, 255))
self.button.setGraphicsEffect(glow)
class TransientWidget(QWidget):
' persistant widget thingy '
def __init__(self, widget_list):
' init sub class '
super(TransientWidget, self).__init__()
vbox = QVBoxLayout(self)
for each_widget in widget_list:
vbox.addWidget(each_widget)
tw = TransientWidget((self.group2, self.group1, self.group3,
QLabel(linesep + ' Logs: '), self.output, self.button))
self.scrollable, self.dock = QScrollArea(), QDockWidget()
self.scrollable.setWidgetResizable(True)
self.scrollable.setWidget(tw)
self.dock.setWindowTitle(__doc__)
self.dock.setStyleSheet('QDockWidget::title{text-align: center;}')
self.dock.setWidget(self.scrollable)
ExplorerContainer().addTab(self.dock, "Sphinx")
QPushButton(QIcon.fromTheme("help-about"), 'About', self.dock
).clicked.connect(lambda:
QMessageBox.information(self.dock, __doc__, HELPMSG))
def readOutput(self):
"""Read and append sphinx-build output to the logBrowser"""
self.output.append(str(self.process.readAllStandardOutput()))
def readErrors(self):
"""Read and append sphinx-build 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 build(self):
"""Main function calling sphinx-build to generate the project"""
self.output.setText('')
self.output.append(self.formatInfoMsg(
'INFO: OK: Starting at {}'.format(datetime.now())))
self.button.setDisabled(True)
self.sourceDirectory = str(self.inf.text()).strip()
self.outputDirectory = str(self.out.text()).strip()
if not len(self.sourceDirectory):
self.output.append(' ERROR: FAIL: Source directory cannot be empty')
else:
self.output.append(self.formatInfoMsg(
'INFO: OK: Source Directory is {}'.format(self.sourceDirectory)))
if not len(self.outputDirectory):
self.output.append(' ERROR: FAIL: Output directory cannot be empty')
else:
self.output.append(self.formatInfoMsg(
'INFO: OK: Output Directory is {}'.format(self.outputDirectory)))
if not(len(self.sourceDirectory) or len(self.outputDirectory)):
self.button.setDisabled(False)
return
self.output.append(self.formatInfoMsg('INFO:OK: Building. Please wait'))
args = ['-n' if self.chckbx2.isChecked() is True else '',
'-b', 'html', self.sourceDirectory, self.outputDirectory]
if len(self.fle.text()):
args.append(str(self.fle.text()).strip().replace('file:///', '/'))
self.output.append(self.formatInfoMsg(
'INFO: OK: Source Single File is {}'.format(self.fle.text())))
self.output.append(self.formatInfoMsg('INFO:OK: Running sphinx-build!'))
self.process.start('sphinx-build', args)
if not self.process.waitForStarted():
self.output.append(self.formatErrorMsg('ERROR: FAIL: Build Failed'))
self.output.append(self.formatErrorMsg(
'ERROR: FAIL: Failed with Arguments: {} '.format(args)))
self.button.setEnabled(True)
return
# write a .sh bash script file on target
if self.chckbx4.isChecked() is True:
sh_file = 'build_sphinx_documentation.sh'
with open(path.join(self.sourceDirectory, sh_file), 'w') as _sh:
self.output.append(self.formatInfoMsg('''INFO: OK: Writing Bash:
{}'''.format(path.join(self.sourceDirectory, sh_file))))
_sh.write('#!/usr/bin/env bash {}'.format(linesep) +
'sphinx-build {}'.format(' '.join(args)))
_sh.close()
self.output.append(self.formatInfoMsg('INFO: OK: Bash chmod: 775'))
try:
chmod(path.join(self.sourceDirectory, sh_file), 0775) # Py2
except:
chmod(path.join(self.sourceDirectory, sh_file), 0o775) # Py3
self.button.setEnabled(True)
def _process_finished(self):
"""sphinx-build finished sucessfully"""
self.output.append(self.formatInfoMsg(
'INFO: OK: Finished at {}'.format(datetime.now())))
if self.chckbx1.isChecked() is True:
with open(path.join(self.outputDirectory, '_static', 'default.css'),
'a') as f:
css = CSS3.replace('CSSWEBFONT', str(self.fontcss.currentText())
).replace('CSSBACKGR', str(self.backcss.currentText())
).replace('CSSCUSTOM', str(self.basecss.currentText()))
f.write(css)
f.close()
if self.chckbx3.isChecked() is True:
call('xdg-open ' + path.join(self.outputDirectory, 'index.html'),
shell=True)
def toggle_styles_group(self):
' toggle on or off the styles checkboxes '
try:
if self.chckbx1.isChecked() is True:
self.group3.graphicsEffect().setEnabled(False)
self.group3.setEnabled(True)
else:
self.group3.graphicsEffect().setEnabled(True)
self.group3.setEnabled(False)
except:
pass
