def initUI(self):
self.scopeSelector = QComboBox()
self.scopeSelector.addItem("Layout", FileSelector.ScopeLayout)
self.scopeSelector.addItem("Device and RF", FileSelector.ScopeDevice)
self.scopeSelector.addItem("Firmware Update",
FileSelector.ScopeFirmware)
# self.scopeSelector.addItem("All", FileSelector.ScopeAll)
self.scopeSelector.currentIndexChanged.connect(self.scopeUpdate)
self.layoutSettings = LayoutSettingsScope()
self.deviceSettings = DeviceSettingsScope()
self.firmwareSettings = FirmwareSettingsScope()
self.scope = None
self.layout = QVBoxLayout()
self.layout.addWidget(self.scopeSelector)
self.stackedLayout = QStackedLayout()
self.stackedLayout.addWidget(self.layoutSettings)
self.stackedLayout.addWidget(self.deviceSettings)
self.stackedLayout.addWidget(self.firmwareSettings)
self.layout.addLayout(self.stackedLayout)
self.setMinimumSize(0, 300)
self.setLayout(self.layout)
def __init__(self, main_widget_or_layout, side_widgets, parent=None):
super(VerticalSideBarLayout, self).__init__(parent)
self.stars = []
self.signal_mapper_tab_changed = QSignalMapper()
self.signal_mapper_tab_changed.mapped.connect(self._tab_changed)
self.side_widgets = side_widgets
self.stack = QStackedLayout(self)
for w in side_widgets:
self.stack.addWidget(w)
self.stack.setCurrentIndex(-1)
# I need a widget so that I can show/hide it.
# (we can't do that with a layout)
self.stack_widget = QWidget(self)
self.stack_widget.setLayout(self.stack)
layout = QHBoxLayout()
if isinstance(main_widget_or_layout, QWidget):
layout.addWidget(main_widget_or_layout)
else:
layout.addLayout(main_widget_or_layout)
# The panel layout is made of
# stack of widgets, vertical separator, buttons for widget selection
panel_layout = QHBoxLayout()
panel_layout.addWidget(self.stack_widget)
self.separator = VerticalSeparator(self)
panel_layout.addWidget(self.separator)
self.buttons_layout = self._make_tabs_button(
side_widgets,
["appbar.cabinet.files.png", "thumb-up-3x.png"]) # ,"comments.png"
panel_layout.addLayout(self.buttons_layout)
# The panel layout is wrapped into an inline sub frame
isf = InlineSubFrame(panel_layout, parent=self)
isf.setObjectName("HorseSubFrame") # ""HorseTightFrame")
isf.layout().setContentsMargins(2, 2, 2, 2)
# isf.setObjectName("HorseTightFrame")
layout.addWidget(isf)
# layout.setStretch(0,3)
# layout.setStretch(1,2)
self.setLayout(layout)
self._hide_content_pane()
class Browser(QWidget):
def __init__(self):
super(Browser, self).__init__()
self.layout = QStackedLayout(self)
self.layout.setStackingMode(QStackedLayout.StackAll)
self.hostname = os.uname()[1]
self.timer = QTimer()
self.timer.setSingleShot(False)
self.timer.start(2000)
self._init_sites()
self.remote_shell = RemoteShell(self)
self.connect(self.timer, SIGNAL("timeout()"), self, SLOT("show_next()"))
self.show_next()
def _init_sites(self):
self.sites = list()
self.site_id = -1
url = QUrl("https://www.qt.io/developers/")
self.sites.append(Site(self, url, 5, 1))
url = QUrl("https://wiki.qt.io/PySide")
self.sites.append(Site(self, url, 5, 1))
url = QUrl("https://www.python.org/")
self.sites.append(Site(self, url, 5, 1))
@property
def current_site(self):
return self.sites[self.site_id]
def show_next(self):
self.timer.stop()
previous_id = self.site_id
self.site_id = (self.site_id + 1) % len(self.sites)
current_site = self.current_site
self.timer.start(current_site.time * 1000)
current_site.show()
print("show " + current_site.url.toString().encode())
if previous_id >= 0:
self.sites[previous_id].hide()
def __init__(self):
super(Browser, self).__init__()
self.layout = QStackedLayout(self)
self.frontView = QWebView(self)
self.backView = QWebView(self)
self.frontView.page().networkAccessManager().sslErrors.connect(self.onSslErrors)
self.backView.page().networkAccessManager().sslErrors.connect(self.onSslErrors)
self.hostname = os.uname()[1]
self.layout.setStackingMode(QStackedLayout.StackAll)
self.layout.addWidget(self.frontView)
self.layout.addWidget(self.backView)
self.commands = {
'help' : self.cmdHelp,
'refresh' : self.cmdRefresh,
'add' : self.cmdAdd,
'del' : self.cmdDel,
'list' : self.cmdList,
'zoom' : self.cmdZoom,
'fs' : self.cmdFs,
'exit' : self.cmdExit,
'next' : self.cmdNext,
'restart' : self.cmdRestart,
'upgrade' : self.cmdUpgrade,
}
self.timer = QTimer()
self.timer.setSingleShot(False)
self.sites = list()
self.siteId = -1
self.socket = False
url = QUrl("http://dmr.tokiogroup.com/rrs.php")
self.sites.append(Site(url, 10, 1))
url = QUrl("http://dmr.tokiogroup.com/lastheard.php")
self.sites.append(Site(url, 10, 1))
self.server = QTcpServer()
self.server.listen(QHostAddress.Any, 4242)
self.connect(self.server, SIGNAL("newConnection()"), self, SLOT("onConnection()"));
self.connect(self.timer, SIGNAL("timeout()"), self, SLOT("goNext()"));
self.goNext()
self.goNext()
def __init__(self):
super(Browser, self).__init__()
self.layout = QStackedLayout(self)
self.layout.setStackingMode(QStackedLayout.StackAll)
self.hostname = os.uname()[1]
self.timer = QTimer()
self.timer.setSingleShot(False)
self.timer.start(2000)
self._init_sites()
self.remote_shell = RemoteShell(self)
self.connect(self.timer, SIGNAL("timeout()"), self, SLOT("show_next()"))
self.show_next()
class VerticalSideBarLayout(QFrame):
def _hide_content_pane(self):
self.layout().setStretch(0, 1)
self.layout().setStretch(1, 0)
self.stack_widget.setVisible(False)
self.separator.setVisible(False)
@Slot(int)
def _tab_changed(self, ndx):
w = self.side_widgets[ndx]
if self.stack.currentWidget() == w and self.stack_widget.isVisible():
self._hide_content_pane()
else:
self.layout().setStretch(0, 4)
self.layout().setStretch(1, 1)
self.stack_widget.setVisible(True)
self.separator.setVisible(True)
self.stack.setCurrentWidget(w)
def _make_tabs_button(self, side_widgets, side_icons):
if len(side_widgets) != len(side_icons):
raise Exception(
"Bad parameters : len(side_widgets) ({}) != len(side_icons) ({})"
.format(len(side_widgets), len(side_icons)))
layout = QVBoxLayout()
self._side_icons = []
ndx = 0
for w in side_widgets:
resource_name = side_icons[ndx]
pixmap = QPixmap(os.path.join(resource_dir, resource_name))
icon = QIcon(pixmap)
self._side_icons.append(icon)
b = QToolButton()
b.setIcon(icon)
b.setIconSize(pixmap.rect().size())
b.setMaximumWidth(pixmap.rect().width() + 6)
b.clicked.connect(self.signal_mapper_tab_changed.map)
self.signal_mapper_tab_changed.setMapping(b, ndx)
layout.addWidget(b)
layout.setStretch(ndx, 1)
ndx += 1
layout.addStretch()
return layout
def show_star_on_widget(self, w, show=True):
mainlog.debug("show_star_on_widget {} {}".format(w, show))
n = self.stack.indexOf(w)
if n < 0:
mainlog.error("The widget was not found")
return
b = self.buttons_layout.itemAt(n).widget()
widget_star = None
for s in self.stars:
if s.enlightened == b and s.enabled:
mainlog.debug("Found a star for the widget")
widget_star = s
if show == False and widget_star:
mainlog.debug("Removing a star")
self.stars.remove(widget_star)
widget_star.hide()
widget_star.setParent(None)
del widget_star
return
elif show == True and widget_star:
mainlog.debug("Reshow")
widget_star.show()
widget_star.enabled = True
elif show == True and not widget_star:
mainlog.debug("Show new star")
star = Star(b)
star.show()
star.raise_()
self.stars.append(star)
def show_widget(self, widget):
if widget not in self.side_widgets:
raise Exception(
"Tring to show a widget that is not in the side widgets")
self.stack_widget.setVisible(True)
self.separator.setVisible(True)
self.stack.setCurrentWidget(widget)
def __init__(self, main_widget_or_layout, side_widgets, parent=None):
super(VerticalSideBarLayout, self).__init__(parent)
self.stars = []
self.signal_mapper_tab_changed = QSignalMapper()
self.signal_mapper_tab_changed.mapped.connect(self._tab_changed)
self.side_widgets = side_widgets
self.stack = QStackedLayout(self)
for w in side_widgets:
self.stack.addWidget(w)
self.stack.setCurrentIndex(-1)
# I need a widget so that I can show/hide it.
# (we can't do that with a layout)
self.stack_widget = QWidget(self)
self.stack_widget.setLayout(self.stack)
layout = QHBoxLayout()
if isinstance(main_widget_or_layout, QWidget):
layout.addWidget(main_widget_or_layout)
else:
layout.addLayout(main_widget_or_layout)
# The panel layout is made of
# stack of widgets, vertical separator, buttons for widget selection
panel_layout = QHBoxLayout()
panel_layout.addWidget(self.stack_widget)
self.separator = VerticalSeparator(self)
panel_layout.addWidget(self.separator)
self.buttons_layout = self._make_tabs_button(
side_widgets,
["appbar.cabinet.files.png", "thumb-up-3x.png"]) # ,"comments.png"
panel_layout.addLayout(self.buttons_layout)
# The panel layout is wrapped into an inline sub frame
isf = InlineSubFrame(panel_layout, parent=self)
isf.setObjectName("HorseSubFrame") # ""HorseTightFrame")
isf.layout().setContentsMargins(2, 2, 2, 2)
# isf.setObjectName("HorseTightFrame")
layout.addWidget(isf)
# layout.setStretch(0,3)
# layout.setStretch(1,2)
self.setLayout(layout)
self._hide_content_pane()
class FileSelector(QWidget):
ScopeLayout = 0
ScopeDevice = 1
ScopeFirmware = 2
ScopeAll = 3
def __init__(self):
super(FileSelector, self).__init__()
self.initUI()
self.lastDir = None
def initUI(self):
self.scopeSelector = QComboBox()
self.scopeSelector.addItem("Layout", FileSelector.ScopeLayout)
self.scopeSelector.addItem("Device and RF", FileSelector.ScopeDevice)
self.scopeSelector.addItem("Firmware Update",
FileSelector.ScopeFirmware)
# self.scopeSelector.addItem("All", FileSelector.ScopeAll)
self.scopeSelector.currentIndexChanged.connect(self.scopeUpdate)
self.layoutSettings = LayoutSettingsScope()
self.deviceSettings = DeviceSettingsScope()
self.firmwareSettings = FirmwareSettingsScope()
self.scope = None
self.layout = QVBoxLayout()
self.layout.addWidget(self.scopeSelector)
self.stackedLayout = QStackedLayout()
self.stackedLayout.addWidget(self.layoutSettings)
self.stackedLayout.addWidget(self.deviceSettings)
self.stackedLayout.addWidget(self.firmwareSettings)
self.layout.addLayout(self.stackedLayout)
self.setMinimumSize(0, 300)
self.setLayout(self.layout)
# self.updateUI(FileSelector.ScopeLayout)
def scopeUpdate(self, index):
self.stackedLayout.setCurrentIndex(index)
def updateUI(self, scope):
if self.scope == scope:
return
self.layout.removeWidget(self.layoutSettings)
self.layout.removeWidget(self.deviceSettings)
self.layout.removeWidget(self.firmwareSettings)
if scope == FileSelector.ScopeLayout:
self.layout.addWidget(self.layoutSettings)
elif scope == FileSelector.ScopeDevice:
self.layout.addWidget(self.deviceSettings)
elif scope == FileSelector.ScopeFirmware:
self.layout.addWidget(self.firmwareSettings)
elif scope == FileSelector.ScopeAll:
self.layout.addWidget(self.layoutSettings)
self.layout.addWidget(self.deviceSettings)
self.layout.addWidget(self.firmwareSettings)
def getProgramingInfo(self):
return self.scopeSelector.currentIndex()
def getFirmwareFile(self):
return self.firmwareSettings.getFirmwareFile()
def getLayoutFile(self):
return self.layoutSettings.getLayoutFile()
def getRFLayoutFile(self):
return self.deviceSettings.getCurrentSettings()[2]
def getRFFile(self):
return self.deviceSettings.getCurrentSettings()[1]
def getTargetID(self):
return self.deviceSettings.getCurrentSettings()[0]
class OrderOverviewWidget(HorsePanel):
def close_panel(self):
self.persistent_filter.remember_current_selection(configuration)
def _set_criteria_access(self, base_date):
return
#
# if base_date.year < date.today().year or \
# (base_date.year == date.today().year and self.base_date.month < date.today().month):
#
# self.select_active_orders.setEnabled(False)
# self.select_preorders.setEnabled(False)
# self.select_orders_on_hold.setEnabled(False)
# self.select_orders_finished.setEnabled(True)
# self.select_orders_aborted.setEnabled(True)
#
# # self.select_orders_finished.setChecked(True) # Preselects active order but do not trigger refresh
#
# else:
# self.select_active_orders.setEnabled(True)
# self.select_preorders.setEnabled(True)
# self.select_orders_on_hold.setEnabled(True)
# self.select_orders_finished.setEnabled(True)
# self.select_orders_aborted.setEnabled(True)
#
# @Slot()
# def month_today(self):
# self.base_date = date.today()
# self.refresh_action_gui()
@Slot()
def month_before(self):
self.base_date = month_before(self.base_date)
self.refresh_action_gui()
@Slot()
def month_after(self):
m = self.base_date.month
if self.base_date.year < date.today().year or m < date.today().month:
if m < 12:
self.base_date = date(self.base_date.year, m + 1,
self.base_date.day)
else:
self.base_date = date(self.base_date.year + 1, 1,
self.base_date.day)
self.refresh_action_gui()
@Slot()
def save_slot(self):
self.current_orders_overview.save_slot()
# @Slot()
# def monthly_goal_slot(self):
# ndx = self.table_view.currentIndex()
# model = self.table_view.model()
# data = model.data( model.index(ndx.row(),0), Qt.UserRole)
# if data:
# order_part_id,order_id = data
# monthly_goal = model.data( model.index(ndx.row(),7), Qt.DisplayRole)
# mainlog.debug("Touched orders : {} -> {}".format(order_id,monthly_goal))
# self.touched_orders[order_id] = monthly_goal
def set_visibility(self, visible):
# Make sure the cursor is in the orderparts table
# when the panel becomes visible again.
# This allows to hit Enter from the order parts view
# to look at a specific order, then close the view
# of that sepcific order with Ctrl-W and then be
# right in the order parts list here to choose
# another order. All with the keyboard.
super(OrderOverviewWidget, self).set_visibility(visible)
self.retake_focus()
def retake_focus(self):
if self.stack_layout.currentWidget() == self.current_orders_overview:
self.current_orders_overview.table_view.setFocus(
Qt.OtherFocusReason)
# elif self.stack_layout.currentWidget() == self.past_orders_overview:
# self.past_orders_overview.table_view.setFocus(Qt.OtherFocusReason)
def refresh_action_gui(self, warn_too_many_results=True):
mainlog.debug("OrderOverview : refresh action")
# Figure out selection criteria
f = self.persistent_filter.get_filters_combo().current_filter()
if f:
criteria = f.query
else:
criteria = ""
# criteria = None
# if self.select_active_orders.isChecked():
# criteria = dao.order_part_dao.ORDER_PART_SELECTION_ACTIVE_ORDERS
# elif self.select_preorders.isChecked():
# criteria = dao.order_part_dao.ORDER_PART_SELECTION_PREORDERS
# elif self.select_orders_on_hold.isChecked():
# criteria = dao.order_part_dao.ORDER_PART_SELECTION_ON_HOLD
# elif self.select_orders_finished.isChecked():
# criteria = dao.order_part_dao.ORDER_PART_SELECTION_COMPLETED_THIS_MONTH
# elif self.select_orders_aborted.isChecked():
# criteria = dao.order_part_dao.ORDER_PART_SELECTION_ABORTED_THIS_MONTH
# elif text_filter:
# criteria = text_filter
# else:
# return # Filter not valid so nothing to do
# today = date.today()
# if self.base_date.year < today.year or self.base_date.month < today.month:
# # Display parts in the past
# if self.stack_layout.currentWidget() == self.current_orders_overview:
# if not self.current_orders_overview.save_if_necessary():
# return
# self.old_criteria = criteria
# self.stack_layout.setCurrentWidget(self.past_orders_overview)
# self.past_orders_overview.refresh_action(self.base_date,criteria,warn_too_many_results)
# else:
# Display current month's parts
# if self.stack_layout.currentWidget() == self.past_orders_overview:
# mainlog.debug("remembering criteria {}".format(self.old_criteria))
# criteria = self.old_criteria
# # FIXME use a ButtonGroup to avoid that kind of stuff
# if criteria == dao.order_part_dao.ORDER_PART_SELECTION_ACTIVE_ORDERS:
# self.select_active_orders.setChecked(True)
# elif criteria == dao.order_part_dao.ORDER_PART_SELECTION_PREORDERS:
# self.select_preorders.setChecked(True)
# elif criteria == dao.order_part_dao.ORDER_PART_SELECTION_ON_HOLD:
# self.select_orders_on_hold.setChecked(True)
# elif criteria == dao.order_part_dao.ORDER_PART_SELECTION_COMPLETED_THIS_MONTH:
# self.select_orders_finished.setChecked(True)
# elif criteria == dao.order_part_dao.ORDER_PART_SELECTION_ABORTED_THIS_MONTH:
# self.select_orders_aborted.setChecked(True)
# else:
# self.super_filter_entry.setText(criteria)
self.stack_layout.setCurrentWidget(self.current_orders_overview)
last_date = _last_moment_of_month(self.base_date)
self.current_orders_overview.refresh_action(last_date, criteria,
warn_too_many_results)
self._set_criteria_access(self.base_date)
self.current_orders_overview.table_view.setFocus(Qt.OtherFocusReason)
@Slot()
def refresh_action(self):
self.refresh_action_gui(warn_too_many_results=False)
# @Slot()
# def month_synthesis(self):
# d = MonthlyReportOverviewDialog(self)
# d.refresh_action_gui(self.base_date)
# d.exec_()
# @Slot(QModelIndex,QModelIndex)
# def order_part_selected(self, ndx_cur, ndx_old):
# if ndx_cur.isValid():
# order_part_id,order_id = self._table_model.data(self._table_model.index(ndx_cur.row(),0),Qt.UserRole)
# self.operations_view.set_order_part_id(order_part_id)
# else:
# self.operations_view.set_order_part_id(None)
# @Slot()
# def edit_order_slot(self):
# # Need this because there's a mismatch in the parameter
# # signature of the edit orders slot. See order_part_activated
# # below
# self.order_part_activated(self.table_view.currentIndex())
@Slot(int)
def set_on_order_part_slot(self, order_part_id):
# Is used by othe views to set this one on
# a specific order part
self.current_orders_overview.set_on_order_part(order_part_id)
order_part_activated_signal = Signal(OrderPart) # order_part_id
order_parts_changed = Signal()
@Slot(QModelIndex)
def order_part_activated_slot(self, order_part_id):
mainlog.debug("order_part_activated_slot : {}".format(order_part_id))
order_part = dao.order_part_dao.find_by_id(order_part_id)
self.order_part_activated_signal.emit(order_part)
@Slot(QModelIndex)
def order_parts_changed_slot(self):
self.order_parts_changed.emit()
def current_order_id(self):
if self.stack_layout.currentWidget() == self.current_orders_overview:
return self.current_orders_overview.current_order_id()
# else:
# return self.past_orders_overview.current_order_id()
def set_title(self):
save_notice = ""
if self.data_changed():
save_notice = " <b><font color='red'>***</font></b>"
self.title_box.set_title(_("Orders overview") + save_notice)
def data_changed(self):
return self.current_orders_overview.data_changed()
@Slot()
def super_filter(self, filter_query: str):
self.current_orders_overview.filter(filter_query, True)
@Slot()
def show_actions(self):
button = self.action_menu.parent()
p = button.mapToGlobal(QPoint(0, button.height()))
self.action_menu.exec_(p)
# def _show_filter(self,fq):
# if fq:
# self.super_filter_entry.setText(fq.query)
# self.save_filter_button.setEnabled(fq.owner_id == user_session.user_id)
# self.delete_filter_button.setEnabled(fq.owner_id == user_session.user_id)
# if fq.shared:
# self.share_filter.setCheckState(Qt.Checked)
# else:
# self.share_filter.setCheckState(Qt.Unchecked)
# else:
# self.super_filter_entry.setText("")
# self.share_filter.setCheckState(Qt.Unchecked)
# self.save_filter_button.setEnabled(True)
# self.delete_filter_button.setEnabled(True)
# def _load_available_queries(self,preselect_fq_id=None):
# self.filter_name.clear()
# filters = dao.filters_dao.usable_filters(user_session.user_id)
# ndx_to_select = None
# self.filter_name.addItem(None, None)
# i = 0
# for fq in filters:
# if preselect_fq_id == fq.filter_query_id:
# ndx_to_select = i
# n = fq.name
# if fq.owner_id != user_session.user_id:
# n = n + u" ({})".format(fq.fullname)
# self.filter_name.addItem(n, fq.filter_query_id)
# i = i + 1
# if ndx_to_select is not None:
# self.filter_name.setCurrentIndex(ndx_to_select+1) # +1 to skip the empty item
# self._show_filter(filters[ndx_to_select])
# else:
# self._show_filter(None)
# @Slot()
# def filter_activated_slot(self,ndx):
# fq_id = self.filter_name.itemData(self.filter_name.currentIndex())
# if fq_id:
# try:
# fq = dao.filters_dao.find_by_id(fq_id)
# self._show_filter(fq)
# self.super_filter()
# except Exception,e:
# showErrorBox(_("There was a problem while loading the filter. It may have been deleted by its owner"),None,e,object_name="missing_filter")
# # MAke sure the filter doesn't appear anymore
# self._load_available_queries()
# self._show_filter(None)
# return
# else:
# self._show_filter(None)
# @Slot()
# def delete_filter_action_slot(self):
# try:
# fq_id = None
# if self.filter_name.currentIndex() >= 0:
# fq_id = self.filter_name.itemData(self.filter_name.currentIndex())
# if not fq_id:
# showWarningBox(_("The filter you want to delete was never saved"),None,parent=self,object_name="no_need_to_delete_filter")
# return
# fq = dao.filters_dao.find_by_id(fq_id)
# if fq.owner_id != user_session.user_id:
# showWarningBox(_("You can't delete the filter because it doesn't belong to you."),None,parent=self,object_name="not_my_filter")
# return
# dao.filters_dao.delete_by_id(fq_id,user_session.user_id)
# self._load_available_queries()
# except Exception, e:
# mainlog.error("Can't delete fq_id = {}".format(fq_id))
# showErrorBox(_("There was a problem while deleting the filter."),None,e,object_name="delete_filter_fatal")
# def _check_and_copy_filter(self,dto):
# fq_query = self.super_filter_entry.text()
# if not fq_query or not fq_query.strip():
# showWarningBox(_("The filter's query can't be empty"),None,parent=self,object_name="empty_filter_query")
# return False
# dto.owner_id = user_session.user_id
# dto.shared = self.share_filter.checkState() == Qt.Checked
# dto.query = fq_query
# return True
# @Slot()
# def save_filter_as_action_slot(self):
# d = GiveNewNameDialog(self)
# d.exec_()
# if d.result() == QDialog.Accepted:
# new_name = d.line_edit.text()
# if not dao.filters_dao.is_name_used(new_name, user_session.user_id):
# fq = dao.filters_dao.get_dto(None)
# if self._check_and_copy_filter(fq):
# fq.name = new_name
# fq_id = dao.filters_dao.save(fq)
# self._load_available_queries(fq_id)
# else:
# showErrorBox(_("There is already a filter with that name. You must delete it first if you want to use that name."),None,None,object_name="filter_with_same_name")
# @Slot()
# def save_filter_action_slot(self):
# ndx = self.filter_name.currentIndex()
# fq_id = None
# if ndx > 0:
# fq_id = self.filter_name.itemData(ndx)
# fq = dao.filters_dao.get_dto(fq_id)
# if fq.owner_id == user_session.user_id:
# if self._check_and_copy_filter(fq):
# fq.name = self.filter_name.itemText(ndx)
# fq_id = dao.filters_dao.save(fq)
# self._load_available_queries(fq_id)
# else:
# if yesNoBox(_("This is not your filter !"), _("OK to save it under another name ?")) == QMessageBox.Yes:
# self.save_filter_as_action_slot()
# else:
# self.save_filter_as_action_slot()
# @Slot(int,int)
# def cursorPositionChanged_slot(self,old,new):
# return
# @Slot()
# def completEditFinished_slot(self):
# # self.super_filter_entry.completion.hide()
# self.nofocuslost = False
@Slot(QAbstractButton)
def button_clicked(self, button):
return
#
# for b in self.button_group.buttons():
# if b != button:
# b.setChecked(False)
# self.refresh_action_gui()
def clear_search_buttons(self):
return
#
# for b in self.button_group.buttons():
# b.setChecked(False)
@Slot()
def _toggle_edit_filters(self):
self.persistent_filter.setVisible(
not self.persistent_filter.isVisible())
def __init__(self,
parent,
find_order_action_slot,
create_delivery_slip_action,
show_prices=True):
super(OrderOverviewWidget, self).__init__(parent)
self.set_panel_title(_("Order Overview"))
self.base_date = date.today()
self.touched_row = set()
# maps order_id -> monthlygoal (true or false)
self.touched_orders = dict()
self.create_delivery_slip_action = create_delivery_slip_action
# self.edit_action = QAction(_('Edit order'),self)
# self.edit_action.triggered.connect( self.edit_order_slot)
# self.past_orders_overview = PastOrdersOverviewWidget(None,None,None,show_prices)
self.current_orders_overview = CurrentOrdersOverviewWidget(
None, None, None, show_prices)
self.current_orders_overview.order_part_activated_signal.connect(
self.order_part_activated_slot)
self.current_orders_overview.order_parts_changed.connect(
self.order_parts_changed_slot)
# self.past_orders_overview.order_part_activated_signal.connect(self.order_part_activated_slot)
self.vlayout = QVBoxLayout(self)
# self.select_active_orders = QRadioButton(_("Production"),self)
# self.select_active_orders.setToolTip(_("Order that are in production (as specified by their state)"))
#
# self.select_preorders = QRadioButton(_("Preorders"),self)
#
# self.select_orders_on_hold = QRadioButton(_("Dormant"),self)
# self.select_orders_on_hold.setToolTip(_("Orders that are either on hold or to be defined (as specified by their state)"))
# self.select_orders_finished = QRadioButton(_("Finished"),self)
# self.select_orders_finished.setToolTip(_("Orders that were marked as completed this month"))
#
# self.select_orders_aborted = QRadioButton(_("Aborted"),self)
# self.select_orders_aborted.setToolTip(_("Orders that were prematurely cancelled"))
# I need a button group which is exclusive but
# which also allows *all* the buttons to bl cleared
# at once. The regular exclusive flags forces
# us to have always one button checked...
# self.button_group = QButtonGroup(self)
# self.button_group.addButton(self.select_active_orders)
# self.button_group.addButton(self.select_preorders)
# self.button_group.addButton(self.select_orders_on_hold)
# self.button_group.addButton(self.select_orders_finished)
# self.button_group.addButton(self.select_orders_aborted)
# self.button_group.setExclusive(False)
# self.button_group.buttonClicked.connect(self.button_clicked)
# I need to be able to unselect all buttons (in case I use the super filter)
# self.select_active_orders.setAutoExclusive(False)
# self.select_preorders.setAutoExclusive(False)
# self.select_orders_on_hold.setAutoExclusive(False)
# self.select_orders_finished.setAutoExclusive(False)
# self.select_orders_aborted.setAutoExclusive(False)
# self.select_active_orders.setChecked(True) # Preselects active order
self.persistent_filter = PersistentFilter(
FilterQuery.ORDER_PARTS_OVERVIEW_FAMILY, find_suggestions)
self.persistent_filter.apply_filter.connect(self.super_filter)
navigation = NavBar(
self, [(self.persistent_filter.get_filters_combo(), None),
(_("Edit filter"), self._toggle_edit_filters),
(_("Find"), find_order_action_slot)])
self.persistent_filter.hide()
# self.persistent_filter.select_default_filter()
# navigation.buttons[7].setObjectName("specialMenuButton")
# self.save_filter_action = QAction(_("Save filter"),self)
# self.save_filter_action.triggered.connect( self.save_filter_action_slot)
# self.save_filter_as_action = QAction(_("Save filter as"),self)
# self.save_filter_as_action.triggered.connect( self.save_filter_as_action_slot)
# self.delete_filter_action = QAction(_("Delete filter"),self)
# self.delete_filter_action.triggered.connect( self.delete_filter_action_slot)
def action_to_button(action):
b = QPushButton(action.text())
b.clicked.connect(action.trigger)
return b
# self.action_menu = QMenu(navigation.buttons[8])
# self.filter_menu = QMenu("Filter menu")
# self.filter_menu.addAction("filter alpha")
# self.filter_menu.addAction("filter beta")
# list_actions = [ (self.save_filter_action,None,None),
# (self.save_filter_as_action,None,None),
# (self.delete_filter_action, None,None),
# (self.filter_menu, None,None) ]
# populate_menu(self.action_menu, self, list_actions, context=Qt.WidgetWithChildrenShortcut)
self.title_box = TitleWidget(
_("Orders overview"), self,
navigation) # + date.today().strftime("%B %Y"),self)
self.vlayout.addWidget(self.title_box)
self.vlayout.addWidget(self.persistent_filter)
# hlayout_god_mode = QHBoxLayout()
# hlayout_god_mode.addWidget(QLabel(_("Filter :")))
# self.filter_name = QComboBox()
# self.filter_name.setMinimumWidth(100)
# # self.filter_name.setEditable(True)
# I use activated so that reselecting the same index
# triggers an action (for example, clears a badly
# edited filter)
# self.filter_name.activated.connect(self.filter_activated_slot)
# hlayout_god_mode.addWidget(self.filter_name)
# hlayout_god_mode.addWidget(QLabel(_("Query :")))
# hlayout_god_mode.addWidget(self.super_filter_entry)
# # self.completion.setParent(self.super_filter_entry)
# self.super_filter_entry.cursorPositionChanged.connect(self.cursorPositionChanged_slot)
# # self.super_filter_entry.editingFinished.connect(self.completEditFinished_slot)
# # self.super_filter_entry.returnPressed.connect(self.super_filter)
# self.share_filter = QCheckBox(_("Shared"))
# hlayout_god_mode.addWidget(self.share_filter)
# self.super_filter_button = QPushButton(_("Filter"))
# hlayout_god_mode.addWidget(self.super_filter_button)
# self.save_filter_button = action_to_button(self.save_filter_action)
# hlayout_god_mode.addWidget(self.save_filter_button)
# hlayout_god_mode.addWidget(action_to_button(self.save_filter_as_action))
# self.delete_filter_button = action_to_button(self.delete_filter_action)
# hlayout_god_mode.addWidget(self.delete_filter_button)
# self.vlayout.addLayout(hlayout_god_mode)
# self.super_filter_button.clicked.connect(self.super_filter)
# self.select_active_orders.clicked.connect(self.refresh_action)
# self.select_preorders.clicked.connect(self.refresh_action)
# self.select_orders_on_hold.clicked.connect(self.refresh_action)
# self.select_orders_finished.clicked.connect(self.refresh_action)
# self.select_orders_aborted.clicked.connect(self.refresh_action)
self.current_orders_overview.data_changed_signal.connect(
self.set_title)
self.stack_layout = QStackedLayout()
self.stack_layout.addWidget(self.current_orders_overview)
# self.stack_layout.addWidget(self.past_orders_overview)
self.vlayout.addLayout(self.stack_layout)
self.setLayout(self.vlayout)
# self._load_available_queries()
self.persistent_filter.load_last_filter(configuration)
def __init__(self,
parent,
find_order_action_slot,
create_delivery_slip_action,
show_prices=True):
super(OrderOverviewWidget, self).__init__(parent)
self.set_panel_title(_("Order Overview"))
self.base_date = date.today()
self.touched_row = set()
# maps order_id -> monthlygoal (true or false)
self.touched_orders = dict()
self.create_delivery_slip_action = create_delivery_slip_action
# self.edit_action = QAction(_('Edit order'),self)
# self.edit_action.triggered.connect( self.edit_order_slot)
# self.past_orders_overview = PastOrdersOverviewWidget(None,None,None,show_prices)
self.current_orders_overview = CurrentOrdersOverviewWidget(
None, None, None, show_prices)
self.current_orders_overview.order_part_activated_signal.connect(
self.order_part_activated_slot)
self.current_orders_overview.order_parts_changed.connect(
self.order_parts_changed_slot)
# self.past_orders_overview.order_part_activated_signal.connect(self.order_part_activated_slot)
self.vlayout = QVBoxLayout(self)
# self.select_active_orders = QRadioButton(_("Production"),self)
# self.select_active_orders.setToolTip(_("Order that are in production (as specified by their state)"))
#
# self.select_preorders = QRadioButton(_("Preorders"),self)
#
# self.select_orders_on_hold = QRadioButton(_("Dormant"),self)
# self.select_orders_on_hold.setToolTip(_("Orders that are either on hold or to be defined (as specified by their state)"))
# self.select_orders_finished = QRadioButton(_("Finished"),self)
# self.select_orders_finished.setToolTip(_("Orders that were marked as completed this month"))
#
# self.select_orders_aborted = QRadioButton(_("Aborted"),self)
# self.select_orders_aborted.setToolTip(_("Orders that were prematurely cancelled"))
# I need a button group which is exclusive but
# which also allows *all* the buttons to bl cleared
# at once. The regular exclusive flags forces
# us to have always one button checked...
# self.button_group = QButtonGroup(self)
# self.button_group.addButton(self.select_active_orders)
# self.button_group.addButton(self.select_preorders)
# self.button_group.addButton(self.select_orders_on_hold)
# self.button_group.addButton(self.select_orders_finished)
# self.button_group.addButton(self.select_orders_aborted)
# self.button_group.setExclusive(False)
# self.button_group.buttonClicked.connect(self.button_clicked)
# I need to be able to unselect all buttons (in case I use the super filter)
# self.select_active_orders.setAutoExclusive(False)
# self.select_preorders.setAutoExclusive(False)
# self.select_orders_on_hold.setAutoExclusive(False)
# self.select_orders_finished.setAutoExclusive(False)
# self.select_orders_aborted.setAutoExclusive(False)
# self.select_active_orders.setChecked(True) # Preselects active order
self.persistent_filter = PersistentFilter(
FilterQuery.ORDER_PARTS_OVERVIEW_FAMILY, find_suggestions)
self.persistent_filter.apply_filter.connect(self.super_filter)
navigation = NavBar(
self, [(self.persistent_filter.get_filters_combo(), None),
(_("Edit filter"), self._toggle_edit_filters),
(_("Find"), find_order_action_slot)])
self.persistent_filter.hide()
# self.persistent_filter.select_default_filter()
# navigation.buttons[7].setObjectName("specialMenuButton")
# self.save_filter_action = QAction(_("Save filter"),self)
# self.save_filter_action.triggered.connect( self.save_filter_action_slot)
# self.save_filter_as_action = QAction(_("Save filter as"),self)
# self.save_filter_as_action.triggered.connect( self.save_filter_as_action_slot)
# self.delete_filter_action = QAction(_("Delete filter"),self)
# self.delete_filter_action.triggered.connect( self.delete_filter_action_slot)
def action_to_button(action):
b = QPushButton(action.text())
b.clicked.connect(action.trigger)
return b
# self.action_menu = QMenu(navigation.buttons[8])
# self.filter_menu = QMenu("Filter menu")
# self.filter_menu.addAction("filter alpha")
# self.filter_menu.addAction("filter beta")
# list_actions = [ (self.save_filter_action,None,None),
# (self.save_filter_as_action,None,None),
# (self.delete_filter_action, None,None),
# (self.filter_menu, None,None) ]
# populate_menu(self.action_menu, self, list_actions, context=Qt.WidgetWithChildrenShortcut)
self.title_box = TitleWidget(
_("Orders overview"), self,
navigation) # + date.today().strftime("%B %Y"),self)
self.vlayout.addWidget(self.title_box)
self.vlayout.addWidget(self.persistent_filter)
# hlayout_god_mode = QHBoxLayout()
# hlayout_god_mode.addWidget(QLabel(_("Filter :")))
# self.filter_name = QComboBox()
# self.filter_name.setMinimumWidth(100)
# # self.filter_name.setEditable(True)
# I use activated so that reselecting the same index
# triggers an action (for example, clears a badly
# edited filter)
# self.filter_name.activated.connect(self.filter_activated_slot)
# hlayout_god_mode.addWidget(self.filter_name)
# hlayout_god_mode.addWidget(QLabel(_("Query :")))
# hlayout_god_mode.addWidget(self.super_filter_entry)
# # self.completion.setParent(self.super_filter_entry)
# self.super_filter_entry.cursorPositionChanged.connect(self.cursorPositionChanged_slot)
# # self.super_filter_entry.editingFinished.connect(self.completEditFinished_slot)
# # self.super_filter_entry.returnPressed.connect(self.super_filter)
# self.share_filter = QCheckBox(_("Shared"))
# hlayout_god_mode.addWidget(self.share_filter)
# self.super_filter_button = QPushButton(_("Filter"))
# hlayout_god_mode.addWidget(self.super_filter_button)
# self.save_filter_button = action_to_button(self.save_filter_action)
# hlayout_god_mode.addWidget(self.save_filter_button)
# hlayout_god_mode.addWidget(action_to_button(self.save_filter_as_action))
# self.delete_filter_button = action_to_button(self.delete_filter_action)
# hlayout_god_mode.addWidget(self.delete_filter_button)
# self.vlayout.addLayout(hlayout_god_mode)
# self.super_filter_button.clicked.connect(self.super_filter)
# self.select_active_orders.clicked.connect(self.refresh_action)
# self.select_preorders.clicked.connect(self.refresh_action)
# self.select_orders_on_hold.clicked.connect(self.refresh_action)
# self.select_orders_finished.clicked.connect(self.refresh_action)
# self.select_orders_aborted.clicked.connect(self.refresh_action)
self.current_orders_overview.data_changed_signal.connect(
self.set_title)
self.stack_layout = QStackedLayout()
self.stack_layout.addWidget(self.current_orders_overview)
# self.stack_layout.addWidget(self.past_orders_overview)
self.vlayout.addLayout(self.stack_layout)
self.setLayout(self.vlayout)
# self._load_available_queries()
self.persistent_filter.load_last_filter(configuration)
def testStackedReference(self):
#QStackedLayout.addWidget reference count
w = QWidget()
self.checkLayoutReference(QStackedLayout(w))
def __init__(self, parent=None):
super(SummaryTab, self).__init__(parent)
#create the widgets
self.label_info = QLabel("No summary data to display")
label_sent_packets = QLabel("Sent Packet Count")
self.label_sent_packets = StyledLabel()
self.label_sent_packets.setMaximumHeight(30)
label_received_packets = QLabel("Received Packet Count")
self.label_received_packets = StyledLabel()
self.label_received_packets.setMaximumHeight(30)
label_packets_lost = QLabel("Packets Lost")
self.label_packets_lost = StyledLabel()
self.label_packets_lost.setMaximumHeight(30)
label_loss_percentage = QLabel("Packet Loss Percentage")
self.label_loss_percentage = StyledLabel()
self.label_loss_percentage.setMaximumHeight(30)
label_output_delay = QLabel("Average Output Delay")
self.label_output_delay = StyledLabel()
self.label_output_delay.setMaximumHeight(30)
#setup summary_layout
#first, setup a stacked summary_layout to indicate first there's no summary data
self.layout_stack = QStackedLayout()
summary_centerer_layout = QHBoxLayout()
summary_layout = QGridLayout() #if I use formlayout, i'm afraid things will stretch out too much horizontally
row = 1; col = 0;
summary_layout.addWidget(label_sent_packets, row, col)
col += 2
summary_layout.addWidget(self.label_sent_packets, row, col) #leave a middle column empty
row += 1; col -= 2;
summary_layout.addWidget(label_received_packets, row, col)
col += 2
summary_layout.addWidget(self.label_received_packets, row, col)
row += 1; col -= 2
summary_layout.addWidget(label_packets_lost, row, col)
col += 2
summary_layout.addWidget(self.label_packets_lost, row, col)
row += 1; col -= 2;
summary_layout.addWidget(label_loss_percentage, row, col)
col += 2
summary_layout.addWidget(self.label_loss_percentage, row, col)
row += 1; col -= 2;
summary_layout.addWidget(label_output_delay, row, col)
col += 2
summary_layout.addWidget(self.label_output_delay, row, col)
#center things out
summary_layout.setColumnMinimumWidth(1, 100) # 100 pixels in the middle
summary_layout.setRowMinimumHeight(0, 10) #100 pixels from top
summary_centerer_layout.addStretch()
summary_centerer_layout.addLayout(summary_layout)
summary_centerer_layout.addStretch()
#make a dump widget for the stacked summary_layout
widget = QWidget()
widget.setLayout(summary_centerer_layout)
self.layout_stack.insertWidget(0, widget)
#setup summary_layout for info label!
layout_info_label = QVBoxLayout()
layout_info_label.addStretch()
layout_info_label.addWidget(self.label_info)
layout_info_label.addStretch()
#make dump widget for info label summary_layout!!
widget_info_label = QWidget()
widget_info_label.setLayout(layout_info_label)
self.layout_stack.insertWidget(1, widget_info_label)
self.setLayout(self.layout_stack)
self.zeroOut()
class Browser(QWidget):
def __init__(self):
super(Browser, self).__init__()
self.layout = QStackedLayout(self)
self.frontView = QWebView(self)
self.backView = QWebView(self)
self.frontView.page().networkAccessManager().sslErrors.connect(self.onSslErrors)
self.backView.page().networkAccessManager().sslErrors.connect(self.onSslErrors)
self.hostname = os.uname()[1]
self.layout.setStackingMode(QStackedLayout.StackAll)
self.layout.addWidget(self.frontView)
self.layout.addWidget(self.backView)
self.commands = {
'help' : self.cmdHelp,
'refresh' : self.cmdRefresh,
'add' : self.cmdAdd,
'del' : self.cmdDel,
'list' : self.cmdList,
'zoom' : self.cmdZoom,
'fs' : self.cmdFs,
'exit' : self.cmdExit,
'next' : self.cmdNext,
'restart' : self.cmdRestart,
'upgrade' : self.cmdUpgrade,
}
self.timer = QTimer()
self.timer.setSingleShot(False)
self.sites = list()
self.siteId = -1
self.socket = False
url = QUrl("http://dmr.tokiogroup.com/rrs.php")
self.sites.append(Site(url, 10, 1))
url = QUrl("http://dmr.tokiogroup.com/lastheard.php")
self.sites.append(Site(url, 10, 1))
self.server = QTcpServer()
self.server.listen(QHostAddress.Any, 4242)
self.connect(self.server, SIGNAL("newConnection()"), self, SLOT("onConnection()"));
self.connect(self.timer, SIGNAL("timeout()"), self, SLOT("goNext()"));
self.goNext()
self.goNext()
def goNext(self):
self.cmdNext(list())
def onConnection(self):
self.socket = self.server.nextPendingConnection()
self.socket.write(self.hostname + ' % ')
self.connect(self.socket, SIGNAL("readyRead()"), self, SLOT("onDataReceived()"));
def print_(self, text):
if (self.socket != False):
self.socket.write(text + '\n')
print(text)
def onDataReceived(self):
data = self.socket.readAll().data().strip()
try:
args = data.split(' ')
map(lambda x : x.strip(), args)
self.commands.get(args[0])(args)
except Exception:
self.print_('>> syntax error')
self.printCommandsList()
if self.socket.isOpen():
self.socket.write(self.hostname + ' % ')
def printCommandsList(self):
self.print_('avaible commands:')
for command in self.commands:
self.print_(' ' + command)
def onSslErrors(self, reply, errors):
url = unicode(reply.url().toString())
reply.ignoreSslErrors()
# commands
def cmdHelp(self, args):
self.print_('>> help')
self.printCommandsList()
def cmdRefresh(self, args):
self.print_('>> refresh ' + self.url.toString().encode())
self.frontView.reload()
def cmdAdd(self, args):
self.print_('>> add ' + args[1] + ' ' + args[2] + ' ' + args[3])
self.sites.append(Site(QUrl(args[1]), int(args[2], int(args[3]))))
def cmdDel(self, args):
self.print_('>> del ' + args[1])
self.sites.pop(int(args[1]))
def cmdList(self, args):
self.print_('>> list')
self.print_('current list:')
sitesCount = len(self.sites)
i = 0
while i < sitesCount:
self.print_('%1c[%1d] %2ds : %3s' % ((i==self.siteId) and '*' or ' ' ,i, self.sites[i].time, self.sites[i].url.toString().encode()))
i = i + 1
def cmdZoom(self, args):
self.print_('>> zoom ' + args[1])
self.frontView.setZoomFactor(float(args[1]))
def cmdFs(self, args):
self.print_('>> fs ' + args[1])
if (args[1] == '1'):
self.showFullScreen()
else:
self.showNormal()
def cmdExit(self, args):
self.print_('>> exit')
self.socket.close()
def cmdNext(self, args):
self.timer.stop()
self.timer.start(self.sites[self.siteId].time * 1000)
self.siteId = (self.siteId + 1) % len(self.sites)
print('>> next ' + self.sites[self.siteId].url.toString().encode())
self.backView.show()
self.frontView, self.backView = self.backView, self.frontView
self.backView.load(self.sites[self.siteId].url)
self.backView.setZoomFactor(self.sites[self.siteId].zoom)
self.backView.hide()
def cmdRestart(self, args):
self.print_('>> restart')
self.close()
def cmdUpgrade(self, args):
self.print_('>> upgrade')
update = urllib.urlopen('https://raw.githubusercontent.com/tjardick/monitoring_browser/master/webkit.py').read()
script = file('webkit.py', 'w')
script.write(update)
script.close()
self.close()
def __init__(self):
super(Browser, self).__init__()
self.layout = QStackedLayout(self)
self.frontView = QWebView(self)
self.backView = QWebView(self)
self.frontView.page().networkAccessManager().sslErrors.connect(self.onSslErrors)
self.backView.page().networkAccessManager().sslErrors.connect(self.onSslErrors)
self.hostname = os.uname()[1]
self.layout.setStackingMode(QStackedLayout.StackAll)
self.layout.addWidget(self.frontView)
self.layout.addWidget(self.backView)
self.commands = {
'help' : self.cmdHelp,
'refresh' : self.cmdRefresh,
'add' : self.cmdAdd,
'del' : self.cmdDel,
'list' : self.cmdList,
'zoom' : self.cmdZoom,
'fs' : self.cmdFs,
'exit' : self.cmdExit,
'next' : self.cmdNext,
'restart' : self.cmdRestart,
'upgrade' : self.cmdUpgrade,
}
self.timer = QTimer()
self.timer.setSingleShot(False)
self.sites = list()
self.siteId = -1
self.socket = False
url = QUrl("http://status.mobilevikings.com/")
self.sites.append(Site(url, 10, 1.5))
url = QUrl("http://ihackernews.com")
self.sites.append(Site(url, 10, 1))
url = QUrl("http://demo.kibana.org")
self.sites.append(Site(url, 10, 1))
url = QUrl("http://logstash.openstack.org")
self.sites.append(Site(url, 10, 1))
url = QUrl("http://demo.mathias-kettner.de/demo/check_mk/")
url.setUserName("demo897");
url.setPassword("demo");
self.sites.append(Site(url, 15, 1))
self.server = QTcpServer()
self.server.listen(QHostAddress.Any, 4242)
self.connect(self.server, SIGNAL("newConnection()"), self, SLOT("onConnection()"));
self.connect(self.timer, SIGNAL("timeout()"), self, SLOT("goNext()"));
self.goNext()
self.goNext()
