def getModel(self):
self.m_model = QStandardItemModel(0, 1, self)
m_completer = QCompleter(self.m_model, self)
self.lineEdit.setCompleter(m_completer)
m_completer.activated[str].connect(self.onUrlChoosed)
def __init__(self, parent, node, active_data_type_detector):
super(SubscriberWindow, self).__init__(parent)
self.setWindowTitle(self.WINDOW_NAME_PREFIX)
self.setAttribute(
Qt.WA_DeleteOnClose) # This is required to stop background timers!
self._node = node
self._active_data_type_detector = active_data_type_detector
self._active_data_type_detector.message_types_updated.connect(
self._update_data_type_list)
self._message_queue = queue.Queue()
self._subscriber_handle = None
self._update_timer = QTimer(self)
self._update_timer.setSingleShot(False)
self._update_timer.timeout.connect(self._do_redraw)
self._update_timer.start(100)
self._log_viewer = QPlainTextEdit(self)
self._log_viewer.setReadOnly(True)
self._log_viewer.setLineWrapMode(QPlainTextEdit.NoWrap)
self._log_viewer.setFont(get_monospace_font())
self._log_viewer.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
try:
self._log_viewer.setPlaceholderText(
'Received messages will be printed here in YAML format')
except AttributeError: # Old PyQt
pass
self._num_rows_spinbox = QSpinBox(self)
self._num_rows_spinbox.setToolTip(
'Number of rows to display; large number will impair performance')
self._num_rows_spinbox.valueChanged.connect(
lambda: self._log_viewer.setMaximumBlockCount(
self._num_rows_spinbox.value()))
self._num_rows_spinbox.setMinimum(1)
self._num_rows_spinbox.setMaximum(1000000)
self._num_rows_spinbox.setValue(100)
self._num_errors = 0
self._num_messages_total = 0
self._num_messages_past_filter = 0
self._msgs_per_sec_estimator = RateEstimator()
self._num_messages_total_label = QuantityDisplay(self, 'Total', 'msgs')
self._num_messages_past_filter_label = QuantityDisplay(
self, 'Accepted', 'msgs')
self._msgs_per_sec_label = QuantityDisplay(self, 'Accepting',
'msg/sec')
self._type_selector = CommitableComboBoxWithHistory(self)
self._type_selector.setToolTip(
'Name of the message type to subscribe to')
self._type_selector.setInsertPolicy(QComboBox.NoInsert)
completer = QCompleter(self._type_selector)
completer.setCaseSensitivity(Qt.CaseSensitive)
completer.setModel(self._type_selector.model())
self._type_selector.setCompleter(completer)
self._type_selector.on_commit = self._do_start
self._type_selector.setFont(get_monospace_font())
self._type_selector.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self._type_selector.setFocus(Qt.OtherFocusReason)
self._active_filter = None
self._filter_bar = FilterBar(self)
self._filter_bar.on_filter = self._install_filter
self._start_stop_button = make_icon_button(
'video-camera',
'Begin subscription',
self,
checkable=True,
on_clicked=self._toggle_start_stop)
self._pause_button = make_icon_button(
'pause',
'Pause updates, non-displayed messages will be queued in memory',
self,
checkable=True)
self._clear_button = make_icon_button(
'trash-o',
'Clear output and reset stat counters',
self,
on_clicked=self._do_clear)
self._show_all_message_types = make_icon_button(
'puzzle-piece',
'Show all known message types, not only those that are '
'currently being exchanged over the bus',
self,
checkable=True,
on_clicked=self._update_data_type_list)
layout = QVBoxLayout(self)
controls_layout = QHBoxLayout(self)
controls_layout.addWidget(self._start_stop_button)
controls_layout.addWidget(self._pause_button)
controls_layout.addWidget(self._clear_button)
controls_layout.addWidget(self._filter_bar.add_filter_button)
controls_layout.addWidget(self._show_all_message_types)
controls_layout.addWidget(self._type_selector, 1)
controls_layout.addWidget(self._num_rows_spinbox)
layout.addLayout(controls_layout)
layout.addWidget(self._filter_bar)
layout.addWidget(self._log_viewer, 1)
stats_layout = QHBoxLayout(self)
stats_layout.addWidget(self._num_messages_total_label)
stats_layout.addWidget(self._num_messages_past_filter_label)
stats_layout.addWidget(self._msgs_per_sec_label)
layout.addLayout(stats_layout)
self.setLayout(layout)
# Initial updates
self._update_data_type_list()
def initUI(self):
############################### Create Actions ##############################
self.loadimagesaction = QAction("Load Images", self)
self.loadimagesaction.setCheckable(True)
self.loadimagesaction.triggered.connect(self.loadimages)
self.javascriptmode = QAction("Enable Javascript", self)
self.javascriptmode.setCheckable(True)
self.javascriptmode.triggered.connect(self.setjavascript)
self.useragent_mode_desktop = QAction("Desktop", self)
self.useragent_mode_desktop.setCheckable(True)
self.useragent_mode_desktop.triggered.connect(self.setUserAgentDesktop)
self.useragent_mode_mobile = QAction("Mobile", self)
self.useragent_mode_mobile.setCheckable(True)
self.useragent_mode_mobile.triggered.connect(self.setUserAgentMobile)
self.useragent_mode_custom = QAction("Custom", self)
self.useragent_mode_custom.setCheckable(True)
self.useragent_mode_custom.triggered.connect(self.setUserAgentCustom)
################ Add Actions to Menu ####################
# This sub-menu sets useragent mode to desktop/mobile/custom
self.useragentMenu = QMenu('UserAgent', self)
self.useragentMenu.setIcon(QIcon.fromTheme("computer"))
self.useragentMenu.addAction(self.useragent_mode_desktop)
self.useragentMenu.addAction(self.useragent_mode_mobile)
self.useragentMenu.addAction(self.useragent_mode_custom)
# This is main menu
self.menu = QMenu(self)
self.menu.addAction(QIcon.fromTheme("edit-find"), "Find Text",
self.findmode, "Ctrl+F")
self.menu.addAction(QIcon.fromTheme("list-add"), "Zoom In",
self.zoomin, "Ctrl++")
self.menu.addAction(QIcon.fromTheme("list-remove"), "Zoom Out",
self.zoomout, "Ctrl+-")
self.menu.addAction(QIcon.fromTheme("view-fullscreen"),
"Toggle Fullscreen", self.fullscreenmode, "F11")
self.menu.addSeparator()
self.menu.addAction(self.loadimagesaction)
self.menu.addAction(self.javascriptmode)
self.menu.addMenu(self.useragentMenu)
self.menu.addAction(QIcon.fromTheme("applications-system"), "Settings",
self.settingseditor, "Ctrl+,")
self.menu.addSeparator()
self.menu.addAction(QIcon.fromTheme("image-x-generic"),
"Save as Image", self.saveAsImage, "Shift+Ctrl+S")
self.menu.addAction(QIcon.fromTheme("text-html"), "Save as HTML",
self.saveashtml, "Ctrl+S")
self.menu.addAction(QIcon.fromTheme("document-print"), "Print to PDF",
self.printpage, "Ctrl+P")
self.menu.addSeparator()
self.menu.addAction(QIcon.fromTheme("process-stop"), "Quit",
self.forceClose, "Ctrl+Q")
self.bmk_menu = QMenu(self)
self.bmk_menu.addAction(QIcon(':/add-bookmark.png'), 'Add Bookmark',
self.addbookmark)
self.bmk_menu.addAction(QIcon(':/favourites.png'), 'Add to Home',
self.addToFavourites)
############################### Create Gui Parts ##############################
grid = QGridLayout()
grid.setSpacing(1)
grid.setContentsMargins(0, 2, 0, 0)
self.centralwidget = QWidget(self)
self.centralwidget.setLayout(grid)
self.setCentralWidget(self.centralwidget)
self.addtabBtn = QPushButton(QIcon(":/add-tab.png"), "", self)
self.addtabBtn.setToolTip("New Tab\n[Ctrl+Tab]")
self.addtabBtn.setShortcut("Ctrl+Tab")
self.addtabBtn.clicked.connect(self.addTab)
self.reload = QPushButton(QIcon(":/refresh.png"), "", self)
self.reload.setMinimumSize(35, 26)
self.reload.setToolTip("Reload/Stop\n [Space]")
self.reload.setShortcut("Space")
self.reload.clicked.connect(self.Reload)
self.back = QPushButton(QIcon(":/prev.png"), "", self)
self.back.setToolTip("Previous Page\n [Backspace]")
self.back.setMinimumSize(35, 26)
self.back.clicked.connect(self.Back)
self.forw = QPushButton(QIcon(":/next.png"), "", self)
self.forw.setToolTip("Next Page\n [Shift+Backspace]")
self.forw.setMinimumSize(35, 26)
self.forw.clicked.connect(self.Forward)
self.homeBtn = QPushButton(QIcon(":/home.png"), "", self)
self.homeBtn.setToolTip("Go Home")
self.homeBtn.clicked.connect(self.goToHome)
self.videoDownloadButton = QPushButton(QIcon(":/video-dwnld.png"), "",
self)
self.videoDownloadButton.setToolTip("Download this Video")
self.videoDownloadButton.clicked.connect(self.downloadVideo)
self.videoDownloadButton.hide()
self.addbookmarkBtn = QToolButton(self)
self.addbookmarkBtn.setIcon(QIcon(":/add-bookmark.png"))
self.addbookmarkBtn.setToolTip("Add Bookmark")
self.addbookmarkBtn.setMenu(self.bmk_menu)
self.addbookmarkBtn.setPopupMode(QToolButton.InstantPopup)
self.menuBtn = QToolButton(self)
self.menuBtn.setIcon(QIcon(":/menu.png"))
self.menuBtn.setMenu(self.menu)
self.menuBtn.setPopupMode(QToolButton.InstantPopup)
self.bookmarkBtn = QPushButton(QIcon(":/bookmarks.png"), "", self)
self.bookmarkBtn.setToolTip("Manage Bookmarks\n [Alt+B]")
self.bookmarkBtn.setShortcut("Alt+B")
self.bookmarkBtn.clicked.connect(self.managebookmarks)
self.historyBtn = QPushButton(QIcon(":/history.png"), "", self)
self.historyBtn.setShortcut("Alt+H")
self.historyBtn.setToolTip("View History\n [Alt+H]")
self.historyBtn.clicked.connect(self.viewhistory)
self.downloadsBtn = QPushButton(QIcon(":/download.png"), "", self)
self.downloadsBtn.setToolTip("Download Manager")
self.downloadsBtn.clicked.connect(self.download_manager)
self.find = QPushButton(self)
self.find.setText("Find/Next")
self.find.clicked.connect(self.findnext)
self.find.hide()
self.findprev = QPushButton(self)
self.findprev.setText("Backward")
self.findprev.clicked.connect(self.findback)
self.findprev.hide()
self.cancelfind = QPushButton(self)
self.cancelfind.setText("Cancel")
self.cancelfind.clicked.connect(self.cancelfindmode)
self.cancelfind.hide()
self.pbar = QProgressBar(self)
self.pbar.setTextVisible(False)
self.pbar.setStyleSheet(
"QProgressBar::chunk { background-color: #bad8ff; }")
pbarLayout = QGridLayout(self.pbar)
pbarLayout.setContentsMargins(0, 0, 0, 0)
self.line = webkit.UrlEdit(self.pbar)
self.line.openUrlRequested.connect(self.Enter)
self.line.textEdited.connect(self.urlsuggestions)
self.line.downloadRequested.connect(self.download_requested_file)
pbarLayout.addWidget(self.line)
self.listmodel = QStringListModel(self)
self.completer = QCompleter(self.listmodel, self.line)
self.completer.setCompletionMode(1)
self.completer.setMaxVisibleItems(10)
self.line.setCompleter(self.completer)
self.statusbar = QLabel(self)
self.statusbar.setStyleSheet(
"QLabel { font-size: 12px; border-radius: 2px; padding: 2px; background: palette(highlight); color: palette(highlighted-text); }"
)
self.statusbar.setMaximumHeight(16)
self.statusbar.hide()
self.tabWidget = QTabWidget(self)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setDocumentMode(True)
self.tabWidget.tabBar().setExpanding(True)
self.tabWidget.tabBar().setElideMode(Qt.ElideMiddle)
self.tabWidget.currentChanged.connect(self.onTabSwitch)
self.tabWidget.tabCloseRequested.connect(self.closeTab)
self.addTab()
self.applysettings()
#
for index, widget in enumerate([
self.addtabBtn, self.back, self.forw, self.reload,
self.homeBtn, self.videoDownloadButton, self.pbar, self.find,
self.findprev, self.cancelfind, self.addbookmarkBtn,
self.menuBtn, self.bookmarkBtn, self.historyBtn,
self.downloadsBtn
]):
grid.addWidget(widget, 0, index, 1, 1)
grid.addWidget(self.tabWidget, 2, 0, 1, 15)
def __init__(self,
installed_plugins,
highlighted_plugins=None,
parent=None):
super().__init__(parent)
self.backend_handler = BackendHandler()
self.backend_handler.set_gnuradio_installed_status()
self.ui = Ui_DialogOptions()
self.ui.setupUi(self)
self.device_options_model = DeviceOptionsTableModel(
self.backend_handler, self)
self.device_options_model.update()
self.ui.tblDevices.setModel(self.device_options_model)
self.ui.tblDevices.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.ui.tblDevices.setItemDelegateForColumn(
1, ComboBoxDelegate(["native", "GNU Radio"]))
self.setAttribute(Qt.WA_DeleteOnClose)
layout = QHBoxLayout(self.ui.tab_plugins)
self.plugin_controller = PluginFrame(installed_plugins,
highlighted_plugins,
parent=self)
layout.addWidget(self.plugin_controller)
self.ui.tab_plugins.setLayout(layout)
self.ui.btnViewBuildLog.hide()
self.build_log = ""
# We use bundled native device backends on windows, so no need to reconfigure them
self.ui.groupBoxNativeOptions.setVisible(sys.platform != "win32")
self.ui.labelIconTheme.setVisible(sys.platform == "linux")
self.ui.comboBoxIconTheme.setVisible(sys.platform == "linux")
self.ui.comboBoxTheme.setCurrentIndex(
constants.SETTINGS.value("theme_index", 0, int))
self.ui.comboBoxIconTheme.setCurrentIndex(
constants.SETTINGS.value("icon_theme_index", 0, int))
self.ui.checkBoxShowConfirmCloseDialog.setChecked(
not constants.SETTINGS.value('not_show_close_dialog', False, bool))
self.ui.checkBoxHoldShiftToDrag.setChecked(
constants.SETTINGS.value('hold_shift_to_drag', True, bool))
self.ui.checkBoxDefaultFuzzingPause.setChecked(
constants.SETTINGS.value('use_default_fuzzing_pause', True, bool))
self.ui.checkBoxAlignLabels.setChecked(
constants.SETTINGS.value('align_labels', True, bool))
self.ui.doubleSpinBoxRAMThreshold.setValue(
100 * constants.SETTINGS.value('ram_threshold', 0.6, float))
self.ui.radioButtonGnuradioDirectory.setChecked(
self.backend_handler.use_gnuradio_install_dir)
self.ui.radioButtonPython2Interpreter.setChecked(
not self.backend_handler.use_gnuradio_install_dir)
if self.backend_handler.gnuradio_install_dir:
self.ui.lineEditGnuradioDirectory.setText(
self.backend_handler.gnuradio_install_dir)
if self.backend_handler.python2_exe:
self.ui.lineEditPython2Interpreter.setText(
self.backend_handler.python2_exe)
self.ui.doubleSpinBoxFuzzingPause.setValue(
constants.SETTINGS.value("default_fuzzing_pause", 10**6, int))
self.ui.doubleSpinBoxFuzzingPause.setEnabled(
constants.SETTINGS.value('use_default_fuzzing_pause', True, bool))
self.ui.checkBoxMultipleModulations.setChecked(
constants.SETTINGS.value("multiple_modulations", False, bool))
completer = QCompleter()
completer.setModel(QDirModel(completer))
self.ui.lineEditPython2Interpreter.setCompleter(completer)
self.ui.lineEditGnuradioDirectory.setCompleter(completer)
self.refresh_device_tab()
self.create_connects()
self.old_show_pause_as_time = False
self.field_type_table_model = FieldTypeTableModel([], parent=self)
self.ui.tblLabeltypes.setModel(self.field_type_table_model)
self.ui.tblLabeltypes.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.ui.tblLabeltypes.setItemDelegateForColumn(
1,
ComboBoxDelegate([f.name for f in FieldType.Function],
return_index=False,
parent=self))
self.ui.tblLabeltypes.setItemDelegateForColumn(
2, ComboBoxDelegate(ProtocolLabel.DISPLAY_FORMATS, parent=self))
self.read_options()
self.old_default_view = self.ui.comboBoxDefaultView.currentIndex()
self.old_num_sending_repeats = self.ui.spinBoxNumSendingRepeats.value()
self.ui.labelRebuildNativeStatus.setText("")
self.show_available_colormaps()
try:
self.restoreGeometry(
constants.SETTINGS.value("{}/geometry".format(
self.__class__.__name__)))
except TypeError:
pass
def __init__(self, core_args=None, core_env=None):
QMainWindow.__init__(self)
QCoreApplication.setOrganizationDomain("nl")
QCoreApplication.setOrganizationName("TUDelft")
QCoreApplication.setApplicationName("Tribler")
QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
self.gui_settings = QSettings()
api_port = int(
get_gui_setting(self.gui_settings, "api_port", DEFAULT_API_PORT))
dispatcher.update_worker_settings(port=api_port)
self.navigation_stack = []
self.tribler_started = False
self.tribler_settings = None
self.debug_window = None
self.core_manager = CoreManager(api_port)
self.pending_requests = {}
self.pending_uri_requests = []
self.download_uri = None
self.dialog = None
self.new_version_dialog = None
self.start_download_dialog_active = False
self.request_mgr = None
self.search_request_mgr = None
self.search_suggestion_mgr = None
self.selected_torrent_files = []
self.vlc_available = True
self.has_search_results = False
self.last_search_query = None
self.last_search_time = None
self.start_time = time.time()
self.exception_handler_called = False
self.token_refresh_timer = None
sys.excepthook = self.on_exception
uic.loadUi(get_ui_file_path('mainwindow.ui'), self)
TriblerRequestManager.window = self
self.tribler_status_bar.hide()
# Load dynamic widgets
uic.loadUi(get_ui_file_path('torrent_channel_list_container.ui'),
self.channel_page_container)
self.channel_torrents_list = self.channel_page_container.items_list
self.channel_torrents_detail_widget = self.channel_page_container.details_tab_widget
self.channel_torrents_detail_widget.initialize_details_widget()
self.channel_torrents_list.itemClicked.connect(
self.channel_page.clicked_item)
uic.loadUi(get_ui_file_path('torrent_channel_list_container.ui'),
self.search_page_container)
self.search_results_list = self.search_page_container.items_list
self.search_torrents_detail_widget = self.search_page_container.details_tab_widget
self.search_torrents_detail_widget.initialize_details_widget()
self.search_results_list.itemClicked.connect(
self.on_channel_item_click)
self.search_results_list.itemClicked.connect(
self.search_results_page.clicked_item)
self.token_balance_widget.mouseReleaseEvent = self.on_token_balance_click
def on_state_update(new_state):
self.loading_text_label.setText(new_state)
self.core_manager.core_state_update.connect(on_state_update)
self.magnet_handler = MagnetHandler(self.window)
QDesktopServices.setUrlHandler("magnet", self.magnet_handler,
"on_open_magnet_link")
self.debug_pane_shortcut = QShortcut(QKeySequence("Ctrl+d"), self)
self.debug_pane_shortcut.activated.connect(
self.clicked_menu_button_debug)
# Remove the focus rect on OS X
for widget in self.findChildren(QLineEdit) + self.findChildren(
QListWidget) + self.findChildren(QTreeWidget):
widget.setAttribute(Qt.WA_MacShowFocusRect, 0)
self.menu_buttons = [
self.left_menu_button_home, self.left_menu_button_search,
self.left_menu_button_my_channel,
self.left_menu_button_subscriptions,
self.left_menu_button_video_player,
self.left_menu_button_downloads, self.left_menu_button_discovered
]
self.video_player_page.initialize_player()
self.search_results_page.initialize_search_results_page()
self.settings_page.initialize_settings_page()
self.subscribed_channels_page.initialize()
self.edit_channel_page.initialize_edit_channel_page()
self.downloads_page.initialize_downloads_page()
self.home_page.initialize_home_page()
self.loading_page.initialize_loading_page()
self.discovering_page.initialize_discovering_page()
self.discovered_page.initialize_discovered_page()
self.trust_page.initialize_trust_page()
self.stackedWidget.setCurrentIndex(PAGE_LOADING)
# Create the system tray icon
if QSystemTrayIcon.isSystemTrayAvailable():
self.tray_icon = QSystemTrayIcon()
use_monochrome_icon = get_gui_setting(self.gui_settings,
"use_monochrome_icon",
False,
is_bool=True)
self.update_tray_icon(use_monochrome_icon)
# Create the tray icon menu
menu = self.create_add_torrent_menu()
show_downloads_action = QAction('Show downloads', self)
show_downloads_action.triggered.connect(
self.clicked_menu_button_downloads)
token_balance_action = QAction('Show token balance', self)
token_balance_action.triggered.connect(
lambda: self.on_token_balance_click(None))
quit_action = QAction('Quit Tribler', self)
quit_action.triggered.connect(self.close_tribler)
menu.addSeparator()
menu.addAction(show_downloads_action)
menu.addAction(token_balance_action)
menu.addSeparator()
menu.addAction(quit_action)
self.tray_icon.setContextMenu(menu)
else:
self.tray_icon = None
self.hide_left_menu_playlist()
self.left_menu_button_debug.setHidden(True)
self.top_menu_button.setHidden(True)
self.left_menu.setHidden(True)
self.token_balance_widget.setHidden(True)
self.settings_button.setHidden(True)
self.add_torrent_button.setHidden(True)
self.top_search_bar.setHidden(True)
# Set various icons
self.top_menu_button.setIcon(QIcon(get_image_path('menu.png')))
self.search_completion_model = QStringListModel()
completer = QCompleter()
completer.setModel(self.search_completion_model)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.item_delegate = QStyledItemDelegate()
completer.popup().setItemDelegate(self.item_delegate)
completer.popup().setStyleSheet("""
QListView {
background-color: #404040;
}
QListView::item {
color: #D0D0D0;
padding-top: 5px;
padding-bottom: 5px;
}
QListView::item:hover {
background-color: #707070;
}
""")
self.top_search_bar.setCompleter(completer)
# Toggle debug if developer mode is enabled
self.window().left_menu_button_debug.setHidden(not get_gui_setting(
self.gui_settings, "debug", False, is_bool=True))
# Start Tribler
self.core_manager.start(core_args=core_args, core_env=core_env)
self.core_manager.events_manager.received_search_result_channel.connect(
self.search_results_page.received_search_result_channel)
self.core_manager.events_manager.received_search_result_torrent.connect(
self.search_results_page.received_search_result_torrent)
self.core_manager.events_manager.torrent_finished.connect(
self.on_torrent_finished)
self.core_manager.events_manager.new_version_available.connect(
self.on_new_version_available)
self.core_manager.events_manager.tribler_started.connect(
self.on_tribler_started)
self.core_manager.events_manager.events_started.connect(
self.on_events_started)
self.core_manager.events_manager.low_storage_signal.connect(
self.on_low_storage)
# Install signal handler for ctrl+c events
def sigint_handler(*_):
self.close_tribler()
signal.signal(signal.SIGINT, sigint_handler)
self.installEventFilter(self.video_player_page)
# Resize the window according to the settings
center = QApplication.desktop().availableGeometry(self).center()
pos = self.gui_settings.value(
"pos",
QPoint(center.x() - self.width() * 0.5,
center.y() - self.height() * 0.5))
size = self.gui_settings.value("size", self.size())
self.move(pos)
self.resize(size)
self.show()
def createWindow(self, mainWindow, placeholder, team):
"""Create readme sub window."""
super().__init__(None)
self.mainWindow = mainWindow
self.controller = mainWindow.controller
self.team = team
self.liquipediaGrabber = LiquipediaGrabber()
self.setWindowIcon(QIcon(
scctool.settings.getResFile("liquipedia.png")))
self.setWindowModality(Qt.ApplicationModal)
mainLayout = QGridLayout()
self.qle_search = QLineEdit(placeholder)
self.qle_search.setAlignment(Qt.AlignCenter)
self.qle_search.returnPressed.connect(self.search)
completer = QCompleter(
scctool.settings.config.getMyTeams() +
self.controller.historyManager.getTeamList(), self.qle_search)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
completer.setWrapAround(True)
self.qle_search.setCompleter(completer)
mainLayout.addWidget(self.qle_search, 0, 0, 1, 2)
searchButton = QPushButton(_("Search"))
searchButton.clicked.connect(self.search)
mainLayout.addWidget(searchButton, 0, 2)
self.box = QGroupBox(_("Results"))
layout = QHBoxLayout()
self.result_list = QListWidget()
self.result_list.setViewMode(QListWidget.IconMode)
self.result_list.itemDoubleClicked.connect(self.doubleClicked)
self.result_list.setContextMenuPolicy(Qt.CustomContextMenu)
self.result_list.customContextMenuRequested.connect(
self.listItemRightClicked)
self.result_list.setIconSize(QSize(75, 75))
# list.setWrapping(False)
# list.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.result_list.setAcceptDrops(False)
self.result_list.setDragEnabled(False)
layout.addWidget(self.result_list)
self.box.setLayout(layout)
mainLayout.addWidget(self.box, 1, 0, 1, 3)
selectButton = QPushButton(" " + _("Use Selected Logo") + " ")
selectButton.clicked.connect(self.applyLogo)
closeButton = QPushButton(_("Cancel"))
closeButton.clicked.connect(self.close)
mainLayout.addItem(
QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Minimum), 2,
0)
mainLayout.addWidget(closeButton, 2, 1)
mainLayout.addWidget(selectButton, 2, 2)
self.setLayout(mainLayout)
self.setWindowTitle(_("Liqupedia Image Search"))
self.resize(
QSize(mainWindow.size().width() * 0.9,
self.sizeHint().height()))
relativeChange = QPoint(mainWindow.size().width() / 2,
mainWindow.size().height() / 3)\
- QPoint(self.size().width() / 2,
self.size().height() / 3)
self.move(mainWindow.pos() + relativeChange)
return
if completionPrefix != self.completer.completionPrefix():
self.completer.setCompletionPrefix(completionPrefix)
self.completer.popup().setCurrentIndex(
self.completer.completionModel().index(0, 0))
cr = self.cursorRect()
cr.setWidth(
self.completer.popup().sizeHintForColumn(0) +
self.completer.popup().verticalScrollBar().sizeHint().width())
self.completer.complete(cr)
def is_special_key(self, e):
if self.completer and self.completer.popup().isVisible():
if e.key() in (Qt.Key_Enter, Qt.Key_Return):
return True
if e.key() == Qt.Key_Tab:
return True
return False
if __name__ == "__main__":
app = QApplication([])
completer = QCompleter(
["alabama", "arkansas", "avocado", "breakfast", "sausage"])
te = CompletionTextEdit()
te.set_completer(completer)
te.show()
app.exec_()
def set_simple_completer(self):
completer = QCompleter(list(pt_indexes.keys()))
self.textInterface.setCompleter(completer)
def setupUi(self):
self.load_ui("apol/terulequery.ui")
# set up source/target autocompletion
typeattr_completion_list = [str(t) for t in self.policy.types()]
typeattr_completion_list.extend(
str(a) for a in self.policy.typeattributes())
typeattr_completer_model = QStringListModel(self)
typeattr_completer_model.setStringList(
sorted(typeattr_completion_list))
self.typeattr_completion = QCompleter()
self.typeattr_completion.setModel(typeattr_completer_model)
self.source.setCompleter(self.typeattr_completion)
self.target.setCompleter(self.typeattr_completion)
# set up default autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.default_type.setCompleter(self.type_completion)
# setup indications of errors on source/target/default
self.errors = set()
self.orig_palette = self.source.palette()
self.error_palette = self.source.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_source_error()
self.clear_target_error()
self.clear_default_error()
self.clear_xperm_error()
# populate class list
self.class_model = SEToolsListModel(self)
self.class_model.item_list = sorted(self.policy.classes())
self.tclass.setModel(self.class_model)
# populate perm list
self.perms_model = PermListModel(self, self.policy)
self.perms.setModel(self.perms_model)
# populate bool list
self.bool_model = SEToolsListModel(self)
self.bool_model.item_list = sorted(self.policy.bools())
self.bool_criteria.setModel(self.bool_model)
# set up results
self.table_results_model = TERuleTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.terulequery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.set_source_regex(self.source_regex.isChecked())
self.set_target_regex(self.target_regex.isChecked())
self.set_default_regex(self.default_regex.isChecked())
self.toggle_xperm_criteria()
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# connect signals
self.buttonBox.clicked.connect(self.run)
self.allowxperm.toggled.connect(self.toggle_xperm_criteria)
self.auditallowxperm.toggled.connect(self.toggle_xperm_criteria)
self.neverallowxperm.toggled.connect(self.toggle_xperm_criteria)
self.dontauditxperm.toggled.connect(self.toggle_xperm_criteria)
self.clear_ruletypes.clicked.connect(self.clear_all_ruletypes)
self.all_ruletypes.clicked.connect(self.set_all_ruletypes)
self.source.textEdited.connect(self.clear_source_error)
self.source.editingFinished.connect(self.set_source)
self.source_regex.toggled.connect(self.set_source_regex)
self.target.textEdited.connect(self.clear_target_error)
self.target.editingFinished.connect(self.set_target)
self.target_regex.toggled.connect(self.set_target_regex)
self.tclass.selectionModel().selectionChanged.connect(self.set_tclass)
self.invert_class.clicked.connect(self.invert_tclass_selection)
self.perms.selectionModel().selectionChanged.connect(self.set_perms)
self.invert_perms.clicked.connect(self.invert_perms_selection)
self.xperms.textEdited.connect(self.clear_xperm_error)
self.xperms.editingFinished.connect(self.set_xperm)
self.default_type.textEdited.connect(self.clear_default_error)
self.default_type.editingFinished.connect(self.set_default_type)
self.default_regex.toggled.connect(self.set_default_regex)
self.bool_criteria.selectionModel().selectionChanged.connect(
self.set_bools)
def __init__(self):
QMainWindow.__init__(self)
self.navigation_stack = []
self.feedback_dialog_is_open = False
self.tribler_started = False
self.tribler_settings = None
self.debug_window = None
self.core_manager = CoreManager()
self.pending_requests = {}
self.pending_uri_requests = []
self.download_uri = None
self.dialog = None
self.new_version_dialog = None
self.start_download_dialog_active = False
self.request_mgr = None
self.search_request_mgr = None
self.search_suggestion_mgr = None
self.selected_torrent_files = []
self.vlc_available = True
self.has_search_results = False
self.last_search_query = None
self.last_search_time = None
self.start_time = time.time()
self.exception_handler_called = False
sys.excepthook = self.on_exception
uic.loadUi(get_ui_file_path('mainwindow.ui'), self)
TriblerRequestManager.window = self
# Load dynamic widgets
uic.loadUi(get_ui_file_path('torrent_channel_list_container.ui'), self.channel_page_container)
self.channel_torrents_list = self.channel_page_container.items_list
self.channel_torrents_detail_widget = self.channel_page_container.details_tab_widget
self.channel_torrents_detail_widget.initialize_details_widget()
self.channel_torrents_list.itemClicked.connect(self.channel_page.clicked_item)
uic.loadUi(get_ui_file_path('torrent_channel_list_container.ui'), self.search_page_container)
self.search_results_list = self.search_page_container.items_list
self.search_torrents_detail_widget = self.search_page_container.details_tab_widget
self.search_torrents_detail_widget.initialize_details_widget()
self.search_results_list.itemClicked.connect(self.on_channel_item_click)
self.search_results_list.itemClicked.connect(self.search_results_page.clicked_item)
def on_state_update(new_state):
self.loading_text_label.setText(new_state)
self.core_manager.core_state_update.connect(on_state_update)
self.magnet_handler = MagnetHandler(self.window)
QDesktopServices.setUrlHandler("magnet", self.magnet_handler, "on_open_magnet_link")
QCoreApplication.setOrganizationDomain("nl")
QCoreApplication.setOrganizationName("TUDelft")
QCoreApplication.setApplicationName("Tribler")
QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
self.read_settings()
self.debug_pane_shortcut = QShortcut(QKeySequence("Ctrl+d"), self)
self.debug_pane_shortcut.activated.connect(self.clicked_menu_button_debug)
# Remove the focus rect on OS X
for widget in self.findChildren(QLineEdit) + self.findChildren(QListWidget) + self.findChildren(QTreeWidget):
widget.setAttribute(Qt.WA_MacShowFocusRect, 0)
self.menu_buttons = [self.left_menu_button_home, self.left_menu_button_search, self.left_menu_button_my_channel,
self.left_menu_button_subscriptions, self.left_menu_button_video_player,
self.left_menu_button_downloads, self.left_menu_button_discovered]
self.video_player_page.initialize_player()
self.search_results_page.initialize_search_results_page()
self.settings_page.initialize_settings_page()
self.subscribed_channels_page.initialize()
self.edit_channel_page.initialize_edit_channel_page()
self.downloads_page.initialize_downloads_page()
self.home_page.initialize_home_page()
self.loading_page.initialize_loading_page()
self.discovering_page.initialize_discovering_page()
self.discovered_page.initialize_discovered_page()
self.trust_page.initialize_trust_page()
self.stackedWidget.setCurrentIndex(PAGE_LOADING)
# Create the system tray icon
if QSystemTrayIcon.isSystemTrayAvailable():
self.tray_icon = QSystemTrayIcon()
self.tray_icon.setIcon(QIcon(QPixmap(get_image_path('tribler.png'))))
self.tray_icon.show()
else:
self.tray_icon = None
self.hide_left_menu_playlist()
self.left_menu_button_debug.setHidden(True)
self.top_menu_button.setHidden(True)
self.left_menu.setHidden(True)
self.trust_button.setHidden(True)
self.settings_button.setHidden(True)
self.add_torrent_button.setHidden(True)
self.top_search_bar.setHidden(True)
# Set various icons
self.top_menu_button.setIcon(QIcon(get_image_path('menu.png')))
self.search_completion_model = QStringListModel()
completer = QCompleter()
completer.setModel(self.search_completion_model)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.item_delegate = QStyledItemDelegate()
completer.popup().setItemDelegate(self.item_delegate)
completer.popup().setStyleSheet("""
QListView {
background-color: #404040;
}
QListView::item {
color: #D0D0D0;
padding-top: 5px;
padding-bottom: 5px;
}
QListView::item:hover {
background-color: #707070;
}
""")
self.top_search_bar.setCompleter(completer)
# Toggle debug if developer mode is enabled
self.window().left_menu_button_debug.setHidden(
not get_gui_setting(self.gui_settings, "debug", False, is_bool=True))
self.core_manager.start()
self.core_manager.events_manager.received_search_result_channel.connect(
self.search_results_page.received_search_result_channel)
self.core_manager.events_manager.received_search_result_torrent.connect(
self.search_results_page.received_search_result_torrent)
self.core_manager.events_manager.torrent_finished.connect(self.on_torrent_finished)
self.core_manager.events_manager.new_version_available.connect(self.on_new_version_available)
self.core_manager.events_manager.tribler_started.connect(self.on_tribler_started)
self.core_manager.events_manager.low_storage_signal.connect(self.on_low_storage)
# Install signal handler for ctrl+c events
def sigint_handler(*_):
self.close_tribler()
signal.signal(signal.SIGINT, sigint_handler)
self.installEventFilter(self.video_player_page)
self.show()
def set_extended_completer(self):
completer = QCompleter(list(pt_indexes.keys()) +
list(geo_groups.keys()) +
list(names_abbrv.keys()))
self.textInterface.setCompleter(completer)
def initUI(self):
self.screen = QDesktopWidget().screenGeometry()
# Первоначальные настройки
self.setGeometry(0, 0, self.screen.width(), self.screen.height())
self.showMaximized()
self.setWindowTitle('Certificate')
# создаем рабочую область
grid = QGridLayout()
grid.setSpacing(10)
self.imgWidth = int(self.screen.width() - self.screen.width() / 4)
self.imgHeight = self.screen.height()
# Пустой сертификат
self.img = Image.open("image/first.jpg").resize(
(self.imgWidth, self.imgHeight))
self.img.save(self.new_img)
self.pixmap = QPixmap(self.new_img)
self.image = QLabel(self)
self.image.setPixmap(self.pixmap)
grid.addWidget(self.image, 0, 0, 10, 1)
# Выбор шаблона сертификата
self.template = 0
self.rbt0 = QRadioButton("Образец 1")
self.rbt0.setChecked(True)
self.rbt1 = QRadioButton("Образец 2")
grid.addWidget(self.rbt0, 1, 1)
grid.addWidget(self.rbt1, 1, 2)
# radioBtn = self.sender()
# Метка (Код)
self.lbl_code = QLabel(text="Номер")
grid.addWidget(self.lbl_code, 2, 1)
# Поле ввода текста (Код)
self.ent_code = QLineEdit()
grid.addWidget(self.ent_code, 2, 2, 1, 4)
# Метка (Имя)
self.lbl_name = QLabel(text="Имя")
grid.addWidget(self.lbl_name, 3, 1)
# Поле ввода текста (Имя)
self.ent_name = QLineEdit()
grid.addWidget(self.ent_name, 3, 2, 1, 4)
# Метка (Процедура1)
self.lbl_pro1 = QLabel(text="Процедура")
grid.addWidget(self.lbl_pro1, 4, 1)
# Поле ввода текста (Процедура1)
self.ent_pro1 = QLineEdit()
pro1List = ['SPA Комплекс', 'SPA Комплекс 2']
completer = QCompleter(pro1List, self.ent_pro1)
self.ent_pro1.setCompleter(completer)
grid.addWidget(self.ent_pro1, 4, 2, 1, 4)
# Метка (Процедура2)
self.lbl_pro2 = QLabel(text="Доплнение")
grid.addWidget(self.lbl_pro2, 5, 1)
# Поле ввода текста (Процедура2)
self.ent_pro2 = QLineEdit()
pro2List = ['Классика на двоих', 'Еще что-нибудь']
completer = QCompleter(pro2List, self.ent_pro1)
self.ent_pro2.setCompleter(completer)
grid.addWidget(self.ent_pro2, 5, 2, 1, 4)
# Метка (Дата)
self.lbl_date = QLabel(text="Дата")
grid.addWidget(self.lbl_date, 6, 1)
# Фрейм ввода текста (Дата)
# Создание даты
self.lbl_dateEnd = QLabel(text=datetime.now().strftime("%d.%m.%Y"))
grid.addWidget(self.lbl_dateEnd, 6, 2)
self.ent_dateDel = QLineEdit()
grid.addWidget(self.ent_dateDel, 6, 3, 1, 3)
# Кнопка обновить
button = QPushButton('Обновить', self)
button.clicked.connect(self.but_upgrade)
grid.addWidget(button, 7, 1, 1, 5)
# Кнопка сохранить
button = QPushButton('Сохранить', self)
button.clicked.connect(self.but_save)
grid.addWidget(button, 8, 1, 1, 5)
self.ent_code.editingFinished.connect(self.but_upgrade)
self.ent_name.editingFinished.connect(self.but_upgrade)
self.ent_pro1.editingFinished.connect(self.but_upgrade)
self.ent_pro2.editingFinished.connect(self.but_upgrade)
self.ent_dateDel.editingFinished.connect(self.but_upgrade)
self.setLayout(grid)
self.show()
def __init__(self, cols: dict, parent=None, address_space: dict=None):
super(AnalyzerView, self).__init__(parent)
self.cols = cols
self.address_space = address_space
self.dataformat = {}
self.entry = QLineEdit(self)
self.entry.setClearButtonEnabled(True)
self.entry.setPlaceholderText('Base Address or Register Name')
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchContains)
self.entry.setCompleter(completer)
self.entry.setMinimumWidth(500)
self.entry.setMinimumHeight(35)
self.close_btn = QPushButton('X', self,)
self.close_btn.setMaximumWidth(40)
hbox1 = QHBoxLayout()
hbox1.addWidget(self.entry)
hbox1.addStretch(1)
# hbox1.addWidget()
ctrl_box = QHBoxLayout()
self.show_detail = QCheckBox('Show Detail', self)
self.show_reserved = QCheckBox('Show Reserved', self)
self.add_col = QPushButton('Add Column', self,)
self.add_col.setDisabled(True)
ctrl_box.addWidget(self.show_detail)
# ctrl_box.addWidget(detail_label)
ctrl_box.addWidget(self.show_reserved)
ctrl_box.addWidget(self.add_col)
ctrl_box.addStretch(1)
ctrl_box.addWidget(self.close_btn)
self.string_model = QStringListModel()
completer.setModel(self.string_model)
self.string_model.setStringList(self.address_space.keys())
self.model = QStandardItemModel()
self.table = TableView(self)
self.table.setWordWrap(True)
self.table.setModel(self.model)
self.table.setHorizontalHeader(MetaHeaderView(Qt.Horizontal, parent=self.table))
vbox = QVBoxLayout()
vbox.addLayout(hbox1)
# vbox.addWidget(self.entry)
vbox.addLayout(ctrl_box)
vbox.addWidget(self.table)
self.setLayout(vbox)
# self.table.horizontalHeader().setHidden(True)
self.table.verticalHeader().setHidden(True)
self.table.setShowGrid(False)
self.table.setSizeAdjustPolicy(
QAbstractScrollArea.AdjustToContents
)
# self.table.setMinimumHeight(600)
self.reserved_row = []
self.add_col.clicked.connect(self.add_column)
self.close_btn.clicked.connect(self.close)
self.show_detail.stateChanged.connect(self.detail)
self.show_reserved.stateChanged.connect(self.hide_reserved)
self.entry.textChanged.connect(self.create_rows)
# self.table.dataChangedSignal.connect(self.test)
self.default_col = list(self.cols.keys()).index('Default')
self.create_cols()
self.detail()
def edit_contact_dialog(wallet_api, contact_key=None):
editing = contact_key is not None
if editing:
title = _("Edit Contact")
else:
title = _("New Contact")
d = WindowModalDialog(wallet_api.wallet_window, title)
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(title + ':'))
def _contact_insert_completion(text):
if text:
index = combo1.findText(text)
combo1.setCurrentIndex(index)
identity_line = QLineEdit()
name_line = QLineEdit()
combo1 = QComboBox()
combo1.setFixedWidth(280)
combo1.setEditable(True)
# add a filter model to filter matching items
contact_filter_model = QSortFilterProxyModel(combo1)
contact_filter_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
contact_filter_model.setSourceModel(combo1.model())
contact_completer = QCompleter(contact_filter_model, combo1)
contact_completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
combo1.setCompleter(contact_completer)
ok_button = OkButton(d)
ok_button.setEnabled(False)
def _validate_form() -> None:
def _set_validation_state(element, is_valid) -> None:
if not is_valid:
element.setStyleSheet("border: 1px solid red")
else:
element.setStyleSheet("")
can_submit = True
system_name = combo1.currentText().lower().strip()
is_valid = True
try:
system_id = get_system_id(system_name)
except ContactDataError:
system_id = None
is_valid = False
_set_validation_state(combo1, is_valid)
can_submit = can_submit and is_valid
identity_text = identity_line.text().strip()
if system_id is None:
identity_result = IdentityCheckResult.Invalid
else:
identity_result = wallet_api.check_identity_valid(
system_id, identity_text, skip_exists=editing)
is_valid = identity_result == IdentityCheckResult.Ok
_set_validation_state(identity_line, is_valid)
if is_valid:
identity_line.setToolTip("")
elif identity_result == IdentityCheckResult.Invalid:
if system_id == IdentitySystem.OnChain:
identity_line.setToolTip(_("Not a valid Bitcoin address"))
else:
identity_line.setToolTip(_("Incorrect format"))
elif identity_result == IdentityCheckResult.InUse:
identity_line.setToolTip(_("Already in use"))
can_submit = can_submit and is_valid
name_text = name_line.text().strip()
name_result = wallet_api.check_label(name_text)
is_valid = (name_result == IdentityCheckResult.Ok
or editing and name_result == IdentityCheckResult.InUse)
_set_validation_state(name_line, is_valid)
if is_valid:
name_line.setToolTip("")
elif name_result == IdentityCheckResult.Invalid:
name_line.setToolTip(_("Name too short"))
elif name_result == IdentityCheckResult.InUse:
name_line.setToolTip(_("Name already in use"))
can_submit = can_submit and is_valid
ok_button.setEnabled(can_submit)
def _contact_text_changed(text: str) -> None:
_validate_form()
combo1.lineEdit().textEdited.connect(
contact_filter_model.setFilterFixedString)
combo1.editTextChanged.connect(_contact_text_changed)
identity_line.textChanged.connect(_contact_text_changed)
name_line.textChanged.connect(_contact_text_changed)
contact_completer.activated.connect(_contact_insert_completion)
combo1.addItems(list(IDENTITY_SYSTEM_NAMES.values()))
grid = QGridLayout()
identity_line.setFixedWidth(280)
name_line.setFixedWidth(280)
grid.addWidget(QLabel(_("Identity Type")), 1, 0)
grid.addWidget(combo1, 1, 1)
grid.addWidget(QLabel(_("Identity")), 2, 0)
grid.addWidget(identity_line, 2, 1)
grid.addWidget(QLabel(_("Name")), 3, 0)
grid.addWidget(name_line, 3, 1)
vbox.addLayout(grid)
vbox.addLayout(Buttons(CancelButton(d), ok_button))
if contact_key is None:
combo1.lineEdit().setText(
IDENTITY_SYSTEM_NAMES[IdentitySystem.OnChain])
identity_line.setFocus()
else:
entry = wallet_api.get_contact(contact_key[0])
identity = [
ci for ci in entry.identities if ci.identity_id == contact_key[1]
][0]
combo1.lineEdit().setText(IDENTITY_SYSTEM_NAMES[identity.system_id])
identity_line.setText(identity.system_data)
name_line.setText(entry.label)
name_line.setFocus()
if d.exec_():
name_text = name_line.text().strip()
identity_text = identity_line.text().strip()
system_id = get_system_id(combo1.currentText())
if contact_key is not None:
contact = wallet_api.get_contact(contact_key[0])
identity = [
ci for ci in contact.identities
if ci.identity_id == contact_key[1]
][0]
if contact_key[1] != identity.identity_id:
wallet_api.remove_identity(contact_key[0], contact_key[1])
wallet_api.add_identity(contact_key[0], system_id,
identity_text)
if contact.label != name_text:
wallet_api.set_label(contact_key[0], name_text)
else:
wallet_api.add_contact(system_id, name_text, identity_text)
def creaCompleter(self, datos=[]):
completer = QCompleter(datos)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.setCompleter(completer)
def __init__(self, gtoAction, parent=None):
super(ExtendedComboBox, self).__init__(parent)
self.gtomain = gtoAction.gtomain
self.debug = gtoAction.debug
self.info = gtoAction.info
self.config = gtoAction.config
self.tools = []
self.doQueryOnShow = False
# speed up
# // For performance reasons use this policy on large models
# // or AdjustToMinimumContentsLengthWithIcon
self.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
# // Improving Performance: It is possible to give the view hints
# // about the data it is handling in order to improve its performance
# // when displaying large numbers of items. One approach that can be taken
# // for views that are intended to display items with equal sizes
# // is to set the uniformItemSizes property to true.
self.view().setUniformItemSizes(True)
# // This property holds the layout mode for the items. When the mode is Batched,
# // the items are laid out in batches of batchSize items, while processing events.
# // This makes it possible to instantly view and interact with the visible items
# // while the rest are being laid out.
self.view().setLayoutMode(QListView.Batched)
# // batchSize : int
# // This property holds the number of items laid out in each batch
# // if layoutMode is set to Batched. The default value is 100."
try:
self.setInsertPolicy(self.NoInsert)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(
QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
# connect signals
self.lineEdit().textEdited.connect(
self.pFilterModel.setFilterFixedString)
self.lineEdit().textEdited.connect(self.correctInput)
# corrct qt bug:
style = "QWidget{font-size: " + str(self.fontInfo().pointSize(
)) + "pt;font-family: " + self.fontInfo().family() + ";}"
self.completer.popup().setStyleSheet(style)
# stat vars
self.query = None
self.layer = None
self.doQueryOnShow = False
self.masterExpression = None
self.child = None
except Exception as e:
self.info.err(e)
def __init__(self,
settings,
core_args=None,
core_env=None,
api_port=None,
api_key=None):
QMainWindow.__init__(self)
self._logger = logging.getLogger(self.__class__.__name__)
QCoreApplication.setOrganizationDomain("nl")
QCoreApplication.setOrganizationName("TUDelft")
QCoreApplication.setApplicationName("Tribler")
self.setWindowIcon(QIcon(QPixmap(get_image_path('tribler.png'))))
self.gui_settings = settings
api_port = api_port or int(
get_gui_setting(self.gui_settings, "api_port", DEFAULT_API_PORT))
api_key = api_key or get_gui_setting(
self.gui_settings, "api_key",
hexlify(os.urandom(16)).encode('utf-8'))
self.gui_settings.setValue("api_key", api_key)
api_port = get_first_free_port(start=api_port, limit=100)
request_manager.port, request_manager.key = api_port, api_key
self.tribler_started = False
self.tribler_settings = None
# TODO: move version_id to tribler_common and get core version in the core crash message
self.tribler_version = version_id
self.debug_window = None
self.error_handler = ErrorHandler(self)
self.core_manager = CoreManager(api_port, api_key, self.error_handler)
self.pending_requests = {}
self.pending_uri_requests = []
self.download_uri = None
self.dialog = None
self.create_dialog = None
self.chosen_dir = None
self.new_version_dialog = None
self.start_download_dialog_active = False
self.selected_torrent_files = []
self.last_search_query = None
self.last_search_time = None
self.start_time = time.time()
self.token_refresh_timer = None
self.shutdown_timer = None
self.add_torrent_url_dialog_active = False
sys.excepthook = self.error_handler.gui_error
uic.loadUi(get_ui_file_path('mainwindow.ui'), self)
TriblerRequestManager.window = self
self.tribler_status_bar.hide()
self.token_balance_widget.mouseReleaseEvent = self.on_token_balance_click
def on_state_update(new_state):
self.loading_text_label.setText(new_state)
connect(self.core_manager.core_state_update, on_state_update)
self.magnet_handler = MagnetHandler(self.window)
QDesktopServices.setUrlHandler("magnet", self.magnet_handler,
"on_open_magnet_link")
self.debug_pane_shortcut = QShortcut(QKeySequence("Ctrl+d"), self)
connect(self.debug_pane_shortcut.activated,
self.clicked_debug_panel_button)
self.import_torrent_shortcut = QShortcut(QKeySequence("Ctrl+o"), self)
connect(self.import_torrent_shortcut.activated,
self.on_add_torrent_browse_file)
self.add_torrent_url_shortcut = QShortcut(QKeySequence("Ctrl+i"), self)
connect(self.add_torrent_url_shortcut.activated,
self.on_add_torrent_from_url)
connect(self.top_search_bar.clicked, self.clicked_search_bar)
connect(self.top_search_bar.returnPressed,
self.on_top_search_bar_return_pressed)
# Remove the focus rect on OS X
for widget in self.findChildren(QLineEdit) + self.findChildren(
QListWidget) + self.findChildren(QTreeWidget):
widget.setAttribute(Qt.WA_MacShowFocusRect, 0)
self.menu_buttons = [
self.left_menu_button_downloads,
self.left_menu_button_discovered,
self.left_menu_button_popular,
]
self.search_results_page.initialize(hide_xxx=self.hide_xxx)
connect(
self.core_manager.events_manager.received_remote_query_results,
self.search_results_page.received_remote_results.emit,
)
self.settings_page.initialize_settings_page()
self.downloads_page.initialize_downloads_page()
self.loading_page.initialize_loading_page()
self.discovering_page.initialize_discovering_page()
self.discovered_page.initialize_content_page(hide_xxx=self.hide_xxx)
self.popular_page.initialize_content_page(
hide_xxx=self.hide_xxx,
controller_class=PopularContentTableViewController)
self.trust_page.initialize_trust_page()
self.trust_graph_page.initialize_trust_graph()
self.stackedWidget.setCurrentIndex(PAGE_LOADING)
# Create the system tray icon
self.tray_icon = None
# System tray doesn't make sense on Mac
if QSystemTrayIcon.isSystemTrayAvailable():
self.tray_icon = QSystemTrayIcon()
if not DARWIN:
connect(self.tray_icon.activated,
self.on_system_tray_icon_activated)
use_monochrome_icon = get_gui_setting(self.gui_settings,
"use_monochrome_icon",
False,
is_bool=True)
self.update_tray_icon(use_monochrome_icon)
# Create the tray icon menu
menu = TriblerActionMenu(self)
menu.addAction(tr('Show Tribler window'), self.raise_window)
menu.addSeparator()
self.create_add_torrent_menu(menu)
menu.addSeparator()
menu.addAction(tr('Show downloads'),
self.clicked_menu_button_downloads)
menu.addSeparator()
menu.addAction(tr('Quit Tribler'), self.close_tribler)
self.tray_icon.setContextMenu(menu)
self.debug_panel_button.setHidden(True)
self.top_menu_button.setHidden(True)
self.left_menu.setHidden(True)
self.token_balance_widget.setHidden(True)
self.settings_button.setHidden(True)
self.add_torrent_button.setHidden(True)
self.top_search_bar.setHidden(True)
# Set various icons
self.top_menu_button.setIcon(QIcon(get_image_path('menu.png')))
self.search_completion_model = QStringListModel()
completer = QCompleter()
completer.setModel(self.search_completion_model)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.item_delegate = QStyledItemDelegate()
completer.popup().setItemDelegate(self.item_delegate)
completer.popup().setStyleSheet("""
QListView {
background-color: #404040;
}
QListView::item {
color: #D0D0D0;
padding-top: 5px;
padding-bottom: 5px;
}
QListView::item:hover {
background-color: #707070;
}
""")
self.top_search_bar.setCompleter(completer)
# Start Tribler
self.core_manager.start(core_args=core_args, core_env=core_env)
connect(self.core_manager.events_manager.torrent_finished,
self.on_torrent_finished)
connect(self.core_manager.events_manager.new_version_available,
self.on_new_version_available)
connect(self.core_manager.events_manager.tribler_started,
self.on_tribler_started)
connect(self.core_manager.events_manager.low_storage_signal,
self.on_low_storage)
connect(self.core_manager.events_manager.tribler_shutdown_signal,
self.on_tribler_shutdown_state_update)
connect(self.core_manager.events_manager.config_error_signal,
self.on_config_error_signal)
# Install signal handler for ctrl+c events
def sigint_handler(*_):
self.close_tribler()
signal.signal(signal.SIGINT, sigint_handler)
# Resize the window according to the settings
center = QApplication.desktop().availableGeometry(self).center()
pos = self.gui_settings.value(
"pos",
QPoint(center.x() - self.width() * 0.5,
center.y() - self.height() * 0.5))
size = self.gui_settings.value("size", self.size())
self.move(pos)
self.resize(size)
self.show()
self.add_to_channel_dialog = AddToChannelDialog(self.window())
self.add_torrent_menu = self.create_add_torrent_menu()
self.add_torrent_button.setMenu(self.add_torrent_menu)
self.channels_menu_list = self.findChild(ChannelsMenuListWidget,
"channels_menu_list")
connect(self.channels_menu_list.itemClicked,
self.open_channel_contents_page)
# The channels content page is only used to show subscribed channels, so we always show xxx
# contents in it.
connect(
self.core_manager.events_manager.node_info_updated,
lambda data: self.channels_menu_list.reload_if_necessary([data]),
)
connect(self.left_menu_button_new_channel.clicked,
self.create_new_channel)
connect(self.debug_panel_button.clicked,
self.clicked_debug_panel_button)
connect(self.trust_graph_button.clicked,
self.clicked_trust_graph_page_button)
def setCompleterMarca(self):
listMarcas = self.conexionProducto.listMarcas()
self.completerMarca = QCompleter(listMarcas)
self.completerMarca.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.winPrincipal.txtMarca_p.setCompleter(self.completerMarca)
def setupUi(self):
self.log.debug("Initializing UI.")
self.load_ui("dta.ui")
# set up source/target autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.source.setCompleter(self.type_completion)
self.target.setCompleter(self.type_completion)
# setup indications of errors on source/target/default
self.orig_palette = self.source.palette()
self.error_palette = self.source.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_source_error()
self.clear_target_error()
# set up processing thread
self.thread = ResultsUpdater(self.query)
self.thread.raw_line.connect(self.raw_results.appendPlainText)
self.thread.finished.connect(self.update_complete)
self.thread.trans.connect(self.reset_browser)
# set up browser thread
self.browser_thread = BrowserUpdater(self.query)
self.browser_thread.trans.connect(self.add_browser_children)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.setCancelButton(None)
self.busy.reset()
# update busy dialog from DTA INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.dta").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.max_path_length.setEnabled(self.all_paths.isChecked())
self.source.setEnabled(not self.flows_in.isChecked())
self.target.setEnabled(not self.flows_out.isChecked())
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
self.browser_tab.setEnabled(self.flows_in.isChecked()
or self.flows_out.isChecked())
# connect signals
self.buttonBox.clicked.connect(self.run)
self.source.textEdited.connect(self.clear_source_error)
self.source.editingFinished.connect(self.set_source)
self.target.textEdited.connect(self.clear_target_error)
self.target.editingFinished.connect(self.set_target)
self.all_paths.toggled.connect(self.all_paths_toggled)
self.flows_in.toggled.connect(self.flows_in_toggled)
self.flows_out.toggled.connect(self.flows_out_toggled)
self.reverse.stateChanged.connect(self.reverse_toggled)
self.exclude_types.clicked.connect(self.choose_excluded_types)
self.browser.currentItemChanged.connect(self.browser_item_selected)
def setCompleterProveedor(self):
listProveedores = self.conexionProducto.listProveedor()
self.completerProveedor = QCompleter(listProveedores)
pass
self.completerProveedor.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.winPrincipal.txtProveedor_p.setCompleter(self.completerProveedor)
def __init__(self, *args, **kwargs):
super().__init__()
#Create our 4 main buttons, the add contacts button will only be visible
#on the contacts screen
self.setStyleSheet(
'background-color: #242424; color: white; font-size: 14pt;'
'font: Courier;')
self.create = QtWidgets.QPushButton(self)
self.create.setText("Create Project")
# padding: 6px;')
self.create.setStyleSheet(
"QPushButton{background-color : darkSlateGray;}"
"QPushButton::pressed{background-color : #242424;}")
self.create.setCursor(QCursor(QtCore.Qt.PointingHandCursor))
self.create.clicked.connect(self.createProj)
self.view = QtWidgets.QPushButton(self)
self.view.setText("View All Projects")
self.view.setStyleSheet(
"QPushButton{background-color : darkSlateGray;}"
"QPushButton::pressed{background-color : #242424;}")
self.view.setCursor(QCursor(QtCore.Qt.PointingHandCursor))
self.view.clicked.connect(self.projView)
self.contacts = QtWidgets.QPushButton(self)
self.contacts.setText("Contacts")
self.contacts.setStyleSheet(
"QPushButton{background-color : darkSlateGray;}"
"QPushButton::pressed{background-color : #242424;}")
self.contacts.setCursor(QCursor(QtCore.Qt.PointingHandCursor))
self.contacts.clicked.connect(self.contactsView)
#This button is hidden and only made visible on contacts screen
self.NewContact = QtWidgets.QPushButton(self)
self.NewContact.setText("Add New Contact")
self.NewContact.clicked.connect(self.addNew)
self.NewContact.setStyleSheet(
"QPushButton{background-color : darkSlateGray;}"
"QPushButton::pressed{background-color : #242424;}")
self.NewContact.setCursor(QCursor(QtCore.Qt.PointingHandCursor))
self.NewContact.hide()
self.controls = QWidget() #Controls container widget.
self.controlsLayout = QVBoxLayout() #Controls container layout.
# List of names, widgets are stored in a dictionary by these keys.
self.projWidget = []
project_dict = s.listProjects(folder_id, service)
#Iterating through all the projects, creating a widget
#for each one with their own buttons
for name in project_dict:
project_id = project_dict[name]
#print("adding",name, "to widget:", project_id, "ProjectWindow")
item = ProjectWidget(
name, project_id, self
) #make a project widget with the name of the current project
self.controlsLayout.insertWidget(
0, item
) #^^^ we pass self so we can hide it from the widgets inside it
self.projWidget.append(
item) #append it to our list of widgets of projects
self.contWidget = [] #empty list of contact widgets
contacts = s.addContact(None, None, None) #get the list of contacts
for name in contacts:
user_email = contacts[
name] #accessing email from dictionary of contacts
item = contactsWidget(
name, user_email, self
) #make a project widget with the name of the current project
#and with the list with file_id and project_id
self.controlsLayout.insertWidget(0, item)
self.contWidget.append(
item) #append it to our list of widgets of projects
#Hide the contacts until the contact view is opened
for widget in self.contWidget:
widget.hide()
self.fileWidget = [
] #declaring this for later use in viewing the files in a project
#Hide the project view widgets until a project is clicked
for widget in self.fileWidget:
widget.hide()
spacer = QSpacerItem(1, 1, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.controlsLayout.addItem(spacer)
self.controls.setLayout(self.controlsLayout)
# Scroll Area Properties.
self.scroll = QScrollArea()
self.scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scroll.setWidgetResizable(True)
self.scroll.setWidget(self.controls)
# Search bar.
self.searchbar = QLineEdit()
self.searchbar.setStyleSheet(
'background-color: white; color: black; font: Courier; padding: 6px;'
'border-style: outset;'
'border-width: 2px; border-radius: 6px;'
'border-color: beige;')
self.searchbar.textChanged.connect(self.update_display)
# Adding Completer.
self.completer = QCompleter(project_dict)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.searchbar.setCompleter(self.completer)
#Add the items to VBoxLayout (applied to container widget)
#which encompasses the whole window.
container = QWidget()
containerLayout = QVBoxLayout()
containerLayout.addWidget(self.create)
containerLayout.addWidget(self.view)
containerLayout.addWidget(self.contacts)
containerLayout.addWidget(self.NewContact)
containerLayout.addWidget(self.searchbar)
containerLayout.addWidget(self.scroll)
container.setLayout(containerLayout)
self.setCentralWidget(container)
self.showMaximized()
self.setWindowTitle('StudioHub')
#when we initialise this is the current window
#We will keep track of this and hide all other results outside of it
self.currentWindow = self.projWidget
model.setStringList(NWO['Product Code'].unique().tolist())
def get_paper_list(model):
model.setStringList(NWO['Paper Code'].unique().tolist())
def get_Cons_list(model):
model.setStringList(NWO['Construction'].unique().tolist())
def get_order_list(model):
model.setStringList(NWO['Order'].unique().tolist())
PCcompleter = QCompleter()
PaperCompleter = QCompleter()
ConsCompleter = QCompleter()
OrderCompleter = QCompleter()
PCcompleter.setCaseSensitivity(False)
PaperCompleter.setCaseSensitivity(False)
ConsCompleter.setCaseSensitivity(False)
modelPC = QStringListModel()
modelPaper = QStringListModel()
modelCons = QStringListModel()
modelOrder = QStringListModel()
get_PC_list(modelPC)
get_paper_list(modelPaper)
get_Cons_list(modelCons)
get_order_list(modelOrder)
PCcompleter.setModel(modelPC)
def create_send_tab(self):
# A 4-column grid layout. All the stretch is in the last column.
# The exchange rate plugin adds a fiat widget in column 2
self.send_grid = grid = QGridLayout()
grid.setSpacing(8)
grid.setColumnStretch(3, 1)
blocking_warning_text = _(
'Warning: Please be aware that in the process of using the Secure \
Transaction feature, a part of the funds left in your wallet might be blocked. This is a normal procedure linked to UTXO \
and the blockchain parameters of the Bitcoin Vault wallet. Your funds will be unblocked once the transaction is verified \
(after approximately 24 hrs) or canceled (within 24 hrs).')
self.label_transaction_limitations = QLabel(blocking_warning_text)
self.label_transaction_limitations.setStyleSheet(
ColorScheme.RED.as_stylesheet(True))
self.label_transaction_limitations.setWordWrap(True)
from .paytoedit import PayToEdit
self.amount_e = BTCAmountEdit(self.get_decimal_point)
self.payto_e = PayToEdit(self)
msg = _('Recipient of the funds.') + '\n\n' \
+ _(
'You may enter a Bitcoin address, a label from your list of contacts (a list of completions will be proposed), or an alias (email-like address that forwards to a Bitcoin address)')
payto_label = HelpLabel(_('Pay to'), msg)
grid.addWidget(payto_label, 1, 0)
grid.addWidget(self.payto_e, 1, 1, 1, -1)
completer = QCompleter()
completer.setCaseSensitivity(False)
self.payto_e.set_completer(completer)
completer.setModel(self.completions)
msg = _('Description of the transaction (not mandatory).') + '\n\n' \
+ _(
'The description is not sent to the recipient of the funds. It is stored in your wallet file, and displayed in the \'History\' tab.')
description_label = HelpLabel(_('Description'), msg)
grid.addWidget(description_label, 2, 0)
self.message_e = MyLineEdit()
self.message_e.setMinimumWidth(700)
grid.addWidget(self.message_e, 2, 1, 1, -1)
msg = _('Amount to be sent.') + '\n\n' \
+ _('The amount will be displayed in red if you do not have enough funds in your wallet.') + ' ' \
+ _(
'Note that if you have frozen some of your addresses, the available funds will be lower than your total balance.') + '\n\n' \
+ _('Keyboard shortcut: type "!" to send all your coins.')
amount_label = HelpLabel(_('Amount'), msg)
grid.addWidget(amount_label, 3, 0)
grid.addWidget(self.amount_e, 3, 1)
self.fiat_send_e = AmountEdit(self.fx.get_currency if self.fx else '')
if not self.fx or not self.fx.is_enabled():
self.fiat_send_e.setVisible(False)
grid.addWidget(self.fiat_send_e, 3, 2)
self.amount_e.frozen.connect(
lambda: self.fiat_send_e.setFrozen(self.amount_e.isReadOnly()))
self.max_button = EnterButton(_("Max"), self.spend_max)
self.max_button.setFixedWidth(100)
self.max_button.setCheckable(True)
grid.addWidget(self.max_button, 3, 3)
def on_tx_type(index):
if not self.is_2fa:
if self.tx_type_combo.currentIndex() == self.TX_TYPES.Secure:
self.instant_privkey_line.setEnabled(False)
self.instant_privkey_line.clear()
self.label_transaction_limitations.show()
elif self.tx_type_combo.currentIndex(
) == self.TX_TYPES.Secure_Fast:
self.instant_privkey_line.setEnabled(True)
self.label_transaction_limitations.hide()
else:
if self.tx_type_combo.currentIndex() == self.TX_TYPES.Secure:
description_label.setEnabled(True)
self.message_e.setEnabled(True)
self.label_transaction_limitations.setText(
blocking_warning_text)
self.label_transaction_limitations.show()
elif self.tx_type_combo.currentIndex(
) == self.TX_TYPES.Secure_Fast:
self.message_e.setText('')
self.label_transaction_limitations.setText(
_('Description is not supported for Secure Fast transaction'
))
description_label.setEnabled(False)
self.message_e.setEnabled(False)
msg = _('Choose transaction type.') + '\n\n' + \
_('Secure - confirmed after 24 hours. Can be canceled within that time.') + '\n' + \
_('Secure Fast - confirmed immediately. Cannot be canceled. Requires an additional seed phrase.')
tx_type_label = HelpLabel(_('Transaction type'), msg)
self.tx_type_combo = QComboBox()
self.tx_type_combo.addItems(
[_(tx_type.name.replace('_', ' ')) for tx_type in self.TX_TYPES])
self.tx_type_combo.setCurrentIndex(self.TX_TYPES.Secure)
self.tx_type_combo.currentIndexChanged.connect(on_tx_type)
grid.addWidget(tx_type_label, 4, 0)
grid.addWidget(self.tx_type_combo, 4, 1, 1, -1)
if not self.is_2fa:
instant_privkey_label = HelpLabel(_('Secure Fast Tx seed'), msg)
self.instant_privkey_line = CompletionTextEdit()
self.instant_privkey_line.setTabChangesFocus(False)
self.instant_privkey_line.setEnabled(False)
self.instant_privkey_line.textChanged.connect(
self.on_instant_priv_key_line_edit)
self.instant_privkey_line.setContextMenuPolicy(
Qt.PreventContextMenu)
# complete line edit with suggestions
class CompleterDelegate(QStyledItemDelegate):
def initStyleOption(self, option, index):
super().initStyleOption(option, index)
delegate = CompleterDelegate(self.instant_privkey_line)
self.completer = QCompleter(self.wordlist)
self.completer.popup().setItemDelegate(delegate)
self.instant_privkey_line.set_completer(self.completer)
height = self.payto_e.height()
self.instant_privkey_line.setMaximumHeight(2 * height)
grid.addWidget(instant_privkey_label, 5, 0)
grid.addWidget(self.instant_privkey_line, 5, 1, 1, -1)
self.save_button = EnterButton(_("Save"), self.do_save_invoice)
self.send_button = EnterButton(_("Pay"), self.do_pay)
self.clear_button = EnterButton(_("Clear"), self.do_clear)
buttons = QHBoxLayout()
buttons.addStretch(1)
buttons.addWidget(self.clear_button)
buttons.addWidget(self.save_button)
buttons.addWidget(self.send_button)
grid.addLayout(buttons, 6, 1, 1, 4)
hbox_transaction_limits = QHBoxLayout()
hbox_transaction_limits.addWidget(self.label_transaction_limitations)
grid.addLayout(hbox_transaction_limits, 6, 1, 1, 2)
self.amount_e.shortcut.connect(self.spend_max)
def reset_max(text):
self.max_button.setChecked(False)
enable = not bool(text) and not self.amount_e.isReadOnly()
# self.max_button.setEnabled(enable)
self.amount_e.textEdited.connect(reset_max)
self.fiat_send_e.textEdited.connect(reset_max)
self.set_onchain(False)
self.invoices_label = QLabel(_('Outgoing payments'))
from .invoice_list import InvoiceList
self.invoice_list = InvoiceList(self)
vbox0 = QVBoxLayout()
vbox0.addLayout(grid)
hbox = QHBoxLayout()
hbox.addLayout(vbox0)
hbox.addStretch(1)
w = QWidget()
vbox = QVBoxLayout(w)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.invoices_label)
vbox.addWidget(self.invoice_list)
vbox.setStretchFactor(self.invoice_list, 1000)
w.searchable_list = self.invoice_list
run_hook('create_send_tab', grid)
return w
def __init__(self):
super().__init__()
import module_locator
self.module_path = module_locator.module_path()
self.tr = Translator(os.path.join(self.module_path, 'config.ini'))
self.history = History(os.path.join(self.module_path, 'history.txt'))
self.threads = [None for _ in range(5)]
self.setupUi(self)
self.center()
self.inputEdit.pasted.connect(self.translate)
self.inputEdit.up_pressed.connect(self.navigate_history_forward)
self.inputEdit.down_pressed.connect(self.navigate_history_backward)
self.inputEdit.installEventFilter(self)
self.actionExit = QAction('Exit',
self,
shortcut='Ctrl+Shift+Q',
triggered=self.close)
self.actionHideOrShow = QAction('Hide',
self,
shortcut='Ctrl+Q',
triggered=self.hide_or_show)
self.actionTranslate = QAction('Translate',
self,
triggered=self.translate)
self.actionTranslate.setShortcuts(
[16777220, Qt.CTRL + Qt.Key_Space, Qt.Key_Enter])
self.translateButton.pressed.connect(self.translate)
self.actionSettings = QAction('Settings')
selectInputAction = QAction('Focus input',
self,
shortcut='Ctrl+L',
triggered=self.input_edit_set_focus)
self.addAction(selectInputAction)
self.tray = QSystemTrayIcon(
QIcon(os.path.join(self.module_path, 'icon.png')), self)
trayMenu = QMenu()
trayMenu.addAction(self.actionHideOrShow)
trayMenu.addAction(self.actionSettings)
trayMenu.addAction(self.actionExit)
self.tray.setContextMenu(trayMenu)
self.tray.show()
self.menuTranslator.addAction(self.actionTranslate)
self.menuTranslator.addAction(self.actionHideOrShow)
self.menuTranslator.addAction(self.actionExit)
self.menuTranslator.addAction(self.actionSettings)
self.menuBar.addAction(self.menuTranslator.menuAction())
self.show()
dictionary_path = os.path.join(self.module_path, 'dictionary.txt')
if os.path.exists(dictionary_path):
with open(dictionary_path, "r", encoding='utf-8', newline='') as f:
lines_list = list(map(str.strip, f.readlines()))
completer = QCompleter(lines_list, self.inputEdit)
completer.setCaseSensitivity(Qt.CaseInsensitive)
self.inputEdit.setCompleter(completer)
self.swapLangsButton.setIcon(
QIcon(os.path.join(self.module_path, 'arrowupdown.png')))
self.swapLangsButton.pressed.connect(self.swap_languages)
for code, name in LANGUAGES.items():
self.fromComboBox.addItem(name, userData=code)
self.toComboBox.addItem(name, userData=code)
def init(self, config):
self.config = config
redmineData = self.config.getRedminesData()
redmineProjects = []
for (i, item) in enumerate(redmineData):
redmineWorker = RedmineWorker(item[0])
redmineWorker.initWithKey(item[2])
projects = redmineWorker.getProjects()
for project in projects:
redmineProjects.append([project.id, project.name])
projectsModel = RedmineProjectsModel(redmineProjects)
self.redmineProjectsView.setModel(projectsModel)
evolutionData = self.config.getEvolutionData()
evoWorker = EvoWorker(evolutionData[0], evolutionData[2])
evoProjects = evoWorker.getProjects()
if evoProjects != False:
self.evoProjectNames = []
self.evoProjectNamesToId = {}
self.evoProjectIdToName = {}
for project in evoProjects:
self.evoProjectNames.append(project['title'])
self.evoProjectNamesToId[project['title']] = project['id']
self.evoProjectIdToName[project['id']] = project['title']
completer = QCompleter()
self.evoProject.setCompleter(completer)
model = QStringListModel()
completer.setModel(model)
model.setStringList(self.evoProjectNames)
else:
msgBox = QMessageBox()
msgBox.setIcon(QMessageBox.Information)
msgBox.setText("При получении данных из evo произошла ошибка")
msgBox.exec_()
self.selectedIndex = 0
self.redmineProjectsView.selectionModel().selectionChanged.connect(self.changeProject)
self.saveRedmineEvoProject.clicked.connect(self.saveProject)
Qindex = projectsModel.createIndex(0, 0)
self.redmineProjectsView.selectionModel().select(Qindex, QItemSelectionModel.Select)
self.hamsterWorker = HamsterWorker()
self.hamsterProjects = self.hamsterWorker.getProjects()
hamsterProjectsModel = QStringListModel()
hamsterProjectsModel.setStringList(self.hamsterProjects)
self.hamsterProjectView.setModel(hamsterProjectsModel)
Qindex = hamsterProjectsModel.createIndex(0, 0)
self.hamsterProjectView.selectionModel().select(Qindex, QItemSelectionModel.Select)
redminesData = self.config.getRedminesData()
for (i, item) in enumerate(redminesData):
self.redmineCombo.addItem(item[0], i)
self.hamsterProjectView.selectionModel().selectionChanged.connect(self.changeHamsterRedmine)
self.saveHumsterProject.clicked.connect(self.saveHamsterRedmine)
self.selectedIndexHamster = 0
self.changeHamsterRedmine()
def setupUi(self):
self.load_ui("apol/ibpkeyconquery.ui")
# set up user autocompletion
user_completion_list = [str(u) for u in self.policy.users()]
user_completer_model = QStringListModel(self)
user_completer_model.setStringList(sorted(user_completion_list))
self.user_completion = QCompleter()
self.user_completion.setModel(user_completer_model)
self.user.setCompleter(self.user_completion)
# set up role autocompletion
role_completion_list = [str(r) for r in self.policy.roles()]
role_completer_model = QStringListModel(self)
role_completer_model.setStringList(sorted(role_completion_list))
self.role_completion = QCompleter()
self.role_completion.setModel(role_completer_model)
self.role.setCompleter(self.role_completion)
# set up type autocompletion
type_completion_list = [str(t) for t in self.policy.types()]
type_completer_model = QStringListModel(self)
type_completer_model.setStringList(sorted(type_completion_list))
self.type_completion = QCompleter()
self.type_completion.setModel(type_completer_model)
self.type_.setCompleter(self.type_completion)
# setup indications of errors on source/target/default
self.errors = set()
self.orig_palette = self.type_.palette()
self.error_palette = self.type_.palette()
self.error_palette.setColor(QPalette.Base, Qt.red)
self.clear_subnet_prefix_error()
self.clear_pkeys_error()
self.clear_user_error()
self.clear_type_error()
self.clear_role_error()
self.clear_range_error()
# set up results
self.table_results_model = IbpkeyconTableModel(self)
self.sort_proxy = QSortFilterProxyModel(self)
self.sort_proxy.setSourceModel(self.table_results_model)
self.table_results.setModel(self.sort_proxy)
self.table_results.sortByColumn(0, Qt.AscendingOrder)
# set up processing thread
self.thread = QThread()
self.worker = QueryResultsUpdater(self.query, self.table_results_model)
self.worker.moveToThread(self.thread)
self.worker.raw_line.connect(self.raw_results.appendPlainText)
self.worker.finished.connect(self.update_complete)
self.worker.finished.connect(self.thread.quit)
self.thread.started.connect(self.worker.update)
# create a "busy, please wait" dialog
self.busy = QProgressDialog(self)
self.busy.setModal(True)
self.busy.setRange(0, 0)
self.busy.setMinimumDuration(0)
self.busy.canceled.connect(self.thread.requestInterruption)
self.busy.reset()
# update busy dialog from query INFO logs
self.handler = LogHandlerToSignal()
self.handler.message.connect(self.busy.setLabelText)
logging.getLogger("setools.ibpkeyconquery").addHandler(self.handler)
# Ensure settings are consistent with the initial .ui state
self.criteria_frame.setHidden(not self.criteria_expander.isChecked())
self.notes.setHidden(not self.notes_expander.isChecked())
# Range criteria is available only if policy is MLS
if not self.policy.mls:
self.range_criteria.setEnabled(False)
self.range_criteria.setToolTip("MLS is disabled in this policy.")
self.range_.setToolTip("MLS is disabled in this policy.")
self.range_exact.setToolTip("MLS is disabled in this policy.")
self.range_overlap.setToolTip("MLS is disabled in this policy.")
self.range_subset.setToolTip("MLS is disabled in this policy.")
self.range_superset.setToolTip("MLS is disabled in this policy.")
# connect signals
self.buttonBox.clicked.connect(self.run)
self.subnet_prefix.textEdited.connect(self.clear_subnet_prefix_error)
self.subnet_prefix.editingFinished.connect(self.set_subnet_prefix)
self.pkeys.textEdited.connect(self.clear_pkeys_error)
self.pkeys.editingFinished.connect(self.set_pkeys)
self.user.textEdited.connect(self.clear_user_error)
self.user.editingFinished.connect(self.set_user)
self.user_regex.toggled.connect(self.set_user_regex)
self.role.textEdited.connect(self.clear_role_error)
self.role.editingFinished.connect(self.set_role)
self.role_regex.toggled.connect(self.set_role_regex)
self.type_.textEdited.connect(self.clear_type_error)
self.type_.editingFinished.connect(self.set_type)
self.type_regex.toggled.connect(self.set_type_regex)
self.range_.textEdited.connect(self.clear_range_error)
self.range_.editingFinished.connect(self.set_range)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
if CrossSectionFetchWidget.CROSS_SECTION_FETCH_WIDGET_INSTANCE is not None:
raise Exception(
"No more than one instance of CrossSectionFetchWidget"
" should be created")
CrossSectionFetchWidget.CROSS_SECTION_FETCH_WIDGET_INSTANCE = self
self.all_molecules = MoleculeMeta.all_names()
self.parent = parent
self.wn_check: QCheckBox = None
self.numin: QDoubleSpinBox = None
self.numax: QDoubleSpinBox = None
self.pressure_check: QCheckBox = None
self.pressure_min: QDoubleSpinBox = None
self.pressure_max: QDoubleSpinBox = None
self.temp_check: QCheckBox = None
self.temp_min: QDoubleSpinBox = None
self.temp_max: QDoubleSpinBox = None
self.molecule: QComboBox = None
self.cross_section_list: QListWidget = None
self.fetch_button: QPushButton = None
self.apply_filters: QPushButton = None
self.cross_section_meta: CrossSectionMeta = None
self.fetching = False
uic.loadUi('layouts/cross_section_widget.ui', self)
self.pressure_check.toggled.connect(
self.gen_toggle_function([self.pressure_max, self.pressure_min]))
self.temp_check.toggled.connect(
self.gen_toggle_function([self.temp_max, self.temp_min]))
self.wn_check.toggled.connect(
self.gen_toggle_function([self.numax, self.numin]))
self.pressure_check.setChecked(True)
self.temp_check.setChecked(True)
self.wn_check.setChecked(True)
self.temp_check.toggle()
self.wn_check.toggle()
self.pressure_check.toggle()
self.fetch_button.clicked.connect(self.__on_fetch_clicked)
self.apply_filters.clicked.connect(self.__on_apply_filters_clicked)
self.molecule.addItems(
CrossSectionMeta.all_names_sorted_by_hitran_id())
self.molecule.setEditable(True)
self.completer: QCompleter = QCompleter(CrossSectionMeta.all_aliases(),
self)
self.completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.molecule.setCompleter(self.completer)
self.molecule.currentTextChanged.connect(
self.__on_molecule_selection_changed)
self.__on_molecule_selection_changed(self.molecule.currentText())
def __init__(self, new_project=True, project_manager: ProjectManager = None, parent=None):
super().__init__(parent)
if not new_project:
assert project_manager is not None
self.ui = Ui_ProjectDialog()
self.ui.setupUi(self)
if new_project:
self.participant_table_model = self.ProtocolParticipantModel([])
else:
self.participant_table_model = self.ProtocolParticipantModel(project_manager.participants)
self.ui.spinBoxSampleRate.setValue(project_manager.device_conf["sample_rate"])
self.ui.spinBoxFreq.setValue(project_manager.device_conf["frequency"])
self.ui.spinBoxBandwidth.setValue(project_manager.device_conf["bandwidth"])
self.ui.spinBoxGain.setValue(project_manager.device_conf["gain"])
self.ui.txtEdDescription.setPlainText(project_manager.description)
self.ui.lineEdit_Path.setText(project_manager.project_path)
self.ui.lineEditBroadcastAddress.setText(project_manager.broadcast_address_hex)
self.ui.btnSelectPath.hide()
self.ui.lineEdit_Path.setDisabled(True)
self.setWindowTitle("Edit project settings")
self.ui.lNewProject.setText("Edit project")
self.ui.btnOK.setText("Accept")
self.ui.tblParticipants.setModel(self.participant_table_model)
self.ui.tblParticipants.setItemDelegateForColumn(2, ComboBoxDelegate([""] * len(constants.PARTICIPANT_COLORS),
colors=constants.PARTICIPANT_COLORS,
parent=self))
self.__set_relative_rssi_delegate()
"(([a-fA-F]|[0-9]){2}){3}"
self.ui.lineEditBroadcastAddress.setValidator(QRegExpValidator(QRegExp("([a-fA-F ]|[0-9]){,}")))
self.sample_rate = self.ui.spinBoxSampleRate.value()
self.freq = self.ui.spinBoxFreq.value()
self.bandwidth = self.ui.spinBoxBandwidth.value()
self.gain = self.ui.spinBoxGain.value()
self.description = self.ui.txtEdDescription.toPlainText()
self.broadcast_address_hex = self.ui.lineEditBroadcastAddress.text()
self.ui.btnRemoveParticipant.setDisabled(len(self.participants) <= 1)
self.path = self.ui.lineEdit_Path.text()
self.new_project = new_project
self.committed = False
self.setModal(True)
completer = QCompleter()
completer.setModel(QDirModel(completer))
self.ui.lineEdit_Path.setCompleter(completer)
self.create_connects()
# add two participants
if self.participant_table_model.rowCount() == 0:
self.ui.btnAddParticipant.click()
self.ui.btnAddParticipant.click()
if new_project:
self.ui.lineEdit_Path.setText(os.path.realpath(os.path.join(os.curdir, "new")))
self.on_line_edit_path_text_edited()
self.open_editors()
try:
self.restoreGeometry(constants.SETTINGS.value("{}/geometry".format(self.__class__.__name__)))
except TypeError:
pass
def create_send_tab(self):
# A 4-column grid layout. All the stretch is in the last column.
# The exchange rate plugin adds a fiat widget in column 2
self.send_grid = grid = QGridLayout()
grid.setSpacing(8)
grid.setColumnStretch(3, 1)
from .paytoedit import PayToEdit
self.amount_e = BTCAmountEdit(self.get_decimal_point)
self.payto_e = PayToEdit(self)
msg = _('Recipient of the funds.') + '\n\n' \
+ _(
'You may enter a Bitcoin address, a label from your list of contacts (a list of completions will be proposed), or an alias (email-like address that forwards to a Bitcoin address)')
payto_label = HelpLabel(_('Pay to'), msg)
grid.addWidget(payto_label, 1, 0)
grid.addWidget(self.payto_e, 1, 1, 1, -1)
completer = QCompleter()
completer.setCaseSensitivity(False)
self.payto_e.set_completer(completer)
completer.setModel(self.completions)
msg = _('Description of the transaction (not mandatory).') + '\n\n' \
+ _(
'The description is not sent to the recipient of the funds. It is stored in your wallet file, and displayed in the \'History\' tab.')
description_label = HelpLabel(_('Description'), msg)
grid.addWidget(description_label, 2, 0)
self.message_e = MyLineEdit()
self.message_e.setMinimumWidth(700)
grid.addWidget(self.message_e, 2, 1, 1, -1)
msg = _('Amount to be sent.') + '\n\n' \
+ _('The amount will be displayed in red if you do not have enough funds in your wallet.') + ' ' \
+ _(
'Note that if you have frozen some of your addresses, the available funds will be lower than your total balance.') + '\n\n' \
+ _('Keyboard shortcut: type "!" to send all your coins.')
amount_label = HelpLabel(_('Amount'), msg)
grid.addWidget(amount_label, 3, 0)
grid.addWidget(self.amount_e, 3, 1)
self.fiat_send_e = AmountEdit(self.fx.get_currency if self.fx else '')
if not self.fx or not self.fx.is_enabled():
self.fiat_send_e.setVisible(False)
grid.addWidget(self.fiat_send_e, 3, 2)
self.amount_e.frozen.connect(
lambda: self.fiat_send_e.setFrozen(self.amount_e.isReadOnly()))
self.max_button = EnterButton(_("Max"), self.spend_max)
self.max_button.setFixedWidth(100)
self.max_button.setCheckable(True)
grid.addWidget(self.max_button, 3, 3)
self.save_button = EnterButton(_("Save"), self.do_save_invoice)
self.send_button = EnterButton(_("Pay"), self.do_pay)
self.clear_button = EnterButton(_("Clear"), self.do_clear)
buttons = QHBoxLayout()
buttons.addStretch(1)
buttons.addWidget(self.clear_button)
buttons.addWidget(self.save_button)
buttons.addWidget(self.send_button)
grid.addLayout(buttons, 6, 1, 1, 4)
self.label_transaction_limitations = QLabel(
_('Warning: Please be aware that in the process of using the \
Secure Transaction feature, a part of the funds left in your wallet might be blocked. This is a normal procedure linked \
to UTXO and the blockchain parameters of the Bitcoin Vault wallet. Your funds will be unblocked once the transaction is \
verified (after approximately 24 hrs) or canceled (within 24 hrs).'))
self.label_transaction_limitations.setStyleSheet(
ColorScheme.RED.as_stylesheet(True))
self.label_transaction_limitations.setWordWrap(True)
hbox_transaction_limits = QHBoxLayout()
hbox_transaction_limits.addWidget(self.label_transaction_limitations)
grid.addLayout(hbox_transaction_limits, 6, 1, 1, 2)
self.amount_e.shortcut.connect(self.spend_max)
def reset_max(text):
self.max_button.setChecked(False)
enable = not bool(text) and not self.amount_e.isReadOnly()
# self.max_button.setEnabled(enable)
self.amount_e.textEdited.connect(reset_max)
self.fiat_send_e.textEdited.connect(reset_max)
self.set_onchain(False)
self.invoices_label = QLabel(_('Outgoing payments'))
from .invoice_list import InvoiceList
self.invoice_list = InvoiceList(self)
vbox0 = QVBoxLayout()
vbox0.addLayout(grid)
hbox = QHBoxLayout()
hbox.addLayout(vbox0)
hbox.addStretch(1)
w = QWidget()
vbox = QVBoxLayout(w)
vbox.addLayout(hbox)
vbox.addStretch(1)
vbox.addWidget(self.invoices_label)
vbox.addWidget(self.invoice_list)
vbox.setStretchFactor(self.invoice_list, 1000)
w.searchable_list = self.invoice_list
run_hook('create_send_tab', grid)
return w
def __init__(self, device, *args, **kwargs):
super().__init__()
self.setAllowedAreas(Qt.BottomDockWidgetArea)
self.setWindowTitle("Console [{}]".format(device.p["FriendlyName1"]))
self.device = device
self.settings = QSettings("{}/TDM/tdm.cfg".format(QDir.homePath()),
QSettings.IniFormat)
console_font_size = self.settings.value("console_font_size", 9, int)
console_font.setPointSize(console_font_size)
console_word_wrap = self.settings.value("console_word_wrap", True,
bool)
w = QWidget()
vl = VLayout()
self.console = QPlainTextEdit()
self.console.setTabChangesFocus(True)
self.console.setWordWrapMode(console_word_wrap)
self.console.setReadOnly(True)
self.console.setFont(console_font)
self.console_hl = JSONHighLighter(self.console.document())
hl_command_mqttlog = HLayout(0)
self.command = QLineEdit()
self.command.setFont(console_font)
self.command.setPlaceholderText(
"Type the command and press ENTER to send.")
self.command.returnPressed.connect(self.command_enter)
self.command.textChanged.connect(self.command_changed)
self.command.installEventFilter(self)
command_cpl = QCompleter(sorted(commands))
command_cpl.setCaseSensitivity(Qt.CaseInsensitive)
command_cpl.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.command.setCompleter(command_cpl)
# command_cpl.popup().installEventFilter(self)
command_cpl.activated.connect(self.command.clear, Qt.QueuedConnection)
pbSave = QPushButton(QIcon("GUI/icons/save.png"), "")
pbSave.setFlat(True)
pbSave.setToolTip("Save console")
pbSave.clicked.connect(self.save_console)
pbClear = QPushButton(QIcon("GUI/icons/clear.png"), "")
pbClear.setFlat(True)
pbClear.setToolTip("Clear console")
pbClear.clicked.connect(self.clear_console)
self.cbMQTTLog = QComboBox()
self.cbMQTTLog.addItems([
"Disabled", "Error", "Error/Info (default)", "Error/Info/Debug",
"Error/Info/More debug", "All"
])
mqttlog = self.device.p.get("MqttLog", -1)
if mqttlog != -1:
self.cbMQTTLog.setCurrentIndex(int(mqttlog))
else:
self.cbMQTTLog.setEnabled(False)
self.cbMQTTLog.currentIndexChanged.connect(self.change_mqttlog)
hl_command_mqttlog.addWidgets([
self.command, pbSave, pbClear,
QLabel("MQTT Log level"), self.cbMQTTLog
])
vl.addWidget(self.console)
vl.addLayout(hl_command_mqttlog)
w.setLayout(vl)
self.setWidget(w)
