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 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)
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 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()