def contextMenuEvent(self, event):
menu = QMenu(self)
dc = QAction('Disconnect', None)
rc = QAction('Reconnect', None)
connectivity = QAction('Connection Test', None)
menu.addAction(connectivity)
about = QAction('About', None)
if self.state != ClientState.DISCONNECTED:
menu.addAction(dc)
if self.state != ClientState.ONLINE\
and self.state != ClientState.RECONNECTING:
menu.addAction(rc)
menu.addAction(about)
action = menu.exec_(self.mapToGlobal(event.pos()))
if action == dc:
self.disconnect_requested.emit()
elif action == rc:
self.reconnect_requested.emit()
elif action == connectivity:
self.connectivity_dialog_requested.emit()
elif action == about:
self.about_dialog_requested.emit()
def customContext(self, pos):
index = self.listView.indexAt(pos)
index = self.proxyModel.mapToSource(index)
if not index.isValid():
self.rmAction.setEnabled(False)
self.openAction.setEnabled(False)
self.loadAction.setEnabled(False)
elif not self.model.isDir(index):
info = self.model.fileInfo(index)
suffix = info.suffix()
if suffix in ("Rd","Rdata","RData"):
self.loadAction.setEnabled(True)
self.openAction.setEnabled(False)
self.loadExternal.setEnabled(False)
elif suffix in ("txt","csv","R","r"):
self.openAction.setEnabled(True)
self.loadAction.setEnabled(False)
self.loadExternal.setEnabled(True)
else:
self.loadAction.setEnabled(False)
self.openAction.setEnabled(False)
self.loadExternal.setEnabled(True)
menu = QMenu(self)
for action in self.actions:
menu.addAction(action)
menu.exec_(self.listView.mapToGlobal(pos))
def prepareContextMenu(self):
context_menu = QMenu(self)
var = self.selectionModel().currentIndex().internalPointer()
if isinstance(var, TreeStdVariable):
filters.add_actions_for_all_filters(context_menu.addMenu(
"Set Filter for %s..." % var.exp), var)
return context_menu
def contextMenuRequested(point):
" quick and dirty custom context menu "
menu = QMenu()
menu.addActions(
(
qaqq,
qamin,
qanor,
qamax,
qasrc,
qakb,
qacol,
qati,
qasb,
qatb,
qatim,
qatit,
qafnt,
qapic,
qadoc,
qali,
qaslf,
qaqt,
qapy,
qabug,
)
)
menu.exec_(self.mapToGlobal(point))
def create_contextmenu(self):
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.listMenu = QMenu()
self.listMenu1 = QMenu("下载控制")
self.playAction = QAction("播放", self)
self.pauseDownloadAction = QAction("暂停", self)
self.stopDownloadAction = QAction("取消下载", self)
self.startDownloadAction = QAction("开始", self)
self.pauseAllAction = QAction("暂停全部", self)
self.startAllAction = QAction("开始全部", self)
self.stopAllAction = QAction("取消全部", self)
self.removeRowsAction = QAction("移除选中项", self)
self.clearTableAction = QAction("清空列表", self)
self.listMenu1.addAction(self.startDownloadAction)
self.listMenu1.addAction(self.startAllAction)
self.listMenu1.addSeparator()
self.listMenu1.addAction(self.pauseDownloadAction)
self.listMenu1.addAction(self.pauseAllAction)
self.listMenu1.addSeparator()
self.listMenu1.addAction(self.stopDownloadAction)
# self.listMenu.addAction(self.stopAllAction)
self.listMenu.addAction(self.playAction)
self.listMenu.addSeparator()
self.listMenu.addMenu(self.listMenu1)
self.listMenu.addSeparator()
self.listMenu.addAction(self.removeRowsAction)
self.listMenu.addAction(self.clearTableAction)
def showSnippets(self, evt):
popupmenu = QMenu()
for name, snippet in self.snippets.iteritems():
action = QAction(self.tr(name), self.btnSnippets)
action.triggered[()].connect(lambda snippet=snippet: self.editor.insert(snippet))
popupmenu.addAction(action)
popupmenu.exec_(QCursor.pos())
def slot_transportViewMenu(self_):
menu = QMenu(self_)
act_t_hms = menu.addAction("Hours:Minutes:Seconds")
act_t_bbt = menu.addAction("Beat:Bar:Tick")
act_t_fr = menu.addAction("Frames")
act_t_hms.setCheckable(True)
act_t_bbt.setCheckable(True)
act_t_fr.setCheckable(True)
if self_.m_selected_transport_view == TRANSPORT_VIEW_HMS:
act_t_hms.setChecked(True)
elif self_.m_selected_transport_view == TRANSPORT_VIEW_BBT:
act_t_bbt.setChecked(True)
elif self_.m_selected_transport_view == TRANSPORT_VIEW_FRAMES:
act_t_fr.setChecked(True)
act_selected = menu.exec_(QCursor().pos())
if act_selected == act_t_hms:
setTransportView(self_, TRANSPORT_VIEW_HMS)
elif act_selected == act_t_bbt:
setTransportView(self_, TRANSPORT_VIEW_BBT)
elif act_selected == act_t_fr:
setTransportView(self_, TRANSPORT_VIEW_FRAMES)
def __init__(self):
QWidget.__init__(self)
self._line_edit = ClearableLineEdit()
self._calendar_button = QToolButton()
self._calendar_button.setPopupMode(QToolButton.InstantPopup)
self._calendar_button.setFixedSize(26, 26)
self._calendar_button.setAutoRaise(True)
self._calendar_button.setIcon(resourceIcon("calendar.png"))
self._calendar_button.setStyleSheet("QToolButton::menu-indicator { image: none; }")
tool_menu = QMenu(self._calendar_button)
self._calendar_widget = QCalendarWidget(tool_menu)
action = QWidgetAction(tool_menu)
action.setDefaultWidget(self._calendar_widget)
tool_menu.addAction(action)
self._calendar_button.setMenu(tool_menu)
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self._line_edit)
layout.addWidget(self._calendar_button)
self.setLayout(layout)
self._calendar_widget.activated.connect(self.setDate)
class centro(QGraphicsPixmapItem):
def __init__(self, *args):
QGraphicsPixmapItem.__init__(self, *args)
self.setPixmap(QPixmap("sprites/calle/centro.png"))
self.setTransformOriginPoint(self.boundingRect().width()/2.0,self.boundingRect().height()/2.0)
self.setZValue(1)
self.menu = QMenu()
self.Actions =[] #arreglo de acciones
self.Actions.append( self.menu.addAction("girar clockwise") )
self.Actions.append( self.menu.addAction("girar anti-clockwise") )
self.Actions.append( self.menu.addAction("Duplicar") )
self.Actions.append( self.menu.addAction("Eliminar") )
self.menu.triggered[QAction].connect(self.test)
self.offset=QPointF(0,0)
def test(self,act):
print act.text()
if act.text()=="girar clockwise":
self.setRotation(self.rotation()-45)
if act.text()=="girar anti-clockwise":
self.setRotation(self.rotation()+45)
if act.text()=="Duplicar":
self.scene().addItem(centro())
if act.text()=="Eliminar":
self.scene().removeItem(self)
def contextMenuEvent(self,event):
self.menu.popup(event.screenPos())
def mousePressEvent(self, event):
p = event.pos()
self.offset= QPointF(p.x()*1.0,p.y()*1.0)
def mouseMoveEvent(self, event):
#print self.offset,event.scenePos()
self.setPos(event.scenePos()-self.offset)
class BaseTabs(QTabWidget):
def __init__(self, parent, actions=None, menu=None):
QTabWidget.__init__(self, parent)
if menu is None:
self.menu = QMenu(self)
if actions:
add_actions(self.menu, actions)
else:
self.menu = menu
def contextMenuEvent(self, event):
"""Override Qt method"""
if self.menu:
self.menu.popup(event.globalPos())
def mousePressEvent(self, event):
"""Override Qt method"""
if event.button() == Qt.MidButton:
index = self.tabBar().tabAt(event.pos())
if index >= 0:
self.emit(SIGNAL("close_tab(int)"), index)
event.accept()
return
QTabWidget.mousePressEvent(self, event)
def keyPressEvent(self, event):
"""Override Qt method"""
ctrl = event.modifiers() & Qt.ControlModifier
key = event.key()
handled = False
if ctrl and self.count() > 0:
index = self.currentIndex()
if key == Qt.Key_PageUp and index > 0:
self.setCurrentIndex(index-1)
handled = True
elif key == Qt.Key_PageDown and index < self.count()-1:
self.setCurrentIndex(index+1)
handled = True
if handled:
event.accept()
else:
QTabWidget.keyPressEvent(self, event)
def set_close_function(self, func):
"""Setting Tabs close function
None -> tabs are not closable"""
state = func is not None
if state:
self.connect(self, SIGNAL("close_tab(int)"), func)
try:
# Assuming Qt >= 4.5
QTabWidget.setTabsClosable(self, state)
self.connect(self, SIGNAL("tabCloseRequested(int)"), func)
except AttributeError:
# Workaround for Qt < 4.5
close_button = create_toolbutton(self, triggered=func,
icon=get_icon("fileclose.png"),
tip=translate("Tabs",
"Close current tab"))
self.setCornerWidget(close_button if state else None)
def __init__(self, parent, mainWindow, tags, selectItem = None):
QMenu.__init__(self, tags, parent)
self.tags = tags
self.__mainWindow = mainWindow
self.callbackSelected = selectItem
self.loader = loader.loader()
self.Load()
class FilterSetWidget(QWidget, Ui_FilterSetWidget):
def __init__(self, parent=None):
super(FilterSetWidget, self).__init__(parent)
self.setupUi(self)
self._filterSetActionGroup = QActionGroup(self)
self._filterSetActionGroup.addAction(self.saveFilterSetAction)
self._filterSetActionGroup.addAction(self.reloadFilterSetAction)
self._filterSetActionGroup.addAction(self.deleteFilterSetAction)
self._filterSetActionGroup.addAction(self.exportFilterSetAction)
self._filterSetMenu = QMenu(self)
self._filterSetMenu.addActions(self._filterSetActionGroup.actions())
self.filterSetTool.setMenu(self._filterSetMenu)
self.filterSetTool.setDefaultAction(self.saveFilterSetAction)
def setFilterSet(self, filterSet):
self.setFilterSetKey(filterSet.key)
if filterSet.source == 'ark':
self.saveFilterSetAction.setEnabled(False)
self.deleteFilterSetAction.setEnabled(False)
self.filterSetTool.setDefaultAction(self.reloadFilterSetAction)
else:
self.saveFilterSetAction.setEnabled(True)
self.deleteFilterSetAction.setEnabled(True)
self.filterSetTool.setDefaultAction(self.saveFilterSetAction)
def setFilterSetKey(self, key):
self.filterSetCombo.setCurrentIndex(self.filterSetCombo.findData(key))
def currentFilterSetKey(self):
return self.filterSetCombo.itemData(self.filterSetCombo.currentIndex())
def currentFilterSetName(self):
return self.filterSetCombo.currentText()
def __showPyflakesContextMenu( self, pos ):
" Triggered when the icon context menu is requested "
if self.__currentUUID is None:
return
if self.__currentUUID not in self.__flakesResults:
return
messages = self.__flakesResults[ self.__currentUUID ].messages
if not messages:
return
# Check that there is at least one non -1 lineno message
foundLinedMessage = False
for item in messages:
if item[ 1 ] != -1:
foundLinedMessage = True
break
if not foundLinedMessage:
return
# OK, we have something to show
contextMenu = QMenu( self.__uiLabel )
for item in messages:
act = contextMenu.addAction(
PixmapCache().getIcon( 'pyflakesmsgmarker.png' ),
"Line " + str( item[ 1 ] ) + ": " + item[ 0 ] )
act.setData( QVariant( item[ 1 ] ) )
self.connect( contextMenu, SIGNAL( "triggered(QAction*)" ),
self.__onContextMenu )
contextMenu.popup( self.__uiLabel.mapToGlobal( pos ) )
return
def create_menubar(self):
# Create File Menu
self.fileMenu = QMenu("&File")
self.fileMenu.addAction(self.mbNew)
self.fileMenu.addAction(self.mbOpen)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.mbSave)
self.fileMenu.addAction(self.mbSaveAs)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.mbClose)
self.fileMenu.addAction(self.mbExit)
# Create Script Menu
self.scriptMenu = QMenu("&Script")
self.scriptMenu.addAction(self.mbRun)
self.scriptMenu.addAction(self.mbStop)
self.scriptMenu.addAction(self.mbDebug)
# Create Help Menu
self.helpMenu = QMenu("&Help")
self.helpMenu.addAction(self.mbHelp)
self.helpMenu.addAction(self.mbAbout)
# Add menus to menubar
menubar = self.menuBar()
menubar.addMenu(self.fileMenu)
menubar.addMenu(self.scriptMenu)
menubar.addMenu(self.helpMenu)
def set_menu_registry(self, menu_registry):
self.menu_registry = menu_registry
for menu_instance in self.menu_registry.menus():
try:
menu_instance.setCanvasMainWindow(self)
custom_menu = QMenu(menu_instance.name, self)
sub_menus = menu_instance.getSubMenuNamesList()
for index in range(0, len(sub_menus)):
if menu_instance.isSeparator(sub_menus[index]):
custom_menu.addSeparator()
else:
custom_action = \
QAction(sub_menus[index], self,
objectName=sub_menus[index].lower() + "-action",
toolTip=self.tr(sub_menus[index]),
)
custom_action.triggered.connect(getattr(menu_instance, 'executeAction_' + str(index+1)))
custom_menu.addAction(custom_action)
self.menuBar().addMenu(custom_menu)
except Exception as exception:
print("Error in creating Customized Menu: " + str(menu_instance))
print(str(exception.args[0]))
continue
class TabNavigator(QWidget):
def __init__(self):
QWidget.__init__(self)
self.setContextMenuPolicy(Qt.DefaultContextMenu)
self.setMinimumHeight(38)
hbox = QHBoxLayout(self)
self.btnPrevious = QPushButton(QIcon(resources.IMAGES["nav-code-left"]), "")
self.btnPrevious.setToolTip(self.tr("Right click to change navigation options"))
styles.set_style(self.btnPrevious, "tab-navigator")
self.btnNext = QPushButton(QIcon(resources.IMAGES["nav-code-right"]), "")
self.btnNext.setToolTip(self.tr("Right click to change navigation options"))
styles.set_style(self.btnNext, "tab-navigator")
hbox.addWidget(self.btnPrevious)
hbox.addWidget(self.btnNext)
self.setContentsMargins(0, 0, 0, 0)
self.menuNavigate = QMenu(self.tr("Navigate"))
self.codeAction = self.menuNavigate.addAction(self.tr("Code Jumps"))
self.codeAction.setCheckable(True)
self.codeAction.setChecked(True)
self.bookmarksAction = self.menuNavigate.addAction(self.tr("Bookmarks"))
self.bookmarksAction.setCheckable(True)
self.breakpointsAction = self.menuNavigate.addAction(self.tr("Breakpoints"))
self.breakpointsAction.setCheckable(True)
# 0 = Code Jumps
# 1 = Bookmarks
# 2 = Breakpoints
self.operation = 0
self.connect(self.codeAction, SIGNAL("triggered()"), self._show_code_nav)
self.connect(self.breakpointsAction, SIGNAL("triggered()"), self._show_breakpoints)
self.connect(self.bookmarksAction, SIGNAL("triggered()"), self._show_bookmarks)
def contextMenuEvent(self, event):
self.menuNavigate.exec_(event.globalPos())
def _show_bookmarks(self):
self.btnPrevious.setIcon(QIcon(resources.IMAGES["book-left"]))
self.btnNext.setIcon(QIcon(resources.IMAGES["book-right"]))
self.bookmarksAction.setChecked(True)
self.breakpointsAction.setChecked(False)
self.codeAction.setChecked(False)
self.operation = 1
def _show_breakpoints(self):
self.btnPrevious.setIcon(QIcon(resources.IMAGES["break-left"]))
self.btnNext.setIcon(QIcon(resources.IMAGES["break-right"]))
self.bookmarksAction.setChecked(False)
self.breakpointsAction.setChecked(True)
self.codeAction.setChecked(False)
self.operation = 2
def _show_code_nav(self):
self.btnPrevious.setIcon(QIcon(resources.IMAGES["nav-code-left"]))
self.btnNext.setIcon(QIcon(resources.IMAGES["nav-code-right"]))
self.bookmarksAction.setChecked(False)
self.breakpointsAction.setChecked(False)
self.codeAction.setChecked(True)
self.operation = 0
def menu_button(self, main_action_id, ids, widget):
'''
Creates an :obj:`.OWButton` with a popup-menu and adds it to the parent ``widget``.
'''
id, name, attr_name, attr_value, callback, icon_name = self._expand_id(main_action_id)
b = OWButton(parent=widget)
m = QMenu(b)
b.setMenu(m)
b._actions = {}
QObject.connect(m, SIGNAL("triggered(QAction*)"), b, SLOT("setDefaultAction(QAction*)"))
if main_action_id:
main_action = OWAction(self._plot, icon_name, attr_name, attr_value, callback, parent=b)
QObject.connect(m, SIGNAL("triggered(QAction*)"), main_action, SLOT("trigger()"))
for id in ids:
id, name, attr_name, attr_value, callback, icon_name = self._expand_id(id)
a = OWAction(self._plot, icon_name, attr_name, attr_value, callback, parent=m)
m.addAction(a)
b._actions[id] = a
if m.actions():
b.setDefaultAction(m.actions()[0])
elif main_action_id:
b.setDefaultAction(main_action)
b.setPopupMode(QToolButton.MenuButtonPopup)
b.setMinimumSize(40, 30)
return b
def contextMenuEvent(self, event):
popup_menu = self.createStandardContextMenu()
menu_lint = QMenu(self.tr("Ignore Lint"))
ignoreLineAction = menu_lint.addAction(
self.tr("Ignore This Line"))
ignoreSelectedAction = menu_lint.addAction(
self.tr("Ignore Selected Area"))
self.connect(ignoreLineAction, SIGNAL("triggered()"),
lambda: helpers.lint_ignore_line(self))
self.connect(ignoreSelectedAction, SIGNAL("triggered()"),
lambda: helpers.lint_ignore_selection(self))
popup_menu.insertSeparator(popup_menu.actions()[0])
popup_menu.insertMenu(popup_menu.actions()[0], menu_lint)
popup_menu.insertAction(popup_menu.actions()[0],
self.__actionFindOccurrences)
#add extra menus (from Plugins)
lang = file_manager.get_file_extension(self.ID)
extra_menus = self.EXTRA_MENU.get(lang, None)
if extra_menus:
popup_menu.addSeparator()
for menu in extra_menus:
popup_menu.addMenu(menu)
#show menu
popup_menu.exec_(event.globalPos())
def __init__(self, main_window):
self.main_window = main_window
QMenu.__init__(self, '&Tracks', main_window)
self.addAction('&Add', self.add_track)
self.addAction('&Remove', self.remove_track)
self.addAction('&Merge', self.merge_tracks)
self.addAction('&Set Index', self.set_index)
def __init__(self, titre='', liste=None, fonction=None, aide=''):
QMenu.__init__(self, titre)
# self.parent = parent
self.fonction = None
# self.titre = titre
# self.setTitle(titre)
self.update(liste, fonction, aide)
def contextMenuEvent(self, event):
menu = QMenu(self)
Action = menu.addAction("print selected rows")
Action.triggered.connect(self.printName)
menu.exec_(event.globalPos())
def create_menu_switch_sink(self):
sink_menu = QMenu(i18n("Move To"), self.popup_menu)
sinks = self.veromix.get_sink_widgets()
for sink in sinks:
action = QAction(sink.name(), self.popup_menu)
sink_menu.addAction(action)
self.popup_menu.addMenu(sink_menu)
def right_click(self, type, champ):
u"Retourne une fonction qui sera executée lors d'un clic avec le bouton du milieu sur le champ 'champ'."
champ.setFocus()
plusieurs = isinstance(type, list)
if plusieurs:
type = type[0]
liste_objets = self.onglet_actuel.feuille_actuelle.objets.lister(False, type = type)
liste_objets.sort(key = attrgetter('nom')) # ordre alphabétique
if not liste_objets:
return
menu = QMenu()
for obj in liste_objets:
action = menu.addAction(obj.nom_complet)
action.nom = obj.nom
action = menu.exec_()
if action:
if plusieurs:
# le champ doit contenir non pas un objet, mais une liste d'objets
val = champ.text().strip()
if val:
if not val.endswith(","):
val += ","
val += " "
champ.setText(val + action.nom)
else:
# le champ contient un seul objet
champ.setText(action.nom)
def setup_context_menu(self):
self.menuFilter = QMenu(self)
self.hide_action = QAction('Hide selected values', self)
self.show_only_action = QAction('Show only selected values', self)
self.clear_all_filters_action = QAction('Clear all filters', self)
self.copy_selection_action = QAction('Copy selection', self)
self.unhide_menu = QMenu('Unhide item from selected column', self.menuFilter)
self.hide_action.triggered.connect(self.hide_rows_based_on_selected_cells)
self.show_only_action.triggered.connect(self.show_rows_based_on_selected_cells)
self.clear_all_filters_action.triggered.connect(self.clear_all_filters)
self.copy_selection_action.triggered.connect(self.prepare_clipboard_text)
self.menuFilter.addAction(self.hide_action)
self.menuFilter.addMenu(self.unhide_menu)
self.menuFilter.addAction(self.show_only_action)
self.menuFilter.addAction(self.clear_all_filters_action)
self.menuFilter.addSeparator()
self.menuFilter.addAction(self.copy_selection_action)
self.hide_action.setShortcut('Ctrl+H')
self.show_only_action.setShortcut('Ctrl+O')
self.clear_all_filters_action.setShortcut('Ctrl+Del')
self.copy_selection_action.setShortcut("Ctrl+C")
def contextMenuEvent(self, event):
menu = QMenu(self)
Action = menu.addAction("delete row")
Action.triggered.connect(self.deleteRow)
menu.exec_(event.globalPos())
def contextMenuEvent(self, event):
if event.reason() == event.Mouse:
pos = event.globalPos()
item = self.itemAt(event.pos())
else:
pos = None
selection = self.selectedItems()
if selection:
item = selection[0]
else:
item = self.currentItem()
if item is None:
item = self.invisibleRootItem().child(0)
if item is not None:
parent = item.parent()
while parent is not None:
parent.setExpanded(True)
parent = parent.parent()
itemrect = self.visualItemRect(item)
portrect = self.viewport().rect()
if not portrect.contains(itemrect.topLeft()):
self.scrollToItem(
item, QTreeWidget.PositionAtCenter)
itemrect = self.visualItemRect(item)
itemrect.setLeft(portrect.left())
itemrect.setWidth(portrect.width())
pos = self.mapToGlobal(itemrect.center())
if pos is not None:
menu = QMenu(self)
menu.addAction(item.text(0))
menu.popup(pos)
event.accept()
def slot_transportViewMenu(self):
menu = QMenu(self)
actHMS = menu.addAction("Hours:Minutes:Seconds")
actBBT = menu.addAction("Beat:Bar:Tick")
actFrames = menu.addAction("Frames")
actHMS.setCheckable(True)
actBBT.setCheckable(True)
actFrames.setCheckable(True)
if self.fCurTransportView == TRANSPORT_VIEW_HMS:
actHMS.setChecked(True)
elif self.fCurTransportView == TRANSPORT_VIEW_BBT:
actBBT.setChecked(True)
elif self.fCurTransportView == TRANSPORT_VIEW_FRAMES:
actFrames.setChecked(True)
actSelected = menu.exec_(QCursor().pos())
if actSelected == actHMS:
self.setTransportView(TRANSPORT_VIEW_HMS)
elif actSelected == actBBT:
self.setTransportView(TRANSPORT_VIEW_BBT)
elif actSelected == actFrames:
self.setTransportView(TRANSPORT_VIEW_FRAMES)
def __init__(self, parent, plot):
QMenu.__init__(self, plot.name(), parent)
color_menu = CurveColorMenu(self,plot)
marker_menu = CurveMarkerMenu(self,plot)
self.addMenu(color_menu)
self.addMenu(marker_menu)
self.addAction('&Remove', lambda: parent.track.remove_plot(plot))
def __createContextMenu( self ):
" Creates context menu for the table raws "
self.__contextMenu = QMenu( self )
self.__callersMenu = QMenu( "Callers", self )
self.__outsideCallersMenu = QMenu( "Outside callers", self )
self.__calleesMenu = QMenu( "Callees", self )
self.__outsideCalleesMenu = QMenu( "Outside callees", self )
self.__contextMenu.addMenu( self.__callersMenu )
self.__contextMenu.addMenu( self.__outsideCallersMenu )
self.__contextMenu.addSeparator()
self.__contextMenu.addMenu( self.__calleesMenu )
self.__contextMenu.addMenu( self.__outsideCalleesMenu )
self.__contextMenu.addSeparator()
self.__disasmAct = self.__contextMenu.addAction(
PixmapCache().getIcon( 'disasmmenu.png' ),
"Disassemble", self.__onDisassemble )
self.__callersMenu.triggered.connect( self.__onCallContextMenu )
self.__outsideCallersMenu.triggered.connect( self.__onCallContextMenu )
self.__calleesMenu.triggered.connect( self.__onCallContextMenu )
self.__outsideCalleesMenu.triggered.connect( self.__onCallContextMenu )
self.__table.setContextMenuPolicy( Qt.CustomContextMenu )
self.__table.customContextMenuRequested.connect( self.__showContextMenu )
return
class ScripterMenu(QObject):
"""
Scripter menu item in mainWindow menubar
"""
def __init__(self, parent):
QObject.__init__(self, parent)
self.setObjectName("Menu")
self.popup = QMenu(i18n("Scripter"))
MenuHooks().insertMenuAfter("E&xtras", self.popup)
self._load_entries()
def _load_entries(self):
for path in [scripter_path, os.path.expanduser("~/.scribus/scripter/")]:
autoload_path = os.path.join(path, "autoload")
if not os.path.exists(autoload_path):
continue
sys.path.insert(0, autoload_path)
from scribusscript import load_scripts
self.autoload_scripts = scripts = load_scripts(autoload_path)
for sd in scripts:
try:
sd.install()
except:
excepthook.show_current_error(i18n("Error installing %r") % sd.name)
def addAction(self, title, callback, *args):
self.popup.addAction(title, callback, *args)
def addSeparator(self):
self.popup.addSeparator()
def onPopupMenu(self, pos):
"""
Display menu on right click
@param pos:
@type pos:
"""
self.menu = QMenu(self)
# index = self.currentIndex()
# get defaults adapters or extra
adapters_default = self.getHelpAdapters()
# get generic adapters
adapters_generic = self.getHelpAdapters(generic=True)
# main menu
menu_adps = QMenu("Add Adapters", self)
# adapters default
menu_adps_generic = QMenu("Generic", self)
menu_adps.addMenu(menu_adps_generic)
if adapters_generic is not None:
for adp in adapters_generic:
adp_menu_generic = QMenu(adp['name'], self)
menu_adps_generic.addMenu(adp_menu_generic)
for cls in adp['classes']:
# extract __init__ function only
fct = None
for fct in cls['functions']:
if fct['name'] == '__init__':
break
if fct is not None:
argsFct = self.parseDocString(docstring=fct['desc'])
argsFct['function'] = "%s::%s" % (adp['name'],cls['name'])
argsFct['main-name'] = "%s" % adp['name']
argsFct['sub-name'] = "%s" % cls['name']
argsFct['is-default'] = "False"
argsFct['is-generic'] = "True"
if 'default-args' in fct:
self.addDefaultValues(defaultValues=fct['default-args'],
currentFunction=argsFct)
adp_menu_generic.addAction(QtHelper.createAction(self,
cls['name'],
self.addAdapter,
cb_arg=argsFct ))
# adapters default
menu_adps_default = QMenu("Extra", self)
menu_adps.addMenu(menu_adps_default)
if adapters_default is not None:
for adp in adapters_default:
adp_menu_default = QMenu(adp['name'], self)
menu_adps_default.addMenu(adp_menu_default)
for cls in adp['classes']:
# extract __init__ function only
fct = None
for fct in cls['functions']:
if fct['name'] == '__init__':
break
if fct is not None:
argsFct = self.parseDocString(docstring=fct['desc'])
argsFct['function'] = "%s::%s" % (adp['name'],cls['name'])
argsFct['main-name'] = "%s" % adp['name']
argsFct['sub-name'] = "%s" % cls['name']
argsFct['is-default'] = "True"
argsFct['is-generic'] = "False"
if 'default-args' in fct:
self.addDefaultValues(defaultValues=fct['default-args'],
currentFunction=argsFct)
adp_menu_default.addAction(QtHelper.createAction(self,
cls['name'],
self.addAdapter,
cb_arg=argsFct ))
indexes = self.selectedIndexes()
if not indexes:
self.delAction.setEnabled(False)
self.menu.addAction( self.delAction )
self.menu.addSeparator()
self.menu.addMenu( menu_adps )
self.menu.addSeparator()
else:
self.delAction.setEnabled(True)
self.menu.addAction( self.delAction )
self.menu.addSeparator()
self.menu.addMenu( menu_adps )
self.menu.addSeparator()
self.menu.popup( self.mapToGlobal(pos) )
class Qgis2threejsDialog(QDialog):
def __init__(self,
iface,
objectTypeManager,
pluginManager,
exportSettings=None,
lastTreeItemData=None):
QDialog.__init__(self, iface.mainWindow())
self.iface = iface
self.objectTypeManager = objectTypeManager
self.pluginManager = pluginManager
self._settings = exportSettings or {}
self.lastTreeItemData = lastTreeItemData
self.localBrowsingMode = True
self.rb_quads = self.rb_point = None
self.templateType = None
self.currentItem = None
self.currentPage = None
# Set up the user interface from Designer.
self.ui = ui = Ui_Qgis2threejsDialog()
ui.setupUi(self)
self.setWindowFlags(self.windowFlags() | Qt.WindowMinimizeButtonHint)
# output html filename
ui.lineEdit_OutputFilename.setText(
self._settings.get("OutputFilename", ""))
ui.lineEdit_OutputFilename.setPlaceholderText("[Temporary file]")
# settings button
icon = QIcon(os.path.join(tools.pluginDir(), "icons", "settings.png"))
ui.toolButton_Settings.setIcon(icon)
# popup menu displayed when settings button is pressed
items = [["Load Settings...", self.loadSettings],
["Save Settings As...", self.saveSettings], [None, None],
["Clear Settings", self.clearSettings], [None, None],
["Plugin Settings...", self.pluginSettings]]
self.menu = QMenu()
self.menu_actions = []
for text, slot in items:
if text:
action = QAction(text, iface.mainWindow())
action.triggered.connect(slot)
self.menu.addAction(action)
self.menu_actions.append(action)
else:
self.menu.addSeparator()
ui.toolButton_Settings.setMenu(self.menu)
ui.toolButton_Settings.setPopupMode(QToolButton.InstantPopup)
# progress bar and message label
ui.progressBar.setVisible(False)
ui.label_MessageIcon.setVisible(False)
# buttons
ui.pushButton_Run.clicked.connect(self.run)
ui.pushButton_Close.clicked.connect(self.reject)
ui.pushButton_Help.clicked.connect(self.help)
# set up map tool
self.previousMapTool = None
self.mapTool = RectangleMapTool(iface.mapCanvas())
#self.mapTool = PointMapTool(iface.mapCanvas())
# set up the template combo box
self.initTemplateList()
self.ui.comboBox_Template.currentIndexChanged.connect(
self.currentTemplateChanged)
# set up the properties pages
self.pages = {}
self.pages[ppages.PAGE_WORLD] = ppages.WorldPropertyPage(self)
self.pages[ppages.PAGE_CONTROLS] = ppages.ControlsPropertyPage(self)
self.pages[ppages.PAGE_DEM] = ppages.DEMPropertyPage(self)
self.pages[ppages.PAGE_VECTOR] = ppages.VectorPropertyPage(self)
container = ui.propertyPagesContainer
for page in self.pages.itervalues():
page.hide()
container.addWidget(page)
# build object tree
self.topItemPages = {
ObjectTreeItem.ITEM_WORLD: ppages.PAGE_WORLD,
ObjectTreeItem.ITEM_CONTROLS: ppages.PAGE_CONTROLS,
ObjectTreeItem.ITEM_DEM: ppages.PAGE_DEM
}
self.initObjectTree()
self.ui.treeWidget.currentItemChanged.connect(
self.currentObjectChanged)
self.ui.treeWidget.itemChanged.connect(self.objectItemChanged)
self.currentTemplateChanged() # update item visibility
ui.toolButton_Browse.clicked.connect(self.browseClicked)
#iface.mapCanvas().mapToolSet.connect(self.mapToolSet) # to show button to enable own map tool
def settings(self, clean=False):
# save settings of current panel
item = self.ui.treeWidget.currentItem()
if item and self.currentPage:
self.saveProperties(item, self.currentPage)
# plugin version
self._settings["PluginVersion"] = plugin_version
# template and output html file path
self._settings["Template"] = self.ui.comboBox_Template.currentText()
self._settings[
"OutputFilename"] = self.ui.lineEdit_OutputFilename.text()
if not clean:
return self._settings
# clean up settings - remove layers that don't exist in the layer registry
registry = QgsMapLayerRegistry.instance()
for itemId in [
ObjectTreeItem.ITEM_OPTDEM, ObjectTreeItem.ITEM_POINT,
ObjectTreeItem.ITEM_LINE, ObjectTreeItem.ITEM_POLYGON
]:
parent = self._settings.get(itemId, {})
for layerId in parent.keys():
if registry.mapLayer(layerId) is None:
del parent[layerId]
return self._settings
def setSettings(self, settings):
self._settings = settings
# template and output html file path
templateName = settings.get("Template")
if templateName:
cbox = self.ui.comboBox_Template
index = cbox.findText(templateName)
if index != -1:
cbox.setCurrentIndex(index)
filename = settings.get("OutputFilename")
if filename:
self.ui.lineEdit_OutputFilename.setText(filename)
# update object tree
self.ui.treeWidget.blockSignals(True)
self.initObjectTree()
self.ui.treeWidget.blockSignals(False)
# update tree item visibility
self.templateType = None
self.currentTemplateChanged()
def loadSettings(self):
# file open dialog
directory = QgsProject.instance().homePath()
if not directory:
directory = os.path.split(
self.ui.lineEdit_OutputFilename.text())[0]
if not directory:
directory = QDir.homePath()
filterString = "Settings files (*.qto3settings);;All files (*.*)"
filename = QFileDialog.getOpenFileName(self, "Load Export Settings",
directory, filterString)
if not filename:
return
# load settings from file (.qto3settings)
import json
with open(filename) as f:
settings = json.load(f)
self.setSettings(settings)
def saveSettings(self, filename=None):
if not filename:
# file save dialog
directory = QgsProject.instance().homePath()
if not directory:
directory = os.path.split(
self.ui.lineEdit_OutputFilename.text())[0]
if not directory:
directory = QDir.homePath()
filename = QFileDialog.getSaveFileName(
self, "Save Export Settings", directory,
"Settings files (*.qto3settings)")
if not filename:
return
# append .qto3settings extension if filename doesn't have
if os.path.splitext(filename)[1].lower() != ".qto3settings":
filename += ".qto3settings"
# save settings to file (.qto3settings)
import codecs
import json
with codecs.open(filename, "w", "UTF-8") as f:
json.dump(self.settings(True),
f,
ensure_ascii=False,
indent=2,
sort_keys=True)
logMessage(u"Settings saved: {0}".format(filename))
def clearSettings(self):
if QMessageBox.question(self, "Qgis2threejs",
"Are you sure to clear all export settings?",
QMessageBox.Ok
| QMessageBox.Cancel) == QMessageBox.Ok:
self.setSettings({})
def pluginSettings(self):
from settingsdialog import SettingsDialog
dialog = SettingsDialog(self)
if dialog.exec_():
self.pluginManager.reloadPlugins()
self.pages[ppages.PAGE_DEM].initLayerComboBox()
def showMessageBar(self, text, level=QgsMessageBar.INFO):
# from src/gui/qgsmessagebaritem.cpp
if level == QgsMessageBar.CRITICAL:
msgIcon = "/mIconCritical.png"
bgColor = "#d65253"
elif level == QgsMessageBar.WARNING:
msgIcon = "/mIconWarn.png"
bgColor = "#ffc800"
else:
msgIcon = "/mIconInfo.png"
bgColor = "#e7f5fe"
stylesheet = "QLabel {{ background-color:{0}; }}".format(bgColor)
label = self.ui.label_MessageIcon
label.setPixmap(QgsApplication.getThemeIcon(msgIcon).pixmap(24))
label.setStyleSheet(stylesheet)
label.setVisible(True)
label = self.ui.label_Status
label.setText(text)
label.setStyleSheet(stylesheet)
def clearMessageBar(self):
self.ui.label_MessageIcon.setVisible(False)
self.ui.label_Status.setText("")
self.ui.label_Status.setStyleSheet(
"QLabel { background-color: rgba(0, 0, 0, 0); }")
def initTemplateList(self):
cbox = self.ui.comboBox_Template
cbox.clear()
templateDir = QDir(tools.templateDir())
for i, entry in enumerate(templateDir.entryList(["*.html", "*.htm"])):
cbox.addItem(entry)
config = tools.getTemplateConfig(entry)
# get template type
templateType = config.get("type", "plain")
cbox.setItemData(i, templateType, Qt.UserRole)
# set tool tip text
desc = config.get("description", "")
if desc:
cbox.setItemData(i, desc, Qt.ToolTipRole)
# select the template of the settings
templatePath = self._settings.get("Template")
# if no template setting, select the last used template
if not templatePath:
templatePath = QSettings().value("/Qgis2threejs/lastTemplate",
def_vals.template,
type=unicode)
if templatePath:
index = cbox.findText(templatePath)
if index != -1:
cbox.setCurrentIndex(index)
return index
return -1
def initObjectTree(self):
tree = self.ui.treeWidget
tree.clear()
# add vector and raster layers into tree widget
topItems = {}
for id, name in zip(ObjectTreeItem.topItemIds,
ObjectTreeItem.topItemNames):
item = QTreeWidgetItem(tree, [name])
item.setData(0, Qt.UserRole, id)
topItems[id] = item
optDEMChecked = False
for layer in self.iface.legendInterface().layers():
parentId = ObjectTreeItem.parentIdByLayer(layer)
if parentId is None:
continue
item = QTreeWidgetItem(topItems[parentId], [layer.name()])
isVisible = self._settings.get(parentId, {}).get(
layer.id(), {}).get(
"visible",
False) #self.iface.legendInterface().isLayerVisible(layer)
check_state = Qt.Checked if isVisible else Qt.Unchecked
item.setData(0, Qt.CheckStateRole, check_state)
item.setData(0, Qt.UserRole, layer.id())
if parentId == ObjectTreeItem.ITEM_OPTDEM and isVisible:
optDEMChecked = True
for id, item in topItems.iteritems():
if id != ObjectTreeItem.ITEM_OPTDEM or optDEMChecked:
tree.expandItem(item)
# disable additional DEM item which is selected as main DEM
layerId = self._settings.get(ObjectTreeItem.ITEM_DEM,
{}).get("comboBox_DEMLayer")
if layerId:
self.primaryDEMChanged(layerId)
def saveProperties(self, item, page):
properties = page.properties()
parent = item.parent()
if parent is None:
# top level item
self._settings[item.data(0, Qt.UserRole)] = properties
else:
# layer item
parentId = parent.data(0, Qt.UserRole)
if parentId not in self._settings:
self._settings[parentId] = {}
self._settings[parentId][item.data(0, Qt.UserRole)] = properties
def setCurrentTreeItemByData(self, data):
it = QTreeWidgetItemIterator(self.ui.treeWidget)
while it.value():
if it.value().data(0, Qt.UserRole) == data:
self.ui.treeWidget.setCurrentItem(it.value())
return True
it += 1
return False
def currentTemplateChanged(self, index=None):
cbox = self.ui.comboBox_Template
templateType = cbox.itemData(cbox.currentIndex(), Qt.UserRole)
if templateType == self.templateType:
return
# hide items unsupported by template
tree = self.ui.treeWidget
for i, id in enumerate(ObjectTreeItem.topItemIds):
hidden = (templateType == "sphere"
and id != ObjectTreeItem.ITEM_CONTROLS)
tree.topLevelItem(i).setHidden(hidden)
# set current tree item
if templateType == "sphere":
tree.setCurrentItem(
tree.topLevelItem(
ObjectTreeItem.topItemIndex(ObjectTreeItem.ITEM_CONTROLS)))
elif self.lastTreeItemData is None or not self.setCurrentTreeItemByData(
self.lastTreeItemData): # restore selection
tree.setCurrentItem(
tree.topLevelItem(
ObjectTreeItem.topItemIndex(ObjectTreeItem.ITEM_DEM))
) # default selection for plain is DEM
# display messages
self.clearMessageBar()
if templateType != "sphere":
# show message if crs unit is degrees
mapSettings = self.iface.mapCanvas().mapSettings(
) if QGis.QGIS_VERSION_INT >= 20300 else self.iface.mapCanvas(
).mapRenderer()
if mapSettings.destinationCrs().mapUnits() in [QGis.Degrees]:
self.showMessageBar(
"The unit of current CRS is degrees, so terrain may not appear well.",
QgsMessageBar.WARNING)
self.templateType = templateType
def currentObjectChanged(self, currentItem, previousItem):
# save properties of previous item
if previousItem and self.currentPage:
self.saveProperties(previousItem, self.currentPage)
self.currentItem = currentItem
self.currentPage = None
# hide text browser and all pages
self.ui.textBrowser.hide()
for page in self.pages.itervalues():
page.hide()
parent = currentItem.parent()
if parent is None:
topItemIndex = currentItem.data(0, Qt.UserRole)
pageType = self.topItemPages.get(topItemIndex, ppages.PAGE_NONE)
page = self.pages.get(pageType, None)
if page is None:
self.showDescription(topItemIndex)
return
page.setup(self._settings.get(topItemIndex))
page.show()
else:
parentId = parent.data(0, Qt.UserRole)
layerId = currentItem.data(0, Qt.UserRole)
layer = QgsMapLayerRegistry.instance().mapLayer(unicode(layerId))
if layer is None:
return
layerType = layer.type()
if layerType == QgsMapLayer.RasterLayer:
page = self.pages[ppages.PAGE_DEM]
page.setup(
self._settings.get(parentId, {}).get(layerId, None), layer,
False)
elif layerType == QgsMapLayer.VectorLayer:
page = self.pages[ppages.PAGE_VECTOR]
page.setup(
self._settings.get(parentId, {}).get(layerId, None), layer)
else:
return
page.show()
self.currentPage = page
def objectItemChanged(self, item, column):
parent = item.parent()
if parent is None:
return
# checkbox of optional layer checked/unchecked
if item == self.currentItem:
if self.currentPage:
# update enablement of property widgets
self.currentPage.itemChanged(item)
else:
# select changed item
self.ui.treeWidget.setCurrentItem(item)
# set visible property
#visible = item.data(0, Qt.CheckStateRole) == Qt.Checked
#parentId = parent.data(0, Qt.UserRole)
#layerId = item.data(0, Qt.UserRole)
#self._settings.get(parentId, {}).get(layerId, {})["visible"] = visible
def primaryDEMChanged(self, layerId):
tree = self.ui.treeWidget
parent = tree.topLevelItem(
ObjectTreeItem.topItemIndex(ObjectTreeItem.ITEM_OPTDEM))
tree.blockSignals(True)
for i in range(parent.childCount()):
item = parent.child(i)
isPrimary = item.data(0, Qt.UserRole) == layerId
item.setDisabled(isPrimary)
tree.blockSignals(False)
def showDescription(self, topItemIndex):
fragment = {
ObjectTreeItem.ITEM_OPTDEM: "additional-dem",
ObjectTreeItem.ITEM_POINT: "point",
ObjectTreeItem.ITEM_LINE: "line",
ObjectTreeItem.ITEM_POLYGON: "polygon"
}.get(topItemIndex)
url = "http://qgis2threejs.readthedocs.org/en/docs-release/ExportSettings.html"
if fragment:
url += "#" + fragment
html = '<a href="{0}">Online Help</a> about this item'.format(url)
self.ui.textBrowser.setHtml(html)
self.ui.textBrowser.show()
def numericFields(self, layer):
# get attributes of a sample feature and create numeric field name list
numeric_fields = []
f = QgsFeature()
layer.getFeatures().nextFeature(f)
for field in f.fields():
isNumeric = False
try:
float(f.attribute(field.name()))
isNumeric = True
except ValueError:
pass
if isNumeric:
numeric_fields.append(field.name())
return numeric_fields
def mapTo3d(self):
canvas = self.iface.mapCanvas()
mapSettings = canvas.mapSettings(
) if QGis.QGIS_VERSION_INT >= 20300 else canvas.mapRenderer()
world = self._settings.get(ObjectTreeItem.ITEM_WORLD, {})
bs = float(world.get("lineEdit_BaseSize", def_vals.baseSize))
ve = float(world.get("lineEdit_zFactor", def_vals.zExaggeration))
vs = float(world.get("lineEdit_zShift", def_vals.zShift))
return MapTo3D(mapSettings, bs, ve, vs)
def progress(self, percentage=None, statusMsg=None):
ui = self.ui
if percentage is not None:
ui.progressBar.setValue(percentage)
if percentage == 100:
ui.progressBar.setVisible(False)
ui.label_Status.setText("")
else:
ui.progressBar.setVisible(True)
if statusMsg is not None:
ui.label_Status.setText(statusMsg)
ui.label_Status.repaint()
QgsApplication.processEvents(QEventLoop.ExcludeUserInputEvents)
def run(self):
self.endPointSelection()
ui = self.ui
filename = ui.lineEdit_OutputFilename.text() # ""=Temporary file
if filename and os.path.exists(filename):
if QMessageBox.question(
self, "Qgis2threejs",
"Output file already exists. Overwrite it?",
QMessageBox.Ok | QMessageBox.Cancel) != QMessageBox.Ok:
return
# export to web (three.js)
export_settings = ExportSettings(self.pluginManager,
self.localBrowsingMode)
export_settings.loadSettings(self.settings())
export_settings.setMapCanvas(self.iface.mapCanvas())
err_msg = export_settings.checkValidity()
if err_msg is not None:
QMessageBox.warning(self, "Qgis2threejs", err_msg
or "Invalid settings")
return
ui.pushButton_Run.setEnabled(False)
ui.toolButton_Settings.setVisible(False)
self.clearMessageBar()
self.progress(0)
if export_settings.exportMode == ExportSettings.PLAIN_MULTI_RES:
# update quads and point on map canvas
self.createRubberBands(export_settings.baseExtent,
export_settings.quadtree())
# export
ret = exportToThreeJS(export_settings, self.iface.legendInterface(),
self.objectTypeManager, self.progress)
self.progress(100)
ui.pushButton_Run.setEnabled(True)
if not ret:
ui.toolButton_Settings.setVisible(True)
return
self.clearRubberBands()
# store last selections
settings = QSettings()
settings.setValue("/Qgis2threejs/lastTemplate",
export_settings.templatePath)
settings.setValue("/Qgis2threejs/lastControls",
export_settings.controls)
# open web browser
if not tools.openHTMLFile(export_settings.htmlfilename):
ui.toolButton_Settings.setVisible(True)
return
# close dialog
QDialog.accept(self)
def reject(self):
# save properties of current object
item = self.ui.treeWidget.currentItem()
if item and self.currentPage:
self.saveProperties(item, self.currentPage)
self.endPointSelection()
self.clearRubberBands()
QDialog.reject(self)
def help(self):
url = "http://qgis2threejs.readthedocs.org/"
import webbrowser
webbrowser.open(url, new=2) # new=2: new tab if possible
def startPointSelection(self):
canvas = self.iface.mapCanvas()
if self.previousMapTool != self.mapTool:
self.previousMapTool = canvas.mapTool()
canvas.setMapTool(self.mapTool)
self.pages[ppages.PAGE_DEM].toolButton_PointTool.setVisible(False)
def endPointSelection(self):
self.mapTool.reset()
if self.previousMapTool is not None:
self.iface.mapCanvas().setMapTool(self.previousMapTool)
def mapToolSet(self, mapTool):
return
#TODO: unstable
if mapTool != self.mapTool and self.currentPage is not None:
if self.currentPage.pageType == ppages.PAGE_DEM and self.currentPage.isPrimary:
self.currentPage.toolButton_PointTool.setVisible(True)
def createRubberBands(self, baseExtent, quadtree):
self.clearRubberBands()
# create quads with rubber band
self.rb_quads = QgsRubberBand(self.iface.mapCanvas(), QGis.Line)
self.rb_quads.setColor(Qt.blue)
self.rb_quads.setWidth(1)
quads = quadtree.quads()
for quad in quads:
geom = baseExtent.subrectangle(quad.rect).geometry()
self.rb_quads.addGeometry(geom, None)
self.log("Quad count: %d" % len(quads))
if not quadtree.focusRect:
return
# create a point with rubber band
if quadtree.focusRect.width() == 0 or quadtree.focusRect.height() == 0:
npt = quadtree.focusRect.center()
self.rb_point = QgsRubberBand(self.iface.mapCanvas(), QGis.Point)
self.rb_point.setColor(Qt.red)
self.rb_point.addPoint(baseExtent.point(npt))
def clearRubberBands(self):
# clear quads and point
if self.rb_quads:
self.iface.mapCanvas().scene().removeItem(self.rb_quads)
self.rb_quads = None
if self.rb_point:
self.iface.mapCanvas().scene().removeItem(self.rb_point)
self.rb_point = None
def browseClicked(self):
directory = os.path.split(self.ui.lineEdit_OutputFilename.text())[0]
if not directory:
directory = QDir.homePath()
filename = QFileDialog.getSaveFileName(
self,
self.tr("Output filename"),
directory,
"HTML file (*.html *.htm)",
options=QFileDialog.DontConfirmOverwrite)
if not filename:
return
# append .html extension if filename doesn't have either .html or .htm
if filename[-5:].lower() != ".html" and filename[-4:].lower(
) != ".htm":
filename += ".html"
self.ui.lineEdit_OutputFilename.setText(filename)
def log(self, msg):
if debug_mode:
qDebug(msg)
def load_menus(self, profile=None, schema=None):
"""
Load menus in the main windows qgis bar
"""
if not schema:
schema = self.combo_schema.currentText()
if not profile:
profile = self.combo_profile.currentText()
# remove previous menus
for menu in self.uiparent.menus:
self.uiparent.iface.mainWindow().menuBar().removeAction(
menu.menuAction())
with self.transaction():
cur = self.connection.cursor()
select = """
select name, profile, model_index, datasource_uri
from {}.{}
where profile = '{}'
""".format(schema, self.table, profile)
cur.execute(select)
rows = cur.fetchall()
# item accessor ex: '0-menu/0-submenu/1-item/'
menudict = {}
# reference to parent item
parent = ''
# reference to qgis main menu bar
menubar = self.uiparent.iface.mainWindow().menuBar()
for name, profile, model_index, datasource_uri in self.sortby_modelindex(
rows):
uri_struct = QgsMimeDataUtils.Uri(datasource_uri)
indexes = json.loads(model_index)
# root menu
parent = '{}-{}/'.format(indexes[0][0], indexes[0][1])
if parent not in menudict:
menu = QMenu(self.uiparent.iface.mainWindow())
self.uiparent.menus.append(menu)
menu.setObjectName(indexes[0][1])
menu.setTitle(indexes[0][1])
menubar.insertMenu(
self.uiparent.iface.firstRightStandardMenu().menuAction(),
menu)
menudict[parent] = menu
else:
# menu already there
menu = menudict[parent]
for idx, subname in indexes[1:-1]:
# intermediate submenus
parent += '{}-{}/'.format(idx, subname)
if parent not in menudict:
submenu = menu.addMenu(subname)
submenu.setObjectName(subname)
submenu.setTitle(subname)
menu = submenu
# store it for later use
menudict[parent] = menu
continue
# already treated
menu = menudict[parent]
# last item = layer
layer = QAction(name, self.uiparent.iface.mainWindow())
if uri_struct.providerKey in ICON_MAPPER:
layer.setIcon(QIcon(ICON_MAPPER[uri_struct.providerKey]))
if uri_struct.providerKey == 'postgres':
# set tooltip to postgres comment
comment = self.get_table_comment(uri_struct.uri)
layer.setStatusTip(comment)
layer.setToolTip(comment)
layer.setData(uri_struct.uri)
layer.setWhatsThis(uri_struct.providerKey)
layer.triggered.connect(self.layer_handler[uri_struct.layerType])
menu.addAction(layer)
class Tabs(QTabWidget):
"""TabWidget with a context-menu"""
def __init__(self, parent, actions=None):
QTabWidget.__init__(self, parent)
tab_bar = TabsBase(self, parent)
self.connect(tab_bar, SIGNAL('move_tab(int,int)'), self.move_tab)
self.connect(tab_bar, SIGNAL('move_tab(long,int,int)'),
self.move_tab_from_another_tabwidget)
self.setTabBar(tab_bar)
self.menu = QMenu(self)
if actions:
add_actions(self.menu, actions)
self.index_history = []
self.connect(self, SIGNAL('currentChanged(int)'),
self.__current_changed)
tabsc = QShortcut(QKeySequence("Ctrl+Tab"), parent, self.tab_navigate)
tabsc.setContext(Qt.WidgetWithChildrenShortcut)
def __current_changed(self, index):
for i, ind in [(i, ind) for i, ind in enumerate(self.index_history)]:
if ind > self.count() - 1:
self.index_history.pop(i)
while index in self.index_history:
self.index_history.pop(self.index_history.index(index))
self.index_history.append(index)
def tab_navigate(self):
"""Ctrl+Tab"""
if len(self.index_history) > 1:
last = len(self.index_history) - 1
index = self.index_history.pop(last)
self.index_history.insert(0, index)
self.setCurrentIndex(self.index_history[last])
elif len(self.index_history) == 0 and self.count():
self.index_history = [self.currentIndex()]
def contextMenuEvent(self, event):
"""Override Qt method"""
if self.menu:
self.menu.popup(event.globalPos())
def mousePressEvent(self, event):
"""Override Qt method"""
if event.button() == Qt.MidButton:
index = self.tabBar().tabAt(event.pos())
if index >= 0:
self.emit(SIGNAL("close_tab(int)"), index)
event.accept()
return
QTabWidget.mousePressEvent(self, event)
def keyPressEvent(self, event):
"""Override Qt method"""
ctrl = event.modifiers() & Qt.ControlModifier
key = event.key()
handled = False
if ctrl and self.count() > 0:
index = self.currentIndex()
if key == Qt.Key_PageUp and index > 0:
self.setCurrentIndex(index - 1)
handled = True
elif key == Qt.Key_PageDown and index < self.count() - 1:
self.setCurrentIndex(index + 1)
handled = True
if handled:
event.accept()
else:
QTabWidget.keyPressEvent(self, event)
def move_tab(self, index_from, index_to):
"""Move tab inside a tabwidget"""
self.emit(SIGNAL('move_data(int,int)'), index_from, index_to)
tip, text = self.tabToolTip(index_from), self.tabText(index_from)
icon, widget = self.tabIcon(index_from), self.widget(index_from)
current_widget = self.currentWidget()
self.removeTab(index_from)
self.insertTab(index_to, widget, icon, text)
self.setTabToolTip(index_to, tip)
self.setCurrentWidget(current_widget)
self.emit(SIGNAL('move_tab_finished()'))
def move_tab_from_another_tabwidget(self, tabwidget_from, index_from,
index_to):
"""Move tab from a tabwidget to another"""
self.emit(SIGNAL('move_tab(long,long,int,int)'), tabwidget_from,
id(self), index_from, index_to)
def setupUi(self, port):
self.setObjectName("MainWindow")
self.resize(600, 600)
self.centralwidget = QWidget(self)
p = self.centralwidget.palette()
self.centralwidget.setAutoFillBackground(True)
p.setColor(self.centralwidget.backgroundRole(), QColor(126, 135, 152))
self.centralwidget.setPalette(p)
self.centralwidget.setObjectName("centralwidget")
self.gridLayout = QGridLayout(self.centralwidget)
self.gridLayout.setObjectName("gridLayout")
self.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(self)
self.menubar.setGeometry(QRect(0, 0, 808, 25))
self.menubar.setObjectName("menubar")
self.menuFile = QMenu(self.menubar)
self.menuFile.setObjectName("menuFile")
self.setMenuBar(self.menubar)
self.statusbar = QStatusBar(self)
self.statusbar.setObjectName("statusbar")
self.setStatusBar(self.statusbar)
self.actionQuit = QAction(self)
self.actionQuit.setObjectName("actionQuit")
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionQuit)
self.menubar.addAction(self.menuFile.menuAction())
self.actionReset = QAction(self)
self.actionReset.setObjectName("reset")
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionReset)
self.menubar.addAction(self.menuFile.menuAction())
# add other GUI objects
self.graph_widget = GraphWidget(self.statusbar)
self.gridLayout.addWidget(self.graph_widget, 1, 11, 10, 10)
pixmap = QPixmap(':/images/cta-logo-mini.png')
lbl = QLabel()
lbl.setPixmap(pixmap)
self.gridLayout.addWidget(lbl, 0, 0)
p = self.graph_widget.palette()
self.graph_widget.setAutoFillBackground(True)
p.setColor(
self.graph_widget.backgroundRole(), QColor(255, 255, 255)) # QColor(226, 235, 252))
self.graph_widget.setPalette(p)
self.quitButton = QPushButton() # self.centralwidget)
self.quitButton.setObjectName("quitButton")
self.quitButton.setText(QApplication.translate
("MainWindow", "Quit", None, QApplication.UnicodeUTF8))
self.gridLayout.addWidget(self.quitButton, 12, 0, 1, 1)
self.info_label = InfoLabel(0, 4)
self.info_label.setAutoFillBackground(True)
self.gridLayout.addWidget(self.info_label, 1, 0, 1, 5)
# self.info_label.setAlignment(PyQt4.Qt.AlignCenter);
palette = QPalette()
palette.setColor(self.info_label.backgroundRole(), Qt.lightGray)
self.info_label.setPalette(palette)
QObject.connect(
self.quitButton, SIGNAL("clicked()"), self.stop)
QObject.connect(
self.actionQuit, SIGNAL("triggered()"), self.stop)
QMetaObject.connectSlotsByName(self)
self.retranslateUi()
QObject.connect(
self.actionQuit, SIGNAL("triggered()"), self.close)
QMetaObject.connectSlotsByName(self)
# Create GuiConnexion for ZMQ comminucation with pipeline
self.guiconnection = GuiConnexion(gui_port=port, statusBar=self.statusbar)
self.guiconnection.message.connect(self.graph_widget.pipechange)
self.guiconnection.message.connect(self.info_label.pipechange)
self.guiconnection.reset_message.connect(self.graph_widget.reset)
self.guiconnection.reset_message.connect(self.info_label.reset)
self.guiconnection.mode_message.connect(self.info_label.mode_receive)
QObject.connect(
self.actionReset, SIGNAL("triggered()"), self.guiconnection.reset)
QMetaObject.connectSlotsByName(self)
# start the process
self.guiconnection.start()
def __init__(self, config):
super(FreeseerApp, self).__init__()
self.config = config
self.icon = QIcon()
self.icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")),
QIcon.Normal, QIcon.Off)
self.setWindowIcon(self.icon)
self.aboutDialog = AboutDialog()
self.aboutDialog.setModal(True)
self.logDialog = LogDialog()
#
# Translator
#
self.app = QApplication.instance()
self.current_language = None
self.uiTranslator = QTranslator()
self.uiTranslator.load(":/languages/tr_en_US.qm")
self.app.installTranslator(self.uiTranslator)
self.langActionGroup = QActionGroup(self)
self.langActionGroup.setExclusive(True)
QTextCodec.setCodecForTr(QTextCodec.codecForName('utf-8'))
self.connect(self.langActionGroup, SIGNAL('triggered(QAction *)'),
self.translate)
# --- Translator
#
# Setup Menubar
#
self.menubar = self.menuBar()
self.menubar.setGeometry(QRect(0, 0, 500, 50))
self.menubar.setObjectName(_fromUtf8("menubar"))
self.menuFile = QMenu(self.menubar)
self.menuFile.setObjectName(_fromUtf8("menuFile"))
self.menuLanguage = QMenu(self.menubar)
self.menuLanguage.setObjectName(_fromUtf8("menuLanguage"))
self.menuHelp = QMenu(self.menubar)
self.menuHelp.setObjectName(_fromUtf8("menuHelp"))
exitIcon = QIcon.fromTheme("application-exit")
self.actionExit = QAction(self)
self.actionExit.setShortcut("Ctrl+Q")
self.actionExit.setObjectName(_fromUtf8("actionExit"))
self.actionExit.setIcon(exitIcon)
helpIcon = QIcon.fromTheme("help-contents")
self.actionOnlineHelp = QAction(self)
self.actionOnlineHelp.setObjectName(_fromUtf8("actionOnlineHelp"))
self.actionOnlineHelp.setIcon(helpIcon)
self.actionAbout = QAction(self)
self.actionAbout.setObjectName(_fromUtf8("actionAbout"))
self.actionAbout.setIcon(self.icon)
self.actionLog = QAction(self)
self.actionLog.setObjectName(_fromUtf8("actionLog"))
self.actionLog.setShortcut("Ctrl+L")
# Actions
self.menuFile.addAction(self.actionExit)
self.menuHelp.addAction(self.actionAbout)
self.menuHelp.addAction(self.actionLog)
self.menuHelp.addAction(self.actionOnlineHelp)
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuLanguage.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
self.setupLanguageMenu()
# --- End Menubar
self.connect(self.actionExit, SIGNAL('triggered()'), self.close)
self.connect(self.actionAbout, SIGNAL('triggered()'),
self.aboutDialog.show)
self.connect(self.actionLog, SIGNAL('triggered()'),
self.logDialog.show)
self.connect(self.actionOnlineHelp, SIGNAL('triggered()'),
self.openOnlineHelp)
self.retranslateFreeseerApp()
self.aboutDialog.aboutWidget.retranslate("en_US")
class FreeseerApp(QMainWindow):
def __init__(self, config):
super(FreeseerApp, self).__init__()
self.config = config
self.icon = QIcon()
self.icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")),
QIcon.Normal, QIcon.Off)
self.setWindowIcon(self.icon)
self.aboutDialog = AboutDialog()
self.aboutDialog.setModal(True)
self.logDialog = LogDialog()
#
# Translator
#
self.app = QApplication.instance()
self.current_language = None
self.uiTranslator = QTranslator()
self.uiTranslator.load(":/languages/tr_en_US.qm")
self.app.installTranslator(self.uiTranslator)
self.langActionGroup = QActionGroup(self)
self.langActionGroup.setExclusive(True)
QTextCodec.setCodecForTr(QTextCodec.codecForName('utf-8'))
self.connect(self.langActionGroup, SIGNAL('triggered(QAction *)'),
self.translate)
# --- Translator
#
# Setup Menubar
#
self.menubar = self.menuBar()
self.menubar.setGeometry(QRect(0, 0, 500, 50))
self.menubar.setObjectName(_fromUtf8("menubar"))
self.menuFile = QMenu(self.menubar)
self.menuFile.setObjectName(_fromUtf8("menuFile"))
self.menuLanguage = QMenu(self.menubar)
self.menuLanguage.setObjectName(_fromUtf8("menuLanguage"))
self.menuHelp = QMenu(self.menubar)
self.menuHelp.setObjectName(_fromUtf8("menuHelp"))
exitIcon = QIcon.fromTheme("application-exit")
self.actionExit = QAction(self)
self.actionExit.setShortcut("Ctrl+Q")
self.actionExit.setObjectName(_fromUtf8("actionExit"))
self.actionExit.setIcon(exitIcon)
helpIcon = QIcon.fromTheme("help-contents")
self.actionOnlineHelp = QAction(self)
self.actionOnlineHelp.setObjectName(_fromUtf8("actionOnlineHelp"))
self.actionOnlineHelp.setIcon(helpIcon)
self.actionAbout = QAction(self)
self.actionAbout.setObjectName(_fromUtf8("actionAbout"))
self.actionAbout.setIcon(self.icon)
self.actionLog = QAction(self)
self.actionLog.setObjectName(_fromUtf8("actionLog"))
self.actionLog.setShortcut("Ctrl+L")
# Actions
self.menuFile.addAction(self.actionExit)
self.menuHelp.addAction(self.actionAbout)
self.menuHelp.addAction(self.actionLog)
self.menuHelp.addAction(self.actionOnlineHelp)
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuLanguage.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
self.setupLanguageMenu()
# --- End Menubar
self.connect(self.actionExit, SIGNAL('triggered()'), self.close)
self.connect(self.actionAbout, SIGNAL('triggered()'),
self.aboutDialog.show)
self.connect(self.actionLog, SIGNAL('triggered()'),
self.logDialog.show)
self.connect(self.actionOnlineHelp, SIGNAL('triggered()'),
self.openOnlineHelp)
self.retranslateFreeseerApp()
self.aboutDialog.aboutWidget.retranslate("en_US")
def openOnlineHelp(self):
"""Opens a link to the Freeseer Online Help"""
url = QUrl("http://freeseer.readthedocs.org")
QDesktopServices.openUrl(url)
def translate(self, action):
"""Translates the GUI via menu action.
When a language is selected from the language menu, this function is
called and the language to be changed to is retrieved.
"""
self.current_language = str(
action.data().toString()).strip("tr_").rstrip(".qm")
log.info("Switching language to: %s" % action.text())
self.uiTranslator.load(":/languages/tr_%s.qm" % self.current_language)
self.app.installTranslator(self.uiTranslator)
self.retranslateFreeseerApp()
self.aboutDialog.aboutWidget.retranslate(self.current_language)
self.retranslate()
self.logDialog.retranslate()
def retranslate(self):
"""
Reimplement this function to provide translations to your app.
"""
pass
def retranslateFreeseerApp(self):
#
# Menubar
#
self.menuFile.setTitle(self.app.translate("FreeseerApp", "&File"))
self.menuLanguage.setTitle(
self.app.translate("FreeseerApp", "&Language"))
self.menuHelp.setTitle(self.app.translate("FreeseerApp", "&Help"))
self.actionExit.setText(self.app.translate("FreeseerApp", "&Quit"))
self.actionAbout.setText(self.app.translate("FreeseerApp", "&About"))
self.actionLog.setText(self.app.translate("FreeseerApp", "View &Log"))
self.actionOnlineHelp.setText(
self.app.translate("FreeseerApp", "Online Documentation"))
# --- Menubar
def setupLanguageMenu(self):
self.languages = QDir(":/languages").entryList()
if self.current_language is None:
self.current_language = QLocale.system().name(
) # Retrieve Current Locale from the operating system.
log.debug("Detected user's locale as %s" % self.current_language)
for language in self.languages:
translator = QTranslator(
) # Create a translator to translate Language Display Text.
translator.load(":/languages/%s" % language)
language_display_text = translator.translate(
"Translation", "Language Display Text")
languageAction = QAction(self)
languageAction.setCheckable(True)
languageAction.setText(language_display_text)
languageAction.setData(language)
self.menuLanguage.addAction(languageAction)
self.langActionGroup.addAction(languageAction)
class FlashDlg(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.ui = dlg.Ui_Form()
self.ui.setupUi(self)
self.ui_init()
self.init_comports()
self.init_romlist()
# menu
self.ctx_menu_init()
# or ABORT
self.init_btn()
# flasher thread
self.init_flasher_thread()
def ctx_menu_init(self):
self.pop_menu = QMenu()
self.pop_menu.addAction(self.ui.action_clear_console)
def init_btn(self):
self.change_btn_to_flash()
def change_btn_to_flash(self):
self.btn_state = 'FLASH'
self.ui.gobtn.setText(u'开始')
# 已写入字节数
self.written = 0
# 时间消耗
self.elapse = time.time()
def change_btn_to_abort(self):
self.btn_state = 'ABORT'
self.ui.gobtn.setText(u'终止')
def action_state(self):
return self.btn_state
def closeEvent(self, evt):
"""
:type evt: QCloseEvent
:param evt:
"""
self.flash_thread.exit()
evt.accept()
def init_flasher_thread(self):
self.flasher = ESP8266Flasher()
self.flash_thread = QThread()
self.flasher.moveToThread(self.flash_thread)
self.flash_thread.start()
'''
begin_flash_sig = pyqtSignal(str, dict)
abort_flash_sig = pyqtSignal()
conn_result_sig = pyqtSignal(int)
flash_progress_sig = pyqtSignal(int)
flash_result_sig = pyqtSignal(int)
console_sig = pyqtSignal(str)
'''
self.flasher.begin_flash_sig.connect(self.flasher.begin_flash)
self.flasher.abort_flash_sig.connect(self.flasher.abort_flash)
self.flasher.conn_result_sig.connect(self.conn_result)
self.flasher.flash_progress_sig.connect(self.flash_progress)
self.flasher.flash_result_sig.connect(self.flash_result)
self.flasher.console_sig.connect(self.consolelog)
def conn_result(self, res):
print('connect result is %r' % res)
if res == 0:
self.consolelog(u'串口同步成功，烧录即将进行')
if res == 1:
self.consolelog(u'同步串口失败，请检查所选串口并重试')
self.change_btn_to_flash()
def flash_result(self, res, desc):
print('flash result is %r' % res)
elapse = time.time() - self.elapse
if res == 1:
self.consolelog(u'烧录失败 %s 耗时 %d 秒' % (desc, elapse))
if res == 0:
self.consolelog(u'固件烧录成功, 耗时 %d 秒' % elapse)
self.change_btn_to_flash()
def flash_progress(self, res, total):
print('flash progress is %d, total %d, writed %d' %
(res, total, self.written))
self.written += res
self.ui.progbar.setValue((float(self.written) / total) * 100)
def ui_init(self):
self.setFixedSize(self.size())
self.consolelog(u'ESPUSH一键烧录工具 v2.0')
url = u'https://espush.cn/api/portal/qqgroup'
self.consolelog(u'加入 <a href="%s">ESPush IoT QQ群</a> 进行讨论。' % url)
self.consolelog(u"\n")
self.ui.textOut.setOpenLinks(True)
self.ui.textOut.setOpenExternalLinks(True)
def init_romlist(self):
url = 'https://espush.cn/api/portal/admin/flasher/firmwares'
rsp = requests.get(url)
data = rsp.json()
for firm in data:
v = QVariant((firm, ))
self.ui.firm_box.addItem(firm['description'], userData=v)
def init_comports(self):
ports = comports()
self.ui.com_box.clear()
ports = [el.device for el in ports]
for port in ports:
self.ui.com_box.addItem(port)
def consolelog(self, msg):
self.ui.textOut.append(msg)
def console_clear(self):
self.ui.textOut.clear()
def down_firmfile(self, firm):
url = 'https://espush.cn/api/portal/admin/down/firmwares/%d' % firm[
'id']
rsp = requests.get(url)
if rsp.status_code != 200:
self.consolelog(u'下载失败')
return
if not self.checksum(rsp.content, firm['checksum']):
self.consolelog('checksum failed!')
return
# write to file.
self.write_local_firm_file(firm['id'], rsp.content)
return rsp.content
def write_local_firm_file(self, fid, content):
# 文件夹是否存在，不存在则新增
if not os.path.exists(ROMS_DIR):
try:
os.mkdir(ROMS_DIR)
except IOError:
self.consolelog(u'创建下载 ROM 临时文件夹失败')
return
# 写入文件
self.consolelog(u'下载完毕，写入本地缓存文件')
with open('%s/%d' % (ROMS_DIR, fid), 'wb') as fout:
fout.write(content)
def checksum(self, content, csum):
md5 = lambda x: hashlib.md5(x).hexdigest()
return md5(content) == csum
def local_firm_exist(self, firm):
firmname = '%s/%d' % (ROMS_DIR, firm['id'])
if not os.path.exists(firmname):
return
with open(firmname, 'rb') as fin:
return fin.read()
def get_firmware(self, firm):
rsp = self.local_firm_exist(firm)
if rsp:
return rsp
self.consolelog(u'本地不存在，网上下载')
rsp = self.down_firmfile(firm)
if not rsp:
self.consolelog(u'下载失败')
return
return rsp
def get_embed_firms(self, fileName):
# ":/resources/blank.bin"
baseName = ':/resources/'
bFile = QFile(baseName + fileName)
if not bFile.open(QIODevice.ReadOnly):
self.consolelog(u'读取内嵌资源 %s 出错！' % fileName)
return
content = bFile.readAll()
return bytearray(content)
def get_all_embed_firms(self):
blank = self.get_embed_firms('blank.bin')
if not blank:
return
boot = self.get_embed_firms('boot_v1.7.bin')
if not boot:
return
esp_init_data = self.get_embed_firms('esp_init_data_default.bin')
if not esp_init_data:
return
return {
'blank': blank,
'boot': boot,
'init': esp_init_data,
}
def go(self):
if self.action_state() == 'FLASH':
self.change_btn_to_abort()
self.go_flash()
elif self.action_state() == 'ABORT':
self.change_btn_to_flash()
self.go_abort()
def go_abort(self):
self.consolelog(u'准备终止烧录过程')
self.flasher.abort_flash_sig.emit()
def go_flash(self):
firmwares = self.get_all_embed_firms()
device = self.ui.com_box.currentText()
firmware = self.ui.firm_box.itemData(self.ui.firm_box.currentIndex())
firmobj = firmware.toPyObject()[0]
firmfile = self.get_firmware(firmobj)
firmwares['app1'] = firmfile
self.consolelog(u'固件准备完毕，准备烧录到 %s' % device)
self.flasher.begin_flash_sig.emit(device, firmwares)
def show_ctx_menu(self):
self.pop_menu.exec_(QCursor.pos())
def clear_console(self):
self.console_clear()
class ProfileTableViewer( QWidget ):
" Profiling results table viewer "
escapePressed = pyqtSignal()
def __init__( self, scriptName, params, reportTime,
dataFile, stats, parent = None ):
QWidget.__init__( self, parent )
self.__table = ProfilerTreeWidget( self )
self.__table.escapePressed.connect( self.__onEsc )
self.__script = scriptName
self.__stats = stats
project = GlobalData().project
if project.isLoaded():
self.__projectPrefix = os.path.dirname( project.fileName )
else:
self.__projectPrefix = os.path.dirname( scriptName )
if not self.__projectPrefix.endswith( os.path.sep ):
self.__projectPrefix += os.path.sep
self.__table.setAlternatingRowColors( True )
self.__table.setRootIsDecorated( False )
self.__table.setItemsExpandable( False )
self.__table.setSortingEnabled( True )
self.__table.setItemDelegate( NoOutlineHeightDelegate( 4 ) )
self.__table.setUniformRowHeights( True )
self.__table.setSelectionMode( QAbstractItemView.SingleSelection )
self.__table.setSelectionBehavior( QAbstractItemView.SelectRows )
headerLabels = [ "", "Calls", "Total time", "Per call",
"Cum. time", "Per call", "File name:line",
"Function", "Callers", "Callees" ]
self.__table.setHeaderLabels( headerLabels )
headerItem = self.__table.headerItem()
headerItem.setToolTip( 0, "Indication if it is an outside function" )
headerItem.setToolTip( 1, "Actual number of calls/primitive calls "
"(not induced via recursion)" )
headerItem.setToolTip( 2, "Total time spent in function "
"(excluding time made in calls "
"to sub-functions)" )
headerItem.setToolTip( 3, "Total time divided by number "
"of actual calls" )
headerItem.setToolTip( 4, "Total time spent in function and all "
"subfunctions (from invocation till exit)" )
headerItem.setToolTip( 5, "Cumulative time divided by number "
"of primitive calls" )
headerItem.setToolTip( 6, "Function location" )
headerItem.setToolTip( 7, "Function name" )
headerItem.setToolTip( 8, "Function callers" )
headerItem.setToolTip( 9, "Function callees" )
self.__table.itemActivated.connect( self.__activated )
totalCalls = self.__stats.total_calls
totalPrimitiveCalls = self.__stats.prim_calls # The calls were not induced via recursion
totalTime = self.__stats.total_tt
txt = "<b>Script:</b> " + self.__script + " " + params.arguments + "<br>" \
"<b>Run at:</b> " + reportTime + "<br>" + \
str( totalCalls ) + " function calls (" + \
str( totalPrimitiveCalls ) + " primitive calls) in " + \
FLOAT_FORMAT % totalTime + " CPU seconds"
summary = QLabel( txt )
summary.setToolTip( txt )
summary.setSizePolicy( QSizePolicy.Ignored, QSizePolicy.Fixed )
summary.setFrameStyle( QFrame.StyledPanel )
summary.setAutoFillBackground( True )
summaryPalette = summary.palette()
summaryBackground = summaryPalette.color( QPalette.Background )
summaryBackground.setRgb( min( summaryBackground.red() + 30, 255 ),
min( summaryBackground.green() + 30, 255 ),
min( summaryBackground.blue() + 30, 255 ) )
summaryPalette.setColor( QPalette.Background, summaryBackground )
summary.setPalette( summaryPalette )
vLayout = QVBoxLayout()
vLayout.setContentsMargins( 0, 0, 0, 0 )
vLayout.setSpacing( 0 )
vLayout.addWidget( summary )
vLayout.addWidget( self.__table )
self.setLayout( vLayout )
self.__createContextMenu()
self.__populate( totalTime )
return
def __onEsc( self ):
" Triggered when Esc is pressed "
self.escapePressed.emit()
return
def __createContextMenu( self ):
" Creates context menu for the table raws "
self.__contextMenu = QMenu( self )
self.__callersMenu = QMenu( "Callers", self )
self.__outsideCallersMenu = QMenu( "Outside callers", self )
self.__calleesMenu = QMenu( "Callees", self )
self.__outsideCalleesMenu = QMenu( "Outside callees", self )
self.__contextMenu.addMenu( self.__callersMenu )
self.__contextMenu.addMenu( self.__outsideCallersMenu )
self.__contextMenu.addSeparator()
self.__contextMenu.addMenu( self.__calleesMenu )
self.__contextMenu.addMenu( self.__outsideCalleesMenu )
self.__contextMenu.addSeparator()
self.__disasmAct = self.__contextMenu.addAction(
PixmapCache().getIcon( 'disasmmenu.png' ),
"Disassemble", self.__onDisassemble )
self.__callersMenu.triggered.connect( self.__onCallContextMenu )
self.__outsideCallersMenu.triggered.connect( self.__onCallContextMenu )
self.__calleesMenu.triggered.connect( self.__onCallContextMenu )
self.__outsideCalleesMenu.triggered.connect( self.__onCallContextMenu )
self.__table.setContextMenuPolicy( Qt.CustomContextMenu )
self.__table.customContextMenuRequested.connect( self.__showContextMenu )
return
def __showContextMenu( self, point ):
" Context menu "
self.__callersMenu.clear()
self.__outsideCallersMenu.clear()
self.__calleesMenu.clear()
self.__outsideCalleesMenu.clear()
# Detect what the item was clicked
item = self.__table.itemAt( point )
funcName = item.getFunctionName()
self.__disasmAct.setEnabled( item.getFileName() != "" and \
not funcName.startswith( "<" ) )
# Build the context menu
if item.callersCount() == 0:
self.__callersMenu.setEnabled( False )
self.__outsideCallersMenu.setEnabled( False )
else:
callers = self.__stats.stats[ item.getFuncIDs() ][ 4 ]
callersList = callers.keys()
callersList.sort()
for callerFunc in callersList:
menuText = self.__getCallLine( callerFunc, callers[ callerFunc ] )
if self.__isOutsideItem( callerFunc[ 0 ] ):
act = self.__outsideCallersMenu.addAction( menuText )
else:
act = self.__callersMenu.addAction( menuText )
funcFileName, funcLine, funcName = self.__getLocationAndName( callerFunc )
act.setData( QVariant( funcFileName + ":" + \
str( funcLine ) + ":" + \
funcName ) )
self.__callersMenu.setEnabled( not self.__callersMenu.isEmpty() )
self.__outsideCallersMenu.setEnabled( not self.__outsideCallersMenu.isEmpty() )
if item.calleesCount() == 0:
self.__calleesMenu.setEnabled( False )
self.__outsideCalleesMenu.setEnabled( False )
else:
callees = self.__stats.all_callees[ item.getFuncIDs() ]
calleesList = callees.keys()
calleesList.sort()
for calleeFunc in calleesList:
menuText = self.__getCallLine( calleeFunc, callees[ calleeFunc ] )
if self.__isOutsideItem( calleeFunc[ 0 ] ):
act = self.__outsideCalleesMenu.addAction( menuText )
else:
act = self.__calleesMenu.addAction( menuText )
funcFileName, funcLine, funcName = self.__getLocationAndName( calleeFunc )
act.setData( QVariant( funcFileName + ":" + \
str( funcLine ) + ":" + \
funcName ) )
self.__calleesMenu.setEnabled( not self.__calleesMenu.isEmpty() )
self.__outsideCalleesMenu.setEnabled( not self.__outsideCalleesMenu.isEmpty() )
self.__contextMenu.popup( QCursor.pos() )
return
def __onDisassemble( self ):
" On disassemble something "
item = self.__table.selectedItems()[ 0 ]
GlobalData().mainWindow.showDisassembler( item.getFileName(),
item.getFunctionName() )
return
def __resize( self ):
" Resizes columns to the content "
self.__table.header().resizeSections( QHeaderView.ResizeToContents )
self.__table.header().setStretchLastSection( True )
self.__table.header().resizeSection( OUTSIDE_COL_INDEX, 28 )
self.__table.header().setResizeMode( OUTSIDE_COL_INDEX,
QHeaderView.Fixed )
return
def setFocus( self ):
" Set focus to the proper widget "
self.__table.setFocus()
return
def __isOutsideItem( self, fileName ):
" Detects if the record should be shown as an outside one "
return not fileName.startswith( self.__projectPrefix )
def __activated( self, item, column ):
" Triggered when the item is activated "
try:
line = item.getLineNumber()
fileName = item.getFileName()
if line == 0 or not os.path.isabs( fileName ):
return
GlobalData().mainWindow.openFile( fileName, line )
except:
logging.error( "Could not jump to function location" )
return
@staticmethod
def __getFuncShortLocation( funcFileName, funcLine ):
" Provides unified shortened function location "
if funcFileName == "":
return ""
return os.path.basename( funcFileName ) + ":" + str( funcLine )
def __getCallLine( self, func, props ):
" Provides the formatted call line "
funcFileName, funcLine, funcName = self.__getLocationAndName( func )
if isinstance( props, tuple ):
actualCalls, primitiveCalls, totalTime, cumulativeTime = props
if primitiveCalls != actualCalls:
callsString = str( actualCalls ) + "/" + str( primitiveCalls )
else:
callsString = str( actualCalls )
return callsString + "\t" + FLOAT_FORMAT % totalTime + "\t" + \
FLOAT_FORMAT % cumulativeTime + "\t" + \
self.__getFuncShortLocation( funcFileName, funcLine ) + \
"(" + funcName + ")"
# I've never seen this branch working so it is just in case.
# There was something like this in the pstats module
return self.__getFuncShortLocation( funcFileName, funcLine ) + \
"(" + funcName + ")"
@staticmethod
def __getLocationAndName( func ):
" Provides standardized function file name, line and its name "
if func[ : 2 ] == ( '~', 0 ):
# special case for built-in functions
name = func[ 2 ]
if name.startswith( '<' ) and name.endswith( '>' ):
return "", 0, "{%s}" % name[ 1 : -1 ]
return "", 0, name
return func[ 0 ], func[ 1 ], func[ 2 ]
def __createItem( self, func, totalCPUTime,
primitiveCalls, actualCalls, totalTime,
cumulativeTime, timePerCall, cumulativeTimePerCall,
callers ):
" Creates an item to display "
values = []
values.append( "" )
if primitiveCalls == actualCalls:
values.append( str( actualCalls ) )
else:
values.append( str( actualCalls ) + "/" + str( primitiveCalls ) )
if totalCPUTime == 0.0:
values.append( FLOAT_FORMAT % totalTime )
else:
values.append( FLOAT_FORMAT % totalTime + " \t(%3.2f%%)" % (totalTime / totalCPUTime * 100) )
values.append( FLOAT_FORMAT % timePerCall )
values.append( FLOAT_FORMAT % cumulativeTime )
values.append( FLOAT_FORMAT % cumulativeTimePerCall )
# Location and name will be filled in the item constructor
values.append( "" )
values.append( "" )
# Callers
callersCount = len( callers )
values.append( str( callersCount ) )
# Callees
if func in self.__stats.all_callees:
calleesCount = len( self.__stats.all_callees[ func ] )
else:
calleesCount = 0
values.append( str( calleesCount ) )
item = ProfilingTableItem( values, self.__isOutsideItem( func[ 0 ] ),
func )
if callersCount != 0:
tooltip = ""
callersList = callers.keys()
callersList.sort()
for callerFunc in callersList[ : MAX_CALLS_IN_TOOLTIP ]:
if tooltip != "":
tooltip += "\n"
tooltip += self.__getCallLine( callerFunc, callers[ callerFunc ] )
if callersCount > MAX_CALLS_IN_TOOLTIP:
tooltip += "\n. . ."
item.setToolTip( 8, tooltip )
if calleesCount != 0:
callees = self.__stats.all_callees[ func ]
tooltip = ""
calleesList = callees.keys()
calleesList.sort()
for calleeFunc in calleesList[ : MAX_CALLS_IN_TOOLTIP ]:
if tooltip != "":
tooltip += "\n"
tooltip += self.__getCallLine( calleeFunc, callees[ calleeFunc ] )
if calleesCount > MAX_CALLS_IN_TOOLTIP:
tooltip += "\n. . ."
item.setToolTip( 9, tooltip )
self.__table.addTopLevelItem( item )
return
def __populate( self, totalCPUTime ):
" Populates the data "
for func, ( primitiveCalls, actualCalls, totalTime,
cumulativeTime, callers ) in self.__stats.stats.items():
# Calc time per call
if actualCalls == 0:
timePerCall = 0.0
else:
timePerCall = totalTime / actualCalls
# Calc time per cummulative call
if primitiveCalls == 0:
cumulativeTimePerCall = 0.0
else:
cumulativeTimePerCall = cumulativeTime / primitiveCalls
self.__createItem( func, totalCPUTime,
primitiveCalls, actualCalls, totalTime,
cumulativeTime, timePerCall, cumulativeTimePerCall,
callers )
self.__resize()
self.__table.header().setSortIndicator( 2, Qt.DescendingOrder )
self.__table.sortItems( 2,
self.__table.header().sortIndicatorOrder() )
return
def togglePath( self, state ):
" Switches between showing full paths or file names in locations "
for index in xrange( 0, self.__table.topLevelItemCount() ):
self.__table.topLevelItem( index ).updateLocation( state )
self.__resize()
return
def __onCallContextMenu( self, act ):
" Triggered when a context menu action is requested "
name = str( act.data().toString() )
for index in xrange( 0, self.__table.topLevelItemCount() ):
item = self.__table.topLevelItem( index )
if item.match( name ):
self.__table.clearSelection()
self.__table.scrollToItem( item )
self.__table.setCurrentItem( item )
return
def onSaveAs( self, fileName ):
" Saves the table to a file in CSV format "
try:
f = open( fileName, "wt" )
headerItem = self.__table.headerItem()
outsideIndex = -1
for index in xrange( 0, headerItem.columnCount() ):
title = str( headerItem.text( index ) )
if title == "":
outsideIndex = index
title = "Outside"
if index != 0:
f.write( ',' + title )
else:
f.write( title )
for index in xrange( 0, self.__table.topLevelItemCount() ):
item = self.__table.topLevelItem( index )
f.write( "\n" )
for column in xrange( 0, item.columnCount() ):
if column != 0:
f.write( ',' )
if column == outsideIndex:
if item.isOutside():
f.write( "Y" )
else:
f.write( "N" )
else:
text = str( item.text( column ) )
f.write( text.replace( '\t', '' ) )
f.close()
except Exception, ex:
logging.error( ex )
return
def __init__(self):
super().__init__()
self.in_data = None
self.in_distance = None
self.in_learner = None
self.in_classifier = None
self.in_object = None
self.auto_execute = False
for s in self.libraryListSource:
s.flags = 0
self._cachedDocuments = { }
self.infoBox = gui.widgetBox(self.controlArea, 'Info')
gui.label(
self.infoBox, self,
"<p>Execute python script.</p><p>Input variables:<ul><li> " + \
"<li>".join(t.name for t in self.inputs) + \
"</ul></p><p>Output variables:<ul><li>" + \
"<li>".join(t.name for t in self.outputs) + \
"</ul></p>"
)
self.libraryList = itemmodels.PyListModel(
[], self,
flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.widgetBox(self.controlArea, 'Library')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers = QListView.DoubleClicked |
QListView.EditKeyPressed,
sizePolicy = QSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
)
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged
)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("Add a new script to the library")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("Remove script from library")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("More", self, toolTip = "More actions")
new_from_file = QAction("Import a script from a file", self)
save_to_file = QAction("Save selected script to a file", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
gui.auto_commit(self.controlArea, self, "auto_execute", "Execute")
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.widgetBox(self, 'Python script')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.widgetBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.__dict__['sc'] = self._sc
self.__dict__['hc'] = self._hc
self.console = PySparkConsole(self.__dict__, self, sc = self.sc)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
select_row(self.libraryView, self.currentScriptIndex)
self.splitCanvas.setSizes([2, 1])
if self.splitterState is not None:
self.splitCanvas.restoreState(QByteArray(self.splitterState))
self.splitCanvas.splitterMoved[int, int].connect(self.onSpliterMoved)
self.controlArea.layout().addStretch(1)
self.resize(800, 600)
class MainWindow(QMainWindow, object):
"""
QMainWindow displays pipeline
Parameters
----------
port : str
used port to communicate with pipeline
Note: The firewall must be configure to accept input/output on this port
"""
def __init__(self, port):
super(MainWindow, self).__init__()
self.setupUi(port)
def setupUi(self, port):
self.setObjectName("MainWindow")
self.resize(600, 600)
self.centralwidget = QWidget(self)
p = self.centralwidget.palette()
self.centralwidget.setAutoFillBackground(True)
p.setColor(self.centralwidget.backgroundRole(), QColor(126, 135, 152))
self.centralwidget.setPalette(p)
self.centralwidget.setObjectName("centralwidget")
self.gridLayout = QGridLayout(self.centralwidget)
self.gridLayout.setObjectName("gridLayout")
self.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(self)
self.menubar.setGeometry(QRect(0, 0, 808, 25))
self.menubar.setObjectName("menubar")
self.menuFile = QMenu(self.menubar)
self.menuFile.setObjectName("menuFile")
self.setMenuBar(self.menubar)
self.statusbar = QStatusBar(self)
self.statusbar.setObjectName("statusbar")
self.setStatusBar(self.statusbar)
self.actionQuit = QAction(self)
self.actionQuit.setObjectName("actionQuit")
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionQuit)
self.menubar.addAction(self.menuFile.menuAction())
self.actionReset = QAction(self)
self.actionReset.setObjectName("reset")
self.menuFile.addSeparator()
self.menuFile.addAction(self.actionReset)
self.menubar.addAction(self.menuFile.menuAction())
# add other GUI objects
self.graph_widget = GraphWidget(self.statusbar)
self.gridLayout.addWidget(self.graph_widget, 1, 11, 10, 10)
pixmap = QPixmap(':/images/cta-logo-mini.png')
lbl = QLabel()
lbl.setPixmap(pixmap)
self.gridLayout.addWidget(lbl, 0, 0)
p = self.graph_widget.palette()
self.graph_widget.setAutoFillBackground(True)
p.setColor(
self.graph_widget.backgroundRole(), QColor(255, 255, 255)) # QColor(226, 235, 252))
self.graph_widget.setPalette(p)
self.quitButton = QPushButton() # self.centralwidget)
self.quitButton.setObjectName("quitButton")
self.quitButton.setText(QApplication.translate
("MainWindow", "Quit", None, QApplication.UnicodeUTF8))
self.gridLayout.addWidget(self.quitButton, 12, 0, 1, 1)
self.info_label = InfoLabel(0, 4)
self.info_label.setAutoFillBackground(True)
self.gridLayout.addWidget(self.info_label, 1, 0, 1, 5)
# self.info_label.setAlignment(PyQt4.Qt.AlignCenter);
palette = QPalette()
palette.setColor(self.info_label.backgroundRole(), Qt.lightGray)
self.info_label.setPalette(palette)
QObject.connect(
self.quitButton, SIGNAL("clicked()"), self.stop)
QObject.connect(
self.actionQuit, SIGNAL("triggered()"), self.stop)
QMetaObject.connectSlotsByName(self)
self.retranslateUi()
QObject.connect(
self.actionQuit, SIGNAL("triggered()"), self.close)
QMetaObject.connectSlotsByName(self)
# Create GuiConnexion for ZMQ comminucation with pipeline
self.guiconnection = GuiConnexion(gui_port=port, statusBar=self.statusbar)
self.guiconnection.message.connect(self.graph_widget.pipechange)
self.guiconnection.message.connect(self.info_label.pipechange)
self.guiconnection.reset_message.connect(self.graph_widget.reset)
self.guiconnection.reset_message.connect(self.info_label.reset)
self.guiconnection.mode_message.connect(self.info_label.mode_receive)
QObject.connect(
self.actionReset, SIGNAL("triggered()"), self.guiconnection.reset)
QMetaObject.connectSlotsByName(self)
# start the process
self.guiconnection.start()
def retranslateUi(self):
self.setWindowTitle(QApplication.translate(
"ctapipe-flow based GUI", "ctapipe-flow based GUI", None, QApplication.UnicodeUTF8))
self.menuFile.setTitle(QApplication.translate(
"MainWindow", "File", None, QApplication.UnicodeUTF8))
self.actionQuit.setText(QApplication.translate(
"MainWindow", "Quit", None, QApplication.UnicodeUTF8))
self.actionReset.setText(QApplication.translate(
"MainWindow", "Reset", None, QApplication.UnicodeUTF8))
def stop(self):
"""Method connect (via Qt slot) to exit button
Stops self.guiconnection (for ZMQ communication) process.
Close main_windows
"""
self.guiconnection.finish()
self.guiconnection.join()
self.close()
def closeEvent(self, event):
self.guiconnection.finish()
self.guiconnection.join()
event.accept() # let the window close
class ProcessingPlugin:
def __init__(self, iface):
self.iface = iface
def initGui(self):
Processing.initialize()
self.commander = None
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
Processing.addAlgListListener(self.toolbox)
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = self.toolbox.toggleViewAction()
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QIcon(os.path.join(cmd_folder, 'images', 'alg.png')))
self.toolboxAction.setText(self.tr('&Toolbox'))
self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T')
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'model.png')),
self.tr('Graphical &Modeler...'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M')
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'history.gif')),
self.tr('&History...'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H')
self.menu.addAction(self.historyAction)
self.configAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'config.png')),
self.tr('&Options...'), self.iface.mainWindow())
self.configAction.setObjectName('configAction')
self.configAction.triggered.connect(self.openConfig)
self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C')
self.menu.addAction(self.configAction)
self.resultsAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'results.png')),
self.tr('&Results Viewer...'), self.iface.mainWindow())
self.resultsAction.setObjectName('resultsAction')
self.resultsAction.triggered.connect(self.openResults)
self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R')
self.menu.addAction(self.resultsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),
self.menu)
self.commanderAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'commander.png')),
self.tr('&Commander'), self.iface.mainWindow())
self.commanderAction.setObjectName('commanderAction')
self.commanderAction.triggered.connect(self.openCommander)
self.menu.addAction(self.commanderAction)
self.iface.registerMainWindowAction(self.commanderAction,
self.tr('Ctrl+Alt+M'))
def unload(self):
self.toolbox.setVisible(False)
self.menu.deleteLater()
# delete temporary output files
folder = tempFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
self.iface.unregisterMainWindowAction(self.commanderAction)
def openCommander(self):
if self.commander is None:
self.commander = CommanderWindow(self.iface.mainWindow(),
self.iface.mapCanvas())
Processing.addAlgListListener(self.commander)
self.commander.prepareGui()
self.commander.show()
def openToolbox(self):
if self.toolbox.isVisible():
self.toolbox.hide()
else:
self.toolbox.show()
def openModeler(self):
dlg = ModelerDialog()
dlg.show()
dlg.exec_()
if dlg.update:
self.toolbox.updateProvider('model')
def openResults(self):
dlg = ResultsDialog()
dlg.show()
dlg.exec_()
def openHistory(self):
dlg = HistoryDialog()
dlg.exec_()
def openConfig(self):
dlg = ConfigDialog(self.toolbox)
dlg.exec_()
def tr(self, message):
return QCoreApplication.translate('ProcessingPlugin', message)
def _menu_context_tree(self, point):
index = self.indexAt(point)
if not index.isValid():
return
item = self.itemAt(point)
handler = None
menu = QMenu(self)
if item.isFolder or item.parent() is None:
self._add_context_menu_for_folders(menu, item)
elif not item.isFolder:
self._add_context_menu_for_files(menu, item)
if item.parent() is None:
#get the extra context menu for this projectType
if isinstance(item, ProjectItem):
return
handler = settings.get_project_type_handler(item.projectType)
self._add_context_menu_for_root(menu, item)
menu.addMenu(self._folding_menu)
#menu for all items (legacy API)!
extra_menus = self.extra_menus.get('all', ())
#menu for all items!
for m in extra_menus:
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#menu for the Project Type(if present)
if handler:
for m in handler.get_context_menus():
if isinstance(m, QMenu):
menu.addSeparator()
menu.addMenu(m)
#show the menu!
menu.exec_(QCursor.pos())
class BasicMonitor(QTableWidget):
"""
基础监控
headerDict中的值对应的字典格式如下
{'chinese': u'中文名', 'cellType': BasicCell}
"""
signal = QtCore.pyqtSignal(type(Event()))
signal_clear = QtCore.pyqtSignal(type(Event()))
# ----------------------------------------------------------------------
def __init__(self, mainEngine=None, eventEngine=None, parent=None):
"""Constructor"""
super(BasicMonitor, self).__init__(parent)
self.mainEngine = mainEngine
self.eventEngine = eventEngine
self.signalemit = None
self.signalclearemit = None
# 保存表头标签用
self.headerDict = OrderedDict() # 有序字典，key是英文名，value是对应的配置字典
self.headerList = [] # 对应self.headerDict.keys()
# 保存相关数据用
self.dataDict = {} # 字典，key是字段对应的数据，value是保存相关单元格的字典
self.dataKey = '' # 字典键对应的数据字段
# 监控的事件类型
self.eventType = ''
self.eventTypeClear = ''
# 字体
self.font = None
# 保存数据对象到单元格
self.saveData = False
# 默认不允许根据表头进行排序，需要的组件可以开启
self.sorting = False
# 初始化右键菜单
self.initMenu()
# ----------------------------------------------------------------------
def setHeaderDict(self, headerDict):
"""设置表头有序字典"""
self.headerDict = headerDict
self.headerList = list(headerDict.keys())
# ----------------------------------------------------------------------
def setDataKey(self, dataKey):
"""设置数据字典的键"""
self.dataKey = dataKey
# ----------------------------------------------------------------------
def setEventType(self, eventType1, eventType2=''):
"""设置监控的事件类型"""
self.eventType = eventType1
self.eventTypeClear = eventType2
# ----------------------------------------------------------------------
def setFont(self, font):
"""设置字体"""
self.font = font
# ----------------------------------------------------------------------
def setSaveData(self, saveData):
"""设置是否要保存数据到单元格"""
self.saveData = saveData
# ----------------------------------------------------------------------
def initTable(self):
"""初始化表格"""
# 设置表格的列数
col = len(self.headerDict)
self.setColumnCount(col)
# 设置列表头
labels = [d['chinese'] for d in list(self.headerDict.values())]
self.setHorizontalHeaderLabels(labels)
# 关闭左边的垂直表头
self.verticalHeader().setVisible(False)
# 设为不可编辑
self.setEditTriggers(self.NoEditTriggers)
# 设为行交替颜色
self.setAlternatingRowColors(True)
# 设置允许排序
self.setSortingEnabled(self.sorting)
# set stretch
# self.horizontalHeader().setResizeMode(QHeaderView.Stretch)
# ----------------------------------------------------------------------
def registerEvent(self):
"""注册GUI更新相关的事件监听"""
self.signal.connect(self.updateEvent)
self.signalemit = self.signal.emit
self.eventEngine.register(self.eventType, self.signalemit)
if len(self.eventTypeClear) > 0:
self.signal_clear.connect(self.clearEvent)
self.signalclearemit = self.signal_clear.emit
self.eventEngine.register(self.eventTypeClear,
self.signalclearemit)
def unRegister(self):
self.eventEngine.unregister(self.eventType, self.signalemit)
if len(self.eventTypeClear) > 0:
self.eventEngine.unregister(self.eventTypeClear,
self.signalclearemit)
# ----------------------------------------------------------------------
def updateEvent(self, event):
"""收到事件更新"""
data = event.dict_['data']
self.updateData(data)
def clearEvent(self, event):
"""收到事件更新"""
self.dataDict.clear()
self.setRowCount(0)
# ----------------------------------------------------------------------
def updateData(self, data):
"""将数据更新到表格中"""
# 如果允许了排序功能，则插入数据前必须关闭，否则插入新的数据会变乱
if self.sorting:
self.setSortingEnabled(False)
# 如果设置了dataKey，则采用存量更新模式
if self.dataKey:
#key = data.__getattribute__(self.dataKey)
key = getattr(data, self.dataKey, None)
# 如果键在数据字典中不存在，则先插入新的一行，并创建对应单元格
if key not in self.dataDict:
self.insertRow(0)
d = {}
for n, header in enumerate(self.headerList):
content = safeUnicode(data.__getattribute__(header))
# content = safeUnicode(getattr(data, header, None))
cellType = self.headerDict[header]['cellType']
try:
cell = cellType(content, self.mainEngine)
except Exception as e:
print(cellType)
print(data)
print(content)
raise (e)
if self.font:
cell.setFont(self.font) # 如果设置了特殊字体，则进行单元格设置
if self.saveData: # 如果设置了保存数据对象，则进行对象保存
cell.data = data
self.setItem(0, n, cell)
d[header] = cell
self.dataDict[key] = d
# 否则如果已经存在，则直接更新相关单元格
else:
d = self.dataDict[key]
for header in self.headerList:
content = safeUnicode(getattr(data, header, None))
cell = d[header]
cell.setContent(content)
if self.saveData: # 如果设置了保存数据对象，则进行对象保存
cell.data = data
# 否则采用增量更新模式
else:
self.insertRow(0)
for n, header in enumerate(self.headerList):
content = safeUnicode(data.__getattribute__(header))
cellType = self.headerDict[header]['cellType']
cell = cellType(content, self.mainEngine)
if self.font:
cell.setFont(self.font)
if self.saveData:
cell.data = data
self.setItem(0, n, cell)
# 调整列宽
self.resizeColumns()
# 重新打开排序
if self.sorting:
self.setSortingEnabled(True)
# ----------------------------------------------------------------------
def resizeColumns(self):
"""调整各列的大小"""
self.horizontalHeader().resizeSections(QHeaderView.ResizeToContents)
# ----------------------------------------------------------------------
def setSorting(self, sorting):
"""设置是否允许根据表头排序"""
self.sorting = sorting
# ----------------------------------------------------------------------
def saveToCsv(self):
"""保存表格内容到CSV文件"""
# 先隐藏右键菜单
self.menu.close()
# 获取想要保存的文件名
path = QtGui.QFileDialog.getSaveFileName(self, '保存数据', '',
'CSV(*.csv)')
try:
if not path.isEmpty():
with open(safeUnicode(path), 'wb') as f:
writer = csv.writer(f)
# 保存标签
headers = [
header.encode('gbk') for header in self.headerList
]
writer.writerow(headers)
# 保存每行内容
for row in range(self.rowCount()):
rowdata = []
for column in range(self.columnCount()):
item = self.item(row, column)
if item is not None:
rowdata.append(
safeUnicode(item.text()).encode('gbk'))
else:
rowdata.append('')
writer.writerow(rowdata)
except IOError:
pass
# ----------------------------------------------------------------------
def initMenu(self):
"""初始化右键菜单"""
self.menu = QMenu(self)
'''
saveAction = QAction(u'保存内容', self)
saveAction.triggered.connect(self.saveToCsv)
resizeAction = QAction(u'调整列宽', self)
resizeAction.triggered.connect(self.resizeColumns)
self.menu.addAction(resizeAction)
self.menu.addAction(saveAction)
'''
# ----------------------------------------------------------------------
def contextMenuEvent(self, event):
"""右键点击事件"""
self.menu.popup(QtGui.QCursor.pos())
def createCtxMenu(self, value, isLink, evt):
'Creates and configures the menu itself'
m = QMenu(self)
sub = QMenu(Label.BROWSER_ASSIGN_TO, m)
m.setTitle(Label.BROWSER_ASSIGN_TO)
for index, label in self._fields.items():
act = QAction(label, m,
triggered=self._makeMenuAction(index, value, isLink))
sub.addAction(act)
m.addMenu(sub)
action = m.exec_(self.mapToGlobal(evt.pos()))
def loadpopup(self, pos):
lmenu = QMenu()
loadAction = lmenu.addAction("Video laden")
action = lmenu.exec_(self.mapToGlobal(pos))
if action == loadAction:
self.handleButton()
def initGui(self):
Processing.initialize()
self.commander = None
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
Processing.addAlgListListener(self.toolbox)
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = self.toolbox.toggleViewAction()
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QIcon(os.path.join(cmd_folder, 'images', 'alg.png')))
self.toolboxAction.setText(self.tr('&Toolbox'))
self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T')
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'model.png')),
self.tr('Graphical &Modeler...'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M')
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'history.gif')),
self.tr('&History...'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H')
self.menu.addAction(self.historyAction)
self.configAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'config.png')),
self.tr('&Options...'), self.iface.mainWindow())
self.configAction.setObjectName('configAction')
self.configAction.triggered.connect(self.openConfig)
self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C')
self.menu.addAction(self.configAction)
self.resultsAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'results.png')),
self.tr('&Results Viewer...'), self.iface.mainWindow())
self.resultsAction.setObjectName('resultsAction')
self.resultsAction.triggered.connect(self.openResults)
self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R')
self.menu.addAction(self.resultsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),
self.menu)
self.commanderAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'commander.png')),
self.tr('&Commander'), self.iface.mainWindow())
self.commanderAction.setObjectName('commanderAction')
self.commanderAction.triggered.connect(self.openCommander)
self.menu.addAction(self.commanderAction)
self.iface.registerMainWindowAction(self.commanderAction,
self.tr('Ctrl+Alt+M'))
class ShellBaseWidget(ConsoleBaseWidget):
"""
Shell base widget
"""
INITHISTORY = None
SEPARATOR = None
def __init__(self, parent, history_filename, debug=False, profile=False):
"""
parent : specifies the parent widget
"""
ConsoleBaseWidget.__init__(self, parent)
# Prompt position: tuple (line, index)
self.current_prompt_pos = None
self.new_input_line = True
# History
self.histidx = None
self.hist_wholeline = False
assert isinstance(history_filename, (str, unicode))
self.history_filename = history_filename
self.history = self.load_history()
# Session
self.historylog_filename = CONF.get('main', 'historylog_filename',
get_conf_path('history.log'))
# Context menu
self.menu = None
self.setup_context_menu()
# Debug mode
self.debug = debug
# Simple profiling test
self.profile = profile
# write/flush
self.__buffer = []
self.__timestamp = 0.0
# Give focus to widget
self.setFocus()
def setup(self):
"""Reimplement ConsoleBaseWidget method"""
ConsoleBaseWidget.setup(self)
self.set_caret(color=Qt.darkGray, width=2)
self.remove_margins() # Suppressing Scintilla margins
def toggle_wrap_mode(self, enable):
"""Reimplement ConsoleBaseWidget method: 'word' -> 'character'"""
self.set_wrap_mode('character' if enable else None)
def set_font(self, font):
"""Set shell styles font"""
self.set_pythonshell_font(font)
#------ Context menu
def setup_context_menu(self):
"""Setup shell context menu"""
self.menu = QMenu(self)
self.cut_action = create_action(self,
translate("ShellBaseWidget", "Cut"),
shortcut=keybinding('Cut'),
icon=get_icon('editcut.png'),
triggered=self.cut)
self.copy_action = create_action(self,
translate("ShellBaseWidget", "Copy"),
shortcut=keybinding('Copy'),
icon=get_icon('editcopy.png'),
triggered=self.copy)
paste_action = create_action(self,
translate("ShellBaseWidget", "Paste"),
shortcut=keybinding('Paste'),
icon=get_icon('editpaste.png'),
triggered=self.paste)
save_action = create_action(self,
translate("ShellBaseWidget",
"Save history log..."),
icon=get_icon('filesave.png'),
tip=translate(
"ShellBaseWidget",
"Save current history log (i.e. all "
"inputs and outputs) in a text file"),
triggered=self.save_historylog)
add_actions(self.menu, (self.cut_action, self.copy_action,
paste_action, None, save_action))
def contextMenuEvent(self, event):
"""Reimplement Qt method"""
state = self.hasSelectedText()
self.copy_action.setEnabled(state)
self.cut_action.setEnabled(state)
self.menu.popup(event.globalPos())
event.accept()
#------ Input buffer
def get_current_line_to_cursor(self):
return self.get_text(self.current_prompt_pos, 'cursor')
def get_current_line_from_cursor(self):
return self.get_text('cursor', 'eof')
def _select_input(self):
"""Select current line (without selecting console prompt)"""
line, index = self.get_position('eof')
if self.current_prompt_pos is None:
pline, pindex = line, index
else:
pline, pindex = self.current_prompt_pos
self.setSelection(pline, pindex, line, index)
def clear_line(self):
"""Clear current line (without clearing console prompt)"""
if self.current_prompt_pos is not None:
self.remove_text(self.current_prompt_pos, 'eof')
def clear_terminal(self):
"""
Clear terminal window
Child classes reimplement this method to write prompt
"""
self.clear()
# The buffer being edited
def _set_input_buffer(self, text):
"""Set input buffer"""
if self.current_prompt_pos is not None:
self.replace_text(self.current_prompt_pos, 'eol', text)
else:
self.insert(text)
self.set_cursor_position('eof')
def _get_input_buffer(self):
"""Return input buffer"""
input_buffer = ''
if self.current_prompt_pos is not None:
input_buffer = self.get_text(self.current_prompt_pos, 'eol')
input_buffer = input_buffer.replace(os.linesep, '\n')
return input_buffer
input_buffer = pyqtProperty("QString", _get_input_buffer,
_set_input_buffer)
#------ Prompt
def new_prompt(self, prompt):
"""
Print a new prompt and save its (line, index) position
"""
self.write(prompt, prompt=True)
# now we update our cursor giving end of prompt
self.current_prompt_pos = self.get_position('cursor')
self.ensureCursorVisible()
self.new_input_line = False
def check_selection(self):
"""
Check if selected text is r/w,
otherwise remove read-only parts of selection
"""
if self.current_prompt_pos is None:
self.set_cursor_position('eof')
else:
self.truncate_selection(self.current_prompt_pos)
#------ Copy / Keyboard interrupt
def copy(self):
"""Copy text to clipboard... or keyboard interrupt"""
if self.hasSelectedText():
text = unicode(self.selectedText()).replace(u"\u2029", os.linesep)
QApplication.clipboard().setText(text)
else:
self.emit(SIGNAL("keyboard_interrupt()"))
def cut(self):
"""Cut text"""
self.check_selection()
if self.hasSelectedText():
ConsoleBaseWidget.cut(self)
def delete(self):
"""Remove selected text"""
self.check_selection()
if self.hasSelectedText():
ConsoleBaseWidget.removeSelectedText(self)
def save_historylog(self):
"""Save current history log (all text in console)"""
title = translate("ShellBaseWidget", "Save history log")
self.emit(SIGNAL('redirect_stdio(bool)'), False)
filename = QFileDialog.getSaveFileName(self, title,
self.historylog_filename,
"History logs (*.log)")
self.emit(SIGNAL('redirect_stdio(bool)'), True)
if filename:
filename = osp.normpath(unicode(filename))
try:
encoding.write(unicode(self.text()), filename)
self.historylog_filename = filename
CONF.set('main', 'historylog_filename', filename)
except EnvironmentError, error:
QMessageBox.critical(self, title,
translate("ShellBaseWidget",
"<b>Unable to save file '%1'</b>"
"<br><br>Error message:<br>%2") \
.arg(osp.basename(filename)).arg(str(error)))
def initMenu(self):
"""初始化右键菜单"""
self.menu = QMenu(self)
'''
def createContextMenu(self):
menu = QMenu()
actionAddGroup = QgisHelper.createAction(menu, "&Add GroupLayer",
self.addGroup)
actionAddVectorLayer = QgisHelper.createAction(menu,
"&Add VectorLayer",
self.addVectorLayer)
actionZoomToGroup = QgisHelper.createAction(menu, "&Zoom To Group",
self.zoomToGroup)
actionRenameGroupOrLayer = QgisHelper.createAction(
menu, "&Rename", self.rename)
actionRemoveLayer = QgisHelper.createAction(menu, "&Remove",
self.removeLayer)
actionGroupSelected = QgisHelper.createAction(menu, "&Group Selected",
self.groupSelected)
actionZoomToLayer = QgisHelper.createAction(menu, "&Zoom To Layer",
self.zoomToLayer)
actionOpenAttributetable = QgisHelper.createAction(
menu, "&Open Attribute Table", self.openAttriTable)
actionSaveAs = QgisHelper.createAction(menu, "&Save as...",
self.saveAs)
actionLayerProperty = QgisHelper.createAction(menu, "&Property",
self.layerProperty)
self.actionShowOverview = QgisHelper.createAction(
menu, "&Show in overview...", self.showOverview, None, None, None,
True)
idx = self.mView.currentIndex()
node = self.mView.layerTreeModel().index2node(idx)
if not idx.isValid():
#global menu
menu.addAction(actionAddGroup)
menu.addAction(actionAddVectorLayer)
# menu.addAction( QgsApplication.getThemeIcon( "/mActionExpandTree.png" ), "&Expand All" , self.mView, "expandAll()" )
# menu.addAction( QgsApplication.getThemeIcon( "/mActionCollapseTree.png" ), "&Collapse All" , self.mView, "collapseAll()" )
elif (node != None):
if (QgsLayerTree.isGroup(node)):
menu.addAction(actionZoomToGroup)
menu.addAction(actionRemoveLayer)
# menu.addAction( QgsApplication.getThemeIcon( "/mActionSetCRS.png" ),
# tr( "&Set Group CRS" ), QgisApp.instance(), SLOT( legendGroupSetCRS() ) );
menu.addAction(actionRenameGroupOrLayer)
if (str(self.mView.selectedNodes(True)) >= 2):
menu.addAction(actionGroupSelected)
menu.addAction(actionAddGroup)
menu.addAction(actionAddVectorLayer)
elif (QgsLayerTree.isLayer(node)):
menu.addAction(actionZoomToLayer)
menu.addAction(actionRemoveLayer)
menu.addAction(self.actionShowOverview)
if self.mView.currentLayer().type() == QgsMapLayer.VectorLayer:
menu.addAction(actionOpenAttributetable)
menu.addAction(actionLayerProperty)
menu.addAction(actionSaveAs)
# menu.addAction( actions.actionShowInOverview( menu ) )
# if layer.type() == QgsMapLayer.RasterLayer :
# menu.addAction( "&Zoom to Best Scale (100%)" , QgisApp.instance(), " legendLayerZoomNative() " )
# rasterLayer = qobject_cast<QgsRasterLayer *>( layer );
# if ( rasterLayer && rasterLayer.rastertype() != QgsRasterLayer.Palette )
# menu.addAction( tr( "&Stretch Using Current Extent" ), QgisApp.instance(), SLOT( legendLayerStretchUsingCurrentExtent() ) );
# }
# menu.addAction( QgsApplication.getThemeIcon( "/mActionRemoveLayer.svg" ), tr( "&Remove" ), QgisApp.instance(), " removeLayer() ");
# // duplicate layer
# QAction* duplicateLayersAction = menu.addAction( QgsApplication.getThemeIcon( "/mActionDuplicateLayer.svg" ), tr( "&Duplicate" ), QgisApp.instance(), SLOT( duplicateLayers() ) );
#
# // set layer scale visibility
# menu.addAction( tr( "&Set Layer Scale Visibility" ), QgisApp.instance(), SLOT( setLayerScaleVisibility() ) );
#
# // set layer crs
# menu.addAction( QgsApplication.getThemeIcon( "/mActionSetCRS.png" ), tr( "&Set Layer CRS" ), QgisApp.instance(), SLOT( setLayerCRS() ) );
#
# // assign layer crs to project
# menu.addAction( QgsApplication.getThemeIcon( "/mActionSetProjectCRS.png" ), tr( "Set &Project CRS from Layer" ), QgisApp.instance(), SLOT( setProjectCRSFromLayer() ) );
#
# menu.addSeparator();
#
# if ( layer && layer.type() == QgsMapLayer.VectorLayer )
# {
# QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer *>( layer );
#
# QAction *toggleEditingAction = QgisApp.instance().actionToggleEditing();
# QAction *saveLayerEditsAction = QgisApp.instance().actionSaveActiveLayerEdits();
# QAction *allEditsAction = QgisApp.instance().actionAllEdits();
#
# // attribute table
# menu.addAction( QgsApplication.getThemeIcon( "/mActionOpenTable.png" ), tr( "&Open Attribute Table" ),
# QgisApp.instance(), SLOT( attributeTable() ) );
#
# // allow editing
# int cap = vlayer.dataProvider().capabilities();
# if ( cap & QgsVectorDataProvider.EditingCapabilities )
# {
# if ( toggleEditingAction )
# {
# menu.addAction( toggleEditingAction );
# toggleEditingAction.setChecked( vlayer.isEditable() );
# }
# if ( saveLayerEditsAction && vlayer.isModified() )
# {
# menu.addAction( saveLayerEditsAction );
# }
# }
#
# if ( allEditsAction.isEnabled() )
# menu.addAction( allEditsAction );
#
# // disable duplication of memory layers
# if ( vlayer.storageType() == "Memory storage" && self.mView.selectedLayerNodes().count() == 1 )
# duplicateLayersAction.setEnabled( false );
#
# // save as vector file
# menu.addAction( tr( "Save As..." ), QgisApp.instance(), SLOT( saveAsFile() ) );
# menu.addAction( tr( "Save As Layer Definition File..." ), QgisApp.instance(), SLOT( saveAsLayerDefinition() ) );
#
# if ( !vlayer.isEditable() && vlayer.dataProvider().supportsSubsetString() && vlayer.vectorJoins().isEmpty() )
# menu.addAction( tr( "&Filter..." ), QgisApp.instance(), SLOT( layerSubsetString() ) );
#
# menu.addAction( actions.actionShowFeatureCount( menu ) );
#
# menu.addSeparator();
# }
# else if ( layer && layer.type() == QgsMapLayer.RasterLayer )
# {
# menu.addAction( tr( "Save As..." ), QgisApp.instance(), SLOT( saveAsRasterFile() ) );
# menu.addAction( tr( "Save As Layer Definition File..." ), QgisApp.instance(), SLOT( saveAsLayerDefinition() ) );
# }
# else if ( layer && layer.type() == QgsMapLayer.PluginLayer && self.mView.selectedLayerNodes().count() == 1 )
# {
# // disable duplication of plugin layers
# duplicateLayersAction.setEnabled( false );
# }
# addCustomLayerActions( menu, layer );
#
# if ( layer && QgsProject.instance().layerIsEmbedded( layer.id() ).isEmpty() )
# menu.addAction( tr( "&Properties" ), QgisApp.instance(), SLOT( layerProperties() ) );
# if ( node.parent() != self.mView.layerTreeModel().rootGroup() ):
# menu.addAction( actions.actionMakeTopLevel( menu ) )
menu.addAction(actionRenameGroupOrLayer)
if (len(self.mView.selectedNodes(True)) >= 2):
menu.addAction(actionGroupSelected)
# if ( self.mView.selectedLayerNodes().count() == 1 )
# {
# QgisApp* app = QgisApp.instance();
# menu.addAction( tr( "Copy Style" ), app, SLOT( copyStyle() ) );
# if ( app.clipboard().hasFormat( QGSCLIPBOARD_STYLE_MIME ) )
# {
# menu.addAction( tr( "Paste Style" ), app, SLOT( pasteStyle() ) );
# }
# }
return menu
def popup2(self, pos):
contextmenu = QMenu()
contextmenu.addAction("Play / Pause (SPACE)", self.handlePlayButton)
contextmenu.addSeparator()
contextmenu.addAction("Load Video (o)", self.handleButton)
contextmenu.addAction("Toggle Slider (s)", self.toggleSlider)
contextmenu.addSeparator()
contextmenu.addAction("Information (i)", self.handleInfo)
contextmenu.addSeparator()
contextmenu.addAction("Exit (q)", self.handleQuit)
contextmenu.exec_(QCursor.pos())
class DirectoriesDialog(QMainWindow):
def __init__(self, parent, app):
QMainWindow.__init__(self, None)
self.app = app
self.lastAddedFolder = platform.INITIAL_FOLDER_IN_DIALOGS
self.recentFolders = Recent(self.app, 'recentFolders')
self._setupUi()
self.directoriesModel = DirectoriesModel(self.app.model.directory_tree,
view=self.treeView)
self.directoriesDelegate = DirectoriesDelegate()
self.treeView.setItemDelegate(self.directoriesDelegate)
self._setupColumns()
self.app.recentResults.addMenu(self.menuLoadRecent)
self.app.recentResults.addMenu(self.menuRecentResults)
self.recentFolders.addMenu(self.menuRecentFolders)
self._updateAddButton()
self._updateRemoveButton()
self._updateLoadResultsButton()
self._setupBindings()
def _setupBindings(self):
self.scanButton.clicked.connect(self.scanButtonClicked)
self.loadResultsButton.clicked.connect(self.actionLoadResults.trigger)
self.addFolderButton.clicked.connect(self.actionAddFolder.trigger)
self.removeFolderButton.clicked.connect(self.removeFolderButtonClicked)
self.treeView.selectionModel().selectionChanged.connect(
self.selectionChanged)
self.app.recentResults.itemsChanged.connect(
self._updateLoadResultsButton)
self.recentFolders.itemsChanged.connect(self._updateAddButton)
self.recentFolders.mustOpenItem.connect(self.app.model.add_directory)
self.directoriesModel.foldersAdded.connect(
self.directoriesModelAddedFolders)
self.app.willSavePrefs.connect(self.appWillSavePrefs)
def _setupActions(self):
# (name, shortcut, icon, desc, func)
ACTIONS = [
('actionLoadResults', 'Ctrl+L', '', tr("Load Results..."),
self.loadResultsTriggered),
('actionShowResultsWindow', '', '', tr("Results Window"),
self.app.showResultsWindow),
('actionAddFolder', '', '', tr("Add Folder..."),
self.addFolderTriggered),
]
createActions(ACTIONS, self)
def _setupMenu(self):
self.menubar = QMenuBar(self)
self.menubar.setGeometry(QRect(0, 0, 42, 22))
self.menuFile = QMenu(self.menubar)
self.menuFile.setTitle(tr("File"))
self.menuView = QMenu(self.menubar)
self.menuView.setTitle(tr("View"))
self.menuHelp = QMenu(self.menubar)
self.menuHelp.setTitle(tr("Help"))
self.menuLoadRecent = QMenu(self.menuFile)
self.menuLoadRecent.setTitle(tr("Load Recent Results"))
self.setMenuBar(self.menubar)
self.menuFile.addAction(self.actionLoadResults)
self.menuFile.addAction(self.menuLoadRecent.menuAction())
self.menuFile.addSeparator()
self.menuFile.addAction(self.app.actionQuit)
self.menuView.addAction(self.app.actionPreferences)
self.menuView.addAction(self.actionShowResultsWindow)
self.menuView.addAction(self.app.actionIgnoreList)
self.menuHelp.addAction(self.app.actionShowHelp)
self.menuHelp.addAction(self.app.actionRegister)
self.menuHelp.addAction(self.app.actionCheckForUpdate)
self.menuHelp.addAction(self.app.actionOpenDebugLog)
self.menuHelp.addAction(self.app.actionAbout)
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuView.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
# Recent folders menu
self.menuRecentFolders = QMenu()
self.menuRecentFolders.addAction(self.actionAddFolder)
self.menuRecentFolders.addSeparator()
# Recent results menu
self.menuRecentResults = QMenu()
self.menuRecentResults.addAction(self.actionLoadResults)
self.menuRecentResults.addSeparator()
def _setupUi(self):
self.setWindowTitle(self.app.NAME)
self.resize(420, 338)
self.centralwidget = QWidget(self)
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.promptLabel = QLabel(
tr("Select folders to scan and press \"Scan\"."),
self.centralwidget)
self.verticalLayout.addWidget(self.promptLabel)
self.treeView = QTreeView(self.centralwidget)
self.treeView.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
self.treeView.setAcceptDrops(True)
triggers = QAbstractItemView.DoubleClicked|QAbstractItemView.EditKeyPressed\
|QAbstractItemView.SelectedClicked
self.treeView.setEditTriggers(triggers)
self.treeView.setDragDropOverwriteMode(True)
self.treeView.setDragDropMode(QAbstractItemView.DropOnly)
self.treeView.setUniformRowHeights(True)
self.verticalLayout.addWidget(self.treeView)
self.horizontalLayout = QHBoxLayout()
self.removeFolderButton = QPushButton(self.centralwidget)
self.removeFolderButton.setIcon(QIcon(QPixmap(":/minus")))
self.removeFolderButton.setShortcut("Del")
self.horizontalLayout.addWidget(self.removeFolderButton)
self.addFolderButton = QPushButton(self.centralwidget)
self.addFolderButton.setIcon(QIcon(QPixmap(":/plus")))
self.horizontalLayout.addWidget(self.addFolderButton)
spacerItem1 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem1)
self.loadResultsButton = QPushButton(self.centralwidget)
self.loadResultsButton.setText(tr("Load Results"))
self.horizontalLayout.addWidget(self.loadResultsButton)
self.scanButton = QPushButton(self.centralwidget)
self.scanButton.setText(tr("Scan"))
self.scanButton.setDefault(True)
self.horizontalLayout.addWidget(self.scanButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.setCentralWidget(self.centralwidget)
self._setupActions()
self._setupMenu()
if self.app.prefs.directoriesWindowRect is not None:
self.setGeometry(self.app.prefs.directoriesWindowRect)
else:
moveToScreenCenter(self)
def _setupColumns(self):
header = self.treeView.header()
header.setStretchLastSection(False)
header.setResizeMode(0, QHeaderView.Stretch)
header.setResizeMode(1, QHeaderView.Fixed)
header.resizeSection(1, 100)
def _updateAddButton(self):
if self.recentFolders.isEmpty():
self.addFolderButton.setMenu(None)
else:
self.addFolderButton.setMenu(self.menuRecentFolders)
def _updateRemoveButton(self):
indexes = self.treeView.selectedIndexes()
if not indexes:
self.removeFolderButton.setEnabled(False)
return
self.removeFolderButton.setEnabled(True)
def _updateLoadResultsButton(self):
if self.app.recentResults.isEmpty():
self.loadResultsButton.setMenu(None)
else:
self.loadResultsButton.setMenu(self.menuRecentResults)
#--- QWidget overrides
def closeEvent(self, event):
event.accept()
if self.app.model.results.is_modified:
title = tr("Unsaved results")
msg = tr("You have unsaved results, do you really want to quit?")
if not self.app.confirm(title, msg):
event.ignore()
if event.isAccepted():
QApplication.quit()
#--- Events
def addFolderTriggered(self):
title = tr("Select a folder to add to the scanning list")
flags = QFileDialog.ShowDirsOnly
dirpath = str(
QFileDialog.getExistingDirectory(self, title, self.lastAddedFolder,
flags))
if not dirpath:
return
self.lastAddedFolder = dirpath
self.app.model.add_directory(dirpath)
self.recentFolders.insertItem(dirpath)
def appWillSavePrefs(self):
self.app.prefs.directoriesWindowRect = self.geometry()
def directoriesModelAddedFolders(self, folders):
for folder in folders:
self.recentFolders.insertItem(folder)
def loadResultsTriggered(self):
title = tr("Select a results file to load")
files = ';;'.join(
[tr("dupeGuru Results (*.dupeguru)"),
tr("All Files (*.*)")])
destination = QFileDialog.getOpenFileName(self, title, '', files)
if destination:
self.app.model.load_from(destination)
self.app.recentResults.insertItem(destination)
def removeFolderButtonClicked(self):
self.directoriesModel.model.remove_selected()
def scanButtonClicked(self):
if self.app.model.results.is_modified:
title = tr("Start a new scan")
msg = tr(
"You have unsaved results, do you really want to continue?")
if not self.app.confirm(title, msg):
return
self.app.model.start_scanning()
def selectionChanged(self, selected, deselected):
self._updateRemoveButton()
def __init__(self,
iface,
objectTypeManager,
pluginManager,
exportSettings=None,
lastTreeItemData=None):
QDialog.__init__(self, iface.mainWindow())
self.iface = iface
self.objectTypeManager = objectTypeManager
self.pluginManager = pluginManager
self._settings = exportSettings or {}
self.lastTreeItemData = lastTreeItemData
self.localBrowsingMode = True
self.rb_quads = self.rb_point = None
self.templateType = None
self.currentItem = None
self.currentPage = None
# Set up the user interface from Designer.
self.ui = ui = Ui_Qgis2threejsDialog()
ui.setupUi(self)
self.setWindowFlags(self.windowFlags() | Qt.WindowMinimizeButtonHint)
# output html filename
ui.lineEdit_OutputFilename.setText(
self._settings.get("OutputFilename", ""))
ui.lineEdit_OutputFilename.setPlaceholderText("[Temporary file]")
# settings button
icon = QIcon(os.path.join(tools.pluginDir(), "icons", "settings.png"))
ui.toolButton_Settings.setIcon(icon)
# popup menu displayed when settings button is pressed
items = [["Load Settings...", self.loadSettings],
["Save Settings As...", self.saveSettings], [None, None],
["Clear Settings", self.clearSettings], [None, None],
["Plugin Settings...", self.pluginSettings]]
self.menu = QMenu()
self.menu_actions = []
for text, slot in items:
if text:
action = QAction(text, iface.mainWindow())
action.triggered.connect(slot)
self.menu.addAction(action)
self.menu_actions.append(action)
else:
self.menu.addSeparator()
ui.toolButton_Settings.setMenu(self.menu)
ui.toolButton_Settings.setPopupMode(QToolButton.InstantPopup)
# progress bar and message label
ui.progressBar.setVisible(False)
ui.label_MessageIcon.setVisible(False)
# buttons
ui.pushButton_Run.clicked.connect(self.run)
ui.pushButton_Close.clicked.connect(self.reject)
ui.pushButton_Help.clicked.connect(self.help)
# set up map tool
self.previousMapTool = None
self.mapTool = RectangleMapTool(iface.mapCanvas())
#self.mapTool = PointMapTool(iface.mapCanvas())
# set up the template combo box
self.initTemplateList()
self.ui.comboBox_Template.currentIndexChanged.connect(
self.currentTemplateChanged)
# set up the properties pages
self.pages = {}
self.pages[ppages.PAGE_WORLD] = ppages.WorldPropertyPage(self)
self.pages[ppages.PAGE_CONTROLS] = ppages.ControlsPropertyPage(self)
self.pages[ppages.PAGE_DEM] = ppages.DEMPropertyPage(self)
self.pages[ppages.PAGE_VECTOR] = ppages.VectorPropertyPage(self)
container = ui.propertyPagesContainer
for page in self.pages.itervalues():
page.hide()
container.addWidget(page)
# build object tree
self.topItemPages = {
ObjectTreeItem.ITEM_WORLD: ppages.PAGE_WORLD,
ObjectTreeItem.ITEM_CONTROLS: ppages.PAGE_CONTROLS,
ObjectTreeItem.ITEM_DEM: ppages.PAGE_DEM
}
self.initObjectTree()
self.ui.treeWidget.currentItemChanged.connect(
self.currentObjectChanged)
self.ui.treeWidget.itemChanged.connect(self.objectItemChanged)
self.currentTemplateChanged() # update item visibility
ui.toolButton_Browse.clicked.connect(self.browseClicked)
class myMainWindow(QMainWindow, Ui_MainWindow):
askusersig = pyqtSignal(str, str, str, str, str, str) #connected to askUserOUT
refreshmodelsig = pyqtSignal(str)
update_bytestatssig = pyqtSignal(str)
refreshconnectionssig = pyqtSignal()
refreshrulessig = pyqtSignal()
prevstats = ''
model = None
sourcemodel = None
menu = None
#index = None
out_rules_num = 0
def __init__(self):
QMainWindow.__init__(self)
self.setupUi(self)
#title2 = '我的个人防火墙'
#print title2
#title = QString(u'我的个人防火墙')
self.setWindowTitle(u'我的个人防火墙')
#self.setWindowTitle(title)
#self.setWindowIcon(QIcon(":/pics/pic.jpg"))
self.tableView.setShowGrid(False)
self.actionDisplay.triggered.connect(self.displayconnections)
self.actionList_Rules.triggered.connect(self.listrules)
self.actionAdd_Rules.triggered.connect(self.addrules)
self.actionDisconnect.triggered.connect(self.disconnection)
self.actionReconnect.triggered.connect(self.reconnection)
self.actionMessage.triggered.connect(self.message)
#self.menuRules.aboutToShow.connect(self.rulesMenuTriggered)
#self.menuRules.actions()[0].triggered.connect(self.deleteMenuTriggered)
#self.actionShow_active_only.triggered.connect(self.showActiveOnly)
#self.actionShow_all.triggered.connect(self.showAll)
self.actionExit.triggered.connect(self.realQuit)
self.askusersig.connect(self.askUser)
self.update_bytestatssig.connect(self.update_bytestats)
self.refreshmodelsig.connect(self.refreshmodel)
self.refreshconnectionssig.connect(self.refreshconnections)
self.refreshrulessig.connect(self.refreshrules)
#msgQueue.put('LIST')
def message(self):
dialog = msgdialog
dialog.show()
def disconnection(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect( ('127.0.0.1', 9999) )
sock.send("--disconnect")
data = sock.recv(1024)
print data
sock.close()
def reconnection(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect( ('127.0.0.1', 9999) )
sock.send("--reconnect")
data = sock.recv(1024)
print data
sock.close()
def addrules(self):
dialog = addruledialog
dialog.show()
def contextMenuEvent(self, event):
current_layout_lock.acquire()
if(self.sourcemodel.current_layout == "conn"):
current_layout_lock.release()
return
current_layout_lock.release()
#self.index = self.sourcemodel.indexAt(event.pos())
self.menu = QMenu(self)
delete_ruleAction = QAction(u"删除", self)
delete_ruleAction.triggered.connect(self.deleterule)
self.menu.addAction(delete_ruleAction)
self.menu.popup(QtGui.QCursor.pos())
def deleterule(self):
#index = self.tableView.selectedIndexes()
#print(index[0].row())
row_num = (self.tableView.selectedIndexes())[0].row()
if(row_num < self.out_rules_num):
#print ("-d OUT " + str(row_num + 1))
cmd_del = "-d OUT " + str(row_num + 1)
else:
#print ("-d IN " + str(row_num - self.out_rules_num + 1))
cmd_del = "-d IN " + str(row_num - self.out_rules_num + 1)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 9999))
sock.send(cmd_del)
result = sock.recv(1024)
print(result)
sock.close()
self.refreshrules()
def listrules(self):
self.sourcemodel.layout_change_to_rule_sig.emit()
self.refreshrules()
def refreshrules(self):
#self.sourcemodel.layout_change_to_rule_sig.emit()
current_layout_lock.acquire()
if(self.sourcemodel.current_layout != "rule"):
print ("refreshrules error")
current_layout_lock.release()
return
self.sourcemodel.layoutAboutToBeChanged.emit()
self.sourcemodel.removeRows(0, self.sourcemodel.rowCount())
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1', 9999))
sock.send("--list")
ruleslist = ''
while(True):
data = sock.recv(1024)
if not data:
break
ruleslist = ruleslist + data
sock.close()
#print (ruleslist)
if ruleslist:
self.out_rules_num = 0
for ruleline in ruleslist[0:-1].split('\n'):
#print ( 'line: ' + line)
items = ruleline.split()
print (items)
if(items[0] == 'direction:OUT'):
self.out_rules_num += 1
direction = QStandardItem((items[0].split(':'))[1])
lport = QStandardItem((items[1].split(':'))[1])
raddr = QStandardItem((items[3].split(':'))[1])
rport = QStandardItem((items[5].split(':'))[1])
proto = QStandardItem((items[6].split(':'))[1])
target = QStandardItem((items[7].split(':'))[1])
#print (direction + ':' + lport + ':' + raddr + ':' + rport + ':' + proto + ':' + target)
self.sourcemodel.appendRow( (direction, lport, raddr, rport, proto, target) )
self.sourcemodel.layoutChanged.emit()
current_layout_lock.release()
def displayconnections(self):
'''
if(self.sourcemodel.current_layout == "conn"):
self.refreshconnectionssig.emit()
else:
self.sourcemode.layout_change_to_conn_sig.emit()
self.refreshconnections()
'''
self.sourcemodel.layout_change_to_conn_sig.emit()
self.refreshconnections()
def refreshconnections(self):
current_layout_lock.acquire()
if(self.sourcemodel.current_layout != "conn"):
print ("refreshconnections error")
current_layout_lock.release()
return
self.sourcemodel.layoutAboutToBeChanged.emit()
self.sourcemodel.removeRows(0, self.sourcemodel.rowCount())
for conn in psutil.net_connections("inet4"):
if(conn.type == socket.SOCK_STREAM):
proto = QStandardItem("tcp")
else:
proto = QStandardItem("udp")
laddr = QStandardItem(conn.laddr[0])
lport = QStandardItem(str(conn.laddr[1]))
if(len(conn.raddr) == 0):
continue
raddr = QStandardItem(conn.raddr[0])
rport = QStandardItem(str(conn.raddr[1]))
status = QStandardItem(conn.status)
pid = QStandardItem(str(conn.pid))
if(conn.pid != None):
p = psutil.Process(conn.pid)
name = QStandardItem(p.name())
else:
name = QStandardItem("None")
family = QStandardItem("ipv4")
self.sourcemodel.appendRow( (family, proto, laddr, lport, raddr, rport, status, pid, name))
self.sourcemodel.layoutChanged.emit()
current_layout_lock.release()
def showActiveOnly(self):
self.model.toggle_mode_sig.emit('SHOW ACTIVE ONLY')
self.actionShow_active_only.setEnabled(False)
self.actionShow_all.setEnabled(True)
self.actionShow_all.setChecked(False)
def showAll(self):
self.model.toggle_mode_sig.emit('SHOW ALL')
self.actionShow_active_only.setEnabled(True)
self.actionShow_all.setEnabled(False)
self.actionShow_active_only.setChecked(False)
@pyqtSlot(str, str, str, str, str, str)
def askUser(self, req_str_in, path_in, pid_in, addr_in, dport_in, sport_in):
#print "In askUser"
#Convert all incoming QString into normal python strings
req_str = str(req_str_in)
path = unicode(QString.fromUtf8(path_in))
pid = str(pid_in)
addr = str(addr_in)
dport = str(dport_in)
sport = str(sport_in)
if (req_str == 'REQUEST_OUT'):
dialog = dialogOut
rport = sport
lport = dport
elif (req_str == 'REQUEST_IN'):
dialog = dialogOut
rport = dport
lport = sport
name = string.rsplit(path,"/",1)
dialog.path = path
dialog.pid = pid
dialog.label_name.setText(name[1])
dialog.label_ip.setText(addr)
dialog.label_domain.setText("Looking up DNS...")
fullpath = QTableWidgetItem(unicode(QString.fromUtf8(path)))
dialog.tableWidget_details.setItem(0,1,fullpath)
pid_item = QTableWidgetItem(pid)
dialog.tableWidget_details.setItem(1,1,pid_item)
remoteip = QTableWidgetItem(addr)
dialog.tableWidget_details.setItem(2,1,remoteip)
dns = QTableWidgetItem("Looking up DNS...")
dialog.tableWidget_details.setItem(3,1,dns)
rport_item = QTableWidgetItem(rport)
dialog.tableWidget_details.setItem(4,1,rport_item)
lport_item = QTableWidgetItem(lport)
dialog.tableWidget_details.setItem(5,1,lport_item)
QHostInfo.lookupHost(addr, dialog.dnsLookupFinished)
#we don't want the user to accidentally trigger ALLOW
dialog.pushButton_deny.setFocus()
dialog.show()
def rulesMenuTriggered(self):
"If no rules are selected in the view, grey out the Delete... item"
if (len(self.tableView.selectedIndexes()) == 0):
self.menuRules.actions()[0].setEnabled(False)
else:
self.menuRules.actions()[0].setEnabled(True)
def deleteMenuTriggered(self):
"send delete request to backend"
selected_indexes = self.tableView.selectedIndexes()
bFound = False
for index in selected_indexes:
if index.column() != 3: continue
path = unicode(index.data().toPyObject())
bFound = True
break
if not bFound:
#print 'Could not find the path to delete'
return
msgQueue.put('DELETE ' + b64encode(bytearray(path, encoding='utf-8')))
def closeEvent(self, event):
event.ignore()
self.hide()
def realQuit(self):
#print "see you later..."
#msgQueue.put('UNREGISTER')
time.sleep(1) #allow queue to be processed
exit(1)
@pyqtSlot(unicode)
def refreshmodel(self, data_in):
"Fill the frontend with rules data"
rawstr = unicode(QString.fromUtf8(data_in))
export_list = []
rules = rawstr[len('RULES_LIST'):].split('CRLF')
for one_rule in rules:
split_rule = one_rule.split()
if len(split_rule) != 5: continue
export_list.append(split_rule)
export_list.append("EOF")
ruleslist = export_list
#empty the model, we're filling it anew, we can't use clear() cause it flushes headers too:
modellock.acquire()
self.sourcemodel.layoutAboutToBeChanged.emit()
self.sourcemodel.removeRows(0, self.sourcemodel.rowCount())
#if there's only one element, it's EOF; dont go through iterations,just leave the model empty
if (len(ruleslist) == 1):
self.sourcemodel.layoutChanged.emit()
modellock.release()
return
for item in ruleslist[0:-1]:#leave out the last EOF from iteration
path_u = b64decode(item[0]).decode('utf-8')
fullpath = QStandardItem(path_u)
#item[4] contains nfmark
fullpath.setData(item[4])
if (item[1] == "0"):
pid_string = "N/A"
else:
pid_string = item[1]
pid = QStandardItem(pid_string)
perms = QStandardItem(item[2])
#only the name of the executable after the last /
m_list = string.rsplit(path_u,"/",1)
m_name = m_list[1]
name = QStandardItem(m_name)
in_allow_traf = QStandardItem()
out_allow_traf = QStandardItem()
in_deny_traf = QStandardItem()
out_deny_traf = QStandardItem()
self.sourcemodel.appendRow( (name, pid, perms, fullpath,
in_allow_traf, out_allow_traf, in_deny_traf, out_deny_traf) )
#print "Received: %s" %(item[0])
self.sourcemodel.layoutChanged.emit()
modellock.release()
self.update_bytestats()
#Update and remember the stats. The stats may be restored from
#a previous save when model refreshes
@pyqtSlot(str)
def update_bytestats(self, data_in = ''):
data = str(data_in)
items = []
if (data):
message = data.split('EOL')[-2] #discard the last empty one and take the one before it
#take the last message with 5 elements as it is the most recent one
items = message.split('CRLF')[:-1] #discard the last empty one
if (items):
self.prevstats = items
else:
items = self.prevstats
#one item looks like '1212 3232 3243 4343 43434'
modellock.acquire()
self.sourcemodel.layoutAboutToBeChanged.emit()
for one_item in items:
fields = one_item.split()
for j in range(self.sourcemodel.rowCount()):
#4th element of each line has nfmark in its data field
if (self.sourcemodel.item(j,3).data().toString() != fields[0]): continue
#else
self.sourcemodel.item(j,4).setText(fields[1])
self.sourcemodel.item(j,5).setText(fields[2])
self.sourcemodel.item(j,6).setText(fields[3])
self.sourcemodel.item(j,7).setText(fields[4])
break
self.sourcemodel.layoutChanged.emit()
modellock.release()
def initializeOperationActions(self):
actionGroup = QtGui.QActionGroup(self)
self.showAllAction = KToggleAction(KIcon("applications-other"),
i18n("All Packages"), self)
self.actionCollection().addAction("showAllAction", self.showAllAction)
self.connect(self.showAllAction, SIGNAL("triggered()"),
lambda: self.cw.switchState(StateManager.ALL))
self.cw.stateTab.addTab(QWidget(), KIcon("applications-other"),
i18n("All Packages"))
actionGroup.addAction(self.showAllAction)
self.showInstallAction = KToggleAction(KIcon("list-add"),
i18n("Installable Packages"),
self)
self.actionCollection().addAction("showInstallAction",
self.showInstallAction)
self.connect(self.showInstallAction, SIGNAL("triggered()"),
lambda: self.cw.switchState(StateManager.INSTALL))
self.cw.stateTab.addTab(QWidget(), KIcon("list-add"),
i18n("Installable Packages"))
actionGroup.addAction(self.showInstallAction)
self.showRemoveAction = KToggleAction(KIcon("list-remove"),
i18n("Installed Packages"), self)
self.actionCollection().addAction("showRemoveAction",
self.showRemoveAction)
self.connect(self.showRemoveAction, SIGNAL("triggered()"),
lambda: self.cw.switchState(StateManager.REMOVE))
self.cw.stateTab.addTab(QWidget(), KIcon("list-remove"),
i18n("Installed Packages"))
actionGroup.addAction(self.showRemoveAction)
self.showUpgradeAction = KToggleAction(KIcon("system-software-update"),
i18n("Updates"), self)
self.actionCollection().addAction("showUpgradeAction",
self.showUpgradeAction)
self.connect(self.showUpgradeAction, SIGNAL("triggered()"),
lambda: self.cw.switchState(StateManager.UPGRADE))
self.cw.stateTab.addTab(QWidget(), KIcon("system-software-update"),
i18n("Updates"))
actionGroup.addAction(self.showUpgradeAction)
# self.showHistoryAction = KToggleAction(KIcon("view-refresh"), i18n("History"), self)
# self.actionCollection().addAction("showHistoryAction", self.showHistoryAction)
# self.connect(self.showHistoryAction, SIGNAL("triggered()"), lambda:self.cw.switchState(StateManager.HISTORY))
# self.cw.stateTab.addTab(QWidget(), KIcon("view-refresh"), i18n("History"))
# actionGroup.addAction(self.showHistoryAction)
self.cw.menuButton.setMenu(QMenu('MainMenu', self.cw.menuButton))
self.cw.menuButton.setIcon(KIcon('preferences-other'))
self.cw.menuButton.menu().clear()
self.cw.contentHistory.hide()
# self.cw.menuButton.menu().addAction(self.showAllAction)
# self.cw.menuButton.menu().addAction(self.showInstallAction)
# self.cw.menuButton.menu().addAction(self.showRemoveAction)
# self.cw.menuButton.menu().addAction(self.showUpgradeAction)
# self.cw.menuButton.menu().addSeparator()
self.cw.menuButton.menu().addAction(self.actionCollection().action(
KStandardAction.name(KStandardAction.Preferences)))
self.cw.menuButton.menu().addAction(self.actionCollection().action(
KStandardAction.name(KStandardAction.Help)))
self.cw.menuButton.menu().addSeparator()
self.cw.menuButton.menu().addAction(self.actionCollection().action(
KStandardAction.name(KStandardAction.AboutApp)))
self.cw.menuButton.menu().addAction(self.actionCollection().action(
KStandardAction.name(KStandardAction.AboutKDE)))
self.cw.menuButton.menu().addSeparator()
self.cw.menuButton.menu().addAction(self.actionCollection().action(
KStandardAction.name(KStandardAction.Quit)))
self.cw._states = {
self.cw.state.ALL: (0, self.showAllAction),
self.cw.state.INSTALL: (1, self.showInstallAction),
self.cw.state.REMOVE: (2, self.showRemoveAction),
self.cw.state.UPGRADE: (3, self.showUpgradeAction)
}
# self.cw.state.HISTORY:(4, self.showHistoryAction)}
self.showAllAction.setChecked(True)
self.cw.checkUpdatesButton.hide()
self.cw.checkUpdatesButton.setIcon(KIcon('view-refresh'))
self.cw.showBasketButton.clicked.connect(self.cw.showBasket)
# Little time left for the new ui
self.menuBar().setVisible(False)
self.cw.switchState(self.cw.state.ALL)
class AdaptersTableView(QTableView):
"""
Adapters table view
"""
DataChanged = pyqtSignal()
def __init__(self, parent, helper, testParams, testDescrs):
"""
Description table view constructor
"""
QTableView.__init__(self, parent)
self.__parent = parent
self.helper = helper
self.testParams = testParams
self.testDescrs = testDescrs
self.createWidgets()
self.createConnections()
self.createActions()
def getAgents(self):
"""
Get test agents
"""
return self.testParams.agents.table().model.getData()
def getInputs(self):
"""
Get test inputs
"""
return self.testParams.parameters.table().model.getData()
def getOutputs(self):
"""
Get test outputs
"""
return self.testParams.parametersOutput.table().model.getData()
def createWidgets (self):
"""
Create qt widgets
"""
self.proxyModel = QSortFilterProxyModel(self)
self.proxyModel.setDynamicSortFilter(True)
self.model = DescriptionTableModel(self)
self.setModel(self.proxyModel)
self.proxyModel.setSourceModel(self.model)
self.setFrameShape(QFrame.StyledPanel)
self.setShowGrid(True)
self.setGridStyle (Qt.DotLine)
self.setSelectionMode(QAbstractItemView.SingleSelection)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.verticalHeader().setVisible(False)
self.horizontalHeader().setHighlightSections(False)
self.setHorizontalScrollMode(QAbstractItemView.ScrollPerPixel)
self.horizontalHeader().setStretchLastSection(True)
self.setItemDelegateForColumn( COL_SUMMARY_ACTION, AdapterDelegate(self) )
self.setColumnWidth(COL_ID_ACTION, 45)
def createConnections (self):
"""
Create qt connections
"""
self.customContextMenuRequested.connect(self.onPopupMenu)
self.clicked.connect( self.onAbstractItemClicked)
def createActions (self):
"""
Qt actions
"""
self.delAction = QtHelper.createAction(self, self.tr("&Delete"), self.deleteAction,
icon = QIcon(":/adapters-del.png"),
tip = self.tr('Delete the selected adapter'))
self.delAllAction = QtHelper.createAction(self, self.tr("&Delete All"), self.clearItems,
icon = QIcon(":/test-parameter-clear.png"),
tip = self.tr('Delete all adapters'))
# set default actions
self.delAction.setEnabled(False)
self.delAllAction.setEnabled(False)
def onAbstractItemClicked(self):
"""
Called on item clicked
"""
indexes = self.selectedIndexes()
if not indexes:
self.delAction.setEnabled(False)
else:
self.delAction.setEnabled(True)
def deleteAction(self):
"""
Delete action
"""
indexes = self.selectedIndexes()
if not indexes:
return
# map proxy indexes to source
sourceIndexes = []
for proxyIndex in indexes:
if not proxyIndex.isValid():
return
else:
sourceIndexes.append( self.proxyModel.mapToSource( proxyIndex ) )
if sourceIndexes:
answer = QMessageBox.question(self,
self.tr("Remove"),
self.tr("Do you want to remove the selection?"),
QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.Yes:
self.removeValues(sourceIndexes)
def removeValues(self, indexes):
"""
Remove values from data
@param indexes:
@type indexes:
"""
if not indexes:
return
# data from model
datas = self.model.getData()
# remove duplicate index
cleanIndexes = {}
for index in indexes:
if index.row() not in cleanIndexes:
cleanIndexes[index.row()] = index
for cleanIndex in list(cleanIndexes.keys()): # for python3 support
datas.pop(cleanIndex)
self.model.beginResetModel()
self.model.endResetModel()
self.setData( signal = True )
def getHelpAdapters(self, generic=False):
"""
Return the help of all adapters according to the current
version of the test
"""
if generic:
return Helper.instance().helpAdapters(generic=generic)
else:
testDescrs = self.testDescrs.table().model.getData()
currentAdpVersion = None
for descr in testDescrs:
if descr['key'] == 'adapters':
currentAdpVersion = descr['value']
break
return Helper.instance().helpAdapters(name=currentAdpVersion)
def onPopupMenu(self, pos):
"""
Display menu on right click
@param pos:
@type pos:
"""
self.menu = QMenu(self)
# index = self.currentIndex()
# get defaults adapters or extra
adapters_default = self.getHelpAdapters()
# get generic adapters
adapters_generic = self.getHelpAdapters(generic=True)
# main menu
menu_adps = QMenu("Add Adapters", self)
# adapters default
menu_adps_generic = QMenu("Generic", self)
menu_adps.addMenu(menu_adps_generic)
if adapters_generic is not None:
for adp in adapters_generic:
adp_menu_generic = QMenu(adp['name'], self)
menu_adps_generic.addMenu(adp_menu_generic)
for cls in adp['classes']:
# extract __init__ function only
fct = None
for fct in cls['functions']:
if fct['name'] == '__init__':
break
if fct is not None:
argsFct = self.parseDocString(docstring=fct['desc'])
argsFct['function'] = "%s::%s" % (adp['name'],cls['name'])
argsFct['main-name'] = "%s" % adp['name']
argsFct['sub-name'] = "%s" % cls['name']
argsFct['is-default'] = "False"
argsFct['is-generic'] = "True"
if 'default-args' in fct:
self.addDefaultValues(defaultValues=fct['default-args'],
currentFunction=argsFct)
adp_menu_generic.addAction(QtHelper.createAction(self,
cls['name'],
self.addAdapter,
cb_arg=argsFct ))
# adapters default
menu_adps_default = QMenu("Extra", self)
menu_adps.addMenu(menu_adps_default)
if adapters_default is not None:
for adp in adapters_default:
adp_menu_default = QMenu(adp['name'], self)
menu_adps_default.addMenu(adp_menu_default)
for cls in adp['classes']:
# extract __init__ function only
fct = None
for fct in cls['functions']:
if fct['name'] == '__init__':
break
if fct is not None:
argsFct = self.parseDocString(docstring=fct['desc'])
argsFct['function'] = "%s::%s" % (adp['name'],cls['name'])
argsFct['main-name'] = "%s" % adp['name']
argsFct['sub-name'] = "%s" % cls['name']
argsFct['is-default'] = "True"
argsFct['is-generic'] = "False"
if 'default-args' in fct:
self.addDefaultValues(defaultValues=fct['default-args'],
currentFunction=argsFct)
adp_menu_default.addAction(QtHelper.createAction(self,
cls['name'],
self.addAdapter,
cb_arg=argsFct ))
indexes = self.selectedIndexes()
if not indexes:
self.delAction.setEnabled(False)
self.menu.addAction( self.delAction )
self.menu.addSeparator()
self.menu.addMenu( menu_adps )
self.menu.addSeparator()
else:
self.delAction.setEnabled(True)
self.menu.addAction( self.delAction )
self.menu.addSeparator()
self.menu.addMenu( menu_adps )
self.menu.addSeparator()
self.menu.popup( self.mapToGlobal(pos) )
def addDefaultValues(self, defaultValues, currentFunction):
"""
Add default values
"""
for curArg in currentFunction['obj']:
for k,v in defaultValues:
# ignore bad documentation
if "name" not in curArg: continue
if k == curArg['name']:
curArg['advanced'] = "True"
if curArg['type'] in ['strconstant', 'intconstant']:
curArg['default-value'] = self.parseConstant(descr=curArg['descr'])
else:
curArg['default-value'] = unicode(v)
def parseDocString(self, docstring):
"""
Parse doc string
"""
val = {}
desc = docstring.strip()
desc_splitted = desc.splitlines()
val['return-value'] = "False"
params = []
param = { }
for line in desc_splitted:
line = line.strip()
if line.startswith('@param '):
paramName = line.split(':', 1)[0].split('@param ')[1].strip()
paramDescr = line.split(':', 1)[1].strip()
param['name'] = paramName
param['value'] = ''
param['descr'] = paramDescr
param['selected-type'] = ''
param['advanced'] = "False"
elif line.startswith('@type '):
paramType = line.split(':', 1)[1].strip()
param['type'] = paramType
params.append( param )
param = {}
elif line.startswith('@return'):
val['return-value'] = "True"
val['return-descr'] = line.split(':', 1)[1].strip()
else:
pass
val['obj'] = params
return val
def parseConstant(self, descr):
"""
Parse constant
"""
tmpvals = descr.split("|")
nameConstant = ''
for zz in xrange(len(tmpvals)):
if '(default)' in tmpvals[zz]:
nameConstant = tmpvals[zz].split('(default)')[0].strip()
return nameConstant
def addAdapter(self, fctParams):
"""
Add testcase function
"""
actionId = self.getActionId()
tpl = { 'action': ACTION_ADAPTER, 'data': fctParams }
self.insertItem(actionParams=tpl)
def getActionId(self):
"""
Return action Id
"""
data = self.model.getData()
actionId = len(data) + 1
return actionId
def insertItem(self, actionParams):
"""
Insert item
"""
indexes = self.selectedIndexes()
if not len(indexes):
row = self.model.rowCount()
else:
index = self.currentIndex()
row = index.row()
data = self.model.getData()
# add data to model
data.insert(row + 1, actionParams)
# self.model.reset()
self.model.beginResetModel()
self.model.endResetModel()
# open properties on adding, workaround to fix an error (bad agent type)
actionDialog = GenericConfigDialog.ActionDialog(self, self.helper, actionParams, owner=self, variables=[],
adapterMode=True,testParams=self.testParams, noCancel=True)
actionDialog.exec_()
newActionParams = actionDialog.getValues()
data[row]['data']['obj'] = newActionParams
self.delAllAction.setEnabled(True)
self.setData()
def setAdapters(self, adapters):
"""
Set adapters
"""
self.model.setDataModel( adapters )
self.setData( signal = False )
def clearItems(self):
"""
Clear all items
"""
reply = QMessageBox.question(self, self.tr("Clear all adapters"), self.tr("Are you sure ?"),
QMessageBox.Yes | QMessageBox.No )
if reply == QMessageBox.Yes:
data = self.model.getData()
try:
for i in xrange(len(data)):
data.pop()
except Exception as e:
pass
# self.model.reset()
self.model.beginResetModel()
self.model.endResetModel()
self.setData()
self.delAllAction.setEnabled(False)
self.delAction.setEnabled(False)
def clear (self):
"""
clear contents
"""
self.model.setDataModel( [] )
def setData(self, signal = True):
"""
Set table data
@param signal:
@type signal: boolean
"""
if signal: self.DataChanged.emit()
def _setupMenu(self):
self.menubar = QMenuBar(self)
self.menubar.setGeometry(QRect(0, 0, 42, 22))
self.menuFile = QMenu(self.menubar)
self.menuFile.setTitle(tr("File"))
self.menuView = QMenu(self.menubar)
self.menuView.setTitle(tr("View"))
self.menuHelp = QMenu(self.menubar)
self.menuHelp.setTitle(tr("Help"))
self.menuLoadRecent = QMenu(self.menuFile)
self.menuLoadRecent.setTitle(tr("Load Recent Results"))
self.setMenuBar(self.menubar)
self.menuFile.addAction(self.actionLoadResults)
self.menuFile.addAction(self.menuLoadRecent.menuAction())
self.menuFile.addSeparator()
self.menuFile.addAction(self.app.actionQuit)
self.menuView.addAction(self.app.actionPreferences)
self.menuView.addAction(self.actionShowResultsWindow)
self.menuView.addAction(self.app.actionIgnoreList)
self.menuHelp.addAction(self.app.actionShowHelp)
self.menuHelp.addAction(self.app.actionRegister)
self.menuHelp.addAction(self.app.actionCheckForUpdate)
self.menuHelp.addAction(self.app.actionOpenDebugLog)
self.menuHelp.addAction(self.app.actionAbout)
self.menubar.addAction(self.menuFile.menuAction())
self.menubar.addAction(self.menuView.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
# Recent folders menu
self.menuRecentFolders = QMenu()
self.menuRecentFolders.addAction(self.actionAddFolder)
self.menuRecentFolders.addSeparator()
# Recent results menu
self.menuRecentResults = QMenu()
self.menuRecentResults.addAction(self.actionLoadResults)
self.menuRecentResults.addSeparator()
#don't clutter console with debuginfo
if (len(sys.argv) <= 1 or sys.argv[1] != "debug"):
#I don't know how to redirect output to /dev/null so just make a tmp file until I figure out
#logfile = open("/dev/null", "w")
#sys.stdout = logfile
pass
elif (sys.argv[1] != "debug"):
import wingdbstub
'''
app=QApplication(sys.argv)
app.setQuitOnLastWindowClosed(False)
window = myMainWindow()
#tray = QSystemTrayIcon(QIcon(":/pics/pic24.png"))
menu = QMenu()
actionShow = QAction("PF",menu)
actionExit = QAction("Exit",menu)
menu.addAction(actionShow)
menu.addAction(actionExit)
#tray.setContextMenu(menu)
#tray.show()
actionShow.triggered.connect(window.show)
actionExit.triggered.connect(window.realQuit)
sourcemodel = myModel()
model = mySortFilterProxyModel()
model.setSourceModel(sourcemodel)
model.setDynamicSortFilter(True)
window.tableView.setSortingEnabled(True)
def ctx_menu_init(self):
self.pop_menu = QMenu()
self.pop_menu.addAction(self.ui.action_clear_console)
def __init__(self, parent=None):
"""
initialize the widget
"""
QDialog.__init__(self, parent)
Ui_FileDialog.__init__(self)
self.setupUi(self)
#flags = 0
#flags = Qt.Window | Qt.WindowMinimizeButtonHint;
#self.setWindowFlags( flags )
self.hideTckFilter()
self.__controler = ControlerFileDialog(self, parent.getControler())
self.connect(self.closeButton, SIGNAL("clicked()"),
self.__controler.close)
self.connect(self.saveButton, SIGNAL("clicked()"),
self.__controler.save)
self.connect(self.advancedSave, SIGNAL("clicked()"),
self.__controler.advancedSave)
self.connect(self.nextButton, SIGNAL("clicked()"),
self.__controler.next)
self.__model = {}
self.__path = None
self.__fileExtension = None
self.__popUp = QMenu(self.tableView)
self.__jobAction = QAction(self.tr("Job Info"), self.tableView)
self.connect(self.__jobAction, SIGNAL("triggered()"),
self.__controler.jobinfo)
self.__popUp.addAction(self.__jobAction)
self.__ancesstorsAction = QAction(self.tr("Get Anccestors"),
self.tableView)
self.connect(self.__ancesstorsAction, SIGNAL("triggered()"),
self.__controler.getancesstots)
self.__popUp.addAction(self.__ancesstorsAction)
self.__loginfoAction = QAction(self.tr("Logginig informations"),
self.tableView)
self.connect(self.__loginfoAction, SIGNAL("triggered()"),
self.__controler.loggininginfo)
self.__popUp.addAction(self.__loginfoAction)
self.__copyAction = QAction(self.tr("Copy data"), self.tableView)
self.connect(self.__copyAction, SIGNAL("triggered()"),
self.__controler.copy)
self.__popUp.addAction(self.__copyAction)
self.tableView.setContextMenuPolicy(Qt.CustomContextMenu)
self.connect(self.tableView,
SIGNAL('customContextMenuRequested(QPoint)'),
self.popUpMenu)
self.__advancedSave = AdvancedSave(self)
self.__advancedSave.setFocus()
self.__controler.addChild('AdvancedSave',
self.__advancedSave.getControler())
self.__historyDialog = HistoryDialog(self)
self.__controler.addChild('HistoryDialog',
self.__historyDialog.getControler())
self.connect(self.tckcombo, SIGNAL('currentIndexChanged(QString)'),
self.getControler().tckChanged)
self.__proxy = QSortFilterProxyModel()
self.connect(self.tckButton, SIGNAL("clicked()"),
self.__controler.tckButtonPressed)
self.connect(self.tckcloseButton, SIGNAL("clicked()"),
self.__controler.hideFilterWidget)
self.filterWidget.setupControler(self)
self.__controler.addChild('TckFilterWidget',
self.filterWidget.getControler())
